結果
| 問題 | No.1675 Strange Minimum Query |
| ユーザー |
 lloyz
|
| 提出日時 | 2021-11-24 00:22:44 |
| 言語 | PyPy3 (7.3.15) |
| 結果 |
AC
|
| 実行時間 | 1,704 ms / 2,000 ms |
| コード長 | 8,291 bytes |
| コンパイル時間 | 316 ms |
| コンパイル使用メモリ | 86,496 KB |
| 実行使用メモリ | 123,020 KB |
| 最終ジャッジ日時 | 2023-09-08 05:01:01 |
| 合計ジャッジ時間 | 38,338 ms |
|
ジャッジサーバーID （参考情報） |
judge14 / judge15 |
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 75 ms
71,012 KB |
| testcase_01 | AC | 75 ms
70,988 KB |
| testcase_02 | AC | 76 ms
70,992 KB |
| testcase_03 | AC | 944 ms
100,680 KB |
| testcase_04 | AC | 920 ms
102,120 KB |
| testcase_05 | AC | 491 ms
87,852 KB |
| testcase_06 | AC | 997 ms
103,540 KB |
| testcase_07 | AC | 1,120 ms
108,348 KB |
| testcase_08 | AC | 91 ms
75,904 KB |
| testcase_09 | AC | 173 ms
78,772 KB |
| testcase_10 | AC | 527 ms
103,068 KB |
| testcase_11 | AC | 394 ms
94,892 KB |
| testcase_12 | AC | 561 ms
104,692 KB |
| testcase_13 | AC | 711 ms
115,588 KB |
| testcase_14 | AC | 897 ms
120,656 KB |
| testcase_15 | AC | 794 ms
119,560 KB |
| testcase_16 | AC | 73 ms
71,092 KB |
| testcase_17 | AC | 724 ms
91,500 KB |
| testcase_18 | AC | 778 ms
92,336 KB |
| testcase_19 | AC | 879 ms
101,860 KB |
| testcase_20 | AC | 1,287 ms
111,352 KB |
| testcase_21 | AC | 1,205 ms
110,320 KB |
| testcase_22 | AC | 1,384 ms
113,368 KB |
| testcase_23 | AC | 1,188 ms
101,024 KB |
| testcase_24 | AC | 1,137 ms
104,116 KB |
| testcase_25 | AC | 1,013 ms
97,772 KB |
| testcase_26 | AC | 772 ms
94,620 KB |
| testcase_27 | AC | 1,125 ms
108,544 KB |
| testcase_28 | AC | 863 ms
101,748 KB |
| testcase_29 | AC | 747 ms
100,432 KB |
| testcase_30 | AC | 772 ms
95,412 KB |
| testcase_31 | AC | 1,428 ms
110,764 KB |
| testcase_32 | AC | 1,680 ms
121,744 KB |
| testcase_33 | AC | 1,676 ms
121,724 KB |
| testcase_34 | AC | 1,704 ms
122,356 KB |
| testcase_35 | AC | 1,662 ms
123,020 KB |
| testcase_36 | AC | 1,665 ms
122,340 KB |
ソースコード
class lazy_segtree():
def update(self,k):self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def all_apply(self,k,f):
self.d[k]=self.mapping(f,self.d[k])
if (k<self.size):self.lz[k]=self.composition(f,self.lz[k])
def push(self,k):
self.all_apply(2*k,self.lz[k])
self.all_apply(2*k+1,self.lz[k])
self.lz[k]=self.identity
def __init__(self,V,OP,E,MAPPING,COMPOSITION,ID):
self.n=len(V)
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
self.lz=[ID for i in range(self.size)]
self.e=E
self.op=OP
self.mapping=MAPPING
self.composition=COMPOSITION
self.identity=ID
for i in range(self.n):self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
self.d[p]=x
for i in range(1,self.log+1):self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
return self.d[p]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
if l==r:return self.e
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):self.push(l>>i)
if (((r>>i)<<i)!=r):self.push(r>>i)
sml,smr=self.e,self.e
while(l<r):
if l&1:
sml=self.op(sml,self.d[l])
l+=1
if r&1:
r-=1
smr=self.op(self.d[r],smr)
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):return self.d[1]
def apply_point(self,p,f):
assert 0<=p and p<self.n
p+=self.size
for i in range(self.log,0,-1):self.push(p>>i)
self.d[p]=self.mapping(f,self.d[p])
for i in range(1,self.log+1):self.update(p>>i)
def apply(self,l,r,f):
assert 0<=l and l<=r and r<=self.n
if l==r:return
l+=self.size
r+=self.size
for i in range(self.log,0,-1):
if (((l>>i)<<i)!=l):self.push(l>>i)
if (((r>>i)<<i)!=r):self.push((r-1)>>i)
l2,r2=l,r
while(l<r):
if (l&1):
self.all_apply(l,f)
l+=1
if (r&1):
r-=1
self.all_apply(r,f)
l>>=1
r>>=1
l,r=l2,r2
for i in range(1,self.log+1):
if (((l>>i)<<i)!=l):self.update(l>>i)
if (((r>>i)<<i)!=r):self.update((r-1)>>i)
def max_right(self,l,g):
assert 0<=l and l<=self.n
assert g(self.e)
if l==self.n:return self.n
l+=self.size
for i in range(self.log,0,-1):self.push(l>>i)
sm=self.e
while(1):
while(i%2==0):l>>=1
if not(g(self.op(sm,self.d[l]))):
while(l<self.size):
self.push(l)
l=(2*l)
if (g(self.op(sm,self.d[l]))):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:break
return self.n
def min_left(self,r,g):
assert (0<=r and r<=self.n)
assert g(self.e)
if r==0:return 0
r+=self.size
for i in range(self.log,0,-1):self.push((r-1)>>i)
sm=self.e
while(1):
r-=1
while(r>1 and (r%2)):r>>=1
if not(g(self.op(self.d[r],sm))):
while(r<self.size):
self.push(r)
r=(2*r+1)
if g(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r&-r)==r:break
return 0
class SegmentTree:
__all__ = ['setval', 'pointupdate', 'segquery', 'segsearch_right', 'pointgetval']
def __init__(self, n=10**6, idetify_elt=-10**9, func=max):
assert (func(idetify_elt, idetify_elt) == idetify_elt)
self._n = n
self._seg_length_half = 2**(n-1).bit_length()
self._idetify_elt = idetify_elt
self._seg = [idetify_elt]*(2*self._seg_length_half)
self._func = func
def setval(self, x_list):
'''Set value : A = x_list'''
assert (len(x_list) == self._n)
# Set value at the bottom
for i in range(self._n):
self._seg[i+self._seg_length_half-1] = x_list[i]
# Build value
for i in range(self._seg_length_half-2, -1, -1):
self._seg[i] = self._func(self._seg[2*i+1], self._seg[2*i+2])
def pointupdate(self, k, x):
'''Update : A[k] = x '''
pos = k + self._seg_length_half - 1
# Set value at k-th
self._seg[pos] = x
# Build bottom-up
while pos:
pos = (pos-1)//2
self._seg[pos] = self._func(self._seg[pos*2+1], self._seg[pos*2+2])
def pointgetval(self, k):
''' Return A[k] '''
return self._seg[k + self._seg_length_half - 1]
def segquery(self, left, right):
''' Return func(A[left], ... , A[right-1]) '''
# if not left < right
if right <= left:
return self._idetify_elt
func_value = self._idetify_elt
leftpos = left + self._seg_length_half - 1 # leftmost segment
rightpos = right + self._seg_length_half - 2 # rightmost segment
while leftpos < rightpos-1:
if leftpos&1 == 0:
# if leftpos is right-child
func_value = self._func(func_value, self._seg[leftpos])
if rightpos&1 == 1:
# if rightpos is leftchild
func_value = self._func(func_value, self._seg[rightpos])
rightpos -= 1
# move up
leftpos = leftpos//2
rightpos = (rightpos-1)//2
func_value = self._func(func_value, self._seg[leftpos])
if leftpos != rightpos:
func_value = self._func(func_value, self._seg[rightpos])
return func_value
def segsearch_right(self, condfunc, left=0):
''' Return min_i satisfying condfunc( func( A[left], ... , A[i]))
if impossible : return n
'''
# if impossible (ie. condfunc( func( A[left], ... , A[-1])) is False)
if not condfunc(self._segquery(left, self._n)):
return self._n
# possible
func_value = self._idetify_elt
rightpos = left + self._seg_length_half - 1
while True:
# while rightpos is the left-child, move bottom-up
while rightpos&1 == 1:
rightpos //= 2
# try
up_value_trial = self._func(func_value, self._seg[rightpos])
if not condfunc(up_value_trial):
# move up and right
func_value = up_value_trial
rightpos = (rightpos-1)//2 + 1
else:
# move top-down
while rightpos < self._seg_length_half-1:
down_value_trial = self._func(func_value, self._seg[rightpos*2 + 1])
if condfunc(down_value_trial):
# move left-child
rightpos = rightpos*2 + 1
else:
# move right-child
func_value = down_value_trial
rightpos = rightpos*2 + 2
return rightpos - self._seg_length_half + 1
n, q = map(int, input().split())
INF = 10**9
lazysegtree = lazy_segtree([1 for _ in range(n)], max, 1, max, max, 0)
Q = [list(map(int, input().split())) for _ in range(q)]
for l, r, b in Q:
lazysegtree.apply(l - 1, r, b)
ans = [lazysegtree.get(i) for i in range(n)]
segtree = SegmentTree(n=n, idetify_elt=INF, func=min)
for i in range(n):
segtree.pointupdate(i, ans[i])
for l, r, b in Q:
if segtree.segquery(l - 1, r) != b:
print(-1)
exit()
print(*ans)