s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s634590320 | p02345 | u728992264 | 1490387669 | Python | Python3 | py | Runtime Error | 30 | 7628 | 717 | dat = []
def init(n):
global dat
k = 1
while (k < n):
k = k * 2
dat = [2**31 - 1 for i in range(2 * k - 1)]
def update(k, y):
global dat
k += len(dat) - 1
dat[k] = y;
while (k > 0):
k = int((k - 1) / 2)
dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2])
def query(a, b, k, l, r):
if (r <= a or b <= l):
return 2**31 - 1
if (a <= l and r <= b):
return dat[k]
vl = query(a, b, k * 2 + 1, l, int((l + r) / 2))
vr = query(a, b, k * 2 + 2, int((l + r / 2)), r)
return min(vl, vr)
# main
n, q = map(int, input().split())
init(n)
for i in range(q):
com, x, y = map(int, input().split())
if com == 0:
update(x, y)
else:
print(query(x, y+1, 0, 0, len(dat))) |
s340858880 | p02345 | u362104929 | 1495377070 | Python | Python3 | py | Runtime Error | 0 | 0 | 407 | def updt(lst, i, x):
lst[i] = x
def fnd(lst, s, t):
return min(lst[s:t])
def rmq():
n, q = map(int, input().split())
A = [x for x in range(n)]
ans = []
for _ in range(q):
cmd, x, y = map(int, input().split())
if cmd == 0:
updt(A, x, y)
else:
ans.append(fnd(A, x, y))
print(*ans, sep="\n")
if __name__ == "__main__":
rmq() |
s099513772 | p02345 | u362104929 | 1495380883 | Python | Python3 | py | Runtime Error | 0 | 0 | 750 | import sys
def updt(lstv, lstk, i, x):
lstv[i] = x
lstk[i] = i
def fnd(lstv, lstk, s, t):
if max(lstk[s:t+1]) == -1:
return 2**31 -1
else:
m = 2**31 -1
for k in lstk[s:t+1]:
if k >= 0:
if m > lstv[k]:
m = lstv[k]
return m
def rmq():
n, q = map(int, sys.stdin.reakline().split())
Av = [0 for _ in range(n)]
Ak = [-1 for _ in range(n)]
ans = []
for _ in range(q):
cmd, x, y = map(int, sys.stdin.reakline().split())
if cmd == 0:
updt(Av, Ak, x, y)
else:
ans.append(fnd(Av, Ak, x, y))
print(*ans, sep="\n")
if __name__ == "__main__":
rmq() |
s316939174 | p02345 | u603049633 | 1496735541 | Python | Python3 | py | Runtime Error | 0 | 0 | 260 | import numpy as np
n,q = map(int, input().split())
A = np.array([float("inf")] * n)
for i in range(q):
c,x,y = map(int,input().split())
if c == 0:
A[x] = y
else:
a = np.min(A[x:y+1])
if a == float("inf"): a = "2147483647"
else: a = str(a)
print(a) |
s022541281 | p02345 | u603049633 | 1496735607 | Python | Python3 | py | Runtime Error | 0 | 0 | 244 | import numpy as np
n,q = map(int, input().split())
A = np.array([None] * n)
for i in range(q):
c,x,y = map(int,input().split())
if c == 0:
A[x] = y
else:
a = np.min(A[x:y+1])
if a is None: a = "2147483647"
else: a = str(a)
print(a) |
s872376478 | p02345 | u603049633 | 1496735656 | Python | Python3 | py | Runtime Error | 20 | 7464 | 212 | n,q = map(int, input().split())
A = [None] * n
for i in range(q):
c,x,y = map(int,input().split())
if c == 0:
A[x] = y
else:
a = min(A[x:y+1])
if a is None: a = "2147483647"
else: a = str(a)
print(a) |
s475968115 | p02345 | u798803522 | 1511615555 | Python | Python3 | py | Runtime Error | 0 | 0 | 1040 | class RMQ:
import math
def __init__(self, length):
self.length = 2 ** math.ceil(math.log(length, 2))
self.segtree = [float("inf")] * (2 ** (self.length + 1) - 1)
def update(self, index, n):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = n
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = min(self.segtree[leaf_index * 2 + 1], self.segtree[leaf_index * 2 + 2])
def find(self, a, b, index, l, r):
if b < l or r < a:
return float("inf")
elif a <= l <= r <= b:
return self.segtree[index]
else:
return min(self.find(a, b, index * 2 + 1, l, (l + r) // 2), self.find(a, b, index * 2 + 2, (l + r) // 2, r))
v_num, query = (int(n) for n in input().split(" "))
rmq = RMQ(v_num)
for _ in range(query):
com, i, n = (int(n) for n in input().split(" ") )
if com == 0:
rmq.update(i, n)
else:
print(rmq.find(i, n, 0, 0, rmq.length)) |
s366208168 | p02345 | u798803522 | 1511618296 | Python | Python3 | py | Runtime Error | 0 | 0 | 1080 | class RMQ:
def __init__(self, length, ini_num = float("inf")):
self.length = 1
while self.length <= n:
self.length <<= 1
self.segtree = [ini_num] * (2 * self.length - 1)
def update(self, index, n):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = n
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = min(self.segtree[leaf_index * 2 + 1], self.segtree[leaf_index * 2 + 2])
def find(self, a, b, index, l, r):
if a <= l <= r <= b or a == b:
return self.segtree[index]
if b <= l or r <= a:
return float("inf")
else:
return min(self.find(a, b, index * 2 + 1, l, (l + r) // 2), self.find(a, b, index * 2 + 2, (l + r) // 2, r))
v_num, query = (int(n) for n in input().split(" "))
rmq = RMQ(v_num, 2147483647)
for _ in range(query):
com, i, n = (int(n) for n in input().split(" ") )
if com == 0:
rmq.update(i, n)
else:
(rmq.find(i, n, 0, 0, rmq.length)) |
s618663410 | p02345 | u798803522 | 1511618330 | Python | Python3 | py | Runtime Error | 0 | 0 | 1085 | class RMQ:
def __init__(self, length, ini_num = float("inf")):
self.length = 1
while self.length <= n:
self.length <<= 1
self.segtree = [ini_num] * (2 * self.length - 1)
def update(self, index, n):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = n
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = min(self.segtree[leaf_index * 2 + 1], self.segtree[leaf_index * 2 + 2])
def find(self, a, b, index, l, r):
if a <= l <= r <= b or a == b:
return self.segtree[index]
if b <= l or r <= a:
return float("inf")
else:
return min(self.find(a, b, index * 2 + 1, l, (l + r) // 2), self.find(a, b, index * 2 + 2, (l + r) // 2, r))
v_num, query = (int(n) for n in input().split(" "))
rmq = RMQ(v_num, 2147483647)
for _ in range(query):
com, i, n = (int(n) for n in input().split(" ") )
if com == 0:
rmq.update(i, n)
else:
print(rmq.find(i, n, 0, 0, rmq.length)) |
s628806714 | p02345 | u798803522 | 1511618437 | Python | Python3 | py | Runtime Error | 0 | 0 | 1085 | class RMQ:
def __init__(self, length, ini_num = float("inf")):
self.length = 1
while self.length <= n:
self.length <<= 1
self.segtree = [ini_num] * (2 * self.length - 1)
def update(self, index, n):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = n
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = min(self.segtree[leaf_index * 2 + 1], self.segtree[leaf_index * 2 + 2])
def find(self, a, b, index, l, r):
if a <= l <= r <= b or a == b:
return self.segtree[index]
if b <= l or r <= a:
return float("inf")
else:
return min(self.find(a, b, index * 2 + 1, l, (l + r) // 2), self.find(a, b, index * 2 + 2, (l + r) // 2, r))
v_num, query = (int(n) for n in input().split(" "))
rmq = RMQ(v_num, 2147483647)
for _ in range(query):
com, i, n = (int(n) for n in input().split(" ") )
if com == 0:
rmq.update(i, n)
else:
print(rmq.find(i, n, 0, 0, rmq.length)) |
s887803083 | p02345 | u798087532 | 1511849201 | Python | Python3 | py | Runtime Error | 20 | 5620 | 1769 | class SegmentTree():
def __init__(self,n):
self.dat = [INF for _ in range(n*2-1)]
#index n???????????????????????¢?????????:
#???????????? : (n-1)//2
#???????????? : (2n+1) , (2n+2)
self.n = n
def update (self,node_index,value):
""" index?????????value????????´?????? """
index = node_index + (self.n-1) #node_index????????????dot???index?????????
self.dat[index] = value
#?????°????????????????????????????????´????????????
while index > 0 :
index = (index - 1) // 2 #???????????????????????£???
self.dat[index] = min([self.dat[index*2+1],self.dat[index*2+2]]) #??????????????????????????????
def querry (self,left,right,nowNode,nowLeft,nowRight):
"""[left,right):??¢?´¢??????,noeNode:?????¨????????????,[nowLeft,nowRight):?????¨?????????????????????"""
# ??????????????¶??£????????????
if nowRight < left or nowLeft > right:
return INF
# ?????¨?????¢?´¢???????????¨????????????????????????????????????
if left <= nowLeft and nowRight <= right:
return self.dat[nowNode]
# ???????????????????????????????????¨???????????????
else:
value_left =self.querry(left,right,2*nowNode+1,nowLeft,(nowLeft+nowRight)//2)
value_right = self.querry(left,right,2*nowNode+2,(nowLeft+nowRight)//2+1,nowRight)
return min([value_left,value_right])
def DEBUG_dat(self):
print(self.dat)
if __name__ == "__main__":
# ??????????????????
INF = 2147483647
n ,q = map(int,input().split(" "))
result = []
for i in range(1,9):
if 2 ** i >= n:
min_pow2 = 2 ** i
break
tree = SegmentTree(min_pow2)
for i in range(q):
com,x,y = map(int,input().split(" "))
if com == 0:
tree.update(x,y)
else:
result.append(tree.querry(x,y,0,0,min_pow2-1))
for i in result:
print(i)
|
s777505396 | p02345 | u045830275 | 1512172690 | Python | Python3 | py | Runtime Error | 0 | 0 | 667 | import numpy as np
def update(a, i, x) :
a[i] = x
def find(a, s, t) :
return a[s:t+1].min()
def main() :
n, q = [int(i) for i in input().split()]
a = np.ones(n, dtype=int) * (2**31 - 1)
com = np.array([], dtype=int)
x = np.array([], dtype=int)
y= np.array([], dtype=int)
for _ in range(q) :
tmp = list(map(int, input().split()))
com = np.append(com, tmp[0])
x = np.append(x, tmp[1])
y = np.append(y, tmp[2])
for i in range(q) :
if com[i] == 0 :
update(a, x[i], y[i])
elif com[i] == 1 :
print(find(a, x[i], y[i]))
if __name__ == '__main__' :
main() |
s265657852 | p02345 | u045830275 | 1512172731 | Python | Python3 | py | Runtime Error | 0 | 0 | 667 | import numpy as np
def update(a, i, x) :
a[i] = x
def find(a, s, t) :
return a[s:t+1].min()
def main() :
n, q = [int(i) for i in input().split()]
a = np.ones(n, dtype=int) * (2**31 - 1)
com = np.array([], dtype=int)
x = np.array([], dtype=int)
y= np.array([], dtype=int)
for _ in range(q) :
tmp = list(map(int, input().split()))
com = np.append(com, tmp[0])
x = np.append(x, tmp[1])
y = np.append(y, tmp[2])
for i in range(q) :
if com[i] == 0 :
update(a, x[i], y[i])
elif com[i] == 1 :
print(find(a, x[i], y[i]))
if __name__ == '__main__' :
main() |
s688292012 | p02345 | u045830275 | 1512172824 | Python | Python3 | py | Runtime Error | 0 | 0 | 667 | import numpy as np
def update(a, i, x) :
a[i] = x
def find(a, s, t) :
return a[s:t+1].min()
def main() :
n, q = [int(i) for i in input().split()]
a = np.ones(n, dtype=int) * (2**31 - 1)
com = np.array([], dtype=int)
x = np.array([], dtype=int)
y= np.array([], dtype=int)
for _ in range(q) :
tmp = list(map(int, input().split()))
com = np.append(com, tmp[0])
x = np.append(x, tmp[1])
y = np.append(y, tmp[2])
for i in range(q) :
if com[i] == 0 :
update(a, x[i], y[i])
elif com[i] == 1 :
print(find(a, x[i], y[i]))
if __name__ == '__main__' :
main() |
s778196395 | p02345 | u045830275 | 1512173230 | Python | Python3 | py | Runtime Error | 0 | 0 | 682 | import numpy
def update(a, i, x) :
a[i] = x
def find(a, s, t) :
return a[s:t+1].min()
def main() :
n, q = [int(i) for i in input().split()]
a = numpy.ones(n, dtype=int) * (2**31 - 1)
com = numpy.array([], dtype=int)
x = numpy.array([], dtype=int)
y= numpy.array([], dtype=int)
for _ in range(q) :
tmp = list(map(int, input().split()))
com = numpy.append(com, tmp[0])
x = numpy.append(x, tmp[1])
y = numpy.append(y, tmp[2])
for i in range(q) :
if com[i] == 0 :
update(a, x[i], y[i])
elif com[i] == 1 :
print(find(a, x[i], y[i]))
if __name__ == '__main__' :
main() |
s426657145 | p02345 | u011621222 | 1513253028 | Python | Python3 | py | Runtime Error | 0 | 0 | 2195 | # -*- coding: utf-8 -*-
# !/bin/python
import math
import itertools
INITER = 2**32-1
class sqrt_deco(object):
"""
>>> data = sqrt_deco(5, min)
>>> data.update(1, 2)
>>> data.raw_data
[INF, 2, INF]
>>> data.query(0, 2)
2
"""
def __init__(self, len_element: int, op=min):
self.len_element = len_element
self.op = op
self.raw_data = list(itertools.repeat(INITER, self.len_element))
self.deco_data = self.init_operation(self.raw_data)
def init_operation(self, raw_data):
index_size = int(math.ceil(math.sqrt(self.len_element)))
index = [i * index_size for i in range(index_size)]
_ = index.pop()
init_data = [self.op(raw_data[s: s+index_size]) for s in index]
return init_data
def update(self, target_index: int, target_data: int):
self.raw_data[target_index] = target_data
each_size = len(self.deco_data)
deco_index = int(math.floor(target_index/each_size))
self.deco_data[deco_index] = self.op(self.raw_data[each_size*deco_index: each_size *(deco_index+1)])
def query(self, start_pos: int, end_pos: int):
# 愚直に探すところを見つける
start_naive = (start_pos, len(self.deco_data)*int(math.ceil(start_pos/len(self.deco_data))))
end_naive = (len(self.deco_data)*int(math.ceil(end_pos/len(self.deco_data))), end_pos)
deco_check_index = (int(math.ceil(start_pos/len(self.deco_data))), int(math.ceil(end_pos/len(self.deco_data))))
target = self.deco_data[deco_check_index[0]: deco_check_index[1]]+self.raw_data[start_naive[0]:start_naive[1]]+self.raw_data[end_naive[0]:end_naive[1]]
return self.op(target)
if __name__ =='__main__':
num_element, query_num = zip(int(i) for i in input().split(' '))
data = sqrt_deco(num_element)
for i in range(query_num):
order, first, second = zip([int(i) for i in input()])
if order == 0:
data.update(first, second)
else order == 1:
print(data.query(first, second)) |
s726144582 | p02345 | u167493070 | 1524464346 | Python | Python3 | py | Runtime Error | 0 | 0 | 898 | import sys;
def init(n_):
length = 1;
while(length < n_):
length*=2
element=[0]*(2*length-1)
for i in range(2*length-1):
element[i] = initial
return element
def update(k,a,element):
k+=n
element[k]=a
while(k > 0):
k = (int)((k-1)/2)
element[k] = min(element[k*2+1],element[k*2+2])
def findmin(a, b):
return findquery(a,b+1,0,0,n)
def findquery(a, b, k, l, r):
if(r <= a or b <= l):
return initial
if(a <= l and r <= b):
return element[k]
vl = findquery(a,b,k*2+1,l,(int)((l+r)/2+0.5))
vr = findquery(a,b,k*2+2,(int)((l+r)/2),r)
return min(vl,vr)
n,q = map(int, input().split());
initial = pow(2,31)-1
element = init(n)
for i in range(q):
query,key,value = map(int, input().split());
if(query == 0):
update(key,value,element)
else :
print(findmin(key,value))
|
s039883523 | p02345 | u408284582 | 1524715844 | Python | Python3 | py | Runtime Error | 20 | 5612 | 909 | import sys
def initRMQ(n, D):
n_ = 1
while n_ < n:
n_ *= 2
for i in range(2*n_ - 1):
D.append(2147483647)
return n_
def update(k, a):
k += n_ - 1
D[k] = a
while k > 0:
k = int((k - 1) / 2)
D[k] = min(D[k*2 + 1], D[k*2 + 2])
def findMin(a, b):
return query(a, b + 1, 0, 0, n)
def query(a, b, k, l, r):
#print('q', a, b, k, l, r)
if r <= a or b <= l:
return 2147483647
if a <= l and r <= b:
return D[k]
vl = query(a, b, k*2 + 1, l, int((1 + r)/2))
vr = query(a, b, k*2 + 2, int((1 + r)/2), r)
return min(vl, vr)
if __name__ == '__main__':
n, q = map(int, input().split())
D = []
n_ = initRMQ(n, D)
for _ in range(q):
#print(D)
c, x, y = map(int, input().split())
if c == 0:
update(x, y)
else :
print(findMin(x, y))
|
s910351999 | p02345 | u408284582 | 1524716099 | Python | Python3 | py | Runtime Error | 20 | 5608 | 939 | import sys
sys.setrecursionlimit(10000)
def initRMQ(n, D):
n_ = 1
while n_ < n:
n_ *= 2
for i in range(2*n_ - 1):
D.append(2147483647)
return n_
def update(k, a):
k += n_ - 1
D[k] = a
while k > 0:
k = int((k - 1) / 2)
D[k] = min(D[k*2 + 1], D[k*2 + 2])
def findMin(a, b):
return query(a, b + 1, 0, 0, n)
def query(a, b, k, l, r):
#print('q', a, b, k, l, r)
if r <= a or b <= l:
return 2147483647
if a <= l and r <= b:
return D[k]
vl = query(a, b, k*2 + 1, l, int((1 + r)/2))
vr = query(a, b, k*2 + 2, int((1 + r)/2), r)
return min(vl, vr)
if __name__ == '__main__':
n, q = map(int, input().split())
D = []
n_ = initRMQ(n, D)
for _ in range(q):
#print(D)
c, x, y = map(int, input().split())
if c == 0:
update(x, y)
else :
print(findMin(x, y))
|
s884557689 | p02346 | u209989098 | 1531356990 | Python | Python3 | py | Runtime Error | 0 | 0 | 329 | a = list(map(int,input().split()))
b = []
ss = 1
f = 0
for i in range(a[0]):
k = int(input())
ss*= k
b.append(ss)
if k == 0:
print(a[0])
f = 1
break
k = 0
ss = 0
if f == 0:
for i in range(a[0]):
for j in range(a[0]-i):
k = b[a[0]-1-j] / b[i]
if k <= a[1]:
if a[0]-j-i >= ss:
ss = a[0]-i-j
print(ss)
|
s430855593 | p02346 | u209989098 | 1531358629 | Python | Python3 | py | Runtime Error | 0 | 0 | 251 | a = list(map(int,input().split()))
b = [0]*a[0]
for i in range(a[1]):
c = list(map(int,input().split()))
if c[0] == 0:
for j in range(a[0]-c[1]):
b[c[1]+j] += c[2]
else:
if c[1] == 1:
print(b[c[2]])
else:
print(b[c[2]]-b[c[1]-1])
|
s512387371 | p02346 | u938878704 | 1531659908 | Python | Python3 | py | Runtime Error | 20 | 5612 | 930 | n, q = map(int, input().split())
answer = []
# create segtree
size = 1
while size < n :
size *= 2
size = size * 2 - 1
segtree = [0 for x in range(size)]
# update query
def update(i, x) :
ind = size // 2 + i
segtree[ind] += x
while ind :
ind = (ind - 1) // 2 # parent
ch1 = segtree[ind * 2 + 1]
ch2 = segtree[ind * 2 + 2]
segtree[ind] = ch1 + ch2
def query(s, t, l, r, p) :
if s > r or t < l :
return 0
if s <= l and t >= r :
return segtree[p]
else :
vl = query(s, t, l, (l + r) // 2, p * 2 + 1)
vr = query(s, t, (l + r) // 2 + 1, r, p * 2 + 2)
return vl + vr
for i in range(q) :
# print("DBG : ", segtree)
com, x, y = map(int, input().split())
if com == 0 :
update(x, y)
else :
answer.append(query(x, y, 0, size // 2, 0))
for a in answer :
print(a)
|
s029476330 | p02346 | u197615397 | 1545375923 | Python | Python3 | py | Runtime Error | 0 | 0 | 934 | import sys
class BinaryIndexedTree(object):
__slots__ = ["tree"]
def __init__(self, size: int):
self.tree = [0]*(size+1)
def add(self, index: int, value: int) -> None:
tree = self.tree
next_index = index + 1
while next_index < len(tree):
tree[next_index] += value
next_index += next_index & -next_index
def sum(self, index: int):
tree, result = self.tree, 0
next_index = index + 1
while next_index:
result += tree[next_index]
next_index -= next_index & -next_index
return result
if __name__ == "__main__":
n, q = map(int, input().split())
bit = BinaryIndexedTree(n)
result = []
for com, x, y in (map(int, l.split()) for l in sys.stdin):
if not com:
bit.add(x, y)
else:
result.append(bit.sum(y) - bit.sum(x-1))
print(*result, sep="\n")
|
s572644725 | p02346 | u165578704 | 1556452780 | Python | Python3 | py | Runtime Error | 20 | 5612 | 1144 | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
INF=2**31-1
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
# [0, i]を合計する
def sum(self, i):
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
# 値の追加：添字, 値
def add(self, i, x):
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
# 区間和の取得 [l, r)
def get(self, l, r=None):
# 引数が1つなら一点の値を取得
if r is None: r = l+1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
N,Q=MAP()
bit=BIT(N)
for _ in range(Q):
com,x,y=MAP()
if com==0:
bit.add(x, y)
else:
print(bit.get(x, y+1))
|
s461155780 | p02346 | u284474275 | 1423980547 | Python | Python | py | Runtime Error | 20 | 4428 | 1209 | import sys
import itertools
class RSQ:
def __init__(self, n):
self.sz = 1
self.inf = (1 << 31) - 1
while self.sz < n: self.sz = self.sz << 1
self.dat = [0] * (2 * self.sz - 1)
def update(self, idx, x):
idx += self.sz - 1
self.dat[idx] += x
while idx > 0:
idx = (idx - 1) >> 1
self.dat[idx] += x
def query(self, a, b):
return self.query_help(a, b, 0, 0, self.sz)
def query_help(self, a, b, k, l, r):
if r <= a or b <= l:
return 0
elif a <= l and r <= b:
return self.dat[k]
else:
return self.query_help(a, b, 2 * k + 1, l, (l + r)>>1) + \
self.query_help(a, b, 2 * k + 2, (l + r) >> 1, r)
if __name__ == '__main__':
line = sys.stdin.readline()
n, q = line.split()
n, q = int(n), int(q)
rmq = RSQ(n)
for i in range(q):
line = sys.stdin.readline()
op, a, b = line.split()
op, a, b = int(op), int(a), int(b)
if op == 0:
rmq.update(a, b)
else:
sys.stdout.write(str(rmq.query(a, b + 1)) + '\n')
|
s900774801 | p02346 | u633068244 | 1432618207 | Python | Python | py | Runtime Error | 0 | 0 | 644 | class BIT:
def __init__(self, size):
self.size = size
self.bit = [0] * (size + 1)
# sum [0, i)
def sum(self, i):
s = 0
while (i > 0):
s += self.bit[i]
i -= i & -i
return s
# sum [i, j)
def sum_sec(self, i, j):
return self.sum(j) - self.sum(j)
def add(self, i, x):
i += 1
while (i <= self.size):
self.bit[i] += x
i += i & -i
n, q = map(int, raw_input().split())
bit = BIT(n)
for i in xrange(q):
c, x, y = map(int, raw_input().split())
if c == 0: bit.add(x - 1, y)
else: print bit.sum(x - 1, y) |
s253338269 | p02346 | u797673668 | 1455599225 | Python | Python3 | py | Runtime Error | 30 | 7772 | 626 | from math import sqrt, ceil
n, q = map(int, input().split())
unit = ceil(sqrt(n))
l = [(0, [0] * unit) for _ in range(unit)]
while q:
op, s, t = map(int, input().split())
sd, sm = s // unit, s % unit
if op:
td, tm = t // unit, t % unit
if sd == td:
print(sum(l[sd][1][sm:tm + 1]))
else:
unit_sum = sum((tup[0] for tup in l[sd + 1:td]))
s_sum = sum(l[sd][1][sm:])
t_sum = sum(l[td][1][:tm + 1])
print(unit_sum + s_sum + t_sum)
else:
tup = l[sd]
tup[1][sm] += t
l[sd] = (tup[0] + t, tup[1])
q -= 1 |
s827206961 | p02346 | u603049633 | 1497056324 | Python | Python3 | py | Runtime Error | 30 | 7796 | 1331 | import math, sys
#??°????????????????????§????¨????????????¨???????????°??????????????????????§????
class SegmentTree():
def __init__(self, n):
self.TreeRange = pow(2, math.ceil(math.log2(n)))
self.List = [0] * (2 * self.TreeRange - 1)
def add(self, i, x):
i += self.TreeRange - 1
self.List[i] += x
while i > 0:
i = (i - 1) // 2
self.List[i] += x
def getsum(self, s, t, i=0, left=0, right=float("inf")):
#??¢?´¢????±?????????????????????§????????°0????????????
if right <= s or t <= left:
return 0
#??¢?´¢????±?????????????????????§????????°??????????????????????????????
elif s <= left <= right <= t:
return self.List[i]
#??¢?´¢????±????????????????????????????????????°????????????????????°
else:
l = self.getsum(s, t, i * 2 + 1, left, (left + right) // 2)
r = self.getsum(s, t, i * 2 + 2, (left + right) // 2, right)
return l + r
_input = sys.stdin.readlines()
n,q = map(int, _input[0].split())
qlist = map(lambda x:x.split(), _input[1:])
ST = SegmentTree(n)
for q in qlist:
cmd, x, y = map(int, q)
if cmd == 0:
ST.add(x, y)
elif cmd == 1:
print(ST.getsum(x,y + 1, right = ST.TreeRange)) |
s189068407 | p02346 | u811733736 | 1506786549 | Python | Python3 | py | Runtime Error | 20 | 7804 | 2193 | # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_2_B&lang=jp
"""
import sys
from sys import stdin
input = stdin.readline
class RSQ(object):
INT_MAX = 2**31 - 1
def __init__(self, nn, init_val=0):
self.val = [init_val] * (nn+1)
self.n = 1
while self.n < nn:
self.n *= 2
self.dat = [init_val] * ((2 * self.n)-1)
def update(self, k, a):
# A[k]???a?????´??°?????????????????°???????????¨?????´??°
self.val[k] = a
k += (self.n - 1)
self.dat[k] = a
while k > 0:
k = (k - 1) // 2 # ??????index??????
self.dat[k] = self.dat[k * 2 + 1] + self.dat[k * 2 + 2]
def add(self, k, a):
self.val[k] += a
self.update(k, self.val[k])
def query(self, a, b, k, l, r):
# [a, b)???????°????????±??????? (0????????§b???????????????)
# ??????????????¨?????????query(a, b, 0, 0, n)?????¢??§??????????????????k, l, r???????????????????????´??°?????????
if r <= a or b <= l: # ?????????????????§??¨??????????????????
return RSQ.INT_MAX
if a ==l and r == b:
return self.dat[k] # ???????????°???????????????????????§????????°????????¨??????????????????????°?????????????????????????
else:
mid = (l+r) // 2
if b <= mid:
return self.query(a, b, k*2+1, l, (l+r)//2) # ????????°????????????????°????
elif a >= mid:
return self.query(a, b, k*2+2, (l+r)//2, r) # ????????°????????????????°????
else:
vl = self.query(a, mid, k*2+1, l, mid)
vr = self.query(mid, b, k*2+2, mid, r)
return vl + vr
def find(self, s, t):
return self.query(s, t+1, 0, 0, self.n)
def main(args):
n, q = map(int, input().split(' '))
rq = RSQ(n)
for _ in range(q):
com, x, y = map(int, input().split(' '))
if com == 0:
rq.add(x, y)
elif com == 1:
res = rq.find(x, y)
print(res)
if __name__ == '__main__':
main(sys.argv[1:]) |
s137982959 | p02346 | u798803522 | 1511706858 | Python | Python3 | py | Runtime Error | 30 | 7748 | 1515 | class RSQ:
def __init__(self, length, ini_num = float("inf")):
self.length = 1
self.ini_num = ini_num
while self.length < length:
self.length <<= 1
self.segtree = [ini_num] * (2 * self.length - 1)
def update(self, index, num):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = num
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = self.segtree[2 * leaf_index + 1] + self.segtree[2 * leaf_index + 2]
def add(self, index, num):
leaf_index = index + self.length - 1
self.segtree[leaf_index] += num
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = self.segtree[2 * leaf_index + 1] + self.segtree[2 * leaf_index + 2]
def call_search(self, a, b):
return self.search(a, b, index = 0, l = 0, r = self.length - 1)
def search(self, a, b, index, l, r):
if a <= l <= r <= b:
return self.segtree[index]
elif r < a or b < l:
return self.ini_num
else:
return self.search(a, b, index * 2 + 1, l, (l + r) // 2) + self.search(a, b, index * 2 + 2, (l + r) // 2 + 1, r)
v_num, query = map(int, input().split(" "))
rsq = RSQ(v_num, 0)
for _ in range(query):
comm, index, num = map(int, input().split(" "))
if comm == 0:
rsq.add(index, num)
else:
print(rsq.call_search(index, num)) |
s847665316 | p02346 | u798803522 | 1511707049 | Python | Python3 | py | Runtime Error | 20 | 7788 | 1550 | class RSQ:
def __init__(self, length, ini_num = float("inf")):
self.length = 1
self.ini_num = ini_num
if length == 1:
length = 2
while self.length < length:
self.length <<= 1
self.segtree = [ini_num] * (2 * self.length - 1)
def update(self, index, num):
leaf_index = index + self.length - 1
self.segtree[leaf_index] = num
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = self.segtree[2 * leaf_index + 1] + self.segtree[2 * leaf_index + 2]
def add(self, index, num):
leaf_index = index + self.length - 1
self.segtree[leaf_index] += num
while leaf_index > 0:
leaf_index = (leaf_index - 1) // 2
self.segtree[leaf_index] = self.segtree[2 * leaf_index + 1] + self.segtree[2 * leaf_index + 2]
def call_search(self, a, b):
return self.search(a, b, index = 0, l = 0, r = self.length - 1)
def search(self, a, b, index, l, r):
if a <= l <= r <= b:
return self.segtree[index]
elif r < a or b < l:
return self.ini_num
else:
return self.search(a, b, index * 2 + 1, l, (l + r) // 2) + self.search(a, b, index * 2 + 2, (l + r) // 2 + 1, r)
v_num, query = map(int, input().split(" "))
rsq = RSQ(v_num, 0)
for _ in range(query):
comm, index, num = map(int, input().split(" "))
if comm == 0:
rsq.add(index, num)
else:
print(rsq.call_search(index, num)) |
s811996675 | p02346 | u798087532 | 1511850895 | Python | Python3 | py | Runtime Error | 20 | 5612 | 1717 | class SegmentTree():
def __init__(self,n):
self.dat = [0 for _ in range(n*2-1)]
#index n???????????????????????¢?????????:
#???????????? : (n-1)//2
#???????????? : (2n+1) , (2n+2)
self.n = n
def update (self,node_index,value):
""" index?????????value????????´?????? """
index = node_index + (self.n-1) #node_index????????????dot???index?????????
self.dat[index] += value
#?????°????????????????????????????????´????????????
while index > 0 :
index = (index - 1) // 2 #???????????????????????£???
self.dat[index] = self.dat[index*2+1] + self.dat[index*2+2] #??????????????????????????????
def querry (self,left,right,nowNode,nowLeft,nowRight):
"""[left,right):??¢?´¢??????,noeNode:?????¨????????????,[nowLeft,nowRight):?????¨?????????????????????"""
# ??????????????¶??£????????????
if nowRight < left or nowLeft > right:
return 0
# ?????¨?????¢?´¢???????????¨????????????????????????????????????
if left <= nowLeft and nowRight <= right:
return self.dat[nowNode]
# ???????????????????????????????????¨???????????????
else:
value_left = self.querry(left,right,2*nowNode+1,nowLeft,(nowLeft+nowRight)//2)
value_right = self.querry(left,right,2*nowNode+2,(nowLeft+nowRight)//2+1,nowRight)
return (value_left + value_right)
def DEBUG_dat(self):
print(self.dat)
if __name__ == "__main__":
n ,q = map(int,input().split(" "))
result = []
for i in range(1,20):
if 2 ** i >= n:
min_pow2 = 2 ** i
break
tree = SegmentTree(min_pow2)
for i in range(q):
com,x,y = map(int,input().split(" "))
if com == 0:
tree.update(x,y)
else:
result.append(tree.querry(x,y,0,0,min_pow2-1))
for ans in result:
print(ans) |
s979840201 | p02346 | u167493070 | 1524466002 | Python | Python3 | py | Runtime Error | 20 | 5620 | 866 | import sys;
def init(n_):
length = 1;
while(length < n_):
length*=2
element=[0]*(2*length-1)
for i in range(2*length-1):
element[i] = 0
return element,length
def update(k,a,element):
k+=n-1
element[k]+=a
while(k > 0):
k = (int)((k-1)/2)
element[k] = element[k*2+1]+element[k*2+2]
def findmin(a, b):
return findquery(a,b+1,0,0,n)
def findquery(a, b, k, l, r):
if(r <= a or b <= l):
return 0
if(a <= l and r <= b):
return element[k]
vl = findquery(a,b,k*2+1,l,(int)((l+r)/2+0.5))
vr = findquery(a,b,k*2+2,(int)((l+r)/2),r)
return vl+vr
n,q = map(int, input().split());
element,n = init(n)
for i in range(q):
query,key,value = map(int, input().split());
if(query == 0):
update(key,value,element)
else :
print(findmin(key,value))
|
s872125585 | p02346 | u167493070 | 1524466783 | Python | Python3 | py | Runtime Error | 20 | 5620 | 866 | import sys;
def init(n_):
length = 1;
while(length < n_):
length*=2
element=[0]*(2*length-1)
for i in range(2*length-1):
element[i] = 0
return element,length
def update(k,a,element):
k+=n-1
element[k]+=a
while(k > 0):
k = (int)((k-1)/2)
element[k] = element[k*2+1]+element[k*2+2]
def findmin(a, b):
return findquery(a,b+1,0,0,n)
def findquery(a, b, k, l, r):
if(r <= a or b <= l):
return 0
if(a <= l and r <= b):
return element[k]
vl = findquery(a,b,k*2+1,l,(int)((l+r)/2+0.5))
vr = findquery(a,b,k*2+2,(int)((l+r)/2),r)
return vl+vr
n,q = map(int, input().split());
element,n = init(n)
for i in range(q):
query,key,value = map(int, input().split());
if(query == 0):
update(key,value,element)
else :
print(findmin(key,value))
|
s806848069 | p02346 | u167493070 | 1524467156 | Python | Python3 | py | Runtime Error | 20 | 5620 | 995 | import sys;
def init(n_):
length = 1;
while(length < n_):
length*=2
length2 = (2*length-2)
if(length2 == 0):
length2 = 1
element=[0]*length2
for i in range(length2):
element[i] = 0
return element,length
def update(k,a,element):
k+=n-1
if(n == 1):
k = 0
element[k]+=a
while(k > 0):
k = (int)((k-1)/2)
element[k] = element[k*2+1]+element[k*2+2]
def findmin(a, b):
return findquery(a,b+1,0,0,n)
def findquery(a, b, k, l, r):
if(r <= a or b <= l):
return 0
if(a <= l and r <= b):
return element[k]
vl = findquery(a,b,k*2+1,l,(int)((l+r)/2+0.5))
vr = findquery(a,b,k*2+2,(int)((l+r)/2),r)
return vl+vr
n,q = map(int, input().split());
element,n = init(n)
for i in range(q):
query,key,value = map(int, input().split());
if(query == 0):
update(key,value,element)
else :
if(n==1):
key = 0
print(findmin(key,value))
|
s714510095 | p02346 | u167493070 | 1524467187 | Python | Python3 | py | Runtime Error | 20 | 5624 | 995 | import sys;
def init(n_):
length = 1;
while(length < n_):
length*=2
length2 = (2*length-1)
if(length2 == 0):
length2 = 1
element=[0]*length2
for i in range(length2):
element[i] = 0
return element,length
def update(k,a,element):
k+=n-1
if(n == 1):
k = 0
element[k]+=a
while(k > 0):
k = (int)((k-1)/2)
element[k] = element[k*2+1]+element[k*2+2]
def findmin(a, b):
return findquery(a,b+1,0,0,n)
def findquery(a, b, k, l, r):
if(r <= a or b <= l):
return 0
if(a <= l and r <= b):
return element[k]
vl = findquery(a,b,k*2+1,l,(int)((l+r)/2+0.5))
vr = findquery(a,b,k*2+2,(int)((l+r)/2),r)
return vl+vr
n,q = map(int, input().split());
element,n = init(n)
for i in range(q):
query,key,value = map(int, input().split());
if(query == 0):
update(key,value,element)
else :
if(n==1):
key = 0
print(findmin(key,value))
|
s212959065 | p02346 | u265136581 | 1524566275 | Python | Python3 | py | Runtime Error | 20 | 5612 | 784 |
n, q = map(int, input().split())
n_ = 1 # 実際に確保した配列のサイズ
while n_ < n:
n_ *= 2
seg_tree = [0 for i in range(2*n_-1)]
def add(i, x):
i += n_ - 1
seg_tree[i] += x
while i > 0 :
i = int((i - 1)/2)
#seg_tree[i] = seg_tree[i*2+1] + seg_tree[i*2+2]
seg_tree[i] += x
def getSum(s, t):
return query(s, t+1, 0, 0, n_)
def query(a, b, k, l, r):
if r <= a or b <= l :
return 0
if a <= l and r <= b:
return seg_tree[k]
vl = query(a, b, k*2+1, l, int((l+r)/2))
vr = query(a, b, k*2+2, int((l+r)/2), r)
return vl + vr
output = []
for i in range(q):
line = list(map(int, input().split()))
if line[0] == 0:
add(line[1], line[2])
else :
output.append(getSum(line[1],line[2]))
for ans in output:
print(ans)
|
s517603430 | p02346 | u408284582 | 1524716955 | Python | Python3 | py | Runtime Error | 20 | 5612 | 879 | import sys
sys.setrecursionlimit(10000)
def initRMQ(n):
n_ = 1
while n_ < n:
n_ *= 2
D = [0] * (2*n_ - 1)
return n_, D
def update(k, a):
k += n_ - 1
D[k] += a
while k > 0:
k = int((k - 1) / 2)
D[k] = D[k*2 + 1] + D[k*2 + 2]
def findSum(a, b):
return query(a, b + 1, 0, 0, n_)
def query(a, b, k, l, r):
#print('q', a, b, k, l, r)
if r <= a or b <= l:
return 0
if a <= l and r <= b:
return D[k]
vl = query(a, b, k*2 + 1, l, int((l + r)/2))
vr = query(a, b, k*2 + 2, int((l + r)/2), r)
return vl + vr
if __name__ == '__main__':
n, q = map(int, input().split())
n_, D = initRMQ(n)
for _ in range(q):
#print(D)
c, x, y = map(int, input().split())
if c == 0:
update(x, y)
else :
print(findSum(x, y))
|
s213975908 | p02346 | u408284582 | 1524717281 | Python | Python3 | py | Runtime Error | 20 | 5608 | 915 | import sys
sys.setrecursionlimit(10000)
def initRMQ(n):
n_ = 1
while n_ < n:
n_ *= 2
D = []
for _ in range(2*n_ - 1):
D.append(0)
return n_, D
def update(k, a):
k += n_ - 1
D[k] += a
while k > 0:
k = int((k - 1) / 2)
D[k] = D[k*2 + 1] + D[k*2 + 2]
def findSum(a, b):
return query(a, b + 1, 0, 0, n_)
def query(a, b, k, l, r):
#print('q', a, b, k, l, r)
if r <= a or b <= l:
return 0
if a <= l and r <= b:
return D[k]
vl = query(a, b, k*2 + 1, l, int((l + r)/2))
vr = query(a, b, k*2 + 2, int((l + r)/2), r)
return vl + vr
if __name__ == '__main__':
n, q = map(int, input().split())
n_, D = initRMQ(n)
for _ in range(q):
#print(D)
c, x, y = map(int, input().split())
if c == 0:
update(x, y)
else :
print(findSum(x, y))
|
s782078099 | p02346 | u126478680 | 1528113373 | Python | Python3 | py | Runtime Error | 20 | 5696 | 1277 | import math
class SegmentTree():
def __init__(self, n):
self.n = n
self.height = math.ceil(math.log2(n))
self.nodes = [0 for i in range(pow(2, self.height+1)-1)]
self.leaf_start = pow(2, self.height)-1
def update(self, i, x):
pntr = self.leaf_start + i
self.nodes[pntr] += x
while True:
pntr = (pntr-1)//2
if pntr == -1: break
self.nodes[pntr] += x
def __query(self, s, t, k, l, r):
if t - s <= 0: return 0
if r <= s or t <= l: return 0
if l == s and t == r: return self.nodes[k]
else:
m = (l+r)//2
if t <= m:
return self.__query(s, t, k*2+1, l, m)
elif m <= s:
return self.__query(s, t, k*2+2, m, r)
else:
vl = self.__query(s, m, k*2+1, l, m)
vr = self.__query(m, t, k*2+2, m, r)
return vl + vr
def find(self, s, t):
return self.__query(s, t+1, 0, 0, pow(2, self.height))
n, q = list(map(int, input().split(' ')))
st = SegmentTree(n)
for i in range(q):
com, x, y = list(map(int, input().split(' ')))
if com == 0:
st.update(x, y)
elif com == 1:
print(st.find(x, y))
|
s812701358 | p02347 | u567380442 | 1427618547 | Python | Python3 | py | Runtime Error | 0 | 0 | 2370 | #???????????£?????§????????????????±???¨????????¢?????´?????????
def partition(data, l, r, pivotIndex, key):
pivotValue = key(data[pivotIndex])
data[pivotIndex], data[r] = data[r], data[pivotIndex]
storeIndex = l
for i in range(l, r):
if key(data[i]) < pivotValue:
data[storeIndex], data[i] = data[i], data[storeIndex]
storeIndex += 1
data[r], data[storeIndex] = data[storeIndex], data[r]
return storeIndex
from random import randint
# partition()??§data[pivot]???m????????§???????????¨????±???????
# n != m ????????°pivot???????????????????????????????????°?????????
# pivot?????????????????????????????´????????????O(nlog(n))????????????????????§???????????????????????????
def select(data, l, r, n, key):
while True:
pivot = randint(l, r)
m = partition(data, l, r, pivot, key)
if n == m:
return data[n]
elif n < m:
r = m - 1
else:
l = m + 1
import math
class twodtree:
def __init__(self, data):
self.data = [None] * (1 << (int(math.log(len(data), 2)) + 1))
self.update(data,(0, 1),0,len(data)-1)
def update(self, data, k, l, r, i=1):
if l > r:
return
if l == r:
self.data[i] = data[l]
return
m = (l + r) // 2
self.data[i] = select(data, l, r, m, itemgetter(*k))
k = (k[0],k[1])
self.update(data,k,l,m - 1,2 * i)
self.update(data,k,m + 1,r,2 * i + 1)
def find(self, s, t, k=0, i=1):
ret = []
if len(self.data) <= i or self.data[i] is None:
return ret
if s[0] <= self.data[i][0] <= t[0] and s[1] <= self.data[i][1] <= t[1]:
ret.append(self.data[i][2])
if s[k] <= self.data[i][k]:
ret.extend(self.find(s, t, k^1, 2 * i))
if self.data[i][k] <= t[k]:
ret.extend(self.find(s, t, k^1, 2 * i + 1))
return ret
from sys import stdin
readline = stdin.readline
n = int(readline())
xyi = [list(map(int, readline().split())) + [i] for i in range(n)]
two = twodtree(xyi)
print
q = int(readline())
for sx, tx, sy, ty in [map(int, readline().split()) for _ in range(q)]:
id = two.find((sx,sy),(tx,ty))
id.sort()
print('\n'.join(map(str, id)))
print() |
s940418566 | p02347 | u797673668 | 1455715739 | Python | Python3 | py | Runtime Error | 0 | 0 | 2890 | n = int(input())
def memoize(f):
global n
memo = [-1] * n
def main(x):
result = memo[x]
if result == -1:
result = memo[x] = f(x)
return result
return main
class Bound:
def __init__(self, sx, tx, sy, ty):
self.sx = sx
self.tx = tx
self.sy = sy
self.ty = ty
def contains(self, point):
return self.sx <= point[1] <= self.tx and self.sy <= point[2] <= self.ty
def update_intersection(self, intersection, point, horizontal):
sx, tx, sy, ty = intersection
div = point[2 if horizontal else 1]
if horizontal:
return (sx, tx, sy, self.ty >= div) if self.sy <= div else None, \
(sx, tx, self.sy <= div, ty) if self.ty >= div else None
else:
return (sx, self.tx >= div, sy, ty) if self.sx <= div else None, \
(self.sx <= div, tx, sy, ty) if self.tx >= div else None
class Kdt:
LIMIT_TREE_NODES = 2 ** 8 - 1
def __init__(self, n, points):
self.n = n
self.tree = [None] * n
self._build(0, points, n)
def _build(self, i, points, num):
depth = self.depth(i)
if num <= self.LIMIT_TREE_NODES:
self.tree[i] = (None, set(points) if depth >= 4 else None)
return
rnum = (num - 1) // 2
lnum = num - rnum - 1
xy_index = 2 if depth & 1 else 1
sorted_points = sorted(points, key=lambda p: p[xy_index])
self.tree[i] = (sorted_points[lnum], set(p[0] for p in points))
if lnum:
self._build(i * 2 + 1, sorted_points[:lnum], lnum)
if rnum:
self._build(i * 2 + 2, sorted_points[lnum + 1:], rnum)
def search(self, i, bound, intersection):
node = self.tree[i]
point = node[0]
if point is None:
return set(p[0] for p in node[1] if bound.contains(p))
if all(intersection):
return node[1]
result = {point[0]} if bound.contains(point) else set()
li, ri = i * 2 + 1, i * 2 + 2
if li < self.n:
lis, ris = bound.update_intersection(intersection, point, self.depth(i) & 1)
if lis:
result |= self.search(li, bound, lis)
if ris and ri < self.n:
result |= self.search(ri, bound, ris)
return result
@staticmethod
@memoize
def depth(x):
""" x>=0 """
i, x = 0, (x + 1) // 2
while x:
x //= 2
i += 1
return i
point_list = [(i,) + tuple(map(int, input().split())) for i in range(n)]
kdt = Kdt(n, point_list)
q = int(input())
while q:
inside_points = kdt.search(0, Bound(*map(int, input().split())), tuple([False] * 4))
if inside_points:
print('\n'.join(map(str, sorted(inside_points))))
print()
q -= 1 |
s152411244 | p02347 | u669284080 | 1466693547 | Python | Python3 | py | Runtime Error | 0 | 0 | 953 | import sys
import stdin
import math
from operator import itemgetter
from bisect import bisect_left, bisect_right
readline = stdin.readline
# main
n = int(readline())
xy = [tuple(map(int, readline().split())) + (i,) for i in range(n)]
# [..., (x_i, y_i, i), ...]
# sort by x
xy.sort()
root = int(math.sqrt(len(xy)))
low = [x for x, y, i in xy[::root]]
high = [x for x, y, i in xy[root - 1::root]] + [float('inf')]
xy = [sorted(xy[i:i + root], key=itemgetter(1)) for i in range(0, len(xy), root)]
xy = [([y for x, y, i in xyi], xyi) for xyi in xy]
for sx, tx, sy, ty in (map(int, readline().split()) for _ in range(int(readline()))):
ret = []
for i in range(bisect_left(high, sx), bisect_right(low, tx)):
k, v = xy[i]
for i in range(bisect_left(k, sy), bisect_right(k, ty)):
if sx <= v[i][0] <=tx:
ret.append(v[i][2])
if ret:
ret.sort()
print('\n'.join(map(str,ret)))
print() |
s308356622 | p02347 | u072053884 | 1468811852 | Python | Python3 | py | Runtime Error | 0 | 0 | 1427 | import sys
i_f = sys.stdin
n = int(i_f.readline())
T = [[i, *map(int, i_f.readline().split()), None, None] for i in range(n)]
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n[1])
else:
T[l:r] = sorted(T[l:r], key=lambda n: n[2])
T[mid][3] = make2DTree(l, mid, depth + 1)
T[mid][4] = make2DTree(mid + 1, r, depth + 1)
return mid
make2DTree(0, n, 0)
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(v, sx, tx, sy, ty, depth):
node = T[v]
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] != None and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] != None and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(v, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
v = n // 2
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print(*Ans, sep='\n') |
s272670205 | p02347 | u072053884 | 1468811894 | Python | Python3 | py | Runtime Error | 0 | 0 | 1427 | import sys
i_f = sys.stdin
n = int(i_f.readline())
T = [[i, *map(int, i_f.readline().split()), None, None] for i in range(n)]
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n[1])
else:
T[l:r] = sorted(T[l:r], key=lambda n: n[2])
T[mid][3] = make2DTree(l, mid, depth + 1)
T[mid][4] = make2DTree(mid + 1, r, depth + 1)
return mid
make2DTree(0, n, 0)
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(v, sx, tx, sy, ty, depth):
node = T[v]
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] != None and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] != None and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(v, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
v = n // 2
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print(*Ans, sep='\n') |
s454826044 | p02347 | u072053884 | 1468812982 | Python | Python3 | py | Runtime Error | 0 | 0 | 1427 | import sys
i_f = sys.stdin
n = int(i_f.readline())
T = [[i, *map(int, i_f.readline().split()), None, None] for i in range(n)]
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n[1])
else:
T[l:r] = sorted(T[l:r], key=lambda n: n[2])
T[mid][3] = make2DTree(l, mid, depth + 1)
T[mid][4] = make2DTree(mid + 1, r, depth + 1)
return mid
make2DTree(0, n, 0)
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(v, sx, tx, sy, ty, depth):
node = T[v]
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] != None and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] != None and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(v, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
v = n // 2
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print(*Ans, sep='\n') |
s453928793 | p02347 | u072053884 | 1468813452 | Python | Python3 | py | Runtime Error | 0 | 0 | 1426 | import sys
i_f = sys.stdin
n = int(i_f.readline())
T = [[i, map(int, i_f.readline().split()), None, None] for i in range(n)]
def make2DTree(l, r, depth):
if l >= r:
return None
mid = (l + r) // 2
if depth % 2 == 0:
T[l:r] = sorted(T[l:r], key=lambda n: n[1])
else:
T[l:r] = sorted(T[l:r], key=lambda n: n[2])
T[mid][3] = make2DTree(l, mid, depth + 1)
T[mid][4] = make2DTree(mid + 1, r, depth + 1)
return mid
make2DTree(0, n, 0)
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(v, sx, tx, sy, ty, depth):
node = T[v]
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] != None and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] != None and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(v, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
v = n // 2
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print(*Ans, sep='\n') |
s483124363 | p02347 | u072053884 | 1469002305 | Python | Python3 | py | Runtime Error | 4330 | 93472 | 1734 | import sys
i_f = sys.stdin
n = int(i_f.readline())
T = []
for i in range(n):
x, y = map(int, i_f.readline().split())
# [0] is input number.
# [3] is left node, and [4] is right node.
T.append([i, x, y, None, None])
def partition(A, l, r, key):
x = A[r][key]
i = l - 1
for j in range(l, r):
if A[j][key] <= x:
i += 1
A[i], A[j] = A[j], A[i]
A[i + 1], A[r] = A[r], A[i + 1]
return i + 1
def make2DTree(l, r, depth):
if l == r:
return None
if depth % 2 == 0:
separator = partition(T, l, r - 1, 1)
else:
separator = partition(T, l, r - 1, 2)
T[separator][3] = make2DTree(l, separator, depth + 1)
T[separator][4] = make2DTree(separator + 1, r, depth + 1)
return T[separator]
root_node = make2DTree(0, n, 0)
Ans = []
def range_search(sx, tx, sy, yx):
ans = []
def _find(node, sx, tx, sy, ty, depth):
x = node[1]
y = node[2]
if sx <= x <= tx and sy <= y <= ty:
ans.append(node[0])
if depth % 2 == 0:
if node[3] and sx <= x:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and x <= tx:
_find(node[4], sx, tx, sy, ty, depth + 1)
else:
if node[3] and sy <= y:
_find(node[3], sx, tx, sy, ty, depth + 1)
if node[4] and y <= ty:
_find(node[4], sx, tx, sy, ty, depth + 1)
_find(root_node, sx, tx, sy, ty, 0)
if ans:
ans.sort()
Ans.extend(ans)
Ans.append('')
q = int(i_f.readline())
for l in i_f:
sx, tx, sy, ty = map(int, l.split())
range_search(sx, tx, sy, ty)
print('\n'.join(map(str, Ans))) |
s693126703 | p02347 | u022407960 | 1480097982 | Python | Python3 | py | Runtime Error | 30 | 8076 | 2312 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
from sys import stdin
from operator import attrgetter
from collections import namedtuple
class Node(object):
__slots__ = ('location', 'left', 'right')
def __init__(self):
self.location = -1
self.left, self.right = None, None
def make2DTree(left, right, depth):
global np
if not left < right:
return None
mid = (left + right) // 2
cursor = np
np += 1
if depth % 2 == 0:
points_list[left:right] = sorted(points_list[left:right], key=attrgetter('x'))
else:
points_list[left:right] = sorted(points_list[left:right], key=attrgetter('y'))
node_list[cursor].location = mid
node_list[cursor].left = make2DTree(left, mid, depth + 1)
node_list[cursor].right = make2DTree(mid + 1, right, depth + 1)
return cursor
def find(v, sx, tx, sy, ty, depth):
_point = points_list[node_list[v].location]
x, y, p_index = _point.x, _point.y, _point.i
if (sx <= x <= tx) and (sy <= y <= ty):
ans.append(p_index)
if depth % 2 == 0:
if node_list[v].left is not None and sx <= x:
find(node_list[v].left, sx, tx, sy, ty, depth + 1)
if node_list[v].right is not None and x <= tx:
find(node_list[v].right, sx, tx, sy, ty, depth + 1)
else:
if node_list[v].left is not None and sy <= y:
find(node_list[v].left, sx, tx, sy, ty, depth + 1)
if node_list[v].right is not None and y <= ty:
find(node_list[v].right, sx, tx, sy, ty, depth + 1)
return None
def action():
global ans
for area in areas:
sx, tx, sy, ty = map(int, area)
find(root, sx, tx, sy, ty, 0)
print(*sorted(ans), sep='\n')
print('')
ans = []
return None
if __name__ == '__main__':
_input = stdin.readlines()
points_num = int(_input[0])
point = namedtuple('Point', 'i x y')
points_list = [point(i=index, x=int(each[0]), y=int(each[2])) for index, each in
enumerate(_input[1:points_num + 1])]
areas_num = int(_input[points_num + 1])
areas = map(lambda x: x.split(), _input[points_num + 2:])
node_list = [Node() for _ in range(points_num)]
np = 0
ans = []
root = make2DTree(0, points_num, 0)
action() |
s454903032 | p02347 | u848688448 | 1488113691 | Python | Python3 | py | Runtime Error | 0 | 0 | 1625 | import sys
readline = sys.stdin.readline
from bisect import bisect, bisect_right
from itertools import chain
n = input()
n0 = 2**n.bit_length()
data = [None]*(n0*2)
# ?????°???????????¨????§????
def init(k, l, r):
if r - l == 1:
data[k] = [ys[l]]
else:
le = 2*k+1; ri = 2*k+2
init(le, l, (l+r)/2)
init(ri, (l+r)/2, r)
# ????????????????´????merge??????
# (heapq.merge??????????????????list???????????¨????????????)
# --> list(heapq.merge(data[le], data[ri]))
data[k] = sorted(chain(data[le], data[ri]))
# [a, b)???????????????x??\??????????´??????????
def query(a, b, x, k, l, r):
if b<=l or r<=a:
return []
if a<=l and r<=b:
d = data[k]
idx = bisect_right(d, x)
return d[:idx]
lc = query(a, b, x, 2*k+1, l, (l+r)/2)
rc = query(a, b, x, 2*k+2, (l+r)/2, r)
return lc + rc
def solve(a, b, x):
return query(a, b, x, 0, 0, n)
ps = [map(int, (readline() + " %d"%i).split()) for i in xrange(n)]
ps.sort()
xs = [x for x, y, i in ps]
ys = [(y, i) for x, y, i in ps]
init(0, 0, n)
q = input()
for i in xrange(q):
sx, tx, sy, ty = map(int, readline().split())
# x??§??¢?´¢??????????????????????´?(l_idx)??¨?????????????´?(r_idx)????±???????
l_idx = bisect(xs, sx-1)
r_idx = bisect_right(xs, tx)
# x??§?????£???????´??????????sy <= y <= ty??¨??????(x, y)???????????????
T = set(i for y, i in solve(l_idx, r_idx, (ty, n)))
S = set(i for y, i in solve(l_idx, r_idx, (sy-1, n)))
ans = list(T-S)
ans.sort()
for e in ans:
print e
print |
s633520713 | p02347 | u796784914 | 1509168203 | Python | Python | py | Runtime Error | 10 | 6444 | 849 | from operator import itemgetter
from bisect import bisect_left, bisect_right
import sys
def main():
n = int(sys.stdin.readline())
keys = map(lambda i:map(int,sys.stdin.readline().split())+[i],xrange(n))
keys.sort()
q = int(sys.stdin.readline())
for i in xrange(q):
x0,x1,y0,y1 = map(int,sys.stdin.readline().split())
key_x,key_y,ids = zip(*keys)
interval = xrange(bisect_left(key_x,x0),bisect_right(key_x,x1))
key1 = map(lambda j:[key_x[j],key_y[j],ids[j]],interval)
key1.sort(key=itemgetter(1))
key_x,key_y,ids = zip(*key1)
interval = xrange(bisect_left(key_y,y0),bisect_right(key_y,y1))
ids = map(lambda j:ids[j],interval)
ids.sort()
map(lambda x: sys.stdout.write("{}\n".format(x)),ids)
print ("")
if __name__ == "__main__":
main() |
s572414264 | p02347 | u526040679 | 1518504678 | Python | Python3 | py | Runtime Error | 0 | 0 | 1693 | import numpy as np
n = int(input())
xy = []
for i in range(n):
x,y = [int(i) for i in input().split()]
xy.append([x,y,i])
xy = np.array(sorted(xy))
q = int(input())
for i in range(q):
sx,tx,sy,ty = [int(i) for i in input().split()]
ans = kdtree(xy,sx,tx,sy,ty)
for i in ans:
print(int(i))
print("\n")
def kdtree(xy,sx,tx,sy,ty):
x_i = np.array(binary_search(xy[0:,0],sx,0))
x_i = min(x_i)
print(x_i)
x_j = np.array(binary_search(xy[x_i:,0],tx,1))
x_j += x_i
x_j = max(x_j)
print(x_j)
ans = []
for k in range(x_i,x_j+1):
if sy <= xy[k,1] <= ty:
ans.append(xy[k,2])
return(sorted(ans))
def binary_search(array, p, min_or_max):
end = len(array)
i = end // 2
while array[i]!=p or i==0 or i==end-1:
if array[i] > p:
if i==0:
break
if array[i-1] < p:
if min_or_max==0:
return([i-1])
else:
return([i])
i = i // 2
continue
if array[i] < p:
if i==end-1:
break
if array[i+1] > p:
if min_or_max==0:
return([i])
else:
return([i+1])
i += (end-i) // 2
continue
if array[i]!=p:
if i==0:
return([0])
if i==end-1:
return([end-1])
min_,max_ = i,i
while array[min_-1]==p:
min_ -= 1
while array[max_+1]==p:
max_ += 1
if min_==max_:
return([i])
else:
return(np.arange(min_,max_+1))
|
s116214593 | p02347 | u526040679 | 1518505560 | Python | Python3 | py | Runtime Error | 0 | 0 | 1696 | import numpy as np
def kdtree(xy,sx,tx,sy,ty):
x_i = np.array(binary_search(xy[0:,0],sx,0))
x_i = min(x_i)
print(x_i)
x_j = np.array(binary_search(xy[x_i:,0],tx,1))
x_j += x_i
x_j = max(x_j)
print(x_j)
ans = []
for k in range(x_i,x_j+1):
if sy <= xy[k,1] <= ty:
ans.append(xy[k,2])
return(sorted(ans))
def binary_search(array, p, min_or_max):
end = len(array)
i = end // 2
while array[i]!=p or i==0 or i==end-1:
if array[i] > p:
if i==0:
break
if array[i-1] < p:
if min_or_max==0:
return([i-1])
else:
return([i])
i = i // 2
continue
if array[i] < p:
if i==end-1:
break
if array[i+1] > p:
if min_or_max==0:
return([i])
else:
return([i+1])
i += (end-i) // 2
continue
if array[i]!=p:
if i==0:
return([0])
if i==end-1:
return([end-1])
min_,max_ = i,i
while array[min_-1]==p:
min_ -= 1
while array[max_+1]==p:
max_ += 1
if min_==max_:
return([i])
else:
return(np.arange(min_,max_+1))
n = int(input())
xy = []
for i in range(n):
x,y = [int(j) for j in input().split()]
xy.append([x,y,i])
print(xy)
xy = np.array(sorted(xy))
q = int(input())
for i in range(q):
sx,tx,sy,ty = [int(j) for j in input().split()]
ans = kdtree(xy,sx,tx,sy,ty)
for i in ans:
print(i)
print("\n")
|
s933389403 | p02347 | u662418022 | 1518936903 | Python | Python3 | py | Runtime Error | 0 | 0 | 1821 | # -*- coding: utf-8 -*-
from IPython import embed
class Node():
def __init__(self, loc=None, left=None, right=None):
self.loc = loc
self.l = left
self.r = right
class Point():
def __init__(self, id, xy):
self.id = int(id)
self.x = int(xy[0])
self.y = int(xy[1])
if __name__ == '__main__':
n = int(input())
P = [Point(i, input().split(" ")) for i in range(n)]
q = int(input())
Q = [list(map(int, input().split(" "))) for _ in range(q)]
T = [None]*n
np = 0
def make2DTree(l, r, depth):
global np
if l >= r:
return None
mid = (l+r)//2
t = np
np += 1
if depth%2 == 0:
P[l:r].sort(key=lambda p:p.x)
else:
P[l:r].sort(key=lambda p:p.y)
T[t] = Node(loc=mid)
T[t].l = make2DTree(l, mid, depth+1)
T[t].r = make2DTree(mid+1, r, depth+1)
return t
def find(v, sx, tx, sy, ty, depth, ans):
x = P[T[v].loc].x
y = P[T[v].loc].y
if (sx <= x <= tx) and (sy <= y <= ty):
ans.append(P[T[v].loc].id)
if depth%2 == 0:
if T[v].l is not None and sx <= x:
find(T[v].l, sx, tx, sy, ty, depth+1, ans)
if T[v].r is not None and x <= tx:
find(T[v].r, sx, tx, sy, ty, depth+1, ans)
else:
if T[v].l is not None and sy <= y:
find(T[v].l, sx, tx, sy, ty, depth+1, ans)
if T[v].r is not None and y <= ty:
find(T[v].r, sx, tx, sy, ty, depth+1, ans)
root = make2DTree(0, n, 0)
for sx, tx, sy, ty in Q:
ans = []
find(root, sx, tx, sy, ty, 0, ans)
ans.sort()
print("\n".join(map(str, ans)))
print("")
|
s495367618 | p02347 | u662418022 | 1518938878 | Python | Python3 | py | Runtime Error | 0 | 0 | 1850 | # -*- coding: utf-8 -*-
class Node():
def __init__(self, loc=None, left=None, right=None):
self.loc = loc
self.l = left
self.r = right
class Point():
def __init__(self, id, xy):
self.id = int(id)
self.x = int(xy[0])
self.y = int(xy[1])
if __name__ == '__main__':
n = int(input())
P = [Point(i, input().split(" ")) for i in range(n)]
q = int(input())
Q = [list(map(int, input().split(" "))) for _ in range(q)]
T = [None] * n
def make2DTree(l, r, depth):
global np
#if l >= r:
# return None
mid = (l + r) // 2
t = np
np += 1
if depth % 2 == 0:
P[l:r] = sorted(P[l:r], key=lambda p: p.x)
else:
P[l:r] = sorted(P[l:r], key=lambda p: p.y)
T[t] = Node(loc=mid)
T[t].l = make2DTree(l, mid, depth + 1)
T[t].r = make2DTree(mid + 1, r, depth + 1)
return t
def find(v, sx, tx, sy, ty, depth, ans):
x = P[T[v].loc].x
y = P[T[v].loc].y
if (sx <= x <= tx) and (sy <= y <= ty):
ans.append(P[T[v].loc].id)
if depth % 2 == 0:
if T[v].l is not None and sx <= x:
find(T[v].l, sx, tx, sy, ty, depth + 1, ans)
if T[v].r is not None and x <= tx:
find(T[v].r, sx, tx, sy, ty, depth + 1, ans)
else:
if T[v].l is not None and sy <= y:
find(T[v].l, sx, tx, sy, ty, depth + 1, ans)
if T[v].r is not None and y <= ty:
find(T[v].r, sx, tx, sy, ty, depth + 1, ans)
np = 0
root = make2DTree(0, n, 0)
for sx, tx, sy, ty in Q:
ans = []
find(root, sx, tx, sy, ty, 0, ans)
ans.sort()
if ans:
print("\n".join(map(str, ans)))
print("")
|
s533935115 | p02348 | u241923784 | 1556441436 | Python | Python3 | py | Runtime Error | 20 | 5680 | 801 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[i]=lazy[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,min(y,(x/b+1)*b)):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s049172387 | p02348 | u241923784 | 1556441499 | Python | Python3 | py | Runtime Error | 20 | 5684 | 806 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[i]=lazy[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s873325607 | p02348 | u241923784 | 1556441551 | Python | Python3 | py | Runtime Error | 20 | 5684 | 808 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),int(min(n-1,(x+1)*b))):a[i]=l[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s230834586 | p02348 | u241923784 | 1556441580 | Python | Python3 | py | Runtime Error | 0 | 0 | 804 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),(min(n-1,(x+1)*b)):a[i]=l[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s566397696 | p02348 | u241923784 | 1556441610 | Python | Python3 | py | Runtime Error | 20 | 5684 | 803 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[i]=l[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s696016686 | p02348 | u241923784 | 1556441648 | Python | Python3 | py | Runtime Error | 20 | 5684 | 808 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[int(i)]=l[x]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s886145806 | p02348 | u241923784 | 1556441690 | Python | Python3 | py | Runtime Error | 20 | 5688 | 808 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[i]=l[int(x)]
l[x]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s597574674 | p02348 | u241923784 | 1556441723 | Python | Python3 | py | Runtime Error | 20 | 5688 | 813 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def update(x):
for i in range(int(x*b),min(n-1,(x+1)*b)):a[i]=l[int(x)]
l[int(x)]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(max(x,y/b**2)),y+1):a[i]=z
|
s125126883 | p02348 | u241923784 | 1556442123 | Python | Python3 | py | Runtime Error | 0 | 0 | 969 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def judge_max(x,y):
if x > y :return x
else:return y
def judge_min(x,y):
if x > y :return y
else return x
def update(x):
for i in range(int(x*b),int(judge_min(n-1,(x+1)*b))):a[i]=l[int(x)]
l[int(x)]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(judge_min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(judge_max(x,y/b**2)),y+1):a[i]=z
|
s547663254 | p02348 | u241923784 | 1556442371 | Python | Python3 | py | Runtime Error | 0 | 0 | 967 | import math
INT_MAX = 2147483647
MAX = 100003
n,q=(int(x) for x in input().split())
b= math.sqrt(n)
def judge_max(x,y):
if x > y :return x
else:return y
def judge_min(x,y):
if x > y :return y
else :return x
def update(x):
for i in range(int(x*b),int(judge_min(n-1,(x+1)*b))):a[i]=l[int(x)]
l[int(x)]=-1;
return;
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for i in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,int(judge_min(y,(x/b+1)*b))):a[i]=z
for i in range(int(x/b)+1,int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(int(judge_max(x,y/b**2)),y+1):a[i]=z
|
s133771397 | p02348 | u241923784 | 1556448467 | Python | Python | py | Runtime Error | 0 | 0 | 833 | import math
INT_MAX = 2147483647
n,q=(int(x) for x in input().split())
b= int(math.sqrt(n))
def update(x_f):
x = int(x_f)
for i in range(int(x*b),min(n-1,int((x+1)*b-1))+1):a[i]=l[x]
l[x]=-1
return
if __name__=='__main__':
a = [INT_MAX for i in range(n)]
l = [-1 for i in range(n)]
for j in range(q):
t, *com = (int(x) for x in input().split())
if t :
x = com[0]
if l[int(x/b)] != -1:update(x/b)
print(a[x])
else:
x,y,z = com
if l[int(x/b)] != -1:update(x/b)
for i in range(x,min(y,int((x/b+1)*b-1))+1):a[i]=z
for i in range(int(x/b+1),int(y/b)):l[i]=z
if l[int(y/b)] != -1:update(y/b)
for i in range(max(x,int(y/b**2)),y+1):a[i]=z
|
s532132769 | p02350 | u464454066 | 1556165338 | Python | Python | py | Runtime Error | 0 | 0 | 2000 | import sys
import math
import time
sys.setrecursionlimit(20000)
INT_MAX = 2**31 - 1
def lazy_tree_merge(lazy,tree,i,N):
if(lazy[i] is not None):
tree[i] = lazy[i]
if(i < N-1):
lazy[i*2+1] = lazy[i]
lazy[i*2+2] = lazy[i]
lazy[i] = None
def update(tree,lazy,x,y,k,l,r,i,z,N):
if (r <= x or y <= l):
lazy_tree_merge(lazy,tree,k,N)
return True
if ( x <= l and r <= y):
lazy[k] = z
lazy_tree_merge(lazy,tree,k,N)
return True
lazy_tree_merge(lazy,tree,k,N)
center = int((l+r)/2)
update(tree, lazy, x, y, k*2 + 1, l, center, i, z, N)
#update(tree, lazy, x, y, k*2 + 2, l, int((l+r)/2), i, z, N)
update(tree, lazy, x, y, k*2 + 2, center, r, i, z, N)
tree[k] = min(tree[k*2+1],tree[k*2+2])
def find(tree,lazy,x,y,k,l,r,N):
if (r <= x or y <= l):
return INT_MAX
if ( x <= l and r <= y):
lazy_tree_merge(lazy,tree,k,N)
return tree[k]
lazy_tree_merge(lazy,tree,k,N)
v_left = find(tree, lazy_A, x, y, k*2 + 1, l, int((l+r)/2), N)
v_right = find(tree, lazy_A, x, y, k*2 + 2, int((l+r)/2), r, N)
#print(v_left)
#print(v_right)
return min(v_left, v_right)
if __name__ == '__main__':
_N,query_num = map(int, input().split())
N = 1
while True:
if(N >= _N):
break
N <<= 1
if not (N == 1):
A = [INT_MAX]*(2*N - 1)
lazy_A = [None]*(2*N - 1)
else:
A = [INT_MAX]*(2*N)
lazy_A = [None]*(2*N)
#start = time.time()
for i in range(query_num):
query = list(map(int,input().split()))
# update
if(query[0]==0):
update(A,lazy_A,query[1],query[2]+1,0,0,N,i,query[3],N)
#print(A,lazy_A)
# find
if(query[0]==1):
z = find(A,lazy_A,query[1],query[2]+1,0,0,N,N)
print(z)
#elapsed_time = time.time() - start
#print ("elapsed_time:{0}".format(elapsed_time) + "[sec]")
|
s095827480 | p02350 | u197615397 | 1499912203 | Python | Python3 | py | Runtime Error | 30 | 7964 | 3953 | import math
class SegmentTree:
__slots__ = ["elem_size", "tree_size", "tree", "lazy"]
def __init__(self, a: list, default: int):
real_size = len(a)
self.elem_size = 1 << math.ceil(math.log2(real_size))
self.tree_size = 2 * self.elem_size
self.tree = [default]*self.elem_size + a + [default]*(self.elem_size - real_size)
self.lazy = [None]*self.tree_size
self.init_tree()
def init_tree(self):
tree = self.tree
for i in range(self.elem_size-1, 0, -1):
left, right = tree[i << 1], tree[(i << 1)+1]
# ===== change me =====
tree[i] = left if left < right else right
def get_indexes(self, l: int, r: int):
'''[x, y)'''
l, r, indexes = l+self.elem_size, r+self.elem_size, []
append = indexes.append
while l < r:
if l & 1:
append(l)
l += 1
if r & 1:
r -= 1
append(r)
l, r = l >> 1, r >> 1
return indexes
def get_indexes_with_propagation(self, l: int, r: int, current_node: int, l_end: int, r_end: int):
# print(l,r,current_node,l_end,r_end,self.lazy[current_node])
indexes = []
tree, lazy = self.tree, self.lazy
lazy_value = lazy[current_node]
left_child, right_child = current_node << 1, (current_node << 1) + 1
if lazy_value is not None:
self.lazy[current_node] = None
tree[current_node] = lazy_value
if left_child < self.tree_size:
if left_child < self.elem_size:
lazy[left_child] = lazy[right_child] = lazy_value
else:
tree[left_child] = tree[right_child] = lazy_value
if l == l_end and r == r_end:
return [current_node]
mid = (l_end + r_end) // 2
if l < mid:
l_r = r if r < mid else mid
indexes += self.get_indexes_with_propagation(l, l_r, left_child, l_end, mid)
if r > mid:
r_l = l if mid < l else mid
indexes += self.get_indexes_with_propagation(r_l, r, right_child, mid, r_end)
return indexes
def update_lazy(self, l, r, value):
indexes = sorted(self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size))
l = self.elem_size
lazy, tree = self.lazy, self.tree
for n in indexes:
lazy[n] = None
if n < l//2:
lazy[n << 1] = value
lazy[(n << 1)+1] = value
elif n < l:
tree[n << 1] = value
tree[(n << 1)+1] = value
else:
tree[n] = value
self.update_tree(n)
def get_value(self, l: int, r: int):
tree = self.tree
index_list = self.get_indexes_with_propagation(l, r, 1, 0, self.elem_size)
# ===== change me =====
return min(tree[n] for n in index_list)
def update_tree(self, k: int):
tree, lazy = self.tree, self.lazy
if k > self.elem_size:
k >>= 1
while k > 1:
left, right = k << 1, (k << 1)+1
left_value = lazy[left] or tree[left]
right_value = lazy[right] or tree[right]
# ===== change me =====
tree[k] = left_value if left_value < right_value else right_value
k >>= 1
def set_value(self, i: int, value: int, op: str):
k = self.elem_size + i
if op == "=":
self.tree[k] = value
elif op == "+":
self.tree[k] += value
self.update_tree(k)
n, q = map(int, input().split())
rmq = SegmentTree([2**31-1]*n, 2**31-1)
ans = []
for _ in [0]*q:
l = list(map(int, input().split()))
if l[0] == 0:
rmq.update_lazy(l[1], l[2]+1, l[3])
else:
ans.append(rmq.get_value(l[1], l[2]+1))
print("\n".join([str(n) for n in ans])) |
s898550138 | p02354 | u176732165 | 1476548586 | Python | Python | py | Runtime Error | 0 | 0 | 453 | import sys
INF = (sys.maxint)/3
def SmallestWindow(S, a_list):
i = 0
j = 0
tmpS = 0
res = INF
while 1 :
while tmpS < S and i <len(a_list):
i +=1
tmpS += a_list[i]
if (tmpS <S):
break
res = min (res, i-j)
j += 1
tmpS -=a_list[j]
if res == INF:
res = 0
return res
def main():
N, S = map(int, raw_input().split())
a_list = map(int, raw_input().split())
print SmallestWindow(S, a_list)
if __name__ == '__main__':
main() |
s663983628 | p02354 | u728137020 | 1525817079 | Python | Python3 | py | Runtime Error | 0 | 0 | 277 | A=map(int,raw_input().split())
list=[]
sum=0
S=1e6+1
for i in map(int,raw_input().split()):
list.append(i)
sum+=i
if sum>A[1]:
while sum>=A[1]:
sum-=list.popleft()
S=min(S,len(list)+1)
if S==1e6+1:
print("0")
else:
print(S)
|
s011332754 | p02354 | u728137020 | 1525817115 | Python | Python3 | py | Runtime Error | 0 | 0 | 273 | A=map(int,raw_input().split())
list=[]
sum=0
S=1e6
for i in map(int,raw_input().split()):
list.append(i)
sum+=i
if sum>A[1]:
while sum>=A[1]:
sum-=list.popleft()
S=min(S,len(list)+1)
if S==1e6:
print("0")
else:
print(S)
|
s555550112 | p02354 | u011621222 | 1530151373 | Python | Python3 | py | Runtime Error | 0 | 0 | 421 | N,S = map(int, input().split())
As = list(map(int, input().split()))
i = 0
j = 0
sum = 0
m_l = float('inf')
"""
while True:
while j < N and sum < S:
sum += As[j]
j += 1
if sum < S:
break
m_l = min(j-i, m_l)
sum -= As[i]
i += 1
"""
while j < N:
sum += As[j]
j += 1
if sum < s:
continue
while i <= j and sum >= S:
m_l = min(j-i, m_l)
sum -= As[i]
i += 1
print(m_l if m_l != float('inf') else 0)
|
s071502308 | p02356 | u136916346 | 1532062729 | Python | Python3 | py | Runtime Error | 0 | 0 | 372 | N,Q=map(int,input().split())
A=map(int,input().split())
X=map(int,input().split())
for x in X:
r=0
s=0
cnt=0
for l in range(N):
while r<N and s<=x:
s+=A[r]
r+=1
if s>x:
cnt+=r-1-l
else:
cnt+=r-l
if r==l:
r+=1
else:
s-=A[l]
print(cnt)
|
s929880285 | p02356 | u938878704 | 1530599399 | Python | Python3 | py | Runtime Error | 0 | 0 | 335 | for plc in x:
cursum = 0
cnt = 0
right = 0
left = 0
for left in range(N) :
while right < N and cursum + a[right] <= plc :
cursum += a[right]
right += 1
cnt += right - left
cursum -= a[left]
# print("DBG : ", left, right)
print(cnt)
|
s184353939 | p02357 | u890713354 | 1559551884 | Python | Python3 | py | Runtime Error | 0 | 0 | 903 | answer=[]
element=[]
D=[]
def initRMQ(nn):
global n
n = 1
while n < nn:
n*=2
for i in range(2*n-1):
D.append(2147483647)
def update(k,a):
k += n-1
D[k] = a
while k>0:
k = (k-1)//2
D[k] = min(D[k*2+1] , D[k*2+2])
def findMin(a,b):
return query(a,b,0,0,n)
def query(a,b,k,l,r):
if r <= a or b <= l:
return 2147483647
if a <= l and r <= b:
return D[k]
vl = query(a, b, (k*2)+1, l, (l+r)//2)
vr = query(a, b, (k*2)+2, (l+r)//2, r)
return min(vl,vr)
N,L = map(int,input().split())
initRMQ(N)
element = input().split()
for i in range(len(element)):
update(i,int(element[i]))
for i in range(N-L+1):
answer.append(findMin(i,i+L))
for i in range(len(answer)):
print(answer[i],end='')
x+=1
if x == len(answer):
print('',end='\n')
break
print(' ',end='')
|
s959875369 | p02357 | u279605379 | 1504601331 | Python | Python3 | py | Runtime Error | 0 | 0 | 861 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(left == right):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left + 1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s510416904 | p02357 | u279605379 | 1504601354 | Python | Python3 | py | Runtime Error | 0 | 0 | 859 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(left == right):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left+1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s266446889 | p02357 | u279605379 | 1504601545 | Python | Python3 | py | Runtime Error | 0 | 0 | 993 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans))
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s505780071 | p02357 | u279605379 | 1504601720 | Python | Python3 | py | Runtime Error | 0 | 0 | 878 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right[0]]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s076310433 | p02357 | u279605379 | 1504601754 | Python | Python3 | py | Runtime Error | 20 | 7760 | 878 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s162011426 | p02357 | u279605379 | 1504659989 | Python | Python3 | py | Runtime Error | 0 | 0 | 1756 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans))def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s145102057 | p02357 | u279605379 | 1504660010 | Python | Python3 | py | Runtime Error | 0 | 0 | 1758 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans))def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left+1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s692797241 | p02357 | u279605379 | 1504660027 | Python | Python3 | py | Runtime Error | 30 | 7852 | 878 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s850609153 | p02357 | u279605379 | 1504660200 | Python | Python3 | py | Runtime Error | 20 | 7852 | 882 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = 1 + len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s700796866 | p02357 | u279605379 | 1504660389 | Python | Python3 | py | Runtime Error | 30 | 7768 | 886 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = 1 + len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2 + 1
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s039162423 | p02357 | u279605379 | 1504660400 | Python | Python3 | py | Runtime Error | 20 | 7832 | 886 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = 1 + len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2 + 1
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s663803669 | p02357 | u279605379 | 1504660658 | Python | Python3 | py | Runtime Error | 60 | 7764 | 880 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left+1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s036547518 | p02357 | u279605379 | 1504660832 | Python | Python3 | py | Runtime Error | 50 | 7836 | 872 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre
elif(A[centre][0] < x[0]) :
left = centre
else :
A.insert(centre,x)
break
centre = left + (right-left+1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s382653998 | p02357 | u279605379 | 1504662017 | Python | Python3 | py | Runtime Error | 0 | 0 | 842 | def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
center = math.floor((low + high) / 2)
if(right == left):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left + 1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s007611275 | p02357 | u279605379 | 1504662037 | Python | Python3 | py | Runtime Error | 0 | 0 | 855 | import math
def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
center = math.floor((low + high) / 2)
if(right == left):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left + 1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s646405522 | p02357 | u279605379 | 1504662077 | Python | Python3 | py | Runtime Error | 0 | 0 | 857 | import math
def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
center = math.floor((left + right) / 2)
if(right == left):
if(x[0]<A[left][0]):
A.insert(left,x)
break
else :
A.insert(left + 1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s546679635 | p02357 | u279605379 | 1504662292 | Python | Python3 | py | Runtime Error | 30 | 7752 | 886 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = 1 + len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left)//2 + 1
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s273802423 | p02357 | u279605379 | 1504662301 | Python | Python3 | py | Runtime Error | 30 | 7708 | 890 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = 1 + len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left + 1)//2 + 1
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s529702238 | p02357 | u279605379 | 1504662317 | Python | Python3 | py | Runtime Error | 20 | 7832 | 886 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left + 1)//2 + 1
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s980761244 | p02357 | u279605379 | 1504662328 | Python | Python3 | py | Runtime Error | 50 | 7768 | 882 | def binaryinsertion(A,x):
left=0;right=len(A)-1;centre = len(A)//2
while(True):
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
centre = left + (right-left + 1)//2
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s531543662 | p02357 | u279605379 | 1504662424 | Python | Python3 | py | Runtime Error | 20 | 7832 | 855 | def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
centre = left + (right-left)//2
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s173136135 | p02357 | u279605379 | 1504662511 | Python | Python3 | py | Runtime Error | 20 | 7764 | 859 | def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
centre = left + (right-left)//2 - 1
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s837250445 | p02357 | u279605379 | 1504662517 | Python | Python3 | py | Runtime Error | 30 | 7792 | 859 | def binaryinsertion(A,x):
left=0;right=len(A)-1
while(True):
centre = left + (right-left)//2 + 1
if(right - left < 2):
if(x[0]<A[left][0]):A.insert(left,x)
else :
if(x[0]<A[right][0]):A.insert(right,x)
else:A.insert(right+1,x)
break
else:
if(x[0] < A[centre][0]) :
right = centre - 1
elif(A[centre][0] < x[0]) :
left = centre + 1
else :
A.insert(centre,x)
break
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
sweep = A[:L]
sweep = sorted(sweep)
ans = [str(sweep[0][0])]
for i in range(L,N) :
sweep.remove(A[i-L])
binaryinsertion(sweep,A[i])
ans.append(str(sweep[0][0]))
print(" ".join(ans)) |
s330529757 | p02357 | u279605379 | 1504684057 | Python | Python3 | py | Runtime Error | 0 | 0 | 6902 | class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
self.balance = 0 # ?????????
# ????????¢
def rotate_right(node):
lnode = node.left
node.left = lnode.right
lnode.right = node
return lnode
# ????????¢
def rotate_left(node):
rnode = node.right
node.right = rnode.left
rnode.left = node
return rnode
#
# ??????????????¢?´¢
#
def search(node, x):
while node is not None:
if node.data == x: return True
if x < node.data:
node = node.left
else:
node = node.right
return False
#
# ??????????????´??° (???????????¢??????)
#
def update_balance(node):
if node.balance == 1:
node.right.balance = -1
node.left.balance = 0
elif node.balance == -1:
node.right.balance = 0
node.left.balance = 1
else:
node.right.balance = 0
node.left.balance = 0
node.balance = 0
#
# ?????????????????\
#
# ?????\????????????????????????????????¨?????¨????¨???\
LEFT = 0
RIGHT = 1
# ????????????????´?????????????????????£??????
def balance(root, path):
new_node = None
while len(path) > 0:
pnode, dir = path.pop() # pnode ???, dir ??¨?????¨????¨???\
if dir == LEFT:
pnode.balance += 1
else:
pnode.balance -= 1
b = pnode.balance
if b == 0: return root # ?????£?????? root ?????????
if b > 1:
if pnode.left.balance < 0:
# LR ???????????¢
pnode.left = rotate_left(pnode.left)
new_node = rotate_right(pnode)
update_balance(new_node)
else:
# LL ???????????¢
new_node = rotate_right(pnode)
new_node.balance = 0
pnode.balance = 0
break
elif b < -1:
if pnode.right.balance > 0:
# RL ???????????¢
pnode.right = rotate_right(pnode.right)
new_node = rotate_left(pnode)
update_balance(new_node)
else:
# RR ???????????¢
new_node = rotate_left(pnode)
new_node.balance = 0
pnode.balance = 0
break
# ??????????????????
if len(path) > 0:
# pnode ?????????????±???????
gnode, gdir = path.pop()
if gdir == LEFT:
gnode.left = new_node
else:
gnode.right = new_node
elif new_node is not None:
return new_node
return root
# ?????\
def insert(root, x):
if root is None: return Node(x)
path = []
node = root
while True:
if node.data == x: return root
elif x < node.data:
path.append((node, LEFT))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
path.append((node, RIGHT))
if node.right is None:
node.right = Node(x)
break
node = node.right
return balance(root, path)
#
# ??????????????????
#
# ????????????????´?????????????????????£??????
def balance_delete(root, path):
while len(path) > 0:
new_node = None
pnode, dir = path.pop() # pnode = ???, dir = ??????????????¨?????¨
if dir == LEFT:
pnode.balance -= 1 # ?????\??¨?????§ left ??? -1, right ??? +1
else:
pnode.balance += 1
b = pnode.balance
if b > 1:
if pnode.left.balance < 0:
# ???????????¢
pnode.left = rotate_left(pnode.left)
new_node = rotate_right(pnode)
update_balance(new_node)
else:
# ???????????¢
new_node = rotate_right(pnode)
if new_node.balance == 0:
new_node.balance = -1
pnode.balance = 1
else:
new_node.balance = 0
pnode.balance = 0
elif b < -1:
if pnode.right.balance > 0:
# ???????????¢
pnode.right = rotate_right(pnode.right)
new_node = rotate_left(pnode)
update_balance(new_node)
else:
# ???????????¢
new_node = rotate_left(pnode)
if new_node.balance == 0:
new_node.balance = 1
pnode.balance = -1
else:
new_node.balance = 0
pnode.balance = 0
elif b != 0:
break # b == 1 or b == -1 ????????£??????
# ??????????????????
if new_node is not None:
if len(path) == 0: return new_node # root ?????????
gnode, gdir = path[len(path) - 1] # pnode ??????
if gdir == LEFT:
gnode.left = new_node
else:
gnode.right = new_node
if new_node.balance != 0: break # ?????£??????
return root
# ??????????????¢???
def _search(node, x, path):
while node is not None:
if node.data == x: return node
if x < node.data:
path.append((node, LEFT))
node = node.left
else:
path.append((node, RIGHT))
node = node.right
return None
# ????°?????????¢???
def _search_min(node, path):
while node.left is not None:
path.append((node, LEFT))
node = node.left
return node
# ??????
def delete(root, x):
if root is None: return None # ????????¨
path = [] # ??????
node = _search(root, x, path) # ??¢?´¢
if node is None: return root # ?????????????????????
if node.left is not None and node.right is not None:
# ????????????????????´???
# ?????¨?????¨???????°?????????¢?????????????????????
path.append((node, RIGHT))
min_node = _search_min(node.right, path)
node.data = min_node.data
node = min_node
if len(path) > 0:
pnode, dir = path[len(path) - 1]
else:
pnode = None
# ??????????????????
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pnode is None:
return cnode
elif dir == LEFT:
pnode.left = cnode
else:
pnode.right = cnode
return balance_delete(root, path)
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
Tree = None
for i in range(L) : Tree = insert(Tree,A[i])
ANS = [str(search_min(Tree)[0])]
for i in range(L,N):
Tree = delete(Tree, A[i-L])
Tree = insert(Tree, A[i])
ANS.append(str(search_min(Tree)[0]))
print(" ".join(ANS)) |
s268357681 | p02357 | u279605379 | 1504684172 | Python | Python3 | py | Runtime Error | 0 | 0 | 5677 | class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
self.balance = 0
def rotate_right(node):
lnode = node.left
node.left = lnode.right
lnode.right = node
return lnode
def rotate_left(node):
rnode = node.right
node.right = rnode.left
rnode.left = node
return rnode
def search(node, x):
while node is not None:
if node.data == x: return True
if x < node.data:
node = node.left
else:
node = node.right
return False
def update_balance(node):
if node.balance == 1:
node.right.balance = -1
node.left.balance = 0
elif node.balance == -1:
node.right.balance = 0
node.left.balance = 1
else:
node.right.balance = 0
node.left.balance = 0
node.balance = 0
LEFT = 0
RIGHT = 1
def balance(root, path):
new_node = None
while len(path) > 0:
pnode, dir = path.pop()
if dir == LEFT:
pnode.balance += 1
else:
pnode.balance -= 1
b = pnode.balance
if b == 0: return root
if b > 1:
if pnode.left.balance < 0:
pnode.left = rotate_left(pnode.left)
new_node = rotate_right(pnode)
update_balance(new_node)
else:
new_node = rotate_right(pnode)
new_node.balance = 0
pnode.balance = 0
break
elif b < -1:
if pnode.right.balance > 0:
pnode.right = rotate_right(pnode.right)
new_node = rotate_left(pnode)
update_balance(new_node)
else:
new_node = rotate_left(pnode)
new_node.balance = 0
pnode.balance = 0
break
if len(path) > 0:
gnode, gdir = path.pop()
if gdir == LEFT:
gnode.left = new_node
else:
gnode.right = new_node
elif new_node is not None:
return new_node
return root
def insert(root, x):
if root is None: return Node(x)
path = []
node = root
while True:
if node.data == x: return root
elif x < node.data:
path.append((node, LEFT))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
path.append((node, RIGHT))
if node.right is None:
node.right = Node(x)
break
node = node.right
return balance(root, path)
def balance_delete(root, path):
while len(path) > 0:
new_node = None
pnode, dir = path.pop()
if dir == LEFT:
pnode.balance -= 1
else:
pnode.balance += 1
b = pnode.balance
if b > 1:
if pnode.left.balance < 0:
pnode.left = rotate_left(pnode.left)
new_node = rotate_right(pnode)
update_balance(new_node)
else:
new_node = rotate_right(pnode)
if new_node.balance == 0:
new_node.balance = -1
pnode.balance = 1
else:
new_node.balance = 0
pnode.balance = 0
elif b < -1:
if pnode.right.balance > 0:
pnode.right = rotate_right(pnode.right)
new_node = rotate_left(pnode)
update_balance(new_node)
else:
new_node = rotate_left(pnode)
if new_node.balance == 0:
new_node.balance = 1
pnode.balance = -1
else:
new_node.balance = 0
pnode.balance = 0
elif b != 0:
break
if new_node is not None:
if len(path) == 0: return new_node
gnode, gdir = path[len(path) - 1]
if gdir == LEFT:
gnode.left = new_node
else:
gnode.right = new_node
if new_node.balance != 0: break
return root
def _search(node, x, path):
while node is not None:
if node.data == x: return node
if x < node.data:
path.append((node, LEFT))
node = node.left
else:
path.append((node, RIGHT))
node = node.right
return None
def _search_min(node, path):
while node.left is not None:
path.append((node, LEFT))
node = node.left
return node
def delete(root, x):
if root is None: return None
path = []
node = _search(root, x, path)
if node is None: return root
if node.left is not None and node.right is not None:
path.append((node, RIGHT))
min_node = _search_min(node.right, path)
node.data = min_node.data
node = min_node
if len(path) > 0:
pnode, dir = path[len(path) - 1]
else:
pnode = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pnode is None:
return cnode
elif dir == LEFT:
pnode.left = cnode
else:
pnode.right = cnode
return balance_delete(root, path)
[N,L] = [int(x) for x in input().split()]
A = [[int(x),int(i)] for i,x in enumerate(input().split())]
Tree = None
for i in range(L) : Tree = insert(Tree,A[i])
ANS = [str(search_min(Tree)[0])]
for i in range(L,N):
Tree = delete(Tree, A[i-L])
Tree = insert(Tree, A[i])
ANS.append(str(search_min(Tree)[0]))
print(" ".join(ANS)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.