input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import heapq
N,Q=list(map(int,input().split()))
event_list=[]
for i in range(N):
S,T,X=list(map(int,input().split()))
event_list.append((S-X-0.5,1,X))
event_list.append((T-X-0.5,-1,X))
dlist=[]
for i in range(Q):
D=int(eval(input()))
event_list.append((D,0,X))
dlist.append(D)
event_list.sort()
#print(event_list)
answer_dic={}
stop_set=set()
min_set=10**9
for t,f,x in event_list:
if f==1:
stop_set.add(x)
if x<min_set:
min_set=x
elif f==-1:
stop_set.remove(x)
if x==min_set:
if len(stop_set)>0:
min_set=min(stop_set)
else:
min_set=10**9
else:
if len(stop_set)>0:
answer_dic[t]=min_set
else:
answer_dic[t]=-1
#print(answer_dic)
for d in dlist:
print((answer_dic[d])) | import heapq
import sys
input=sys.stdin.readline
N,Q=list(map(int,input().split()))
event_list=[]
for i in range(N):
S,T,X=list(map(int,input().split()))
event_list.append((S-X-0.5,1,X))
event_list.append((T-X-0.5,-1,X))
dlist=[]
for i in range(Q):
D=int(eval(input()))
event_list.append((D,0,X))
dlist.append(D)
event_list.sort()
#print(event_list)
answer_dic={}
stop_set=set()
min_set=float("inf")
for t,f,x in event_list:
if f==1:
stop_set.add(x)
if x<min_set:
min_set=x
elif f==-1:
stop_set.remove(x)
if x==min_set:
if len(stop_set)>0:
min_set=min(stop_set)
else:
min_set=float("inf")
else:
if len(stop_set)>0:
answer_dic[t]=min_set
else:
answer_dic[t]=-1
#print(answer_dic)
for d in dlist:
print((answer_dic[d])) | p03033 |
from bisect import bisect_left
N,Q = map(int, input().split())
STX = []
for i in range(N):
*stx, = list(map(int, input().split()))
STX.append(stx)
D = []
for i in range(Q):
D.append(int(input()))
STX = sorted(STX, key=lambda x: x[2])
DI = [i for i in range(Q)]
ANS = [-1]*Q
for (s,t,x) in STX:
s2 = (s - x)
t2 = (t - x)
D_sub = [D[di] for di in DI]
start = bisect_left(D_sub, s2)
end = bisect_left(D_sub, t2, lo=start)
#print(start, end, DI)
DI_copy = DI[:]
while (start < end):
di = DI_copy[start]
ANS[di] = x
DI.remove(di)
start += 1
print(*ANS, sep='\n')
| from bisect import bisect_left
N,Q = map(int, input().split())
STX = []
for i in range(N):
*stx, = list(map(int, input().split()))
STX.append(stx)
D = []
for i in range(Q):
D.append(int(input()))
STX = sorted(STX, key=lambda x: x[2])
mask = [-1]*Q
ANS = [-1]*Q
for (s,t,x) in STX:
s2 = (s - x)
t2 = (t - x)
start = bisect_left(D, s2)
end = bisect_left(D, t2, lo=start)
#print(start, end, DI)
while (start < end):
if (-1 == mask[start]):
ANS[start] = x
mask[start] = end
start += 1
else:
start = mask[start]
print(*ANS, sep='\n')
| p03033 |
import sys
INF = 1 << 30
class Node:
def __init__(self, key, val):
self.key = key
self.val = val
self.lst = None
self.rst = None
self.bias = 0
class AVLTree:
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rst
v.rst = u.lst
u.lst = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lst
v.lst = u.rst
u.rst = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lst
t = u.rst
u.rst = t.lst
t.lst = u
v.lst = t.rst
t.rst = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rst
t = u.lst
u.lst = t.rst
t.rst = u
v.rst = t.lst
t.lst = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rst.bias = -1
v.lst.bias = 0
elif v.bias == -1:
v.rst.bias = 0
v.lst.bias = 1
else:
v.rst.bias = 0
v.lst.bias = 0
v.bias = 0
def insert(self, key, val):
if self.root is None:
self.root = Node(key, val)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lst
elif v.key < key:
history.append((v, -1))
v = v.rst
elif v.key == key:
v.val = val
return
p, pdir = history[-1]
if pdir == 1:
p.lst = Node(key, val)
else:
p.rst = Node(key, val)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lst
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rst
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lst = new_v
else:
p.rst = new_v
def delete(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lst
elif v.key < key:
history.append((v, -1))
v = v.rst
else:
break
else:
return False
if v.lst is not None:
history.append((v, 1))
lmax = v.lst
while lmax.rst is not None:
history.append((lmax, -1))
lmax = lmax.rst
v.key = lmax.key
v.val = lmax.val
v = lmax
c = v.rst if v.lst is None else v.lst
if history:
p, pdir = history[-1]
if pdir == 1:
p.lst = c
else:
p.rst = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lst.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rst.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lst = new_p
else:
gp.rst = new_p
if new_p.bias != 0:
break
return True
def member(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lst
elif v.key < key:
v = v.rst
else:
return True
return False
def get(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lst
elif v.key < key:
v = v.rst
else:
return v.val
return None
def lower_bound(self, key):
ret = INF
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lst
else:
v = v.rst
return ret
def __contains__(self, key): return self.member(key)
def __getitem__(self, key): return self.get(key)
def __setitem__(self, key, val): return self.insert(key, val)
def __delitem__(self, key): return self.delete(key)
def __bool__(self): return self.root is not None
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, -1, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl[x] = 1
else:
del avl[x]
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| import sys
INF = 1 << 30
class Node:
def __init__(self, key, val):
self.key = key
self.val = val
self.lst = None
self.rst = None
self.bias = 0
class AVLTree:
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rst
v.rst = u.lst
u.lst = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lst
v.lst = u.rst
u.rst = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lst
t = u.rst
u.rst = t.lst
t.lst = u
v.lst = t.rst
t.rst = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rst
t = u.lst
u.lst = t.rst
t.rst = u
v.rst = t.lst
t.lst = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rst.bias = -1
v.lst.bias = 0
elif v.bias == -1:
v.rst.bias = 0
v.lst.bias = 1
else:
v.rst.bias = 0
v.lst.bias = 0
v.bias = 0
def insert(self, key, val):
if self.root is None:
self.root = Node(key, val)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lst
elif v.key < key:
history.append((v, -1))
v = v.rst
elif v.key == key:
v.val = val
return
p, pdir = history[-1]
if pdir == 1:
p.lst = Node(key, val)
else:
p.rst = Node(key, val)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lst
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rst
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lst = new_v
else:
p.rst = new_v
def delete(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lst
elif v.key < key:
history.append((v, -1))
v = v.rst
else:
break
else:
return False
if v.lst is not None:
history.append((v, 1))
lmax = v.lst
while lmax.rst is not None:
history.append((lmax, -1))
lmax = lmax.rst
v.key = lmax.key
v.val = lmax.val
v = lmax
c = v.rst if v.lst is None else v.lst
if history:
p, pdir = history[-1]
if pdir == 1:
p.lst = c
else:
p.rst = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lst.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rst.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lst = new_p
else:
gp.rst = new_p
if new_p.bias != 0:
break
return True
def get(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lst
elif v.key < key:
v = v.rst
else:
return v.val
return None
def lower_bound(self, key):
ret = float('inf')
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lst
else:
v = v.rst
return ret
def __contains__(self, key): return self.member(key)
def __getitem__(self, key): return self.get(key)
def __setitem__(self, key, val): return self.insert(key, val)
def __delitem__(self, key): return self.delete(key)
def __bool__(self): return self.root is not None
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, -1, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl[x] = 1
else:
del avl[x]
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| p03033 |
import sys
INF = 1 << 30
class Node:
__slots__ = ["key", "val", "lch", "rch", "bias"]
def __init__(self, key, val):
self.key = key
self.val = val
self.lch = None
self.rch = None
self.bias = 0
class AVLTree:
__slots__ = ["root"]
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def insert(self, key, val):
if self.root is None:
self.root = Node(key, val)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
elif v.key == key:
v.val = val
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key, val)
else:
p.rch = Node(key, val)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
def delete(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
break
else:
return False
if v.lch is not None:
history.append((v, 1))
lmax = v.lch
while lmax.rch is not None:
history.append((lmax, -1))
lmax = lmax.rch
v.key = lmax.key
v.val = lmax.val
v = lmax
c = v.rch if v.lch is None else v.lch
if history:
p, pdir = history[-1]
if pdir == 1:
p.lch = c
else:
p.rch = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lch.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rch.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lch = new_p
else:
gp.rch = new_p
if new_p.bias != 0:
break
return True
def get(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lch
elif v.key < key:
v = v.rch
else:
return v.val
return None
def lower_bound(self, key):
ret = INF
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
def __getitem__(self, key): return self.get(key)
def __setitem__(self, key, val): return self.insert(key, val)
def __delitem__(self, key): return self.delete(key)
def __bool__(self): return self.root is not None
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, -1, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl[x] = 1
else:
del avl[x]
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| import sys
INF = 1 << 30
class Node:
__slots__ = ["key", "val", "lch", "rch", "bias"]
def __init__(self, key, val):
self.key = key
self.val = val
self.lch = None
self.rch = None
self.bias = 0
class AVLTree:
__slots__ = ["root"]
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def insert(self, key, val):
if self.root is None:
self.root = Node(key, val)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
elif v.key == key:
v.val = val
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key, val)
else:
p.rch = Node(key, val)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
def delete(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
break
else:
return False
if v.lch is not None:
history.append((v, 1))
lmax = v.lch
while lmax.rch is not None:
history.append((lmax, -1))
lmax = lmax.rch
v.key = lmax.key
v.val = lmax.val
v = lmax
c = v.rch if v.lch is None else v.lch
if history:
p, pdir = history[-1]
if pdir == 1:
p.lch = c
else:
p.rch = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lch.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rch.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lch = new_p
else:
gp.rch = new_p
if new_p.bias != 0:
break
return True
def get(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lch
elif v.key < key:
v = v.rch
else:
return v.val
return None
def lower_bound(self, key):
ret = INF
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
def __getitem__(self, key): return self.get(key)
def __setitem__(self, key, val): return self.insert(key, val)
def __delitem__(self, key): return self.delete(key)
def __bool__(self): return self.root is not None
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, -1, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl.insert(x, 1)
else:
avl.delete(x)
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| p03033 |
import sys
INF = 1 << 30
class Node:
__slots__ = ["key", "val", "lch", "rch", "bias"]
def __init__(self, key, val):
self.key = key
self.val = val
self.lch = None
self.rch = None
self.bias = 0
class AVLTree:
__slots__ = ["root"]
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def insert(self, key, val):
if self.root is None:
self.root = Node(key, val)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
elif v.key == key:
v.val = val
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key, val)
else:
p.rch = Node(key, val)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
def delete(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
break
else:
return False
if v.lch is not None:
history.append((v, 1))
lmax = v.lch
while lmax.rch is not None:
history.append((lmax, -1))
lmax = lmax.rch
v.key = lmax.key
v.val = lmax.val
v = lmax
c = v.rch if v.lch is None else v.lch
if history:
p, pdir = history[-1]
if pdir == 1:
p.lch = c
else:
p.rch = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lch.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rch.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lch = new_p
else:
gp.rch = new_p
if new_p.bias != 0:
break
return True
def get(self, key):
v = self.root
while v is not None:
if key < v.key:
v = v.lch
elif v.key < key:
v = v.rch
else:
return v.val
return None
def lower_bound(self, key):
ret = INF
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
def __getitem__(self, key): return self.get(key)
def __setitem__(self, key, val): return self.insert(key, val)
def __delitem__(self, key): return self.delete(key)
def __bool__(self): return self.root is not None
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, -1, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl.insert(x, 1)
else:
avl.delete(x)
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| import sys
INF = 1 << 30
class Node:
def __init__(self, key):
self.key = key
self.lch = None
self.rch = None
self.bias = 0
class AVLTree:
def __init__(self):
self.root = None
def rotate_left(self, v):
u = v.rch
v.rch = u.lch
u.lch = v
if u.bias == -1:
u.bias = v.bias = 0
else:
u.bias = 1
v.bias = -1
return u
def rotate_right(self, v):
u = v.lch
v.lch = u.rch
u.rch = v
if u.bias == 1:
u.bias = v.bias = 0
else:
u.bias = -1
v.bias = 1
return u
def rotateLR(self, v):
u = v.lch
t = u.rch
u.rch = t.lch
t.lch = u
v.lch = t.rch
t.rch = v
self.update_bias_double(t)
return t
def rotateRL(self, v):
u = v.rch
t = u.lch
u.lch = t.rch
t.rch = u
v.rch = t.lch
t.lch = v
self.update_bias_double(t)
return t
def update_bias_double(self, v):
if v.bias == 1:
v.rch.bias = -1
v.lch.bias = 0
elif v.bias == -1:
v.rch.bias = 0
v.lch.bias = 1
else:
v.rch.bias = 0
v.lch.bias = 0
v.bias = 0
def add(self, key):
if self.root is None:
self.root = Node(key)
return
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
return
p, pdir = history[-1]
if pdir == 1:
p.lch = Node(key)
else:
p.rch = Node(key)
while history:
v, direction = history.pop()
v.bias += direction
new_v = None
b = v.bias
if b == 0:
break
if b == 2:
u = v.lch
if u.bias == -1:
new_v = self.rotateLR(v)
else:
new_v = self.rotate_right(v)
break
if b == -2:
u = v.rch
if u.bias == 1:
new_v = self.rotateRL(v)
else:
new_v = self.rotate_left(v)
break
if new_v is not None:
if len(history) == 0:
self.root = new_v
return
p, pdir = history.pop()
if pdir == 1:
p.lch = new_v
else:
p.rch = new_v
def remove(self, key):
v = self.root
history = []
while v is not None:
if key < v.key:
history.append((v, 1))
v = v.lch
elif v.key < key:
history.append((v, -1))
v = v.rch
else:
break
else:
return False
if v.lch is not None:
history.append((v, 1))
lmax = v.lch
while lmax.rch is not None:
history.append((lmax, -1))
lmax = lmax.rch
v.key = lmax.key
v = lmax
c = v.rch if v.lch is None else v.lch
if history:
p, pdir = history[-1]
if pdir == 1:
p.lch = c
else:
p.rch = c
else:
self.root = c
return True
while history:
new_p = None
p, pdir = history.pop()
p.bias -= pdir
b = p.bias
if b == 2:
if p.lch.bias == -1:
new_p = self.rotateLR(p)
else:
new_p = self.rotate_right(p)
elif b == -2:
if p.rch.bias == 1:
new_p = self.rotateRL(p)
else:
new_p = self.rotate_left(p)
elif b != 0:
break
if new_p is not None:
if len(history) == 0:
self.root = new_p
return True
gp, gpdir = history[-1]
if gpdir == 1:
gp.lch = new_p
else:
gp.rch = new_p
if new_p.bias != 0:
break
return True
def lower_bound(self, key):
ret = INF
v = self.root
while v is not None:
if v.key >= key:
if ret > v.key:
ret = v.key
v = v.lch
else:
v = v.rch
return ret
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
N, Q = list(map(int, input().split()))
event = []
for i in range(N):
s, t, x = list(map(int, input().split()))
event.append((s-x, 1, x))
event.append((t-x, 0, x))
event.sort(reverse=True)
avl = AVLTree()
ans = []
for d in map(int, read().split()):
while event and event[-1][0] <= d:
time, k, x = event.pop()
if k == 1:
avl.add(x)
else:
avl.remove(x)
x = avl.lower_bound(-INF)
ans.append(x if x < INF else -1)
print(('\n'.join(map(str, ans))))
| p03033 |
import sys
input = sys.stdin.readline
# Segment Tree
class Segment:
def __init__(self, N, init_val):
self.N0 = 2 ** (N - 1).bit_length()
# 0-indexedで管理
self.dat = [identity_element] * (2 * self.N0)
# 値を代入
for i in range(N):
self.dat[i + self.N0 - 1] = init_val[i]
# 構築
for i in range(self.N0 - 2, -1, -1):
self.dat[i] = segfunc(self.dat[2 * i + 1], self.dat[2 * i + 2])
# k番目の要素の値をxに変更
def update(self, k, x):
k += self.N0 - 1
self.dat[k] = x
while k >= 0:
k = (k - 1) // 2
self.dat[k] = segfunc(self.dat[2 * k + 1], self.dat[2 * k + 2])
# 区間[l,r)の最小値を求める
def query(self, l, r):
L = l + self.N0
R = r + self.N0
s = identity_element
# 区間を列挙しながら最小値を求める
while L < R:
if R & 1:
R -= 1
s = segfunc(s, self.dat[R - 1])
if L & 1:
s = segfunc(s, self.dat[L - 1])
L += 1
L >>= 1
R >>= 1
return s
# segfunc : min, +, *, xor, gcd など
# identity_element : 単位元(min:inf, 和:0, 積:1, xor:0, gcd:0)
def segfunc(x, y):
return min(x, y) # 変える
identity_element = 2 ** 31 - 1 # 変える
def compress(arr):
*XS, = set(arr)
XS.sort()
return {e: i for i, e in enumerate(XS)}
n, q = list(map(int, input().split()))
s, t, x = [0] * n, [0] * n, [0] * n
for i in range(n):
s[i], t[i], x[i] = list(map(int, input().split()))
s[i] -= x[i]
t[i] -= x[i]
s[i] = max(s[i], 0)
t[i] = max(t[i], 0)
d = [int(eval(input())) for i in range(q)]
com = compress(s + t + d)
k = len(com) + 1
for i in range(n):
s[i] = com[s[i]]
t[i] = com[t[i]]
for i in range(q):
d[i] = com[d[i]]
INF = 1 << 30
a = [INF] * k
b = [[] for i in range(k)]
c = [[] for i in range(k)]
seg = Segment(n, [INF] * n)
for i in range(n):
b[s[i]].append(i)
c[t[i]].append(i)
for i in range(k):
for j in b[i]:
seg.update(j, x[j])
for j in c[i]:
seg.update(j, INF)
a[i] = seg.query(0, n)
for i in d:
print((-1 if a[i] == INF else a[i]))
| import sys
input = sys.stdin.readline
# Segment Tree
# segfunc : min, +, *, xor, gcd など
# identity_element : 単位元(min:inf, 和:0, 積:1, xor:0, gcd:0)
class Segment:
def __init__(self, N, init_val):
"""[セグメント木]
Args:
N ([int]): [要素数]
init_val ([list]): [初期化する値]
"""
self.identity_element = 2 ** 31 - 1 # 変える
self.N0 = 1 << (N - 1).bit_length()
# 0-indexedで管理
self.dat = [self.identity_element] * (2 * self.N0)
# 値を代入
for i in range(N):
self.dat[i + self.N0 - 1] = init_val[i]
# 構築
for i in range(self.N0 - 2, -1, -1):
self.dat[i] = self.segfunc(self.dat[2 * i + 1], self.dat[2 * i + 2])
# k番目の要素の値をxに変更
def update(self, k, x):
k += self.N0 - 1
self.dat[k] = x
while k >= 0:
k = (k - 1) // 2
self.dat[k] = self.segfunc(self.dat[2 * k + 1], self.dat[2 * k + 2])
# 区間[l,r)の最小値を求める
def query(self, l, r):
L = l + self.N0
R = r + self.N0
s = self.identity_element
# 区間を列挙しながら最小値を求める
while L < R:
if R & 1:
R -= 1
s = self.segfunc(s, self.dat[R - 1])
if L & 1:
s = self.segfunc(s, self.dat[L - 1])
L += 1
L >>= 1
R >>= 1
return s
def segfunc(self, x, y):
return min(x, y) # 変える
def compress(arr):
*XS, = set(arr)
XS.sort()
return {e: i for i, e in enumerate(XS)}
n, q = list(map(int, input().split()))
s, t, x = [0] * n, [0] * n, [0] * n
for i in range(n):
s[i], t[i], x[i] = list(map(int, input().split()))
s[i] -= x[i]
t[i] -= x[i]
s[i] = max(s[i], 0)
t[i] = max(t[i], 0)
d = [int(eval(input())) for i in range(q)]
com = compress(s + t + d)
k = len(com) + 1
for i in range(n):
s[i] = com[s[i]]
t[i] = com[t[i]]
for i in range(q):
d[i] = com[d[i]]
INF = 1 << 30
a = [INF] * k
b = [[] for i in range(k)]
c = [[] for i in range(k)]
seg = Segment(n, [INF] * n)
for i in range(n):
b[s[i]].append(i)
c[t[i]].append(i)
for i in range(k):
for j in b[i]:
seg.update(j, x[j])
for j in c[i]:
seg.update(j, INF)
a[i] = seg.query(0, n)
for i in d:
print((-1 if a[i] == INF else a[i]))
| p03033 |
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
events = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
events.append((s-x-0.5, 's', x)) # start construction
events.append((t-x-0.5, 'e', x)) # end construction
for i in range(q):
d = int(eval(input()))
events.append((d, 'q', i)) # query
events = sorted(events)
is_stop = False
stops = set()
min_stop = float('inf')
ans = [-1]*q
for t, e, x in events: # time, event, distance/index
if e == 's':
stops.add(x)
if x < min_stop:
min_stop = x
is_stop = True
elif e == 'e':
stops.remove(x)
if min_stop == x:
is_stop = False
elif len(stops) > 0:
if not is_stop:
min_stop = min(stops)
is_stop = True
ans[x] = min_stop
print(('\n'.join(map(str,ans)))) | import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
events = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
events.append((s-x-0.5, 1, x)) # start construction
events.append((t-x-0.5, -1, x)) # end construction
for i in range(q):
d = int(eval(input()))
events.append((d, 0, i)) # query
events = sorted(events)
is_stop = False
stops = set()
min_stop = float('inf')
ans = [-1]*q
for t, e, x in events: # time, event, distance/index
if e > 0:
stops.add(x)
if x < min_stop:
min_stop = x
is_stop = True
elif e < 0:
stops.remove(x)
if min_stop == x:
is_stop = False
elif len(stops) > 0:
if not is_stop:
min_stop = min(stops)
is_stop = True
ans[x] = min_stop
print(('\n'.join(map(str, ans)))) | p03033 |
from bisect import bisect_left
from operator import itemgetter
N, Q = list(map(int, input().split(" ")))
check_points = [tuple(map(int, input().split(" "))) for _ in range(N)]
querys = [int(eval(input())) for _ in range(Q)]
time = [-1 for _ in range(Q)]
jump = [-1 for _ in range(Q)]
check_points = sorted(check_points, key=itemgetter(2))
b_left = bisect_left
for line in check_points:
s, f, x = line
start = s-x
end = f-x
left = b_left(querys, start)
right = b_left(querys, end)
while left < right:
if time[left] == -1:
time[left] = x
jump[left] = right
left += 1
else:
left = jump[left]
for t in time:
print(t)
| from bisect import bisect_left
from operator import itemgetter
N, Q = list(map(int, input().split(" ")))
check_points = [tuple(map(int, input().split(" "))) for _ in range(N)]
querys = [int(eval(input())) for _ in range(Q)]
time = [-1] * Q
jump = [-1] * Q
check_points = sorted(check_points, key=itemgetter(2))
b_left = bisect_left
for line in check_points:
s, f, x = line
start = s-x
end = f-x
left = b_left(querys, start)
right = b_left(querys, end)
while left < right:
if time[left] == -1:
time[left] = x
jump[left] = right
left += 1
else:
left = jump[left]
for t in time:
print(t)
| p03033 |
from bisect import bisect_left
from operator import itemgetter
N, Q = list(map(int, input().split(" ")))
check_points = [tuple(map(int, input().split(" "))) for _ in range(N)]
querys = [int(eval(input())) for _ in range(Q)]
time = [-1] * Q
jump = [-1] * Q
check_points = sorted(check_points, key=itemgetter(2))
b_left = bisect_left
for line in check_points:
s, f, x = line
start = s-x
end = f-x
left = b_left(querys, start)
right = b_left(querys, end)
while left < right:
if time[left] == -1:
time[left] = x
jump[left] = right
left += 1
else:
left = jump[left]
for t in time:
print(t)
| from bisect import bisect_left
from operator import itemgetter
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split(" ")))
check_points = [tuple(map(int, input().split(" "))) for _ in range(N)]
querys = [int(eval(input())) for _ in range(Q)]
time = [-1] * Q
jump = [-1] * Q
check_points = sorted(check_points, key=itemgetter(2))
b_left = bisect_left
for line in check_points:
s, f, x = line
start = s-x
end = f-x
left = b_left(querys, start)
right = b_left(querys, end)
while left < right:
if time[left] == -1:
time[left] = x
jump[left] = right
left += 1
else:
left = jump[left]
for t in time:
print(t)
| p03033 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, q = list(map(int, readline().split()))
event = [0] * (2 * n + q)
for i in range(n):
s, t, x = list(map(int, readline().split()))
event[i * 2] = (s - x, x, 0)
event[i * 2 + 1] = (t - x, x, 1)
for i in range(q):
d = int(eval(input()))
event[2 * n + i] = (d, 0, 2)
from operator import itemgetter
event.sort(key=itemgetter(0))
stop = set()
for t, x, ev_type in event:
if ev_type == 0:
stop.add(x)
elif ev_type == 1:
stop.discard(x)
else:
if stop:
print((min(stop)))
else:
print((-1))
if __name__ == '__main__':
main()
| import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n, q = list(map(int, readline().split()))
event = [0] * (2 * n + q)
for i in range(n):
s, t, x = list(map(int, readline().split()))
event[i * 2] = (s - x, x, 0)
event[i * 2 + 1] = (t - x, x, 1)
for i in range(q):
d = int(eval(input()))
event[2 * n + i] = (d, 0, 2)
from operator import itemgetter
event.sort(key=itemgetter(0))
stop = set()
res = INF
for t, x, ev_type in event:
if ev_type == 0:
stop.add(x)
if res == -1:
res = x
elif res > x:
res = x
elif ev_type == 1:
stop.discard(x)
if res == x:
if stop:
res = min(stop)
else:
res = -1
else:
if stop:
print(res)
else:
print((-1))
if __name__ == '__main__':
main()
| p03033 |
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
from collections import defaultdict
N, Q = list(map(int, input().split()))
lst = []
l_append = lst.append
for i in range(N):
s, t, x = list(map(int, input().split()))
l_append((t - x, 0, x)) #xで止まらなくなる
l_append((s - x, 1, x)) #xで止まる
for i in range(Q):
l_append((int(eval(input())), 2, i))
lst.sort()
ans = [-1] * Q
#引っかかっている場所の管理
se = set()
se_hp = [] #heapで最小値を先頭に保つ
#小さい時刻から順に見ていく
s_remove = se.remove
s_add = se.add
for a, b, c in lst:
if b == 0:
s_remove(c)
elif b == 1:
s_add(c)
heappush(se_hp, c)
else:
while se_hp and se_hp[0] not in se:
heappop(se_hp)
ans[c] = se_hp[0] if se_hp else -1
print(('\n'.join(map(str, ans)))) | import sys
input = sys.stdin.readline
from heapq import heappop, heappush
from collections import defaultdict
N, Q = list(map(int, input().split()))
lst = []
l_append = lst.append
for i in range(N):
s, t, x = list(map(int, input().split()))
l_append((t - x, 0, x)) #xで止まらなくなる
l_append((s - x, 1, x)) #xで止まる
for i in range(Q):
l_append((int(eval(input())), 2, i))
lst.sort()
ans = [-1] * Q
#引っかかっている場所の管理
se = set()
se_hp = [] #heapで最小値を先頭に保つ
#小さい時刻から順に見ていく
# s_remove = se.remove
# s_add = se.add
for a, b, c in lst:
if b == 0:
se.remove(c)
elif b == 1:
se.add(c)
heappush(se_hp, c)
else:
while se_hp and se_hp[0] not in se:
heappop(se_hp)
ans[c] = se_hp[0] if se_hp else -1
print(('\n'.join(map(str, ans)))) | p03033 |
def main():
import sys
from collections import defaultdict
from heapq import heappop, heappush
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
used = defaultdict(int)
tank = []
p = []
p_append = p.append
for i in range(N):
s, t, x = list(map(int, input().split()))
p_append((s - x, x))
p_append((t - x, -x))
p.sort()
cnt = 0
for i in range(Q):
d = int(eval(input()))
while cnt <= len(p) - 1 and p[cnt][0] <= d:
w = p[cnt][1]
if w >= 0:
used[w] += 1
heappush(tank, w)
else:
used[-w] -= 1
cnt += 1
while True:
if len(tank) == 0:
print((-1))
break
kouho = tank[0]
if used[kouho] > 0:
print (kouho)
break
else:
heappop(tank)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
from bisect import bisect_left
N, Q = list(map(int, input().split()))
c = []
c_append = c.append
for _ in range(N):
s, t, x = list(map(int, input().split()))
c_append((x, s, t))
c.sort()
D = [int(eval(input())) for _ in range(Q)]
ans = [-1] * Q
skip = [-1] * Q
for x, s, t in c:
left = bisect_left(D, s - x)
right = bisect_left(D, t - x)
while left < right:
if skip[left] == -1:
ans[left] = x
skip[left] = right
left += 1
else:
left = skip[left]
print(('\n'.join(map(str, ans))))
if __name__ == '__main__':
main() | p03033 |
import bisect
n, q = list(map(int, input().split()))
ran = []
for i in range(n):
s, t, x = list(map(int, input().split()))
ran.append((s-x, t-x-1, x))
ran.sort(key=lambda a: a[2])
qu = []
convert = {}
for i in range(q):
que = int(eval(input()))
convert[que] = i
qu.append(que)
qu.sort()
memo = [-1] * q
ans = [-1] * q
for i in range(n):
x = ran[i][2]
l = ran[i][0]
r = ran[i][1]
ql = bisect.bisect_left(qu, l)
qr = bisect.bisect_right(qu, r)
if ql >= qr:
continue
while ql < qr:
if memo[ql] >= 0:
ql = memo[ql]
else:
memo[ql] = qr
ans[convert[qu[ql]]] = x
ql += 1
for i in ans:
print(i) | import sys
input = sys.stdin.readline
import bisect
n, q = list(map(int, input().split()))
ran = []
for i in range(n):
s, t, x = list(map(int, input().split()))
ran.append((s-x, t-x-1, x))
ran.sort(key=lambda a: a[2])
qu = []
convert = {}
for i in range(q):
que = int(eval(input()))
convert[que] = i
qu.append(que)
qu.sort()
memo = [-1] * q
ans = [-1] * q
for i in range(n):
x = ran[i][2]
l = ran[i][0]
r = ran[i][1]
ql = bisect.bisect_left(qu, l)
qr = bisect.bisect_right(qu, r)
if ql >= qr:
continue
while ql < qr:
if memo[ql] >= 0:
ql = memo[ql]
else:
memo[ql] = qr
ans[convert[qu[ql]]] = x
ql += 1
for i in ans:
print(i) | p03033 |
def main():
import sys,heapq
from collections import defaultdict
input = sys.stdin.readline
n,q = list(map(int,input().split()))
#used[i]:0より大きいならi
used = defaultdict(int)
tank = []
p = []
for i in range(n):
s,t,x = list(map(int,input().split()))
p.append((s-x,x))
p.append((t-x-0.5,x))
p.sort()
cnt = 0
for i in range(q):
d = int(eval(input()))
while cnt<=len(p)-1 and p[cnt][0] <= d:
w = p[cnt][1]
if int(p[cnt][0]) == p[cnt][0]:
used[w] += 1
heapq.heappush(tank,w)
else:
used[w] -= 1
cnt += 1
while True:
if len(tank) == 0:
print((-1))
break
kouho = tank[0]
if used[kouho] > 0:
print(kouho)
break
else:
heapq.heappop(tank)
if __name__ == '__main__':
main() | def main():
import sys,heapq
from collections import defaultdict
input = sys.stdin.readline
n,q = list(map(int,input().split()))
#used[i]:0より大きいならi
used = defaultdict(int)
tank = []
p = []
for i in range(n):
s,t,x = list(map(int,input().split()))
p.append((s-x,x))
p.append((t-x,-x))
p.sort()
cnt = 0
for i in range(q):
d = int(eval(input()))
while cnt<=len(p)-1 and p[cnt][0] <= d:
w = p[cnt][1]
if w>=0:
used[w] += 1
heapq.heappush(tank,w)
else:
used[-w] -= 1
cnt += 1
while True:
if len(tank) == 0:
print((-1))
break
kouho = tank[0]
if used[kouho] > 0:
print(kouho)
break
else:
heapq.heappop(tank)
if __name__ == '__main__':
main() | p03033 |
import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr_ind = list(range(N))
stop_arr_ind.sort(key=lambda x:stop_arr[x][2])
# stop_arr.sort(key=lambda x:x[2], reverse=True)
ans_arr = [-1]*Q
skip_arr = [-1]*(Q+1)
def update_skip(skip_arr, x):
if skip_arr[x] == -1:
return x
x_dest = update_skip(skip_arr, skip_arr[x])
skip_arr[x] = x_dest
return x_dest
for i in stop_arr_ind:
s,t,x = stop_arr[i]
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
l = q_start
while l < q_stop:
if skip_arr[l] == -1:
skip_arr[l] = q_stop
ans_arr[l] = x
l += 1
else:
l = update_skip(skip_arr, l)
print(*ans_arr, sep="\n")
| import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr.sort(key=lambda x:x[2])
ans_arr = [-1]*Q
skip_arr = [-1]*(Q+1)
def update_skip(skip_arr, x):
if skip_arr[x] == -1:
return x
x_dest = update_skip(skip_arr, skip_arr[x])
skip_arr[x] = x_dest
return x_dest
for s,t,x in stop_arr:
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
l = q_start
while l < q_stop:
if skip_arr[l] == -1:
skip_arr[l] = q_stop
ans_arr[l] = x
l += 1
else:
l = update_skip(skip_arr, l)
print(*ans_arr, sep="\n")
| p03033 |
import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr.sort(key=lambda x:x[2])
ans_arr = [-1]*Q
skip_arr = [-1]*(Q+1)
def update_skip(skip_arr, x):
if skip_arr[x] == -1:
return x
x_dest = update_skip(skip_arr, skip_arr[x])
skip_arr[x] = x_dest
return x_dest
for s,t,x in stop_arr:
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
l = q_start
while l < q_stop:
if skip_arr[l] == -1:
skip_arr[l] = q_stop
ans_arr[l] = x
l += 1
else:
l = update_skip(skip_arr, l)
print(*ans_arr, sep="\n")
| import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr.sort(key=lambda x:x[2])
ans_arr = [-1]*Q
skip_arr = [-1]*(Q+1)
for s,t,x in stop_arr:
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
l = q_start
while l < q_stop:
if skip_arr[l] == -1:
skip_arr[l] = q_stop
ans_arr[l] = x
l += 1
else:
l = skip_arr[l]
print(*ans_arr, sep="\n")
| p03033 |
import sys
input = sys.stdin.readline
import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr_ind = list(range(N))
stop_arr_ind.sort(key=lambda x:stop_arr[x][2], reverse=True)
ans_arr = [-1]*Q
for i in stop_arr_ind:
s,t,x = stop_arr[i]
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
for i in range(q_start, q_stop):
ans_arr[i] = x
print(*ans_arr, sep="\n")
| import sys
input = sys.stdin.readline
import bisect
N,Q = (int(x) for x in input().split())
stop_arr = [tuple(map(int, input().split())) for _ in range(N)]
Q_arr = [int(input()) for _ in range(Q)]
stop_arr_ind = list(range(N))
stop_arr_ind.sort(key=lambda x:stop_arr[x][2])
ans_arr = [-1]*Q
skip_arr = [-1]*(Q+1)
def update_skip(skip_arr, x):
if skip_arr[x] == -1:
return x
x_dest = update_skip(skip_arr, skip_arr[x])
skip_arr[x] = x_dest
return x_dest
for i in stop_arr_ind:
s,t,x = stop_arr[i]
q_start = bisect.bisect_left(Q_arr, s-x)
q_stop = bisect.bisect_left(Q_arr, t-x)
l = q_start
while l < q_stop:
if skip_arr[l] == -1:
skip_arr[l] = q_stop
ans_arr[l] = x
l += 1
else:
l = update_skip(skip_arr, l)
print(*ans_arr, sep="\n")
| p03033 |
import sys
import bisect
N, Q = list(map(int, input().split(' ')))
G = [list(map(int, sys.stdin.readline().split(' '))) for _ in range(N)]
T = [int(sys.stdin.readline()) for _ in range(Q)]
G.sort(key = lambda x : -x[2])
class SegTree :
def __init__(self, n) :
self.n = n
self.A = [None] * (2 << (n + 1).bit_length())
def update(self, i, l, r, ll, rr, val) :
if r <= ll or rr <= l :
return
if ll <= l and r <= rr :
self.A[i] = val
return
if self.A[i] != None :
self.A[i * 2] = self.A[i * 2 + 1] = self.A[i]
self.A[i] = None
m = (l + r) // 2
self.update(i * 2, l, m, ll, rr, val)
self.update(i * 2 + 1, m, r, ll, rr, val)
def get(self, i, l, r, p) :
while True :
if self.A[i] != None or l + 1 == r :
return self.A[i]
m = (l+r) // 2
if p < m :
i = i * 2
r = m
else :
i = i * 2 + 1
l = m
ST = SegTree(Q)
for g in G :
s = max(0, g[0] - g[2])
e = g[1] - g[2]
if e <= 0 :
continue
ll = bisect.bisect_left(T, s)
rr = bisect.bisect_left(T, e)
if ll == rr :
continue
ST.update(1, 0, Q, ll, rr, g[2])
for i in range(Q) :
ans = ST.get(1, 0, Q, i)
if ans == None :
print((-1))
else :
print(ans)
| import sys
import bisect
N, Q = list(map(int, input().split(' ')))
G = [list(map(int, sys.stdin.readline().split(' '))) for _ in range(N)]
T = [int(sys.stdin.readline()) for _ in range(Q)]
class SegTree :
def __init__(self, n) :
self.n = n
self.A = [10**15] * (2 << (n + 1).bit_length())
def update(self, l, r, val) :
l += len(self.A) // 2
r += len(self.A) // 2
while l < r:
if l & 1 :
self.A[l] = min(self.A[l], val)
l += 1
if r & 1:
self.A[r-1] = min(self.A[r-1], val)
r -= 1
l //= 2
r //= 2
def get(self, i) :
i += len(self.A) // 2
ret = self.A[i]
while i > 0 :
i //= 2
ret = min(ret, self.A[i])
return ret if ret < 10**15 else -1
ST = SegTree(Q)
for g in G :
s = g[0] - g[2]
e = g[1] - g[2]
ll = bisect.bisect_left(T, s)
rr = bisect.bisect_left(T, e)
if ll == rr :
continue
ST.update(ll, rr, g[2])
for i in range(Q) :
ans = ST.get(i)
print(ans)
| p03033 |
N,Q = list(map(int, input().split()))
STX = [list(map(int, input().split())) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
L = [(s-x-0.5, t-x-0.5,x) for s,t,x in STX] + [(d,) for d in D]
L.sort()
import heapq
hp = [] # (x,t-x)を入れる
for l in L:
if len(l)==1:
while hp and l[0] > hp[0][1]:
heapq.heappop(hp)
if hp:
print((hp[0][0]))
else:
print((-1))
else:
heapq.heappush(hp, (l[2],l[1])) | N,Q = list(map(int, input().split()))
STX = [list(map(int, input().split())) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
L = [(s-x-0.5, t-x-0.5,x) for s,t,x in STX] + [(d,) for d in D]
L.sort()
import heapq
hp = [] # xを入れる
memo = {} # x:t-x
for l in L:
if len(l)==1:
while hp and l[0] > memo[hp[0]]:
heapq.heappop(hp)
if hp:
print((hp[0]))
else:
print((-1))
else:
heapq.heappush(hp, l[2])
memo[l[2]]=l[1] | p03033 |
import heapq
def main():
N, Q = list(map(int, input().split()))
ls = []
lt = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
ls.append((s-x, x))
lt.append((t-x, x))
ls.sort(reverse=True)
lt.sort(reverse=True)
dh = []
dl = []
for i in range(Q):
d = int(eval(input()))
while ls and ls[-1][0] <= d:
s, x = ls.pop()
heapq.heappush(dl, x)
while lt and lt[-1][0] <= d:
t, x = lt.pop()
heapq.heappush(dh, x)
while dl and dh and dl[0] == dh[0]:
heapq.heappop(dl)
heapq.heappop(dh)
if not dl:
print('-1')
else:
print((dl[0]))
main()
| import heapq
def main():
N, Q = list(map(int, input().split()))
l = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
l.append((s-x, 1, x))
l.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
l.append((d, 2, i))
r = [-1] * Q
l.sort()
h = []
se = set()
for a, b, c in l:
if b == 0:
se.remove(c)
elif b == 1:
se.add(c)
heapq.heappush(h, c)
else:
while h and h[0] not in se:
heapq.heappop(h)
r[c] = h[0] if h else -1
print(('\n'.join(map(str, r))))
main()
| p03033 |
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
# random_denseがTLE, 他はAC
from bisect import bisect_left, bisect_right # 二分探索
def main_tle():
N, Q = i2nn()
STX = ii2nnn(N) # 座標 X で時刻 [S, T) が工事
D = ii2nn(Q) # 昇順ソート済み
E = [-1] * Q
STX.sort(key=lambda v: v[2])
for s, t, x in STX:
a = bisect_left(D, s-x)
b = bisect_left(D, t-x)
for i in range(a, b):
if E[i] == -1:
E[i] = x
for e in E:
print(e)
def main():
N, Q = i2nn()
STX = ii2nnn(N) # 座標 X で時刻 [S, T) が工事
D = ii2nn(Q) # 昇順ソート済み
events = []
for i, d in enumerate(D):
events.append(('D', d, i))
for s, t, x in STX:
events.append(('S', s-x-0.25, x))
events.append(('T', t-x-0.75, x)) # 0.5 同士だと [1, 2), [0, 1) で吹き飛ぶ
ans = [-1] * Q
events.sort(key=lambda v: v[1])
xset = set()
#xmin = None
xmin = 1e+10
xb = False
for event, time, xi in events:
if event == 'S':
xset.add(xi)
#if xmin is None or xmin > xi:
if xmin > xi:
xmin = xi
xb = True
elif event == 'T':
xset.remove(xi)
if xmin == xi:
#xmin = None
xb = False
elif event == 'D' and xset:
#if xmin is None:
if not xb:
xmin = min(xset)
ans[xi] = xmin
for n in ans:
print(n)
main()
| import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
# random_denseがTLE, 他はAC
"""
from bisect import bisect_left, bisect_right # 二分探索
def main():
N, Q = i2nn()
STX = ii2nnn(N) # 座標 X で時刻 [S, T) が工事
D = ii2nn(Q) # 昇順ソート済み
E = [-1] * Q
STX.sort(key=lambda v: v[2])
for s, t, x in STX:
a = bisect_left(D, s-x)
b = bisect_left(D, t-x)
for i in range(a, b):
if E[i] == -1:
E[i] = x
for e in E:
print(e)
"""
def main():
N, Q = i2nn()
STX = ii2nnn(N) # 座標 X で時刻 [S, T) が工事
D = ii2nn(Q) # 昇順ソート済み
events = []
for s, t, x in STX:
events.append(('S', s-x-0.25, x))
events.append(('T', t-x-0.75, x)) # 0.5 同士だと [1, 2), [0, 1) で吹き飛ぶ
for i, d in enumerate(D):
events.append(('D', d, i))
ans = [-1] * Q
events.sort(key=lambda v: v[1])
xset = set()
#xmin = None
xmin = 1e+10
xb = False
for event, time, xi in events:
if event == 'S':
xset.add(xi)
#if xmin is None or xmin > xi:
if xmin > xi:
xmin = xi
xb = True
elif event == 'T':
xset.remove(xi)
if xmin == xi:
#xmin = None
xb = False
elif event == 'D' and xset:
#if xmin is None:
if not xb:
xmin = min(xset)
xb = True
ans[xi] = xmin
for n in ans:
print(n)
main()
| p03033 |
import sys
from bisect import bisect_left
class RangeUpdateTree:
def __init__(self, n, initial=-1, sentinel=-2):
n2 = 1 << n.bit_length()
self.n = n2
self.offset = n2
self.data = [initial] * (n2 << 1)
self.sentinel = sentinel
def update(self, a, b, x):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if a <= l and r <= b:
self.data[i] = x
continue
y = self.data[i]
j = i << 1
if y != self.sentinel:
self.data[i] = self.sentinel
self.data[j] = self.data[j + 1] = y
m = (l + r) // 2
if a < m:
stack.append((j, l, m))
if m < b:
stack.append((j + 1, m, r))
def aggregate(self):
stack = [1]
ans = 0
while stack:
i = stack.pop()
if self.data[i] != self.sentinel:
ans += self.data[i] * (self.n >> i.bit_length() - 1)
continue
i <<= 1
stack.append(i)
stack.append(i + 1)
return ans
def propagate(self):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if self.data[i] != self.sentinel:
self.data[l + self.offset:r + self.offset] = [self.data[i]] * (r - l)
continue
i <<= 1
m = (l + r) // 2
stack.append((i, l, m))
stack.append((i + 1, m, r))
def debug_print(self):
i = 1
while i <= self.offset:
print((self.data[i:2 * i]))
i <<= 1
n, q = list(map(int, input().split()))
lines = sys.stdin.readlines()
kkk = []
for line in lines[:n]:
s, t, x = list(map(int, line.split()))
kkk.append((x, s, t))
kkk.sort(reverse=True)
ddd = list(map(int, lines[n:]))
rut = RangeUpdateTree(q)
i = 0
while i < n:
x, s, t = kkk[i]
while i < n - 1 and kkk[i + 1][0] == x and kkk[i + 1][2] == s:
i += 1
s = kkk[i][1]
ss = bisect_left(ddd, s - x)
tt = bisect_left(ddd, t - x)
if ss == tt:
continue
# print(x, s, t, s - x, t - x, ss, tt)
rut.update(ss, tt, x)
i += 1
rut.propagate()
# rut.debug_print()
print(('\n'.join(map(str, rut.data[rut.offset:rut.offset + q]))))
| import sys
from bisect import bisect_left
class RangeUpdateTree:
def __init__(self, n, initial=-1, sentinel=-2):
n2 = 1 << n.bit_length()
self.n = n2
self.offset = n2
self.data = [initial] * (n2 << 1)
self.sentinel = sentinel
def update(self, a, b, x):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if a <= l and r <= b:
self.data[i] = x
continue
y = self.data[i]
j = i << 1
if y != self.sentinel:
self.data[i] = self.sentinel
self.data[j] = self.data[j + 1] = y
m = (l + r) // 2
if a < m:
stack.append((j, l, m))
if m < b:
stack.append((j + 1, m, r))
def propagate(self):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if self.data[i] != self.sentinel:
self.data[l + self.offset:r + self.offset] = [self.data[i]] * (r - l)
continue
i <<= 1
m = (l + r) // 2
stack.append((i, l, m))
stack.append((i + 1, m, r))
def debug_print(self):
i = 1
while i <= self.offset:
print((self.data[i:2 * i]))
i <<= 1
n, q = list(map(int, input().split()))
lines = sys.stdin.readlines()
kkk = []
for line in lines[:n]:
s, t, x = list(map(int, line.split()))
kkk.append((x, s, t))
kkk.sort(reverse=True)
ddd = list(map(int, lines[n:]))
rut = RangeUpdateTree(q)
for x, s, t in kkk:
ss = bisect_left(ddd, s - x)
tt = bisect_left(ddd, t - x)
if ss == tt:
continue
# print(x, s, t, s - x, t - x, ss, tt)
rut.update(ss, tt, x)
rut.propagate()
# rut.debug_print()
print(('\n'.join(map(str, rut.data[rut.offset:rut.offset + q]))))
| p03033 |
import sys
from bisect import bisect_left
class RangeUpdateTree:
def __init__(self, n, initial=-1, sentinel=-2):
n2 = 1 << n.bit_length()
self.n = n2
self.offset = n2
self.data = [initial] * (n2 << 1)
self.sentinel = sentinel
def update(self, a, b, x):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if a <= l and r <= b:
self.data[i] = x
continue
y = self.data[i]
j = i << 1
if y != self.sentinel:
self.data[i] = self.sentinel
self.data[j] = self.data[j + 1] = y
m = (l + r) // 2
if a < m:
stack.append((j, l, m))
if m < b:
stack.append((j + 1, m, r))
def propagate(self):
stack = [(1, 0, self.n)]
while stack:
i, l, r = stack.pop()
if self.data[i] != self.sentinel:
self.data[l + self.offset:r + self.offset] = [self.data[i]] * (r - l)
continue
i <<= 1
m = (l + r) // 2
stack.append((i, l, m))
stack.append((i + 1, m, r))
def debug_print(self):
i = 1
while i <= self.offset:
print((self.data[i:2 * i]))
i <<= 1
n, q = list(map(int, input().split()))
lines = sys.stdin.readlines()
kkk = []
for line in lines[:n]:
s, t, x = list(map(int, line.split()))
kkk.append((x, s, t))
kkk.sort(reverse=True)
ddd = list(map(int, lines[n:]))
rut = RangeUpdateTree(q)
for x, s, t in kkk:
ss = bisect_left(ddd, s - x)
tt = bisect_left(ddd, t - x)
if ss == tt:
continue
# print(x, s, t, s - x, t - x, ss, tt)
rut.update(ss, tt, x)
rut.propagate()
# rut.debug_print()
print(('\n'.join(map(str, rut.data[rut.offset:rut.offset + q]))))
| import sys
from bisect import bisect_left
n, q = list(map(int, input().split()))
lines = sys.stdin.readlines()
kkk = []
for line in lines[:n]:
s, t, x = list(map(int, line.split()))
kkk.append((x, s, t))
kkk.sort()
ddd = list(map(int, lines[n:]))
ans = [-1] * q
skip = [-1] * q
for x, s, t in kkk:
ss = bisect_left(ddd, s - x)
tt = bisect_left(ddd, t - x)
while ss < tt:
if skip[ss] == -1:
ans[ss] = x
skip[ss] = tt
ss += 1
else:
ss = skip[ss]
print(('\n'.join(map(str, ans))))
| p03033 |
from collections import deque
import heapq
import sys
n,p=list(map(int,input().split()))
e=[]
for _ in range(n):
s,t,x = list(map(int,input().split()))
e.append((s-x,1,x))
e.append((t-x,-1,x))
e = sorted(e)
q = deque()
for _ in range(p):
q.append(int(eval(input())))
s=set()
for t,f,x in e:
while t > q[0]:
q.popleft()
if s:
print((min(s)))
else:
print((-1))
if not q:
sys.exit()
if f == 1:
s.add(x)
else:
s.remove(x)
while q:
q.pop()
print((-1)) | import sys
input = sys.stdin.readline
n,q = list(map(int,input().split()))
imos = []
for i in range(n):
s,t,x = list(map(int,input().split()))
imos.append((s-x,x))
imos.append((t-x,-x))
ans = set()
j = 0
for i in range(q):
d = int(eval(input()))
imos.append((d,1e100))
imos.sort()
m = 1e100
flag = False
for t,stop in imos:
if stop == 1e100:
if ans:
if not flag:
m = min(ans)
flag = True
print(m)
else:
print((-1))
elif stop > 0:
ans.add(stop)
if stop < m:
m = stop
flag = True
else:
ans.remove(-stop)
if m == -stop:flag = False | p03033 |
n,q=[int(j) for j in input().split()]
l=[]
for i in range(n):
s,t,x=[int(j) for j in input().split()]
l.append((s-x,1,x))
l.append((t-x,0,x))
for i in range(q):
d=int(eval(input()))
l.append((d,2,i))
l.sort()
ans=[-1]*q
ll=set()
m=10**18
p=False
for i,j,x in l:
if j==1:
ll.add(x)
if m>x:
m=x
p=True
elif j==0:
ll.remove(x)
if x==m:
p=False
else:
if not p:
if ll:
p=True
m=min(ll)
else:
m=-1
ans[x]=m
for i in ans:
print(i)
| import sys
input = sys.stdin.readline
n,q=[int(j) for j in input().split()]
l=[]
for i in range(n):
s,t,x=[int(j) for j in input().split()]
l.append((s-x,1,x))
l.append((t-x,0,x))
for i in range(q):
d=int(eval(input()))
l.append((d,2,i))
l.sort()
ans=[-1]*q
ll=set()
m=10**18
p=False
for i,j,x in l:
if j==1:
ll.add(x)
if m>x:
m=x
p=True
elif j==0:
ll.remove(x)
if x==m:
p=False
else:
if not p:
if ll:
p=True
m=min(ll)
else:
m=-1
ans[x]=m
print(('\n'.join(map(str,ans))))
| p03033 |
import sys
input = sys.stdin.readline
n,q=[int(j) for j in input().split()]
l=[]
for i in range(n):
s,t,x=[int(j) for j in input().split()]
l.append((s-x,1,x))
l.append((t-x,0,x))
for i in range(q):
d=int(eval(input()))
l.append((d,2,i))
l.sort()
ans=[-1]*q
ll=set()
m=10**18
p=False
for i,j,x in l:
if j==1:
ll.add(x)
if m>x:
m=x
p=True
elif j==0:
ll.remove(x)
if x==m:
p=False
else:
if not p:
if ll:
p=True
m=min(ll)
else:
m=-1
ans[x]=m
print(('\n'.join(map(str,ans))))
| def f():
import sys
input = sys.stdin.readline
n,q=[int(j) for j in input().split()]
l=[]
for i in range(n):
s,t,x=[int(j) for j in input().split()]
l.append((s-x,1,x))
l.append((t-x,0,x))
for i in range(q):
d=int(eval(input()))
l.append((d,2,i))
l.sort()
ans=[-1]*q
ll=set()
m=10**18
p=False
for i,j,x in l:
if j==1:
ll.add(x)
if m>x:
m=x
p=True
elif j==0:
ll.remove(x)
if x==m:
p=False
else:
if not p:
if ll:
p=True
m=min(ll)
else:
m=-1
ans[x]=m
print(('\n'.join(map(str,ans))))
f() | p03033 |
import sys
from bisect import *
input = sys.stdin.readline
def f(n, q, ss):
xst = []
for ssk in ss[:n]:
s, t, x = map(int, ssk.split())
xst.append([x, s - x, t - x])
xst.sort()
ds = list(map(int, ss[n:]))
ans = [-1] * q
for x, s, t in xst:
i = bisect_left(ds, s)
while i < q:
if ds[i] < t:
if ans[i] == -1:
ans[i] = x
i += 1
else:
break
print(*ans, sep="\n")
n, q = map(int, input().split())
ss = sys.stdin.readlines()
f(n, q, ss)
| import sys
from bisect import *
input = sys.stdin.readline
def f(n, q):
xst = []
for i in range(n):
s, t, x = map(int, input().split())
xst.append([x, s - x, t - x])
xst.sort()
ds = []
for i in range(q):
d = int(input())
ds.append(d)
ans = [-1] * q
jump = [-1] * q
for x, s, t in xst:
i = bisect_left(ds, s)
fi = bisect_left(ds, t)
while i < fi:
if jump[i] != -1:
i = jump[i]
else:
ans[i] = x
jump[i] = fi
i += 1
print(*ans, sep="\n")
n, q = map(int, input().split())
f(n, q)
| p03033 |
from bisect import*
from collections import*
import sys;input=sys.stdin.readline
def doevent(lis):
global stop
a,b=lis
if b>=0:
if stop=={-1}:
stop=set()
stop.add(b)
else:
if -b in stop:
stop.remove(-b)
if stop==set():
stop={-1}
return min(stop)
stop=set([-1])
def main():
n,q=list(map(int,input().split()))
event=[]
for i in range(n):
s,t,x=list(map(int,input().split()))
event.append((s-x,x))
event.append((t-x,-x))
event.sort(key=lambda x:x[0])
minlist=defaultdict(int)
for k,v in enumerate(event):
minlist[k]=doevent(v)
for i in range(q):
sys.stdout.writelines(str(minlist[bisect_right(event,(int(eval(input())),10**9))-1])+"\n")
if __name__ == '__main__':
main() | import sys;input=sys.stdin.readline
n,q=list(map(int, input().split()))
event=[]
for _ in range(n):
s,t,x=list(map(int,input().split()))
event.append((s-x-0.5,1,x))
event.append((t-x-0.5,-1,x))
for i in range(q):
event.append((int(eval(input())),0,i))
event.sort()
is_stop=False
stop=set()
minstop=float('inf')
ans=[-1]*q
for t,e,x in event:
if e > 0:
stop.add(x)
if x<minstop:
minstop=x
is_stop=True
elif e<0:
stop.remove(x)
if minstop==x:
is_stop=False
elif len(stop)>0:
if not is_stop:
minstop=min(stop)
is_stop=True
ans[x]=minstop
print(('\n'.join(map(str, ans)))) | p03033 |
class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.size = 1 << (self.n - 1).bit_length()
self.lazy = [self.e] * (self.size << 1)
def update(self, l, r, x):
"""
半開区間 [l, r) の値を x に更新 （ 0-indexed ） （ O(logN) ）
"""
l += (self.size - 1)
r += (self.size - 1)
self.propagate(l)
self.propagate(r-1)
while l < r:
if r&1 == 0:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.op(x, self.lazy[r])
if l&1 == 0:
self.lazy[l] = self.op(x, self.lazy[l])
l += 1
l = (l - 1) // 2
r = (r - 1) // 2
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
tmp = []
while i>0:
i -= 1
i >>= 1
tmp.append(i)
for x in reversed(tmp):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.op(self.lazy[x], self.lazy[2*x+1])
self.lazy[2*x+2] = self.op(self.lazy[x], self.lazy[2*x+2])
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += (self.size - 1)
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(self.size-1):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.op(self.lazy[x], self.lazy[2*x+1])
self.lazy[2*x+2] = self.op(self.lazy[x], self.lazy[2*x+2])
self.lazy[x] = self.e
for a in self.lazy[self.size-1:self.size-1+self.n]:
yield a
def __str__(self):
for x in range(self.size-1):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.op(self.lazy[x], self.lazy[2*x+1])
self.lazy[2*x+2] = self.op(self.lazy[x], self.lazy[2*x+2])
self.lazy[x] = self.e
return str(self.lazy[self.size-1:self.size-1 + self.n])
class ListList:
""" tupleを一番目の添え字に関してソートする"""
def __init__(self, max_value_list):
"""
:param max_value_list: tuple = (i, j, k) を考えた時、 max_value_list = (j_max, k_max)
"""
self.list_list = []
self.separation = [0]
self.max_value_list = list(map(lambda x: x.bit_length(), max_value_list))
for a in self.max_value_list:
self.separation.append(self.separation[-1] + a)
self.separation.reverse()
self.mask = list(map(lambda x: x-1, self.separation))
def append(self, array):
temp = 0
for x, i in zip(array, self.separation):
temp += x<<i
self.list_list.append(temp)
def sort(self, reverse=False):
return self.list_list.sort(reverse=reverse)
def __getitem__(self, item):
temp = self.list_list[item]
array = []
for a in self.max_value_list:
array = [temp&((1<<a)-1)] + array
temp>>=a
array = [temp] + array
return array
def __iter__(self):
for i in range(len(self.list_list)):
yield self[i]
def __str__(self):
text = []
for a in self:
text.append("[" + ", ".join(list(map(str, a))) + "]")
return "[" + ", ".join(text) + "]"
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = ListList([10**9,10**9])
for _ in range(N):
S, T, X = map(int, input().split())
Qu.append((X, S, T))
Qu.sort(reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
X, S, T = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.size = 1 << (self.n - 1).bit_length()
self.lazy = [self.e] * (self.size << 1)
def update(self, l, r, x):
"""
半開区間 [l, r) の値を x に更新 （ 0-indexed ） （ O(logN) ）
"""
l += (self.size - 1)
r += (self.size - 1)
self.propagate(l)
self.propagate(r-1)
while l < r:
if r&1 == 0:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = x
if l&1 == 0:
self.lazy[l] = x
l += 1
l = (l - 1) // 2
r = (r - 1) // 2
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
tmp = []
while i>0:
i -= 1
i >>= 1
tmp.append(i)
for x in reversed(tmp):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.lazy[x]
self.lazy[2*x+2] = self.lazy[x]
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += (self.size - 1)
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(self.size-1):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.lazy[x]
self.lazy[2*x+2] = self.lazy[x]
self.lazy[x] = self.e
for a in self.lazy[self.size-1:self.size-1+self.n]:
yield a
def __str__(self):
for x in range(self.size-1):
if self.lazy[x] == self.e:
continue
self.lazy[2*x+1] = self.lazy[x]
self.lazy[2*x+2] = self.lazy[x]
self.lazy[x] = self.e
return str(self.lazy[self.size-1:self.size-1 + self.n])
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = [list(map(int, input().split())) for _ in range(N)]
Qu.sort(key=lambda x:x[2], reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
S, T, X = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| p03033 |
class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.depth = (self.n - 1).bit_length()
self.size = 1 << self.depth
self.lazy = [self.e] * ((self.size << 1) + 1)
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.lazy[self.size + i] = array[i]
def update(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate(l0)
self.propagate(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.op(x, self.lazy[r])
if l&1:
self.lazy[l] = self.op(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
for k in range(i.bit_length()-1, 0,-1):
x = i>>k
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
for a in self.lazy[self.size:self.size+self.n]:
yield a
def __str__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
return str(self.lazy[self.size:self.size + self.n])
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = [list(map(int, input().split())) for _ in range(N)]
Qu.sort(key=lambda x:x[2], reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
S, T, X = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.depth = (self.n - 1).bit_length()
self.size = 1 << self.depth
self.lazy = [self.e] * ((self.size << 1) + 1)
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.lazy[self.size + i] = array[i]
def update(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate(l0)
self.propagate(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.op(x, self.lazy[r])
if l&1:
self.lazy[l] = self.op(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
for k in range(self.depth, 0,-1):
x = i>>k
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
for a in self.lazy[self.size:self.size+self.n]:
yield a
def __str__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
return str(self.lazy[self.size:self.size + self.n])
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = [list(map(int, input().split())) for _ in range(N)]
Qu.sort(key=lambda x:x[2], reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
S, T, X = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| p03033 |
class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.depth = (self.n - 1).bit_length()
self.size = 1 << self.depth
self.lazy = [self.e] * ((self.size << 1) + 1)
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.lazy[self.size + i] = array[i]
def update(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
l += self.size
r += self.size
l0 = l//(l&-l)
r0 = r//(r&-r)
self.propagate(l0)
self.propagate(r0-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.op(x, self.lazy[r])
if l&1:
self.lazy[l] = self.op(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
for k in range(i.bit_length()-1, 0,-1):
x = i>>k
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
for a in self.lazy[self.size:self.size+self.n]:
yield a
def __str__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
return str(self.lazy[self.size:self.size + self.n])
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = [list(map(int, input().split())) for _ in range(N)]
Qu.sort(key=lambda x:x[2], reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
S, T, X = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| class DualSegmentTree():
def __init__(self, n, op, e):
"""
:param n: 配列の要素数
:param op: 作用素（モノイド＝結合則＋単位元存在）
:param e: 単位元
"""
self.n = n
self.op = op
self.e = e
self.depth = (self.n - 1).bit_length()
self.size = 1 << self.depth
self.lazy = [self.e] * ((self.size << 1) + 1)
def built(self, array):
"""
arrayを初期値とするセグメント木を構築
"""
for i in range(self.n):
self.lazy[self.size + i] = array[i]
def update(self, l, r, x):
"""
半開区間 [l, r) の各々の要素 a に op(x, a)を作用させる （ 0-indexed ） （ O(logN) ）
"""
l += self.size
r += self.size
self.propagate(l//(l&-l))
self.propagate((r//(r&-r))-1)
while l < r:
if r&1:
r -= 1 # 半開区間なので先に引いてる
self.lazy[r] = self.op(x, self.lazy[r])
if l&1:
self.lazy[l] = self.op(x, self.lazy[l])
l += 1
l >>= 1
r >>= 1
def propagate(self, i):
"""
根から葉に伝搬させる。可換モノイドの場合は更新時の伝搬をサボれる。 （ O(logN) ）
"""
for k in range(i.bit_length()-1, 0,-1):
x = i>>k
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
def get(self, i):
"""
i 番目の値を取得（ 0-indexed ） ( O(logN) )
"""
i += self.size
self.propagate(i)
return self.lazy[i]
def __getitem__(self, i):
return self.get(i)
def __iter__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
for a in self.lazy[self.size:self.size+self.n]:
yield a
def __str__(self):
for x in range(1, self.size):
if self.lazy[x] == self.e:
continue
self.lazy[(x<<1)|1] = self.op(self.lazy[x], self.lazy[(x<<1)|1])
self.lazy[x<<1] = self.op(self.lazy[x], self.lazy[x<<1])
self.lazy[x] = self.e
return str(self.lazy[self.size:self.size + self.n])
##################################################################################################################
import sys
from bisect import *
input = sys.stdin.readline
N, Q = map(int, input().split())
e = -1
op = lambda x, y: x if x != e else y
st = DualSegmentTree(Q, op, e)
Qu = [list(map(int, input().split())) for _ in range(N)]
Qu.sort(key=lambda x:x[2], reverse=True)
D = [int(input()) for _ in range(Q)]
for q in Qu:
S, T, X = q
L = bisect_left(D,S-X)
R = bisect_left(D,T-X)
st.update(L, R, X)
print(*st, sep="\n")
| p03033 |
import sys
from itertools import accumulate
from collections import Counter
from bisect import bisect as br, bisect_left as bl
from operator import itemgetter
class DammyMap:
#1-indexed
def __init__(self, A, B):
#Aに初期状態の要素をすべて入れる,Bは値域のリスト
self.X, self.comp = self.compress(B)
self.size = len(self.X)
self.tree = [0] * (self.size + 1)
self.p = 2**(self.size.bit_length() - 1)
self.dep = self.size.bit_length()
CA = Counter(A)
S = [0] + list(accumulate([CA[self.X[i]] for i in range(self.size)]))
for i in range(1, 1+self.size):
self.tree[i] = S[i] - S[i - (i&-i)]
def compress(self, L):
#座圧
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2, 1)}
# 1-indexed
return L2, C
def leng(self):
#今入っている個数を取得
return self.count(self.size)
def count(self, i):
#i(Bの元)以下の個数を取得
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def less(self, v):
#v(Bの元である必要はない)未満の個数を取得
i = bl(self.X, v)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def leq(self, v):
#v(Bの元である必要はない)以下の個数を取得
i = br(self.X, v)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
#iをx個入れる,負のxで取り出す,iの個数以上取り出すとエラーを出さずにバグる
i = self.comp[i]
while i <= self.size:
self.tree[i] += x
i += i & -i
def get(self, v):
# v番目の値を取得
if v <= 0:
return -1
s = 0
k = self.p
for _ in range(self.dep):
if s + k <= self.size and self.tree[s+k] < v:
s += k
v -= self.tree[s]
k //= 2
return self.X[s]
def compress(L):
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2)}
return L2, C
N, Q = map(int, input().split())
stx = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N)]
stx.sort(key = itemgetter(2))
D = [int(sys.stdin.readline()) for _ in range(Q)]
_, comp = compress(D)
T = DammyMap(D, D)
ans = [-1]*Q
for s, t, x in stx:
tl = T.less(s - x)
tr = T.less(t - x)
d = tr - tl
for _ in range(d):
i = T.get(tl + 1)
T.add(i, -1)
ans[comp[i]] = x
print(*ans, sep = '\n')
| import sys
from itertools import accumulate
from collections import Counter
from bisect import bisect as br, bisect_left as bl
from operator import itemgetter
class DammyMap:
#1-indexed
def __init__(self, A, B):
#Aに初期状態の要素をすべて入れる,Bは値域のリスト
#self.X, self.comp = self.compress(B)
self.X = B[:]
self.comp = {v : k for k, v in enumerate(D, 1)}
self.size = len(self.X)
self.tree = [0] * (self.size + 1)
self.p = 2**(self.size.bit_length() - 1)
self.dep = self.size.bit_length()
CA = Counter(A)
S = [0] + list(accumulate([CA[self.X[i]] for i in range(self.size)]))
for i in range(1, 1+self.size):
self.tree[i] = S[i] - S[i - (i&-i)]
def compress(self, L):
#座圧
L2 = list(set(L))
L2.sort()
C = {v : k for k, v in enumerate(L2, 1)}
# 1-indexed
return L2, C
def leng(self):
#今入っている個数を取得
return self.count(self.size)
def count(self, i):
#i(Bの元)以下の個数を取得
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def less(self, v):
#v(Bの元である必要はない)未満の個数を取得
i = bl(self.X, v)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def leq(self, v):
#v(Bの元である必要はない)以下の個数を取得
i = br(self.X, v)
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
#iをx個入れる,負のxで取り出す,iの個数以上取り出すとエラーを出さずにバグる
i = self.comp[i]
while i <= self.size:
self.tree[i] += x
i += i & -i
def get(self, v):
# v番目の値を取得
if v <= 0:
return -1
s = 0
k = self.p
for _ in range(self.dep):
if s + k <= self.size and self.tree[s+k] < v:
s += k
v -= self.tree[s]
k //= 2
return self.X[s]
N, Q = map(int, input().split())
stx = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N)]
stx.sort(key = itemgetter(2))
D = [int(sys.stdin.readline()) for _ in range(Q)]
T = DammyMap(D, D)
ans = [-1]*Q
for s, t, x in stx:
tl = T.less(s - x)
tr = T.less(t - x)
d = tr - tl
for _ in range(d):
i = T.get(tl + 1)
T.add(i, -1)
ans[T.comp[i]-1] = x
print(*ans, sep = '\n')
| p03033 |
import bisect
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
N, Q = list(map(int, next(sys.stdin).split()))
STX = [list(map(int, next(sys.stdin).split())) for _ in range(N)]
D = [int(next(sys.stdin)) for _ in range(Q)]
ans = [-1 for _ in range(Q)]
nexts = [-1 for _ in range(Q)]
for s, t, x in sorted(STX, key=lambda stx: (stx[2], stx[1])):
# [lo, hi) に出発した人は x で止まる
# x の小さい順にソート済みなのでここで確定
lo = max(0, bisect.bisect_left(D, s - x))
hi = min(len(D), bisect.bisect_left(D, t - x))
p = lo
while p < hi:
if nexts[p] == -1:
ans[p] = x
nexts[p] = hi
p += 1
else:
prev = p
p = nexts[p]
nexts[prev] = hi
print(('\n'.join(map(str, ans))))
| import bisect
import sys
sys.setrecursionlimit(10000)
INF = float('inf')
N, Q = list(map(int, next(sys.stdin).split()))
STX = [list(map(int, next(sys.stdin).split())) for _ in range(N)]
D = [int(next(sys.stdin)) for _ in range(Q)]
ans = [-1] * Q
nexts = [-1] * Q
for s, t, x in sorted(STX, key=lambda stx: (stx[2], stx[1])):
# [lo, hi) に出発した人は x で止まる
# x の小さい順にソート済みなのでここで確定
lo = max(0, bisect.bisect_left(D, s - x))
hi = min(len(D), bisect.bisect_left(D, t - x))
p = lo
while p < hi:
if nexts[p] == -1:
ans[p] = x
nexts[p] = hi
p += 1
else:
prev = p
p = nexts[p]
nexts[prev] = hi
print(('\n'.join(map(str, ans))))
| p03033 |
from collections import defaultdict
from heapq import heappop, heappush
N, Q = list(map(int, input().split()))
INF = float('inf')
events = []
for i in range(N):
S, T, X = list(map(int, input().split()))
events.append((S - X, 0, X))
events.append((T - X, 1, X))
for _ in range(Q):
events.append((int(eval(input())), 2, 0))
events.sort()
cnt = defaultdict(int)
cnt[INF] += 1
que = [INF]
for t, flag, x in events:
if flag == 0:
if cnt[x] == 0:
heappush(que, x)
cnt[x] += 1
elif flag == 1:
cnt[x] -= 1
else:
while cnt[que[0]] == 0:
heappop(que)
print((que[0] if que[0] != INF else -1))
| import sys
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush
N, Q = list(map(int, input().split()))
INF = float('inf')
events = []
for i in range(N):
S, T, X = list(map(int, input().split()))
events.append((S - X, 0, X))
events.append((T - X, 1, X))
for _ in range(Q):
events.append((int(eval(input())), 2, 0))
events.sort()
cnt = defaultdict(int)
cnt[INF] += 1
que = [INF]
for t, flag, x in events:
if flag == 0:
if cnt[x] == 0:
heappush(que, x)
cnt[x] += 1
elif flag == 1:
cnt[x] -= 1
else:
while cnt[que[0]] == 0:
heappop(que)
print((que[0] if que[0] != INF else -1))
| p03033 |
from collections import deque
from heapq import heappush, heappop
N, Q = map(int, input().split())
E = []
for i in range(N):
s, t, x = map(int, input().split())
E.append((0, t - x, x, i))
E.append((1, s - x, x, i))
D = [int(input()) for _ in range(Q)]
E.sort(key=lambda a: a[1], reverse=True)
ans = []
que = [(10**18, -1)]
V = set()
for d in D:
while E and E[-1][1] <= d:
f, _, x, i = E.pop()
if f == 0:
V.add(i)
else:
heappush(que, (x, i))
while que[0][1] in V:
heappop(que)
ans.append(que[0][0])
ans = [a if a < 10**18 else -1 for a in ans]
print(*ans, sep='\n')
| from heapq import heappush, heappop
import sys
input = sys.stdin.buffer.readline
N, Q = map(int, input().split())
E = []
for i in range(N):
s, t, x = map(int, input().split())
E.append((0, t - x, x, i))
E.append((1, s - x, x, i))
D = [int(input()) for _ in range(Q)]
E.sort(key=lambda a: a[1], reverse=True)
ans = []
que = [(10**18, -1)]
V = set()
for d in D:
while E and E[-1][1] <= d:
f, _, x, i = E.pop()
if f == 0:
V.add(i)
else:
heappush(que, (x, i))
while que[0][1] in V:
heappop(que)
ans.append(que[0][0])
ans = [a if a < 10**18 else -1 for a in ans]
print(*ans, sep='\n')
| p03033 |
from bisect import bisect_left
n, Q = [int(x) for x in input().split()]
stx = [[int(x) for x in input().split()] for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | from bisect import bisect_left
n, Q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | p03033 |
from bisect import bisect_left
n, Q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | from bisect import bisect_left
n, Q = [int(x) for x in input().split()]
stx = [[int(x) for x in input().split()] for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | p03033 |
from bisect import bisect_left
n, Q = [int(x) for x in input().split()]
stx = [[int(x) for x in input().split()] for i in range(n)]
q = [int(eval(input())) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | from bisect import bisect_left
import sys
n, Q = [int(x) for x in sys.stdin.readline().split()]
stx = [[int(x) for x in sys.stdin.readline().split()] for i in range(n)]
q = [int(sys.stdin.readline()) for i in range(Q)]
stx.sort(key=lambda x: x[2])
ans = [-1 for i in range(Q)]
skip = [-1 for i in range(Q)]
for (s, t, x) in stx:
begin = bisect_left(q, s-x)
end = bisect_left(q, t-x)
while begin<end:
if skip[begin]==-1:
ans[begin] = x
skip[begin] = end
begin += 1
else:
begin = skip[begin]
for e in ans:
print(e) | p03033 |
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x:x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1]*Q
skip = [-1]*Q
for s, t, x in W:
l = bisect_left(D, s-x)
r = bisect_left(D, t-x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep='\n')
| import sys
input = sys.stdin.readline
from bisect import bisect_left
N, Q = map(int, input().split())
W = [tuple(map(int, input().split())) for _ in range(N)]
W.sort(key=lambda x:x[2])
D = [int(input()) for _ in range(Q)]
ans = [-1]*Q
skip = [-1]*Q
for s, t, x in W:
l = bisect_left(D, s-x)
r = bisect_left(D, t-x)
while l < r:
if skip[l] == -1:
ans[l] = x
skip[l] = r
l += 1
else:
l = skip[l]
print(*ans, sep='\n')
| p03033 |
import heapq
def main():
N, Q = list(map(int, input().split()))
STX = tuple(list(map(int, input().split())) for _ in range(N))
D = tuple([int(eval(input())) for _ in range(Q)])
L = []
for s, t, x in STX:
L.append((x, s - x, t - x))
L.sort(key = lambda x: x[1])
q = []
cnt = 0
for i in range(Q):
while cnt < len(L) and D[i] >= L[cnt][1]:
heapq.heappush(q, L[cnt])
cnt += 1
while q != []:
t = heapq.heappop(q)
if t[2] > D[i]:
print((t[0]))
heapq.heappush(q, t)
break
else:
print((-1))
main()
| import heapq
def main():
N, Q = list(map(int, input().split()))
STX = tuple(list(map(int, input().split())) for _ in range(N))
D = tuple([int(eval(input())) for _ in range(Q)])
L = []
for s, t, x in STX:
L.append((x, s - x, t - x))
L.sort(key = lambda x: x[1])
q = []
cnt = 0
push = heapq.heappush
pop = heapq.heappop
t = []
for i in range(Q):
while cnt < len(L) and D[i] >= L[cnt][1]:
if t != []:
push(q, t)
t = []
push(q, L[cnt])
cnt += 1
if t != [] and t[2] > D[i]:
print((t[0]))
else:
while q != []:
t = pop(q)
if t[2] > D[i]:
print((t[0]))
break
else:
t = []
print((-1))
main()
| p03033 |
def update(l, r, v):
L = l + N0; R = r + N0
while L < R:
if R & 1:
R -= 1
data[R-1] = v
if L & 1:
data[L-1] = v
L += 1
L >>= 1; R >>= 1
# a_iの現在の値を取得
def _query(k):
k += N0-1
s = INF
while k >= 0:
if data[k]:
s = max(s, data[k])
k = (k - 1) // 2
return s
# これを呼び出す
def query(k):
return _query(k)[1]
from bisect import bisect_left
if __name__ == '__main__':
n, q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for _ in range(n)]
l = [int(eval(input())) for _ in range(q)]
INF = (-1, 2**31-1)
N = len(l)
N0 = 2**(N-1).bit_length()
data = [None]*(2*N0)
stx.sort(key=lambda x:x[2], reverse=True)
for i, (s, t, x) in enumerate(stx):
i1 = bisect_left(l, s - 0.5 - x)
i2 = bisect_left(l, t - 0.5 - x)
update(i1, i2, (i, x))
for i in range(q):
tmp = query(i)
if tmp == INF[1]:
print((-1))
else:
print(tmp)
| def update(l, r, v):
L = l + N0; R = r + N0
while L < R:
if R & 1:
R -= 1
data[R-1] = v
if L & 1:
data[L-1] = v
L += 1
L >>= 1; R >>= 1
# a_iの現在の値を取得
def _query(k):
k += N0-1
s = INF
while k >= 0:
if data[k]:
s = max(s, data[k])
k = (k - 1) // 2
return s
# これを呼び出す
def query(k):
return _query(k)[1]
from bisect import bisect_left
from sys import stdin
if __name__ == '__main__':
n, q = list(map(int, stdin.readline().rstrip().split()))
stx = [list(map(int, stdin.readline().rstrip().split())) for _ in range(n)]
l = [int(stdin.readline().rstrip()) for _ in range(q)]
INF = (-1, 2**31-1)
N = len(l)
N0 = 2**(N-1).bit_length()
data = [None]*(2*N0)
stx.sort(key=lambda x:x[2], reverse=True)
for i, (s, t, x) in enumerate(stx):
i1 = bisect_left(l, s - 0.5 - x)
i2 = bisect_left(l, t - 0.5 - x)
update(i1, i2, (i, x))
for i in range(q):
tmp = query(i)
if tmp == INF[1]:
print((-1))
else:
print(tmp)
| p03033 |
from bisect import bisect_right
N,Q,*L = list(map(int, open(0).read().split()))
D = L[3*N:]
ls = [0]*N
for i in range(N):
s,t,x = L[3*i],L[3*i+1],L[3*i+2]
ls[i] = (x,s,t)
ls.sort()
line = [0]*(2*N)
for i in range(N):
x,s,t = ls[i]
line[2*i] = (s-x,0,i)
line[2*i+1] = (t-x,1,i)
line.sort()
road = [c[0] for c in line]
inf = [0]*(2*N)
m = 0
for i in range(2*N):
d,p,j = line[i]
if p:
m -= 1<<j
else:
m += 1<<j
inf[i] = m
for d in D:
i = bisect_right(road,d)
if i==2*N or i==0:
print((-1))
continue
m = inf[i-1]
s = m&-m
if s==0:
print((-1))
else:
ind = len(bin(s)[2:])-1
print((ls[ind][0])) | from heapq import heappush, heappop
N,Q,*L = list(map(int, open(0).read().split()))
D = L[3*N:]
ls = []
for i in range(N):
s,t,x = L[3*i],L[3*i+1],L[3*i+2]
ls.append((s-x,1,x))
ls.append((t-x,0,x))
for i,d in enumerate(D):
ls.append((d,2,i))
ls.sort()
ans = [0]*Q
S = set()
hq = []
for a,b,c in ls:
if b==0:
S.remove(c)
elif b==1:
S.add(c)
heappush(hq,c)
else:
while hq and hq[0] not in S:
heappop(hq)
ans[c] = hq[0] if hq else -1
print(('\n'.join(map(str,ans)))) | p03033 |
n,q = list(map(int, input().split()))
stx = [tuple(map(int, input().split())) for _ in range(n)]
d = [int(eval(input())) for _ in range(q)]
#これはセグ木 * bisect
import bisect
inf = 10**9 + 100
def init(n,init_num=0):
num = len(str(bin(n-1))) + 1
seg = [init_num] * (2**num)
seg[0] = 2**(num-1)
return(seg)
def update(head, tail, x):
# print('{} {} {}'.format(head, tail, x))
head += seg[0]
tail += seg[0]
points = []
while(head <= tail):
if(head == tail):
points.append(head)
break
if(head % 2 ==1):
points.append(head)
head += 1
head = head//2
if(tail % 2 == 0):
points.append(tail)
tail -= 1
tail = (tail-1)//2
for point in points:
seg[point] = min(seg[point], x)
def execute(p):
p += seg[0]
tmp = seg[p]
while(p > 0):
p = p//2
tmp = min(tmp, sep[p])
return(tmp)
def execute_all():
for i in range(2,len(seg)):
seg[i] = min(seg[i], seg[i//2])
seg = init(q, init_num = inf)
for i in range(n):
left = bisect.bisect_left(d, stx[i][0] -stx[i][2])
right = bisect.bisect_right(d, stx[i][1] - stx[i][2] -1) -1
update(left, right, stx[i][2])
# print('{} {} {}'.format(left, right, stx[i][2]))
execute_all()
for i in seg[seg[0]: seg[0] + q]:
if(i == inf):
print((-1))
else:
print(i)
| import sys
input = sys.stdin.readline
n,q = list(map(int, input().split()))
# stx = [tuple(map(int, input().split())) for _ in range(n)]
stx = [0]*n
for i in range(n):
stx[i] = tuple(map(int, input().split()))
# d = [int(input()) for _ in range(q)]
d = [0]*q
for i in range(q):
d[i] = int(eval(input()))
#これはセグ木 * bisect
import bisect
inf = 10**9 + 100
# 定数倍高速化
b_left = bisect.bisect_left
b_right = bisect.bisect_right
def init(n,init_num=0):
num = len(str(bin(n-1))) + 1
seg = [init_num] * (2**num)
# seg[0] = 2**(num-1)
seg0 = 2**(num-1)
return(seg,seg0)
def update(head, tail, x):
# print('{} {} {}'.format(head, tail, x))
head += seg0
tail += seg0
points = []
while(head <= tail):
if(head == tail):
points.append(head)
break
if(head % 2 ==1):
points.append(head)
head += 1
head = head//2
if(tail % 2 == 0):
points.append(tail)
tail -= 1
tail = (tail-1)//2
for point in points:
seg[point] = min(seg[point], x)
def execute_all():
for i in range(2,len(seg)):
seg[i] = min(seg[i], seg[i//2])
seg,seg0 = init(q, init_num = inf)
for i in range(n):
left = b_left(d, stx[i][0] -stx[i][2])
right = b_right(d, stx[i][1] - stx[i][2] -1) -1
update(left, right, stx[i][2])
# print('{} {} {}'.format(left, right, stx[i][2]))
execute_all()
for i in seg[seg0: seg0 + q]:
if(i == inf):
print((-1))
else:
print(i) | p03033 |
n,q = list(map(int, input().split()))
# stx = [tuple(map(int, input().split())) for _ in range(n)]
stx = [0]*n
for i in range(n):
stx[i] = tuple(map(int, input().split()))
# d = [int(input()) for _ in range(q)]
d = [0]*q
for i in range(q):
d[i] = int(eval(input()))
#これはセグ木 * bisect
import bisect
inf = 10**9 + 100
# 定数倍高速化
b_left = bisect.bisect_left
b_right = bisect.bisect_right
def init(n,init_num=0):
num = len(str(bin(n-1))) + 1
seg = [init_num] * (2**num)
# seg[0] = 2**(num-1)
seg0 = 2**(num-1)
return(seg,seg0)
def update(head, tail, x):
# print('{} {} {}'.format(head, tail, x))
head += seg0
tail += seg0
points = []
while(head <= tail):
if(head == tail):
points.append(head)
break
if(head % 2 ==1):
points.append(head)
head += 1
head = head//2
if(tail % 2 == 0):
points.append(tail)
tail -= 1
tail = (tail-1)//2
for point in points:
seg[point] = min(seg[point], x)
def execute_all():
for i in range(2,len(seg)):
seg[i] = min(seg[i], seg[i//2])
seg,seg0 = init(q, init_num = inf)
for i in range(n):
left = b_left(d, stx[i][0] -stx[i][2])
right = b_right(d, stx[i][1] - stx[i][2] -1) -1
update(left, right, stx[i][2])
# print('{} {} {}'.format(left, right, stx[i][2]))
execute_all()
for i in seg[seg0: seg0 + q]:
if(i == inf):
print((-1))
else:
print(i) | import sys
input = sys.stdin.readline
n,q = list(map(int, input().split()))
stx = [tuple(map(int, input().split())) for _ in range(n)]
d = [int(eval(input())) for _ in range(q)]
#これはセグ木 * bisect
import bisect
inf = 10**9 + 100
def init(n,init_num=0):
num = len(str(bin(n-1))) + 1
seg = [init_num] * (2**num)
seg[0] = 2**(num-1)
return(seg)
def update(head, tail, x):
# print('{} {} {}'.format(head, tail, x))
head += seg[0]
tail += seg[0]
points = []
while(head <= tail):
if(head == tail):
points.append(head)
break
if(head % 2 ==1):
points.append(head)
head += 1
head = head//2
if(tail % 2 == 0):
points.append(tail)
tail -= 1
tail = (tail-1)//2
for point in points:
seg[point] = min(seg[point], x)
def execute(p):
p += seg[0]
tmp = seg[p]
while(p > 0):
p = p//2
tmp = min(tmp, sep[p])
return(tmp)
def execute_all():
for i in range(2,len(seg)):
seg[i] = min(seg[i], seg[i//2])
seg = init(q, init_num = inf)
for i in range(n):
left = bisect.bisect_left(d, stx[i][0] -stx[i][2])
right = bisect.bisect_right(d, stx[i][1] - stx[i][2] -1) -1
update(left, right, stx[i][2])
# print('{} {} {}'.format(left, right, stx[i][2]))
execute_all()
for i in seg[seg[0]: seg[0] + q]:
if(i == inf):
print((-1))
else:
print(i) | p03033 |
import heapq
class HeapDict:
def __init__(self):
self.h = []
self.d = {}
def insert(self,x):
if x not in self.d or self.d[x] == 0:
heapq.heappush(self.h, x)
self.d.setdefault(x,0)
self.d[x] += 1
def erase(self,x):
if x not in self.d or self.d[x] == 0:
return
else:
self.d[x] -= 1
while self.h:
if self.d[self.h[0]] == 0:
heapq.heappop(self.h)
else:
break
def get_min(self):
if not self.h:
return None
else:
return self.h[0]
def pop(self):
poped_val = self.h[0]
self.erase(poped_val)
return poped_val
def exist(self, x):
return (x in self.d and self.d[x] > 0)
def show_h(self):
elems = [v for v in self.h if self.d[v] > 0]
print(elems)
def show_d(self):
print((self.d))
def main():
n,q = list(map(int, input().split()))
eventl = []
for _ in range(n):
s,t,x = list(map(int, input().split()))
eventl.append((s-x-0.5, 'stop', x))
eventl.append((t-x-0.5, 'start', x))
for i in range(q):
d = int(eval(input()))
eventl.append((d,'go', i))
eventl.sort()
ans = [0]*q
hd = HeapDict()
for e in eventl:
if e[1] == 'stop':
hd.insert(e[2])
elif e[1] == 'start':
hd.erase(e[2])
else:
min_x = hd.get_min()
if min_x is not None:
ans[e[2]] = min_x
else:
ans[e[2]] = -1
for a in ans:
print(a)
if __name__ == "__main__":
main() | import heapq
class HeapDict:
def __init__(self):
self.h = []
self.d = {}
def insert(self,x):
if x not in self.d or self.d[x] == 0:
heapq.heappush(self.h, x)
self.d.setdefault(x,0)
self.d[x] += 1
def erase(self,x):
if x not in self.d or self.d[x] == 0:
return
else:
self.d[x] -= 1
while self.h:
if self.d[self.h[0]] == 0:
heapq.heappop(self.h)
else:
break
def get_min(self):
if not self.h:
return None
else:
return self.h[0]
def pop(self):
poped_val = self.h[0]
self.erase(poped_val)
return poped_val
def exist(self, x):
return (x in self.d and self.d[x] > 0)
def show_h(self):
elems = [v for v in self.h if self.d[v] > 0]
print(elems)
def show_d(self):
print((self.d))
def main():
n,q = list(map(int, input().split()))
eventl = []
for _ in range(n):
s,t,x = list(map(int, input().split()))
eventl.append((s-x, 'a-stop', x))
eventl.append((t-x, 'b-start', x))
for i in range(q):
d = int(eval(input()))
eventl.append((d,'c-go', i))
eventl.sort()
ans = [0]*q
hd = HeapDict()
for e in eventl:
if e[1] == 'a-stop':
hd.insert(e[2])
elif e[1] == 'b-start':
hd.erase(e[2])
else:
min_x = hd.get_min()
if min_x is not None:
ans[e[2]] = min_x
else:
ans[e[2]] = -1
for a in ans:
print(a)
if __name__ == "__main__":
main() | p03033 |
import heapq
class HeapDict:
def __init__(self):
self.h = []
self.d = {}
def insert(self,x):
if x not in self.d or self.d[x] == 0:
heapq.heappush(self.h, x)
self.d.setdefault(x,0)
self.d[x] += 1
def erase(self,x):
if x not in self.d or self.d[x] == 0:
return
else:
self.d[x] -= 1
while self.h:
if self.d[self.h[0]] == 0:
heapq.heappop(self.h)
else:
break
def get_min(self):
if not self.h:
return None
else:
return self.h[0]
def pop(self):
poped_val = self.h[0]
self.erase(poped_val)
return poped_val
def exist(self, x):
return (x in self.d and self.d[x] > 0)
def show_h(self):
elems = [v for v in self.h if self.d[v] > 0]
print(elems)
def show_d(self):
print((self.d))
def main():
n,q = list(map(int, input().split()))
eventl = []
for _ in range(n):
s,t,x = list(map(int, input().split()))
eventl.append((s-x, 'a-stop', x))
eventl.append((t-x, 'b-start', x))
for i in range(q):
d = int(eval(input()))
eventl.append((d,'c-go', i))
eventl.sort()
ans = [0]*q
hd = HeapDict()
for e in eventl:
if e[1] == 'a-stop':
hd.insert(e[2])
elif e[1] == 'b-start':
hd.erase(e[2])
else:
min_x = hd.get_min()
if min_x is not None:
ans[e[2]] = min_x
else:
ans[e[2]] = -1
for a in ans:
print(a)
if __name__ == "__main__":
main() | import heapq
class HeapDict:
def __init__(self):
self.h = []
self.d = {}
def insert(self,x):
if x not in self.d or self.d[x] == 0:
heapq.heappush(self.h, x)
self.d.setdefault(x,0)
self.d[x] += 1
def erase(self,x):
if x not in self.d or self.d[x] == 0:
return
else:
self.d[x] -= 1
while self.h:
if self.d[self.h[0]] == 0:
heapq.heappop(self.h)
else:
break
def get_min(self):
if not self.h:
return None
else:
return self.h[0]
def pop(self):
poped_val = self.h[0]
self.erase(poped_val)
return poped_val
def exist(self, x):
return (x in self.d and self.d[x] > 0)
def show_h(self):
elems = [v for v in self.h if self.d[v] > 0]
print(elems)
def show_d(self):
print((self.d))
# def main():
n,q = list(map(int, input().split()))
eventl = []
for _ in range(n):
s,t,x = list(map(int, input().split()))
eventl.append((s-x, 'a-stop', x))
eventl.append((t-x, 'b-start', x))
for i in range(q):
d = int(eval(input()))
eventl.append((d,'c-go', i))
eventl.sort()
ans = [0]*q
hd = HeapDict()
for e in eventl:
if e[1] == 'a-stop':
hd.insert(e[2])
elif e[1] == 'b-start':
hd.erase(e[2])
else:
min_x = hd.get_min()
if min_x is not None:
ans[e[2]] = min_x
else:
ans[e[2]] = -1
for a in ans:
print(a)
# if __name__ == "__main__":
# main() | p03033 |
import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
import bisect
"""
各工事場所について，
Dがどのレンジなら引っかかるかを記録しておく．
最初全部のDに関して，infまで行けるものとして，
Xが大きい順に工事区間を見て，引っかかるならば区間更新
"""
N,Q=MI()
xst2=[]#x,ごとに，Dがどの範囲なら引っかかるか(s~t)
xi=[[0,0]for _ in range(N)]
for i in range(N):
s,t,x=MI()
xst2.append([x,s-x,t-x])
xi[i]=[x,i]
xi.sort(reverse=True)
#遅延セグ木##
INF = 2**31-1
LV = (Q-1).bit_length()
N0 = 2**LV
data = [INF]*(2*N0)
lazy = [None]*(2*N0)
# 伝搬対象の区間を求める
def gindex(l, r):
L = (l + N0) >> 1; R = (r + N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
# 遅延伝搬処理
def propagates(*ids):
for i in reversed(ids):
v = lazy[i-1]
if v is None:
continue
lazy[2*i-1] = data[2*i-1] = lazy[2*i] = data[2*i] = v
lazy[i-1] = None
# 区間[l, r)をxで更新
def update(l, r, x):
*ids, = gindex(l, r)
propagates(*ids)
L = N0 + l; R = N0 + r
while L < R:
if R & 1:
R -= 1
lazy[R-1] = data[R-1] = x
if L & 1:
lazy[L-1] = data[L-1] = x
L += 1
L >>= 1; R >>= 1
for i in ids:
data[i-1] = min(data[2*i-1], data[2*i])
# 区間[l, r)内の最小値を求める
def query(l, r):
propagates(*gindex(l, r))
L = N0 + l; R = N0 + r
s = INF
while L < R:
if R & 1:
R -= 1
s = min(s, data[R-1])
if L & 1:
s = min(s, data[L-1])
L += 1
L >>= 1; R >>= 1
return s
D=[0]*Q
for i in range(Q):
D[i]=I()
#1~10**9は大きいので，Dに与えられた値のみを見る，
for i in range(N):
ii=xi[i][1]
x,s,t=xst2[ii][0],xst2[ii][1],xst2[ii][2]
nums=bisect.bisect_left(D,s)
numt=bisect.bisect_left(D,t)
if nums!=numt:
update(nums,numt,x)
for i in range(Q):
ans=query(i,i+1)
if ans==INF:
print((-1))
else:
print(ans)
main()
| import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
import bisect
"""
各工事場所について，
Dがどのレンジなら引っかかるかを記録しておく．
最初全部のDに関して，infまで行けるものとして，
Xが小さい順に工事区間を見て，引っかかるならば区間更新．
一度値を決定した場所は飛ばしながら更新するようにすればO(Q)
nxtを入れながら進めば各ノードを2回しか見ないからO(Q)
事前のソートで NlogN
"""
N,Q=MI()
xst2=[]#x,ごとに，Dがどの範囲なら引っかかるか(s~t)
xi=[[0,0]for _ in range(N)]
for i in range(N):
s,t,x=MI()
xst2.append([x,s-x,t-x])
xi[i]=[x,i]
xi.sort()
D=[0]*Q
for i in range(Q):
D[i]=I()
inf=10**10
ans=[inf]*(Q+4)#すこし多めにとっておく
nxt=[0]*(Q+4)#次に見るべき番号
for i in range(Q+4):
nxt[i]=i+1
"""
print(xi)
print(xst2)"""
for i in range(N):
ii=xi[i][1]
xx=xst2[ii][0]
#0-index
ss=bisect.bisect_left(D,xst2[ii][1])
tt=bisect.bisect_left(D,xst2[ii][2])
j=ss
while j<tt:
if ans[j]==inf:
ans[j]=xx
jj=j
j=nxt[j]
nxt[jj]=tt#次ここにきたら，ttのところまで移動するようにしておく
"""print(ii,xst2[ii][1],xst2[ii][2],xx,ss,tt)
print(ans)
print(nxt)"""
for i in range(Q):
res=ans[i]
if res==inf:
print((-1))
else:
print(res)
main()
| p03033 |
import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int, input().split()))
List = []
dic = {}
for _ in range(N):
s, t, x = list(map(int, input().split()))
List.append([s-0.5-x, 1, x])
List.append([t-0.5-x, -1, x])
dic[x] = False
import heapq
List.sort()
h = []
j = 0
for _ in range(Q):
D = int(eval(input()))
while j < 2*N and List[j][0] < D:
if List[j][1] == 1:
heapq.heappush(h, List[j][2])
dic[List[j][2]] = True
else:
dic[List[j][2]] = False
j += 1
while h:
ans = h[0]
if dic[ans]:
print(ans)
break
else:
heapq.heappop(h)
if not h:
print((-1)) | import sys
input = sys.stdin.buffer.readline
N,Q = list(map(int, input().split()))
List = []
dic = {}
for _ in range(N):
s, t, x = list(map(int, input().split()))
List.append((s-0.5-x, 1, x))
List.append((t-0.5-x, -1, x))
dic[x] = False
import heapq
List.sort()
h = []
j = 0
for _ in range(Q):
D = int(eval(input()))
while j < 2*N and List[j][0] < D:
if List[j][1] == 1:
heapq.heappush(h, List[j][2])
dic[List[j][2]] = True
else:
dic[List[j][2]] = False
j += 1
while h:
ans = h[0]
if dic[ans]:
print(ans)
break
else:
heapq.heappop(h)
if not h:
print((-1)) | p03033 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
for _ in range(num): return []
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
from operator import itemgetter
from bisect import bisect_left
class LazySegmentTree:
def __init__(self,N,default=float('inf')):
#演算の定義
self.op = min
#初期化の値
self.default = default
self.N0 = 2**(N-1).bit_length()
self.tree = [self.default]*(2*self.N0)
self.lazy = [None]*(2*self.N0)
#伝搬される区間のインデックス(1-indexed)を全て列挙するgenerator
def gindex(self,l,r):
L = l + self.N0; R = r + self.N0
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L:
yield L
L >>= 1
#1-indexedで単調増加のインデックスリストを渡す
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.tree[2*i-1] = self.lazy[2*i] = self.tree[2*i] = v
self.lazy[i-1] = None
#区間[l,r)の値をxに更新
def update(self,l,r,x):
if l < r:
*ids, = self.gindex(l, r)
self.propagates(*ids)
L = l + self.N0; R = r + self.N0
while L < R:
if R & 1:
R -= 1
self.lazy[R-1] = self.tree[R-1] = x
if L & 1:
self.lazy[L-1] = self.tree[L-1] = x
L += 1
L >>= 1; R >>= 1
for i in ids:
self.tree[i-1] = self.op(self.tree[2*i-1], self.tree[2*i])
#区間[l,r)へのクエリ
def query(self,l,r):
self.propagates(*self.gindex(l, r))
L = l + self.N0; R = r + self.N0
s = self.default
while L < R:
if R & 1:
R -= 1
s = self.op(s,self.tree[R-1])
if L & 1:
s = self.op(s,self.tree[L-1])
L += 1
L >>= 1; R >>= 1
return s
N,Q = II()
a = []
for _ in range(N):
s,t,x = II()
a.append((x, s-x-0.5, t-x-0.5))
D = Line(Q,1)
a.sort(key=itemgetter(0),reverse=True)
seg = LazySegmentTree(Q, 10**9+1)
for b in a:
l = bisect_left(D,b[1]) + 1
r = bisect_left(D,b[2]) + 1
seg.update(l,r,b[0])
for i in range(Q):
x = seg.query(i+1,i+2)
if x == 10**9+1:
print((-1))
else:
print(x) | import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
for _ in range(num): return []
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(map(int, input().split())) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
from operator import itemgetter
from bisect import bisect_left
N,Q = II()
a = []
for _ in range(N):
s,t,x = II()
a.append((x, s-x-0.5, t-x-0.5))
a.sort(key=itemgetter(0))
D = Line(Q,1)
ans = [-1]*(Q+1)
right = [0]*Q
for a0 in a:
l = bisect_left(D,a0[1])
r = bisect_left(D,a0[2])
while l<r:
while ans[l]!=-1:
l = right[l]
if l==N:
break
if l>=r:
break
ans[l] = a0[0]
right[l] = r
l += 1
for i in range(Q):
print((ans[i])) | p03033 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
for _ in range(num): return []
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
from operator import itemgetter
from bisect import bisect_left
from collections import defaultdict
#1-indexedの遅延評価セグメント木
class LazySegmentTree:
def __init__(self,N,default=float('inf')):
#演算の定義
self.op = min
#初期化の値
self.default = default
self.LV = (N-1).bit_length()
self.N0 = 2**self.LV
self.tree = defaultdict(lambda:default)
self.lazy = defaultdict(lambda:None)
#伝搬対象の区間を求める
def gindex(self, l, r):
L = (l + self.N0) >> 1; R = (r + self.N0) >> 1
lc = 0 if l & 1 else (L & -L).bit_length()
rc = 0 if r & 1 else (R & -R).bit_length()
for i in range(self.LV):
if rc <= i:
yield R
if L < R and lc <= i:
yield L
L >>= 1; R >>= 1
#遅延伝搬処理
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i-1]
if v is None:
continue
self.lazy[2*i-1] = self.tree[2*i-1] = self.lazy[2*i] = self.tree[2*i] = v
self.lazy[i-1] = None
#区間[l,r)の値をxに更新
def update(self,l,r,x):
if l < r:
*ids, = self.gindex(l, r)
self.propagates(*ids)
L = l + self.N0; R = r + self.N0
while L < R:
if R & 1:
R -= 1
self.lazy[R-1] = self.tree[R-1] = x
if L & 1:
self.lazy[L-1] = self.tree[L-1] = x
L += 1
L >>= 1; R >>= 1
for i in ids:
self.tree[i-1] = self.op(self.tree[2*i-1], self.tree[2*i])
#区間[l,r)へのクエリ
def query(self,l,r):
self.propagates(*self.gindex(l, r))
L = l + self.N0; R = r + self.N0
s = self.default
while L < R:
if R & 1:
R -= 1
s = self.op(s,self.tree[R-1])
if L & 1:
s = self.op(s,self.tree[L-1])
L += 1
L >>= 1; R >>= 1
return s
#1-indexedでk番目の値を取得
def get(self,k):
self.propagates(*self.gindex(k, k+1))
return self.tree[k+self.N0-1]
N,Q = II()
a = []
for _ in range(N):
s,t,x = II()
a.append((x, s-x-0.5, t-x-0.5))
D = Line(Q,1)
a.sort(key=itemgetter(0),reverse=True)
seg = LazySegmentTree(Q, 10**9+1)
for b in a:
l = bisect_left(D,b[1]) + 1
r = bisect_left(D,b[2]) + 1
seg.update(l,r,b[0])
for i in range(Q):
x = seg.get(i+1)
if x == 10**9+1:
print((-1))
else:
print(x) | import sys
import math
from collections import defaultdict
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(eval(input()))
def II(): return list(map(int, input().split()))
def III(): return list(map(int, input().split()))
def Line(N,num):
if N<=0:
for _ in range(num): return []
elif num==1:
return [I() for _ in range(N)]
else:
read_all = [tuple(II()) for _ in range(N)]
return list(map(list,list(zip(*read_all))))
#################
from operator import itemgetter
from bisect import bisect_left
class Range_SegmentTree:
def __init__(self,N):
self.N0 = 2**(N-1).bit_length()
self.tree = [None]*(2*self.N0)
self.INF = (-1, 2**31-1)
#区間[l,r]の値をvに書き換える
#vは(t,value)という値にする (新しい値ほどtは大きくなる)
def update(self,l,r,v):
L = l + self.N0; R = r + self.N0 + 1
while L < R:
if R & 1:
R -= 1
self.tree[R-1] = v
if L & 1:
self.tree[L-1] = v
L += 1
L >>= 1; R >>= 1
#a[k]の現在の値を更新時刻と共に取得
def _query(self,k):
k += self.N0-1
s = self.INF
while k >= 0:
if self.tree[k]:
s = max(s, self.tree[k])
k = (k - 1) // 2
return s
#a[k]を返す
def query(self,k):
return self._query(k)[1]
N,Q = II()
a = []
for _ in range(N):
s,t,x = II()
a.append((x, s-x-0.5, t-x-0.5))
D = Line(Q,1)
a.sort(key=itemgetter(0),reverse=True)
seg = Range_SegmentTree(Q)
for i,b in enumerate(a):
l = bisect_left(D,b[1])
r = bisect_left(D,b[2])
seg.update(l,r-1,(i,b[0]))
for i in range(Q):
x = seg.query(i)
if x == 2**31-1:
print((-1))
else:
print(x) | p03033 |
import bisect
N, Q = list(map(int, input().rstrip().split(' ')))
construction = [list(map(int, input().rstrip().split(' '))) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
construction = sorted(construction, key=lambda x: x[2])
dist = [-1] * Q
jump = [-1] * Q
indices = list(range(Q))
for c in construction:
i1 = bisect.bisect_left(D, c[0] - c[2])
i2 = bisect.bisect_left(D, c[1] - c[2])
i = i1
while i < i2:
if jump[i] != -1:
i = jump[i]
continue
else:
jump[i] = i2
dist[i] = c[2]
i += 1
for d in dist:
print(d)
| import sys
import bisect
input=sys.stdin.readline
N, Q = list(map(int, input().split(' ')))
construction = [list(map(int, input().split(' '))) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
construction = sorted(construction, key=lambda x: x[2])
dist = [-1] * Q
jump = [-1] * Q
indices = list(range(Q))
for s, t, x in construction:
i1 = bisect.bisect_left(D, s-x)
i2 = bisect.bisect_left(D, t-x)
i = i1
while i < i2:
k = jump[i]
if k != -1:
i = k
else:
jump[i] = i2
dist[i] = x
i += 1
for d in dist:
print(d)
| p03033 |
def main():
import bisect
n,q=list(map(int,input().split()))
stx=[list(map(int,input().split())) for _ in [0]*n]
d=[int(eval(input())) for _ in [0]*q]
stx=[[s-x,t-x-1,x] for s,t,x in stx]
stx=[[bisect.bisect_left(d,s),bisect.bisect_right(d,t),x] for s,t,x in stx]
#セグ木の要素数（num）および深さ（depth）を計算
basesize=q
num,depth=1,1
while num<basesize:
num*=2
depth+=1
num-=1
#セグ木を構築
treesize=num+basesize
tree=[10**9+1]*treesize
#半開区間[lower,upper)について更新の準備をする関数
def range_update_pre(lower,upper,new_value):
q=[[0,1]] #インデックス、階層
while q:
i,f=q.pop()
#popしたインデックスと階層から、求める下限と上限を算出する
#幅
width=pow(2,depth-f)
#下限と中央と上限
kagen=(i-pow(2,f-1)+1)*width
chuo=kagen+width//2
jogen=kagen+width
k=2*i+1
if lower<=kagen and jogen<=upper:
tree[i]=min(new_value,tree[i])
continue
if k<treesize:
if lower<=kagen and chuo<=upper:tree[k]=min(new_value,tree[k])
elif lower<=chuo:q.append([k,f+1])
if k+1<treesize:
if lower<=chuo and jogen<=upper:tree[k+1]=min(new_value,tree[k+1])
elif chuo<=upper:q.append([k+1,f+1])
for s,t,x in stx:
if s<t:
range_update_pre(s,t,x)
for i in range(1,treesize):
tree[i]=min(tree[i],tree[(i-1)//2])
ans=[i for i in tree[treesize-basesize:]]
for i in ans:
if i==10**9+1:
print((-1))
else:
print(i)
main() | def main():
from bisect import bisect_left
from bisect import bisect_right
from sys import stdin
input=stdin.readline
n,q=list(map(int,input().split()))
stx=[list(map(int,input().split())) for _ in [0]*n]
d=[int(eval(input())) for _ in [0]*q]
stx=[[s-x,t-x-1,x] for s,t,x in stx]
stx=[[bisect_left(d,s),bisect_right(d,t),x] for s,t,x in stx]
#セグ木の要素数（num）および深さ（depth）を計算
basesize=q
num,depth=1,1
while num<basesize:
num*=2
depth+=1
num-=1
#セグ木を構築
treesize=num+basesize
tree=[10**9+1]*treesize
#半開区間[lower,upper)について更新の準備をする関数
def range_update_pre(lower,upper,new_value):
q=[[0,1]] #インデックス、階層
while q:
i,f=q.pop()
#popしたインデックスと階層から、求める下限と上限を算出する
#幅
width=pow(2,depth-f)
#下限と中央と上限
kagen=(i-pow(2,f-1)+1)*width
chuo=kagen+width//2
jogen=kagen+width
k=2*i+1
if lower<=kagen and jogen<=upper:
tree[i]=min(new_value,tree[i])
continue
if k<treesize:
if lower<=kagen and chuo<=upper:tree[k]=min(new_value,tree[k])
elif lower<=chuo:q.append([k,f+1])
if k+1<treesize:
if lower<=chuo and jogen<=upper:tree[k+1]=min(new_value,tree[k+1])
elif chuo<=upper:q.append([k+1,f+1])
for s,t,x in stx:
if s<t:
range_update_pre(s,t,x)
for i in range(1,treesize):
tree[i]=min(tree[i],tree[(i-1)//2])
ans=[i for i in tree[treesize-basesize:]]
for i in ans:
if i==10**9+1:
print((-1))
else:
print(i)
main() | p03033 |
import sys, heapq
input = sys.stdin.buffer.readline # 入出力高速化
def main():
N, Q = list(map(int, input().split()))
tl = [] # イベントタイムライン
for _ in range(N):
S, T, X = list(map(int, input().split()))
tl.append((S-X, 1, X)) # insert
tl.append((T-X, 0, X)) # erase
for _ in range(Q):
D = int(eval(input()))
tl.append((D, 2, 0)) # min
tl.sort()
working = list() # 工事中
todelete = list() # 削除用
for t, c, x in tl:
if c == 0: # erase
heapq.heappush(todelete, x)
elif c == 1: # insert
heapq.heappush(working, x)
else: # min
while todelete and todelete[0] == working[0]:
heapq.heappop(todelete)
heapq.heappop(working)
print((-1 if not working else working[0]))
return
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline # 入出力高速化
def main():
N, Q = list(map(int, input().split()))
tl = [] # イベントタイムライン
for _ in range(N):
S, T, X = list(map(int, input().split()))
tl.append((S-X, 1, X)) # insert
tl.append((T-X, 0, X)) # erase
for _ in range(Q):
D = int(eval(input()))
tl.append((D, 2, 0)) # min
tl.sort()
working = set() # 工事中
wcur = 0 # 工事中の区域の数
curmin = -1
flag = False
for t, c, x in tl:
if c == 0: # erase
wcur -= 1
working.remove(x)
if x <= curmin:
curmin = x
flag = True
elif c == 1: # insert
wcur += 1
working.add(x)
if curmin < 0 or curmin >= x:
curmin = x
flag = False
else: # min
if wcur == 0:
curmin = -1
flag = False
elif flag:
curmin = min(working)
flag = False
print(curmin)
return
if __name__ == "__main__":
main() | p03033 |
from ctypes import *
import subprocess as sp
from operator import itemgetter
import sys
import os.path
set_code = r"""
#include <set>
std::set<int> s;
void add(int x) {
s.insert(x);
}
bool find(int x) {
return s.find(x) != s.end();
}
void remove(int x) {
s.erase(x);
}
bool empty() {
return s.empty();
}
int getMin() {
return *s.begin();
}
"""
class CppSet:
counter = 0
def __init__(self):
lib_name = './hoge{}.so'.format(CppSet.counter)
if not os.path.exists(lib_name):
code_file_name = "tmp.cpp"
with open(code_file_name, "w") as f:
f.write(set_code)
CppSet.counter += 1
sp.Popen(['g++', '-fPIC', '-shared', '-std=c++11', code_file_name, '-o', lib_name]).communicate()
lib = CDLL(lib_name)
self.add = getattr(lib, "_Z3addi")
self.find = CFUNCTYPE(c_bool, c_int)(
("_Z4findi", lib),
((1, "x"), )
)
self.remove = getattr(lib, "_Z6removei")
self.empty = CFUNCTYPE(c_bool)(
("_Z5emptyv", lib),
()
)
self.getMin = CFUNCTYPE(c_int)(
("_Z6getMinv", lib),
()
)
def main():
N, Q = map(int, sys.stdin.readline().split())
tmp = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N)]
stx = [(s - x, 1, x) for s, t, x in tmp] + [(t - x, -1, x) for s, t, x in tmp]
stx.sort()
D = [int(sys.stdin.readline()) for _ in range(Q)]
ans = [-1]*Q
idx = 0
stx_len = len(stx)
se = CppSet()
for i, d in enumerate(D):
while idx < stx_len:
t, com, x = stx[idx]
if t > d:
break
if com == 1:
se.add(x)
else:
se.remove(x)
idx += 1
ans[i] = (-1 if se.empty() else se.getMin())
print(*ans, sep='\n')
if __name__ == "__main__":
main()
| from ctypes import *
import subprocess as sp
from operator import itemgetter
import sys
import os.path
set_code = r"""
#include <set>
std::set<int> s;
void add(int x) {
s.insert(x);
}
bool find(int x) {
return s.find(x) != s.end();
}
void remove(int x) {
s.erase(x);
}
bool empty() {
return s.empty();
}
int getMin() {
return *s.begin();
}
"""
class CppSet:
counter = 0
def __init__(self):
lib_name = './hoge{}.so'.format(CppSet.counter)
code_file_name = "tmp.cpp"
with open(code_file_name, "w") as f:
f.write(set_code)
CppSet.counter += 1
sp.Popen(['g++', '-fPIC', '-shared', '-std=c++11', code_file_name, '-o', lib_name]).communicate()
lib = CDLL(lib_name)
self.add = getattr(lib, "_Z3addi")
self.find = CFUNCTYPE(c_bool, c_int)(
("_Z4findi", lib),
((1, "x"), )
)
self.remove = getattr(lib, "_Z6removei")
self.empty = CFUNCTYPE(c_bool)(
("_Z5emptyv", lib),
()
)
self.getMin = CFUNCTYPE(c_int)(
("_Z6getMinv", lib),
()
)
def main():
N, Q = map(int, sys.stdin.readline().split())
tmp = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N)]
stx = [(s - x, 1, x) for s, t, x in tmp] + [(t - x, -1, x) for s, t, x in tmp]
stx.sort()
D = [int(sys.stdin.readline()) for _ in range(Q)]
ans = [-1]*Q
idx = 0
stx_len = len(stx)
se = CppSet()
for i, d in enumerate(D):
while idx < stx_len:
t, com, x = stx[idx]
if t > d:
break
if com == 1:
se.add(x)
else:
se.remove(x)
idx += 1
ans[i] = (-1 if se.empty() else se.getMin())
print(*ans, sep='\n')
if __name__ == "__main__":
main()
| p03033 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000000)
MOD = 10 ** 9 + 7
INF = (1<<31) - 1
dy = (-1,0,1,0)
dx = (0,1,0,-1)
from bisect import bisect_left
class LazySegmentTree():
fx = min
fa = min
fm = min
unit_x = INF
unit_m = INF
def __init__(self,Q):
self.N = Q
self.tree = [self.unit_x]*(2*self.N)
self.lazy = [self.unit_m]*(2*self.N)
#self._build(array)
def _build(self,array):
for i,value in enumerate(array,self.N):
self.tree[i] = value
for i in range(self.N - 1,0,-1):
self.tree[i] = self.fx(self.tree[i << 1],self.tree[i << 1|1])
def _evaluate(self,K):#Kの上の遅延配列を評価する
H = K.bit_length() - 1
for i in range(H,0,-1):
h = K >> i
if self.lazy[h] == self.unit_m:
continue
self.tree[h] = self.fa(self.tree[h],self.lazy[h])
self.lazy[h << 1] = self.fm(self.lazy[h << 1],self.lazy[h])
self.lazy[h << 1|1] = self.fm(self.lazy[h << 1|1],self.lazy[h])
self.lazy[h] = self.unit_m
def _caluculate(self,K):#Kより上を計算する
while K > 1:
K >>= 1
a = self.fa(self.tree[K << 1],self.lazy[K << 1])
b = self.fa(self.tree[K << 1|1],self.lazy[K << 1|1])
self.tree[K] = self.fx(a,b)
def range_update(self,L,R,M):#[L,R)にMを作用
L += self.N
R += self.N
L0 = L//(L & -L)
R0 = R//(R & -R) - 1
#self._evaluate(L0)
#self._evaluate(R0)
while L < R:
if L&1:
self.lazy[L] = self.fm(self.lazy[L],M)
L += 1
if R&1:
R -= 1
self.lazy[R] = self.fm(self.lazy[R],M)
L >>= 1
R >>= 1
#print("L0 R0 {} {}\n".format(L0,R0))
self._caluculate(L0)
self._caluculate(R0)
def range_query(self,L,R):#[L,R)を計算する
L += self.N
R += self.N
L0 = L//(L & -L)
R0 = R//(R & -R) - 1
self._evaluate(L0)
self._evaluate(R0)
vl = self.unit_x
vr = self.unit_x
while L < R:
if L&1:
vl = self.fx(vl,self.fa(self.tree[L],self.lazy[L]))
L += 1
if R&1:
R -= 1
vr = self.fx(self.fa(self.tree[R],self.lazy[R]),vr)
L >>= 1
R >>= 1
return self.fx(vl,vr)
'''
def __str__(self):
return '\n'.join(' '.join(str(v) for v in self.tree[1<<i:1<<(i + 1)]) for i in range((2*self.N).bit_length()))
'''
def debug(self):
print((self.lazy))
print((self.tree))
def __str__(self):
for i in range(self.N):
self.tree[i] = self.fa(self.tree[i],self.lazy[i])
self.lazy[i << 1] = self.fm(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1|1] = self.fm(self.lazy[i << 1|1],self.lazy[i])
self.lazy[i] = self.unit_m
for i in range(self.N,self.N*2):
self.tree[i] = self.fa(self.tree[i],self.lazy[i])
return '\n'.join(map(str,[k if k < INF else -1 for k in self.tree[self.N:]]))
N,Q = list(map(int,input().split()))
roadwork = [tuple(map(int,input().split())) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
st = LazySegmentTree(Q)
for s,t,x in roadwork:
l = bisect_left(D,s - x)
r = bisect_left(D,t - x)
st.range_update(l,r,x)
print((str(st))) | import sys
input = sys.stdin.readline
INF = (1<<31)
from bisect import bisect_left
class LazySegmentTree():
def __init__(self,Q):
self.N = Q
self.tree = [INF]*(2*self.N)
self.lazy = [INF]*(2*self.N)
def _evaluate(self,K):#Kの上の遅延配列を評価する
H = K.bit_length() - 1
for i in range(H,0,-1):
h = K >> i
if self.lazy[h] == INF:
continue
self.tree[h] = min(self.tree[h],self.lazy[h])
self.lazy[h << 1] = min(self.lazy[h << 1],self.lazy[h])
self.lazy[h << 1|1] = min(self.lazy[h << 1|1],self.lazy[h])
self.lazy[h] = INF
def _caluculate(self,K):#Kより上を計算する
while K > 1:
K >>= 1
self.tree[K] = min(self.tree[K],self.tree[K<<1],self.lazy[K<<1],self.tree[K<<1|1],self.lazy[K<<1|1])
def range_update(self,L,R,M):#[L,R)にMを作用
L += self.N
R += self.N
L0 = L//(L & -L)
R0 = R//(R & -R) - 1
#self._evaluate(L0)
#self._evaluate(R0)
while L < R:
if L&1:
self.lazy[L] = min(self.lazy[L],M)
L += 1
if R&1:
R -= 1
self.lazy[R] = min(self.lazy[R],M)
L >>= 1
R >>= 1
#print("L0 R0 {} {}\n".format(L0,R0))
self._caluculate(L0)
self._caluculate(R0)
def range_query(self,L,R):#[L,R)を計算する
L += self.N
R += self.N
L0 = L//(L & -L)
R0 = R//(R & -R) - 1
self._evaluate(L0)
self._evaluate(R0)
v = INF
while L < R:
if L&1:
v = min(v,self.tree[L],self.lazy[L])
L += 1
if R&1:
R -= 1
v = min(self.tree[R],self.lazy[R],v)
L >>= 1
R >>= 1
return v
'''
def __str__(self):
return '\n'.join(' '.join(str(v) for v in self.tree[1<<i:1<<(i + 1)]) for i in range((2*self.N).bit_length()))
'''
def debug(self):
print((self.lazy))
print((self.tree))
def __str__(self):
for i in range(self.N):
self.tree[i] = min(self.tree[i],self.lazy[i])
self.lazy[i << 1] = min(self.lazy[i << 1],self.lazy[i])
self.lazy[i << 1|1] = min(self.lazy[i << 1|1],self.lazy[i])
self.lazy[i] = INF
for i in range(self.N,self.N*2):
self.tree[i] = min(self.tree[i],self.lazy[i])
return '\n'.join(map(str,[k if k < INF else -1 for k in self.tree[self.N:]]))
N,Q = list(map(int,input().split()))
roadwork = [tuple(map(int,input().split())) for _ in range(N)]
D = [int(eval(input())) for _ in range(Q)]
st = LazySegmentTree(Q)
for s,t,x in roadwork:
l = bisect_left(D,s - x)
r = bisect_left(D,t - x)
st.range_update(l,r,x)
print((str(st))) | p03033 |
from operator import itemgetter
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
events = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
add_event = (s - x, 1, x)
remove_event = (t - x, -1, x)
events.append(add_event)
events.append(remove_event)
events.sort(key=itemgetter(0)) # イベント処理時刻昇順ソート
under_construction = set()
cur = 0
for _ in range(Q):
d = int(eval(input()))
# print('d', d)
while cur < N * 2 and events[cur][0] <= d:
exec_time, event_type, under_construction_x = events[cur]
# print(cur, exec_time, event_type, under_construction_x)
if event_type == 1:
# add_event
under_construction.add(under_construction_x)
else:
# remove_event
under_construction.discard(under_construction_x)
cur += 1
# print('cur', cur, 'events', events)
# print('uc', under_construction)
print((min(under_construction) if under_construction else -1))
# print()
| from operator import itemgetter
import sys
input = sys.stdin.readline
inf = float('inf')
N, Q = list(map(int, input().split()))
events = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
add_event = (s - x, 1, x)
remove_event = (t - x, -1, x)
events.append(add_event)
events.append(remove_event)
events.sort(key=itemgetter(0)) # イベント処理時刻昇順ソート
under_construction = set()
min_stop = inf
chg_flg = False
cur = 0
for _ in range(Q):
d = int(eval(input()))
while cur < N * 2 and events[cur][0] <= d:
exec_time, event_type, under_construction_x = events[cur]
if event_type == 1: # add_event
under_construction.add(under_construction_x)
if not chg_flg:
min_stop = min(min_stop, under_construction_x)
else: # remove_event
under_construction.discard(under_construction_x)
if not chg_flg and min_stop == under_construction_x:
chg_flg = True
cur += 1
if chg_flg:
min_stop = min(under_construction) if under_construction else inf
chg_flg = False
print((min_stop if min_stop != inf else -1))
| p03033 |
from operator import itemgetter
import sys
input = sys.stdin.readline
inf = float('inf')
N, Q = list(map(int, input().split()))
es = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
es.append((s - x, 1, x))
es.append((t - x - 0.5, -1, x))
es.sort(key=itemgetter(0))
st = set()
cur_min_stop = inf
check_needed = True
# print(es)
i = 0
for _ in range(Q):
d = int(eval(input()))
while i < N * 2:
time, typ, pos = es[i]
# print(es[i])
if time > d:
break
if typ == 1:
st.add(pos)
if pos < cur_min_stop:
cur_min_stop = pos
else:
st.remove(pos)
if pos == cur_min_stop:
check_needed = True
i = i + 1
if check_needed:
if st:
cur_min_stop = min(st)
else:
cur_min_stop = inf
check_needed = False
print((cur_min_stop if cur_min_stop < inf else -1))
| from operator import itemgetter
import sys
input = sys.stdin.readline
inf = float('inf')
n, q = list(map(int, input().split()))
e = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
# 区間[s, t)に通行止め
e.append((s - x, x, 0)) # 通行止め開始
e.append((t - x - 0.5, x, 1)) # 通行止め解除
e.sort(key=itemgetter(0))
stop_set = set()
stop_at = inf
cur = 0
for _ in range(q):
changed = False
d = int(eval(input()))
while cur < n * 2:
exec_time, pos, typ = e[cur]
if exec_time <= d:
if typ == 0:
stop_set.add(pos)
if (not changed) and (pos < stop_at):
stop_at = pos
else:
stop_set.remove(pos)
if (not changed) and (pos == stop_at):
changed = True
cur += 1
else:
break
if changed:
if stop_set:
stop_at = min(stop_set)
else:
stop_at = inf
print((stop_at if stop_at != inf else -1))
| p03033 |
# https://atcoder.jp/contests/abc128/submissions/8312583
# 写経
def solve():
from heapq import heappush, heappop
from collections import defaultdict
from operator import itemgetter
import sys
input = sys.stdin.readline
inf = 1 << 31
n, q = map(int, input().split())
e = [] # 通行止めと解除にクエリ分割
for _ in range(n):
s, t, x = map(int, input().split())
# 区間[s, t)に通行止め
e.append((t - x, 0, x)) # 通行止め解除/0にすることで、解除と開始が同時刻の場合、先に解除される
e.append((s - x, 1, x)) # 通行止め開始/1にすることで、同上
for i in range(q):
d = int(input())
e.append((d, 2, i)) # 求値クエリ/2にすることで、通行止めの設定解除の反映後に到着する
e.sort(key=itemgetter(0, 1))
cnt = defaultdict(int)
cnt[inf] = 1
h = [inf]
ret = [-1] * q
for time, type, x in e:
if type == 0:
cnt[x] -= 1
elif type == 1:
heappush(h, x)
cnt[x] += 1
else:
while not (cnt[h[0]]):
heappop(h)
curr = h[0]
if curr != inf:
ret[x] = curr
print(*ret, sep='\n')
if __name__ == '__main__':
solve()
| # https://atcoder.jp/contests/abc128/submissions/8312583
# 写経
def solve():
from heapq import heappush, heappop
from collections import defaultdict
from operator import itemgetter
import sys
input = sys.stdin.readline
inf = 1 << 31
n, q = map(int, input().split())
S = [0] * n
T = [0] * n
X = [0] * n
for i in range(n):
S[i], T[i], X[i] = map(int, input().split())
e = [(t - x, 0, x) for t, x in zip(T, X)]
e.extend([(s - x, 1, x) for s, x in zip(S, X)])
e.extend([(int(input()), 2, idx) for idx in range(q)])
# e = [*((t - x, 0, x) for t, x in zip(T, X)),
# *((s - x, 1, x) for s, x in zip(S, X)),
# *((int(input()), 2, idx) for idx in range(q))
# ]
e.sort(key=itemgetter(0))
# 安定ソートなので、0,1,2順になる（はず
cnt = defaultdict(int)
cnt[inf] = 1
h = [inf]
ret = [-1] * q
for time, type, x in e:
if type == 0:
cnt[x] -= 1
elif type == 1:
heappush(h, x)
cnt[x] += 1
else:
while not (cnt[h[0]]):
heappop(h)
curr = h[0]
if curr != inf:
ret[x] = curr
print(*ret, sep='\n')
if __name__ == '__main__':
solve()
| p03033 |
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
def main():
kouji_num, person_num = list(map(int, input().split()))
koji_data = [list(map(int, input().split())) for i in range(kouji_num)]
person_data = [int(eval(input())) for i in range(person_num)]
event_list = [0 for i in range(kouji_num * 2)]
now_kouji = set()
for i in range(kouji_num):
start, fin, position = koji_data[i]
event_list[2 * i] = (start - position - 0.25, 1, position)
event_list[2 * i + 1] = (fin - position - 0.75, 0, position)
event_list.sort(key=lambda x: x[0])
now_ind = 0
for i in range(person_num):
person_start = person_data[i]
while now_ind < kouji_num * 2:
time_data, flg, position = event_list[now_ind]
if time_data > person_start:
break
if flg:
now_kouji.add(position)
else:
now_kouji.remove(position)
now_ind += 1
if len(now_kouji) == 0:
ans = -1
else:
ans = min(now_kouji)
print(ans)
if __name__ == '__main__':
main()
| from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
input = sys.stdin.readline
from math import factorial
import heapq, bisect
import math
def main():
kouji_num, person_num = list(map(int, input().split()))
koji_data = [list(map(int, input().split())) for i in range(kouji_num)]
person_data = [int(eval(input())) for i in range(person_num)]
event_list = [0 for i in range(kouji_num * 2)]
now_kouji = set()
for i in range(kouji_num):
start, fin, position = koji_data[i]
event_list[2 * i] = (start - position - 0.25, 1, position)
event_list[2 * i + 1] = (fin - position - 0.75, 0, position)
event_list.sort(key=lambda x: x[0])
ans = 10 ** 9 + 1
now_ind = 0
for i in range(person_num):
person_start = person_data[i]
while now_ind < kouji_num * 2:
time_data, flg, position = event_list[now_ind]
if time_data > person_start:
break
if flg:
now_kouji.add(position)
ans = min(ans, position)
else:
now_kouji.remove(position)
if len(now_kouji) == 0:
ans = 10 ** 9 + 1
elif ans == position:
ans = min(now_kouji)
now_ind += 1
if ans == 10 ** 9 + 1:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
| p03033 |
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,Q = LI()
q = LIR(n)
q = [(s-x,x,i) for (i,(s,t,x)) in enumerate(q)]+[(t-x,x,i) for (i,(s,t,x)) in enumerate(q)]
q.sort()
m = [(float("inf"),n)]
f = [1]*(n+1)
f[n] = 0
l = 0
for _ in range(Q):
d = I()
while l < len(q) and q[l][0] <= d:
t,x,i = q[l]
f[i] ^= 1
if not f[i]:
heappush(m,(x,i))
l += 1
while f[m[0][1]]:
heappop(m)
ans,i = heappop(m)
if ans == float("inf"):
print((-1))
else:
print(ans)
heappush(m,(ans,i))
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n,Q = LI()
q = LIR(n)
q.sort(key = lambda x:x[2])
d = IR(Q)
ans = [-1]*(Q+1)
f = [0]*Q
for s,t,x in q:
l = bisect.bisect_left(d,s-x)
r = bisect.bisect_left(d,t-x)
while l < r:
while ans[l] != -1:
l = f[l]
if r <= l:
break
ans[l] = x
f[l] = r
l += 1
for i in ans[:-1]:
print(i)
return
#Solve
if __name__ == "__main__":
solve()
| p03033 |
class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for _ in range(n)]
e = [(s-x,x+i/n,i) for i,(s,_,x) in enumerate(stx)]+[(t-x,x+i/n,i) for i,(_,t,x) in enumerate(stx)]
d = [int(eval(input())) for _ in range(q)]
e += [(di,float("inf"),i) for i,di in enumerate(d)]
e.sort(key = lambda x:x[0])
avl = AVLtree()
ans = []
f = [0]*n
for s,x,i in e:
if x == float("inf"):
m = avl.lower_bound(-float("inf"))
ans.append(int(m) if m != float("inf") else -1)
elif f[i]:
avl.erase(x)
else:
avl.insert(x)
f[i] = 1
for i in ans:
print(i)
| class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
stx = [list(map(int, input().split())) for _ in range(n)]
e = [(s-x,x+i/n,i) for i,(s,_,x) in enumerate(stx)]+[(t-x,x+i/n,i) for i,(_,t,x) in enumerate(stx)]
e.sort(key = lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase(x)
else:
avl.insert(x)
f[i] = 1
j += 1
m = avl.lower_bound(-float("inf"))
ans.append(int(m) if m != float("inf") else -1)
for i in ans:
print(i)
| p03033 |
class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x+i/n,i))
e.append((t-x,x+i/n,i))
e.sort(key=lambda x:x[0], reverse=True)
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
for d in D:
while e and e[-1][0] <= d:
_,x,i = e.pop()
if f[i]:
avl.erase(x)
else:
avl.insert(x)
f[i] = 1
m = avl.lower_bound(-float("inf"))
ans.append(int(m) if m != float("inf") else -1)
for i in ans:
print(i)
| class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| p03033 |
class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x+i/n,i))
e.append((t-x,x+i/n,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase(x)
else:
avl.insert(x)
f[i] = 1
j += 1
m = avl.lower_bound(-float("inf"))
ans.append(int(m) if m != float("inf") else -1)
for i in ans:
print(i)
| class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 1))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, -1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
node.bal += key
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if key == 1:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 1))
node = node.left
else:
q.append((node, -1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, -1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 1))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if key == 1:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
node.bal -= key
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if key == 1:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| p03033 |
class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 0))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, 1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
if not key:
node.bal += 1
else:
node.bal -= 1
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if not key:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 0))
node = node.left
else:
q.append((node, 1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, 1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 0))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if not key:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
if not key:
node.bal -= 1
else:
node.bal += 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if not key:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 1))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, -1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
node.bal += key
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if key == 1:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 1))
node = node.left
else:
q.append((node, -1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, -1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 1))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if key == 1:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
node.bal -= key
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if key == 1:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| p03033 |
class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
self.num = 0
def insert(self, x):
if self.root is None:
self.root = Node(x)
self.num += 1
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 1))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, -1))
if node.right is None:
node.right = Node(x)
break
node = node.right
self.num += 1
# バランス調整
new_node = None
while q:
node, key = q.pop()
node.bal += key
node.size += 1
bal = node.bal
if not bal:
while q:
node, key = q.pop()
node.size += 1
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
node.size += 1
if key == 1:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
while q:
node, key = q.pop()
node.size += 1
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 1))
node = node.left
else:
q.append((node, -1))
node = node.right
else:
return
self.num -= 1
if node.left is not None and node.right is not None:
q.append((node, -1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 1))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if key == 1:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
node.bal -= key
node.size -= 1
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if key == 1:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
while q:
node, key = q.pop()
node.size -= 1
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __len__(self):
return self.num
def __getitem__(self, key):
if key < 0:
key += self.num
key += 1
node = self.root
while True:
idx = node.left.size + 1 if node.left is not None else 1
if idx <= key:
key -= idx
if not key:
break
node = node.right
else:
node = node.left
return node.val
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
self.size = 1
def _rotateR(self):
nodeL = self.left
nodeLL_size = nodeL.left.size if nodeL.left is not None else 0
nodeR_size = self.right.size if self.right is not None else 0
self.size -= nodeLL_size + 1
nodeL.size += nodeR_size + 1
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
nodeRR_size = nodeR.right.size if nodeR.right is not None else 0
nodeL_size = self.left.size if self.left is not None else 0
self.size -= nodeRR_size + 1
nodeR.size += nodeL_size + 1
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| class AVLtree:
"""
参考：http://www.nct9.ne.jp/m_hiroi/light/pyalgo12.html
insert : 挿入
erase : 削除
lower_bound(x) : x <= v なる最小のv、なければ-float("inf")、最小値はlower(-float("inf"))
upper_bound(x) : v < x なる最大のv、なければfloat("inf")、最大値はupper(float("inf"))
print(avltree) : デバッグ用
"""
def __init__(self):
self.root = None
def insert(self, x):
if self.root is None:
self.root = Node(x)
return
q = []
node = self.root
while True:
if node.val == x:
return
elif x < node.val:
q.append((node, 1))
if node.left is None:
node.left = Node(x)
break
node = node.left
else:
q.append((node, -1))
if node.right is None:
node.right = Node(x)
break
node = node.right
# バランス調整
new_node = None
while q:
node, key = q.pop()
node.bal += key
bal = node.bal
if not bal:
return
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
new_node.bal = 0
node.bal = 0
break
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
new_node.bal = 0
node.bal = 0
break
if q:
node, key = q.pop()
if key == 1:
node.left = new_node
else:
node.right = new_node
elif new_node is not None:
self.root = new_node
def erase(self, x):
if self.root is None:
return
q = []
node = self.root
while node is not None:
if node.val == x:
break
if x < node.val:
q.append((node, 1))
node = node.left
else:
q.append((node, -1))
node = node.right
else:
return
if node.left is not None and node.right is not None:
q.append((node, -1))
min_node = node.right
while min_node.left is not None:
q.append((min_node, 1))
min_node = min_node.left
node.val = min_node.val
node = min_node
if q:
pre, key = q[-1]
else:
pre = None
if node.left is None:
cnode = node.right
else:
cnode = node.left
if pre is None:
self.root = cnode
return
if key == 1:
pre.left = cnode
else:
pre.right = cnode
# バランス調整
while q:
new_node = None
node, key = q.pop()
node.bal -= key
bal = node.bal
if bal == 2:
if node.left.bal == -1:
node.left = node.left._rotateL()
new_node = node._rotateR()
new_node._update_bal()
else:
new_node = node._rotateR()
if not new_node.bal:
new_node.bal = -1
node.bal = 1
else:
new_node.bal = 0
node.bal = 0
elif bal == -2:
if node.right.bal == 1:
node.right = node.right._rotateR()
new_node = node._rotateL()
new_node._update_bal()
else:
new_node = node._rotateL()
if not new_node.bal:
new_node.bal = 1
node.bal = -1
else:
new_node.bal= 0
node.bal = 0
elif bal:
break
if new_node is not None:
if not q:
self.root = new_node
return
node, key = q[-1]
if key == 1:
node.left = new_node
else:
node.right = new_node
if new_node.bal:
break
def lower_bound(self, x):
res = float("inf")
node = self.root
while node is not None:
if x <= node.val:
res = node.val
node = node.left
else:
node = node.right
return res
def upper_bound(self, x):
res = -float("inf")
node = self.root
while node is not None:
if x <= node.val:
node = node.left
else:
res = node.val
node = node.right
return res
def __str__(self):
if self.root is None:
return "[]"
buff = "["
for x in self.root._dfs():
buff += str(x)+", "
buff = buff.rstrip(", ")
buff += "]"
return buff
class Node:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
self.bal = 0 #1:左1, -1:右1
def _rotateR(self):
nodeL = self.left
self.left = nodeL.right
nodeL.right = self
return nodeL
def _rotateL(self):
nodeR = self.right
self.right = nodeR.left
nodeR.left = self
return nodeR
def _update_bal(self):
if self.bal == 1:
self.right.bal = -1
self.left.bal = 0
elif self.bal == -1:
self.right.bal = 0
self.left.bal = 1
else:
self.right.bal = 0
self.left.bal = 0
self.bal = 0
def _dfs(self):
if self is not None:
if self.left is not None:
for x in self.left._dfs():
yield x
yield self.val
if self.right is not None:
for x in self.right._dfs():
yield x
n,q = list(map(int, input().split()))
e = []
for i in range(n):
s,t,x = list(map(int, input().split()))
e.append((s-x,x,i))
e.append((t-x,x,i))
e.sort(key=lambda x:x[0])
D = [int(eval(input())) for _ in range(q)]
avl = AVLtree()
ans = []
f = [0]*n
j = 0
N = 2*n
for d in D:
while j < N and e[j][0] <= d:
_,x,i = e[j]
if f[i]:
avl.erase((x,i))
else:
avl.insert((x,i))
f[i] = 1
j += 1
m = avl.lower_bound((-float("inf"),0))
ans.append(m[0] if m != float("inf") else -1)
for i in ans:
print(i)
| p03033 |
# -*- coding: utf-8 -*-
import sys
from collections import Counter, defaultdict
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, Q = MAP()
X = set()
A = defaultdict(list)
for i in range(N):
s, t, x = MAP()
# 全ての工事を同じ時系列に持ってくる
X.add(s-x)
X.add(t-x)
A[s-x].append((x, 0))
A[t-x].append((x, 1))
D = LIST(Q)
Dset = set(D)
S = sorted(X|Dset)
B = {}
C = Counter()
for key in S:
if key in A:
for x, flag in A[key]:
if flag == 0:
C[x] += 1
else:
C[x] -= 1
if C[x] == 0:
del C[x]
if key in Dset:
mn = min(C) if len(C) else -1
B[key] = mn
[print(B[x]) for x in D]
| # -*- coding: utf-8 -*-
import sys
from heapq import heappush, heappop
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, Q = MAP()
# 3種類の状態変化をイベントとして一括管理する
# 0: 工事終了, 1: 工事開始, 2: 人の出発
events = []
for i in range(N):
s, t, x = MAP()
# (開始座標に合わせた状態の工事開始時間, フラグ, 実際の座標)
events.append((s-x, 1, x))
# (開始座標に合わせた状態の工事終了時間, フラグ, 実際の座標)
events.append((t-x, 0, x))
for i in range(Q):
d = INT()
# (人の出発時間, フラグ, index)
events.append((d, 2, i))
# 時系列に沿ってソート、フラグも同時刻な時先に処理して欲しいものから番号を振ってある
events.sort()
# setとheapqを合わせて、時刻に合わせた処理と最小値取得を行う
S = set()
hp = []
ans = [0] * Q
for t, flag, x in events:
# 工事終了
if flag == 0:
S.remove(x)
# 工事開始
elif flag == 1:
S.add(x)
heappush(hp, x)
# 人の移動
elif flag == 2:
# heapqの先頭要素ついて、setと状態を合わせる
while len(hp) and hp[0] not in S:
heappop(hp)
if len(hp):
ans[x] = hp[0]
else:
ans[x] = -1
[print(a) for a in ans]
| p03033 |
import sys
import bisect
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
# TLE
N, Q = list(map(int, input().split()))
STX = [[int(x) for x in input().split()] for _ in range(N)]
EVENT = []
for s, t, x in STX:
EVENT.append((s-x, 1, x))
EVENT.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
EVENT.append((d, 2, i))
ans = [-1] * Q
EVENT.sort()
# print(EVENT)
STOP = set()
h = []
for t, op, x in EVENT:
if op == 2 and STOP:
while h[0] not in STOP:
heappop(h)
ans[x] = h[0]
elif op == 1:
STOP.add(x)
heappush(h, x)
elif op == 0:
STOP.remove(x)
print(("\n".join(map(str, ans))))
| import sys
import bisect
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
# TLE
N, Q = list(map(int, input().split()))
STX = [[int(x) for x in input().split()] for _ in range(N)]
EVENT = []
for s, t, x in STX:
EVENT.append((s-x, 1, x))
EVENT.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
EVENT.append((d, 2, i))
ans = [-1] * Q
EVENT.sort()
# print(EVENT)
STOP = set()
h = []
for t, op, x in EVENT:
if op == 2:
while h and h[0] not in STOP:
heappop(h)
ans[x] = h[0] if h else -1
elif op == 1:
STOP.add(x)
heappush(h, x)
elif op == 0:
STOP.remove(x)
print(("\n".join(map(str, ans))))
| p03033 |
import sys
import bisect
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
# TLE
N, Q = list(map(int, input().split()))
STX = [[int(x) for x in input().split()] for _ in range(N)]
EVENT = []
for s, t, x in STX:
EVENT.append((s-x, 1, x))
EVENT.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
EVENT.append((d, 2, i))
ans = [-1] * Q
EVENT.sort()
# print(EVENT)
STOP = set()
h = []
for t, op, x in EVENT:
if not op:
STOP.remove(x)
elif op == 1:
STOP.add(x)
heappush(h, x)
else:
while h and h[0] not in STOP:
heappop(h)
ans[x] = h[0] if h else -1
'''
if op == 2:
while h and h[0] not in STOP:
heappop(h)
ans[x] = h[0] if h else -1
elif op == 1:
STOP.add(x)
heappush(h, x)
elif op == 0:
STOP.remove(x)
'''
print(("\n".join(map(str, ans))))
| import sys
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
# TLE
N, Q = list(map(int, input().split()))
STX = [[int(x) for x in input().split()] for _ in range(N)]
EVENT = []
for s, t, x in STX:
EVENT.append((s-x, 1, x))
EVENT.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
EVENT.append((d, 2, i))
ans = [-1] * Q
EVENT.sort()
# print(EVENT)
STOP = set()
h = []
for t, op, x in EVENT:
if not op:
STOP.remove(x)
elif op == 1:
STOP.add(x)
heappush(h, x)
else:
while h and h[0] not in STOP:
heappop(h)
ans[x] = h[0] if h else -1
print(("\n".join(map(str, ans))))
| p03033 |
#D in [S_i-X_i,T_i-X_i) → Xiで止まる
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
from collections import defaultdict
N,Q = list(map(int,input().split()))
task = []
STX = [[int(x) for x in input().split()] for _ in range(N)]
for s,t,x in STX:
task.append((t-x,0,x)) # xで止まらなくなる
task.append((s-x,1,x)) # xで止まる
for i in range(Q):
d = int(eval(input()))
task.append((d,2,i)) # 止まる位置を答える
answer = [-1]*Q
task.sort()
# 引っかかってる場所の管理
se = set()
se_hp = [] # heapで最小値を先頭に保つ
# 小さい時刻から順に見ていく
for a,b,c in task:
if not b: # b == 0
se.remove(c)
elif b&1: # b == 1
se.add(c)
heappush(se_hp,c)
else: # b == 2
while se_hp and se_hp[0] not in se:
heappop(se_hp)
answer[c] = se_hp[0] if se_hp else -1
print(('\n'.join(map(str,answer))))
| from heapq import heappush, heappop
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, Q = list(map(int, input().split()))
STX = [[int(x) for x in input().split()] for _ in range(N)]
EVENT = []
for s, t, x in STX:
EVENT.append((s-x, 1, x))
EVENT.append((t-x, 0, x))
for i in range(Q):
d = int(eval(input()))
EVENT.append((d, 2, i))
ans = [-1] * Q
EVENT.sort()
STOP = set()
h = []
for t, op, x in EVENT:
if op == 2 and STOP:
while h and h[0] not in STOP:
heappop(h)
ans[x] = h[0]
elif op == 1:
STOP.add(x)
heappush(h, x)
elif op == 0:
STOP.remove(x)
print(("\n".join(map(str, ans))))
| p03033 |
# coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
STX.sort(key=lambda x: x[2], reverse=True)
event = []
for s, t, x in STX:
event.append((s-x, 0, x))
event.append((t-x, -1, x))
for i in range(Q):
d = ir()
event.append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
# 19 | # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
for s, t, x in STX:
event.append((s-x, 0, x))
event.append((t-x, -1, x))
for i in range(Q):
d = ir()
event.append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
# 19 | p03033 |
# coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
for s, t, x in STX:
event.append((s-x, 0, x))
event.append((t-x, -1, x))
for i in range(Q):
d = ir()
event.append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
# 19
| # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def main():
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
for s, t, x in STX:
event.append((s-x, 0, x))
event.append((t-x, -1, x))
for i in range(Q):
d = ir()
event.append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
if __name__ == "__main__":
main()
| p03033 |
# coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
STX.sort(key=lambda x: x[2], reverse=True)
event = []
for s, t, x in STX:
event.append((s-x, 0, x))
event.append((t-x, -1, x))
for i in range(Q):
d = ir()
event.append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
# 19
| # coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
append = event.append
for s, t, x in STX:
append((s-x, 0, x))
append((t-x, -1, x))
for i in range(Q):
d = ir()
append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
add = cur.add
remove = cur.remove
for a, b, c in event:
if b == 0:
add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
| p03033 |
# coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
append = event.append
for s, t, x in STX:
append((s-x, 0, x))
append((t-x, -1, x))
for i in range(Q):
d = ir()
append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
add = cur.add
remove = cur.remove
for a, b, c in event:
if b == 0:
add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
| # coding: utf-8
import sys
from heapq import heapify, heappop, heappush
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, Q = lr()
STX = [tuple(lr()) for _ in range(N)]
event = []
append = event.append
for s, t, x in STX:
append((s-x, 0, x))
append((t-x, -1, x))
for i in range(Q):
d = ir()
append((d, 1, i))
event.sort()
answer = [-1] * Q
cur = set()
flag = False
INF = 10 ** 10
min_x = INF
for a, b, c in event:
if b == 0:
cur.add(c)
if c < min_x:
min_x = c
flag = True
elif b == -1:
cur.remove(c)
if min_x == c:
flag = False
elif b == 1:
if cur:
if not flag:
min_x = min(cur)
flag = True
answer[c] = min_x
print(('\n'.join(map(str, answer))))
| p03033 |
from bisect import bisect_left
def main():
N, Q, *I = map(int, open(0).read().split())
STX, D = I[:3 * N], I[3 * N:]
E = sorted(zip(*[iter(STX)] * 3), key=lambda x: x[2])
R = [-1] * Q
ans = [-1] * Q
for s, t, x in E:
l = bisect_left(D, s - x)
r = bisect_left(D, t - x)
while l < r:
if R[l] == -1:
ans[l] = x
R[l] = r
l += 1
else:
l = R[l]
print(*ans, sep='\n')
if __name__ == '__main__':
main()
| from bisect import bisect_left
def main():
N, Q, *I = list(map(int, open(0).read().split()))
STX, D = I[:3 * N], I[3 * N:]
E = sorted(zip(*[iter(STX)] * 3), key=lambda x: x[2])
R = [-1] * Q
ans = [-1] * Q
for s, t, x in E:
l = bisect_left(D, s - x)
r = bisect_left(D, t - x)
while l < r:
if R[l] == -1:
ans[l] = x
R[l] = r
l += 1
else:
l = R[l]
print(("\n".join(map(str, ans))))
if __name__ == '__main__':
main()
| p03033 |
#D in [S_i-X_i,T_i-X_i) → Xiで止まる
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
from collections import defaultdict
N,Q = list(map(int,input().split()))
task = []
STX = [[int(x) for x in input().split()] for _ in range(N)]
for s,t,x in STX:
task.append((t-x,0,x)) # xで止まらなくなる
task.append((s-x,1,x)) # xで止まる
for i in range(Q):
d = int(eval(input()))
task.append((d,2,i)) # 止まる位置を答える
answer = [-1]*Q
task.sort()
# 引っかかってる場所の管理
se = set()
se_hp = [] # heapで最小値を先頭に保つ
# 小さい時刻から順に見ていく
for a,b,c in task:
if not b: # b == 0
se.remove(c)
elif b&1: # b == 1
se.add(c)
heappush(se_hp,c)
else: # b == 2
while se_hp and se_hp[0] not in se:
heappop(se_hp)
answer[c] = se_hp[0] if se_hp else -1
print(('\n'.join(map(str,answer))))
| import sys
input = lambda : sys.stdin.readline().rstrip()
from heapq import heappush, heappop
running = []
events = []
delete = set()
n, q = list(map(int, input().split()))
for _ in range(n):
s, t, x = list(map(int, input().split()))
time = max(s - x, 0)
if t - x < 0:
continue
events.append((s - x, x, 1)) # 追加イベント
events.append((t - x, x, 0)) # 削除イベント
events.sort()
ans = []
idx = -1
for _ in range(q):
d = int(eval(input()))
if d >= events[-1][0]:
print((-1))
#ans.append(-1)
continue
while events[idx + 1][0] <= d:
idx += 1
if events[idx][2] == 1:
heappush(running, events[idx][1])
delete.discard(events[idx][1])
else:
delete.add(events[idx][1])
flag = 1
while running:
x = heappop(running)
if x not in delete:
heappush(running, x)
print(x)
#ans.append(x)
flag = 0
break
if flag:
print((-1)) | p03033 |
import sys
input = lambda : sys.stdin.readline().rstrip()
from heapq import heappush, heappop
running = []
events = []
delete = set()
n, q = list(map(int, input().split()))
for _ in range(n):
s, t, x = list(map(int, input().split()))
time = max(s - x, 0)
if t - x < 0:
continue
events.append((s - x, x, 1)) # 追加イベント
events.append((t - x, x, 0)) # 削除イベント
events.sort()
ans = []
idx = -1
for _ in range(q):
d = int(eval(input()))
if d >= events[-1][0]:
print((-1))
#ans.append(-1)
continue
while events[idx + 1][0] <= d:
idx += 1
if events[idx][2] == 1:
heappush(running, events[idx][1])
delete.discard(events[idx][1])
else:
delete.add(events[idx][1])
flag = 1
while running:
x = heappop(running)
if x not in delete:
heappush(running, x)
print(x)
#ans.append(x)
flag = 0
break
if flag:
print((-1)) | def main():
import sys
input = lambda : sys.stdin.readline().rstrip()
from heapq import heappush, heappop
running = []
events = []
delete = set()
n, q = list(map(int, input().split()))
for _ in range(n):
s, t, x = list(map(int, input().split()))
time = max(s - x, 0)
if t - x < 0:
continue
events.append((s - x, x, 1)) # 追加イベント
events.append((t - x, x, 0)) # 削除イベント
events.sort()
ans = []
idx = -1
for _ in range(q):
d = int(eval(input()))
if d >= events[-1][0]:
print((-1))
continue
while events[idx + 1][0] <= d:
idx += 1
if events[idx][2] == 1:
heappush(running, events[idx][1])
delete.discard(events[idx][1])
else:
delete.add(events[idx][1])
flag = 1
while running:
x = heappop(running)
if x not in delete:
heappush(running, x)
print(x)
flag = 0
break
if flag:
print((-1))
if __name__ == '__main__':
main()
| p03033 |
import sys, heapq
input = sys.stdin.buffer.readline # 入出力高速化
def main():
N, Q = list(map(int, input().split()))
tl = [] # イベントタイムライン
for _ in range(N):
S, T, X = list(map(int, input().split()))
tl.append((S-X, 1, X)) # insert
tl.append((T-X, 0, X)) # erase
for _ in range(Q):
D = int(eval(input()))
tl.append((D, 2, 0)) # min
tl.sort()
working = list() # 工事中
todelete = list() # 削除用
for t, c, x in tl:
if c == 0: # erase
heapq.heappush(todelete, x)
elif c == 1: # insert
heapq.heappush(working, x)
else: # min
while todelete and todelete[0] == working[0]:
heapq.heappop(todelete)
heapq.heappop(working)
print((-1 if not working else working[0]))
return
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline # 入出力高速化
def main():
N, Q = list(map(int, input().split()))
tl = [] # イベントタイムライン
for _ in range(N):
S, T, X = list(map(int, input().split()))
tl.append((S-X, 1, X)) # insert
tl.append((T-X, 0, X)) # erase
for _ in range(Q):
D = int(eval(input()))
tl.append((D, 2, 0)) # min
tl.sort()
working = set() # 工事中
wcur = 0 # 工事中の区域の数
curmin = -1
flag = False
for t, c, x in tl:
if c == 0: # erase
wcur -= 1
working.remove(x)
if x <= curmin:
curmin = x
flag = True
elif c == 1: # insert
wcur += 1
working.add(x)
if curmin < 0 or curmin >= x:
curmin = x
flag = False
else: # min
if wcur == 0:
curmin = -1
flag = False
elif flag:
curmin = min(working)
flag = False
print(curmin)
return
if __name__ == "__main__":
main()
| p03033 |
import sys
input = lambda : sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = float("inf")
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == float("inf"):
print((-1))
else:
print(res)
| import sys
input = lambda : sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = 10**9 + 1
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == ide_ele:
print((-1))
else:
print(res)
| p03033 |
def main():
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
mod = 10**9 + 7
from heapq import heappush, heappop
running = [] # 止まりうる座標
events = [] # 時刻順のイベント
finished = set() # 工事が終了した座標
n, q = list(map(int, input().split()))
for _ in range(n):
s, t, x = list(map(int, input().split()))
events.append((s - x, x, 1)) # 追加イベント
events.append((t - x, x, 0)) # 削除イベント
for _ in range(q):
d = int(eval(input()))
events.append((d, 10**10, 2)) # 出発イベント,同じ時刻内で最後になるよう第二引数設定
events.sort()
for i in range(len(events)):
temp = events[i]
if temp[-1] == 1:
heappush(running, temp[1])
finished.discard(temp[1])
elif temp[-1] == 0:
finished.add(temp[1])
else:
flag = 1
while running:
p = heappop(running)
if p not in finished:
flag = 0
heappush(running, p)
print(p)
break
if flag:
print((-1))
main()
| def main():
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
mod = 10**9 + 7
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
N = q
N0 = 2**(N-1).bit_length()
data = [None]*(2*N0)
INF = (-1, 10**9 + 1)
def update(l, r, v):
L = l + N0; R = r + N0
while L < R:
if R & 1:
R -= 1
data[R-1] = v
if L & 1:
data[L-1] = v
L += 1
L >>= 1; R >>= 1
def _query(k):
k += N0-1
s = INF
while k >= 0:
if data[k]:
s = max(s, data[k])
k = (k - 1) // 2
return s
def query(k):
return _query(k)[1]
import bisect
for i, (x, start, last) in enumerate(stx):
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
update(l, r, (i, x))
for i in range(q):
res = query(i)
if res == 10**9 + 1:
print((-1))
else:
print(res)
main()
| p03033 |
# -*- coding: utf-8 -*-
import sys
from heapq import heappush, heappop, heapify
from collections import defaultdict
import copy
N,Q=list(map(int, sys.stdin.readline().split()))
S=[]
event=[]
for _ in range(N):
s,t,x=list(map(int, sys.stdin.readline().split()))
event.append( ( s-x ,1, x) ) #Start
event.append( ( t-x,-1, x) ) #End
for i in range(Q):
d=int(sys.stdin.readline().strip())
event.append( (d ,0, i) )
event.sort(key=lambda x:(x[0]) )
stop=set()
ans=defaultdict(lambda: -1)
is_stop=False
minstop=float("inf")
for s,flag,x in event:
if flag==1:
stop.add(x)
if x<minstop:
minstop=x
is_stop=True
elif flag==-1:
try:
stop.remove(x)
except:
pass
if minstop==x:
is_stop=False
elif flag==0:
if stop:
if not is_stop:
minstop=min(stop)
is_stop=True
ans[x]=minstop
else:
ans[x]=-1
for i in range(Q):
print((ans[i]))
| # -*- coding: utf-8 -*-
import sys
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
N,Q=list(map(int, sys.stdin.readline().split()))
S=[]
event=[] #x, s, t
for _ in range(N):
s,t,x=list(map(int, sys.stdin.readline().split()))
heappush( event, (x, max(0,s-x) , max(0,t-1-x)) )
D=[ int(sys.stdin.readline().strip()) for _ in range(Q) ]
D.sort()
ans=[ float("inf") for _ in range(Q) ]
Next=[ i+1 for i in range(Q) ] #Next
while event:
x,s,t=heappop(event)
start=bisect_left(D,s)
end=bisect_right(D,t)
i=start
while i<end:
ans[i]=min(ans[i],x)
next=Next[i]
Next[i]=end
i=next
for x in ans:
if x==float("inf"):
print(-1)
else:
print(x)
| p03033 |
import sys
input = sys.stdin.readline
from heapq import heappop,heappush
N,Q = list(map(int,input().split()))
task = []
STX = [[int(x) for x in input().split()] for _ in range(N)]
for s,t,x in STX:
task.append((t-x,0,x))
task.append((s-x,1,x))
for i in range(Q):
d = int(eval(input()))
task.append((d,2,i))
answer = [-1]*Q
task.sort()
se = set()
se_hp = []
for a,b,c in task:
if not b:
se.remove(c)
elif b&1:
se.add(c)
heappush(se_hp,c)
else:
while se_hp and se_hp[0] not in se:
heappop(se_hp)
answer[c] = se_hp[0] if se_hp else -1
print(('\n'.join(map(str,answer))))
| import sys
input = sys.stdin.buffer.readline
import heapq
def main():
N,Q = list(map(int,input().split()))
event = []
for _ in range(N):
s,t,x = list(map(int,input().split()))
event.append((s-x,1,x))
event.append((t-x,0,x))
for i in range(Q):
a = int(eval(input()))
event.append((a,2,i))
event.sort()
ans = [-1]*Q
use = set()
stop = []
for a,b,c in event:
if b == 1:
use.add(c)
heapq.heappush(stop,c)
elif b == 0:
use.remove(c)
else:
while stop and stop[0] not in use:
heapq.heappop(stop)
ans[c] = -1 if len(stop) == 0 else stop[0]
for num in ans:
print(num)
if __name__ == "__main__":
main()
| p03033 |
import bisect
n, q = list(map(int, input().split()))
rws = [list(map(int, input().split())) for _ in range(n)]
ds = [int(eval(input())) for _ in range(q)]
rws.sort(key = lambda x: x[2])
ans = [-1 for _ in range(q)]
for rw in rws:
st = bisect.bisect_left(ds, rw[0] - rw[2])
en = bisect.bisect_left(ds, rw[1] - rw[2])
while st < en:
if ans[st] == -1:
ans[st] = rw[2]
st += 1
for a in ans:
print(a) | import bisect
n, q = list(map(int, input().split()))
rws = [list(map(int, input().split())) for _ in range(n)]
ds = [int(eval(input())) for _ in range(q)]
rws.sort(key = lambda x: x[2])
ans = [-1 for _ in range(q)]
nxt = [-1 for _ in range(q)]
for rw in rws:
st = bisect.bisect_left(ds, rw[0] - rw[2])
en = bisect.bisect_left(ds, rw[1] - rw[2])
while st < en:
if nxt[st] == -1:
ans[st] = rw[2]
nxt[st] = en
st += 1
else:
st = nxt[st]
for a in ans:
print(a) | p03033 |
class BIT():
def __init__(self, n):
self.n = n
self.bit = [0] * (n + 1)
def getsum(self, k):
ret = 0
while k:
ret += self.bit[k]
k -= k & -k
return ret
def p_sum(self, i, j):
return self.getsum(j) - self.getsum(i - 1)
def add(self, k, x):
while k <= self.n:
self.bit[k] += x
k += k & -k
def bisect(self, x):
i, m = 0, 1 << (self.n.bit_length() - 1)
while m:
t = i + m
if t < self.n and self.bit[t] < x:
i = t
x -= self.bit[i]
m //= 2
return i + 1
import sys
input = sys.stdin.buffer.readline
from operator import itemgetter as get
def main():
n, q = list(map(int, input().split()))
event = []
Xs = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
event.append((-2, s - x, x))
event.append((-1, t - x, x))
Xs.append(x)
Xs.sort()
for _ in range(q):
d = int(eval(input()))
event.append((0, d, None))
event.sort(key=get(1))
x_to_i = {x: i for i, x in enumerate(Xs)}
bit = BIT(n)
any = 0
ans = []
for flg, time, x in event:
if flg == -2:
bit.add(x_to_i[x], 1)
any += 1
elif flg == -1:
bit.add(x_to_i[x], -1)
any -= 1
else:
if not any:
ans.append(-1)
else:
ans.append(Xs[bit.bisect(1)])
print(("\n".join(map(str, ans))))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.buffer.readline
from operator import itemgetter as get
from heapq import *
def main():
n, q = list(map(int, input().split()))
event = []
Xs = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
event.append((-2, s - x, x))
event.append((-1, t - x, x))
Xs.append(x)
for _ in range(q):
d = int(eval(input()))
event.append((0, d, None))
event.sort(key=get(1))
active = {x: 0 for x in Xs}
candidate = []
ans = []
for flg, time, x in event:
if flg == -2:
active[x] = 1
heappush(candidate, x)
elif flg == -1:
active[x] = 0
else:
res = -1
while candidate:
c = heappop(candidate)
if active[c]:
heappush(candidate, c)
res = c
break
ans.append(res)
print(("\n".join(map(str, ans))))
if __name__ == '__main__':
main()
| p03033 |
from heapq import heappush, heappop
n, q = list(map(int, input().split()))
events = []
for i in range(n):
s, t, i = list(map(int, input().split()))
if t >= i:
events.append([t - i, 0, i])
events.append([s - i, 1, i])
for i in range(q):
d = int(eval(input()))
events.append([d, 2, i])
events.sort()
heap = []
working = set()
distance = [-1] * q
for t, kind, i in events:
if kind == 0:
working.remove(i)
elif kind == 1:
working.add(i)
heappush(heap, i)
elif working:
while not heap[0] in working:
heappop(heap)
distance[i] = heap[0]
for d in distance:
print(d) | from heapq import heappush, heappop
n, q = list(map(int, input().split()))
events = []
for i in range(n):
s, t, x = list(map(int, input().split()))
if t >= x:
events.append([t - x, 0, x])
events.append([s - x, 1, x])
for i in range(q):
d = int(eval(input()))
events.append([d, 2, i])
events.sort()
dist = [-1] * q
walker = []
working = set()
heap = []
for t, kind, x in events:
if kind == 0:
working.remove(x)
elif kind == 1:
working.add(x)
heappush(heap, x)
elif working:
while not heap[0] in working:
heappop(heap)
dist[x] = heap[0]
for d in dist:
print(d) | p03033 |
from heapq import heappush, heappop
n, q = list(map(int, input().split()))
events = []
for i in range(n):
s, t, x = list(map(int, input().split()))
if t >= x:
events.append([t - x, 0, x])
events.append([s - x, 1, x])
for i in range(q):
d = int(eval(input()))
events.append([d, 2, i])
events.sort()
dist = [-1] * q
walker = []
working = set()
heap = []
for t, kind, x in events:
if kind == 0:
working.remove(x)
elif kind == 1:
working.add(x)
heappush(heap, x)
elif working:
while not heap[0] in working:
heappop(heap)
dist[x] = heap[0]
for d in dist:
print(d) | from heapq import heappush, heappop
n, q = map(int, input().split())
events = []
for i in range(n):
s, t, x = map(int, input().split())
if t >= x:
events.append([t - x, 0, x])
events.append([s - x, 1, x])
for i in range(q):
d = int(input())
events.append([d, 2, i])
events.sort()
dist = [-1] * q
walker = []
working = set()
heap = []
for t, kind, x in events:
if kind == 0:
working.remove(x)
elif kind == 1:
working.add(x)
heappush(heap, x)
elif working:
while not heap[0] in working:
heappop(heap)
dist[x] = heap[0]
print(*dist, sep="\n")
| p03033 |
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
import bisect
N,Q = list(map(int,input().split()))
# STX = [list(map(int,input().split())) for _ in range (N)]
STX = []
vals = set()
for _ in range(N):
s,t,x = list(map(int,input().split()))
STX.append([max(0,s-x), max(0,t-x), x])
vals.add(max(0,s-x))
vals.add(max(0,t-x))
D = [int(eval(input())) for _ in range(Q)]
for d in D:
vals.add(d)
vals = list(vals)
vals.sort()
L = len(vals)
mapping = [-1]*(L+1)
imos = [[] for _ in range(L+1)]
STX.sort(key=lambda x:x[2])
priority = 0
for s,t,x in STX:
s1 = bisect.bisect_left(vals, s)
t1 = bisect.bisect_left(vals, t)
imos[s1].append([1, priority, x])
imos[t1].append([0, priority, x])
priority += 1
import heapq
cur = -1
cur_priority = 10**9
que = [[cur_priority, cur]]
valid_priority = [True]*(N+1)
for i in range(L+1):
for f,p,x in imos[i]:
if f:
heapq.heappush(que, [p, x])
else:
valid_priority[p] = False
idx = 0
while que[idx][0]!=10**9 and valid_priority[que[idx][0]]==False:
heapq.heappop(que)
mapping[i] = que[0][1]
for d in D:
d1 = bisect.bisect_left(vals, d)
print((mapping[d1]))
| import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
import bisect
N,Q = list(map(int,input().split()))
# STX = [list(map(int,input().split())) for _ in range (N)]
STX = []
vals = set()
for _ in range(N):
s,t,x = list(map(int,input().split()))
STX.append([max(0,s-x), max(0,t-x), x])
vals.add(max(0,s-x))
vals.add(max(0,t-x))
D = [int(eval(input())) for _ in range(Q)]
for d in D:
vals.add(d)
vals = list(vals)
vals.sort()
L = len(vals)
mapping = [-1]*(L+1)
imos = [[] for _ in range(L+1)]
STX.sort(key=lambda x:x[2])
priority = 0
for s,t,x in STX:
s1 = bisect.bisect_left(vals, s)
t1 = bisect.bisect_left(vals, t)
imos[s1].append([1, priority, x])
imos[t1].append([0, priority, x])
priority += 1
import heapq
cur = -1
cur_priority = 10**9
que = [[cur_priority, cur]]
valid_priority = [True]*(N+1)
for i in range(L+1):
for f,p,x in imos[i]:
if f:
heapq.heappush(que, [p, x])
else:
valid_priority[p] = False
while que[0][1]!=-1 and valid_priority[que[0][0]]==False:
heapq.heappop(que)
mapping[i] = que[0][1]
for d in D:
d1 = bisect.bisect_left(vals, d)
print((mapping[d1]))
| p03033 |
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
import bisect
N,Q = list(map(int,input().split()))
# STX = [list(map(int,input().split())) for _ in range (N)]
STX = []
vals = set()
for _ in range(N):
s,t,x = list(map(int,input().split()))
STX.append((max(0,s-x), max(0,t-x), x))
vals.add(max(0,s-x))
vals.add(max(0,t-x))
D = [int(eval(input())) for _ in range(Q)]
for d in D:
vals.add(d)
vals = list(vals)
vals.sort()
L = len(vals)
mapping = [-1]*(L+10)
STX.sort(key=lambda x:x[2])
for s,t,x in STX:
s1 = bisect.bisect_left(vals, s)
t1 = bisect.bisect_left(vals, t)
for i in range(s1, t1):
if mapping[i]==-1:
mapping[i] = x
for d in D:
d1 = bisect.bisect_left(vals, d)
print((mapping[d1]))
| import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
import bisect
N,Q = list(map(int,input().split()))
# STX = [list(map(int,input().split())) for _ in range (N)]
STX = []
vals = set()
for _ in range(N):
s,t,x = list(map(int,input().split()))
STX.append((max(0,s-x), max(0,t-x), x))
vals.add(max(0,s-x))
vals.add(max(0,t-x))
D = [int(eval(input())) for _ in range(Q)]
for d in D:
vals.add(d)
vals = list(vals)
vals.sort()
L = len(vals)
mapping = [-1]*(L+1)
imos = [[] for _ in range(L+1)]
STX.sort(key=lambda x:x[2])
priority = 0
for s,t,x in STX:
s1 = bisect.bisect_left(vals, s)
t1 = bisect.bisect_left(vals, t)
imos[s1].append([1, priority, x])
imos[t1].append([0, priority, x])
priority += 1
import heapq
cur = -1
cur_priority = 10**9
que = [(cur_priority, cur)]
valid_priority = [True]*(N+1)
for i in range(L+1):
for f,p,x in imos[i]:
if f:
heapq.heappush(que, (p, x))
else:
valid_priority[p] = False
while que[0][1]!=-1 and valid_priority[que[0][0]]==False:
heapq.heappop(que)
mapping[i] = que[0][1]
for d in D:
d1 = bisect.bisect_left(vals, d)
print((mapping[d1]))
| p03033 |
def main():
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
X = []
stx = []
tmp = set([])
for _ in range(n):
s,t,x = list(map(int, input().split()))
stx.append((s,t,x))
tmp.add(x-t)
tmp.add(x-s)
d = {}
for i in range(q):
di = -int(eval(input()))
tmp.add(di)
d[di] = i
stx.sort(key = lambda x:x[2])
v2i = {}
for i, v in enumerate(sorted(tmp)):
v2i[v] = i
l = [1] * (len(tmp) + 1)
for di in d:
l[v2i[di]] = di
#####単位元######
ide_ele_min = 1
#num_min:n以上の最小の2のべき乗
N = len(l)
num_min =2**(N-1).bit_length()
seg_min=[ide_ele_min]*2*num_min
def init_min(init_min_val):
#set_val
for i in range(N):
seg_min[i+num_min-1]=init_min_val[i]
#built
for i in range(num_min-2,-1,-1) :
seg_min[i]=min(seg_min[2*i+1],seg_min[2*i+2])
def update_min(k,x):
k += num_min-1
seg_min[k] = x
while k:
k = (k-1)//2
seg_min[k] = min(seg_min[k*2+1],seg_min[k*2+2])
def query_min(p,q):
if q<=p:
return ide_ele_min
p += num_min-1
q += num_min-2
res=ide_ele_min
while q-p>1:
if p&1 == 0:
res = min(res,seg_min[p])
if q&1 == 1:
res = min(res,seg_min[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,seg_min[p])
else:
res = min(min(res,seg_min[p]),seg_min[q])
return res
init_min(l)
ans = {}
for s, t, x in stx:
l = v2i[x-t] + 1
r = v2i[x-s] + 1
v = query_min(l, r)
while v != 1:
i_d = d[v]
i_sg = v2i[v]
ans[i_d] = x
update_min(i_sg, 1)
v = query_min(l, r)
for i in range(q):
if i in ans:
print((ans[i]))
else:
print((-1))
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
n, q = list(map(int, input().split()))
stx = []
tmp = set([])
for _ in range(n):
s,t,x = list(map(int, input().split()))
stx.append((s,t,x))
tmp.add(x-t)
tmp.add(x-s)
d = {}
for i in range(q):
di = -int(eval(input()))
tmp.add(di)
d[di] = i
stx.sort(key = lambda x:x[2])
v2i = {}
for i, v in enumerate(sorted(tmp)):
v2i[v] = i
l = [1] * (len(tmp) + 1)
for di in d:
l[v2i[di]] = di
#####単位元######
ide_ele_min = 1
#num_min:n以上の最小の2のべき乗
N = len(l)
num_min =2**(N-1).bit_length()
seg_min=[ide_ele_min]*2*num_min
def init_min(init_min_val):
#set_val
for i in range(N):
seg_min[i+num_min-1]=init_min_val[i]
#built
for i in range(num_min-2,-1,-1) :
seg_min[i]=min(seg_min[2*i+1],seg_min[2*i+2])
def update_min(k,x):
k += num_min-1
seg_min[k] = x
while k:
k = (k-1)//2
seg_min[k] = min(seg_min[k*2+1],seg_min[k*2+2])
def query_min(p,q):
if q<=p:
return ide_ele_min
p += num_min-1
q += num_min-2
res=ide_ele_min
while q-p>1:
if p&1 == 0:
res = min(res,seg_min[p])
if q&1 == 1:
res = min(res,seg_min[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,seg_min[p])
else:
res = min(min(res,seg_min[p]),seg_min[q])
return res
init_min(l)
ans = [-1] * q
for s, t, x in stx:
l = v2i[x-t] + 1
r = v2i[x-s] + 1
v = query_min(l, r)
while v != 1:
i_d = d[v]
i_sg = v2i[v]
ans[i_d] = x
update_min(i_sg, 1)
v = query_min(l, r)
for ansi in ans:
print(ansi)
if __name__ == '__main__':
main()
| p03033 |
import sys
import bisect
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
STX = [list(map(int, input().split())) for _ in range(N)]
# xの昇順に工事の区間をsort
STX = sorted(STX, key=lambda x: x[2])
D = [int(eval(input())) for _ in range(Q)]
ans = [-1] * Q
for s, t, x in STX:
left = bisect.bisect_left(D, s - x - 0.5)
right = bisect.bisect_left(D, t - x - 0.5)
for i in range(left, right):
if ans[i] == -1:
ans[i] = x
for a in ans:
print(a) | import sys
import bisect
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
STX = [list(map(int, input().split())) for _ in range(N)]
# xの昇順に工事の区間をsort
STX = sorted(STX, key=lambda x: x[2])
D = [int(eval(input())) for _ in range(Q)]
ans = [-1] * Q
index = [-1] * Q
for s, t, x in STX:
left = bisect.bisect_left(D, s - x - 0.5)
right = bisect.bisect_left(D, t - x - 0.5)
now = left
while now < right:
if index[now] == -1: # まだansが更新されていない場合
ans[now] = x
index[now] = right
now += 1
else:
now = index[now]
for a in ans:
print(a) | p03033 |
# -*- coding: utf-8 -*-
import sys
from heapq import heappush,heappop
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
class BIT:
def __init__(self,n):
self.num=n
self.dat=[0]*(self.num+1)
self.depth=n.bit_length()
def add(self,i,x):
i+=1
while i<=self.num:
self.dat[i]+=x
i+=i&-i
def sum(self,i):
i+=1
s=0
while i>0:
s+=self.dat[i]
i-=i&-i
return s
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
N,Q=map(int,input().split())
S,T,X=[0]*N,[0]*N,[0]*N
for i in range(N):
S[i],T[i],X[i]=map(int,input().split())
unique_X=sorted(list(set(X)))
d={unique_X[i]:i for i,x in enumerate(unique_X)}
h=[]
for i in range(N):
heappush(h,(S[i]-X[i],1,d[X[i]]))
heappush(h,(T[i]-X[i],-1,d[X[i]]))
for _ in range(Q):
heappush(h,(int(input()),2,0))
b=BIT(len(unique_X))
c=0
for _ in range(N*2+Q):
t,q,x=heappop(h)
if q==-1:
c-=1
b.add(x,-1)
elif q==1:
c+=1
b.add(x,1)
else:
res,_=b.lower_bound(1)
print(unique_X[res] if res<len(unique_X) else -1)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
class BIT:
def __init__(self,n):
self.num=n
self.dat=[0]*(self.num+1)
self.depth=n.bit_length()
def add(self,i,x):
i+=1
while i<=self.num:
self.dat[i]+=x
i+=i&-i
def sum(self,i):
i+=1
s=0
while i>0:
s+=self.dat[i]
i-=i&-i
return s
def lower_bound(self,x):
sum_=0
pos=0
for i in range(self.depth,-1,-1):
k=pos+(1<<i)
if k<=self.num and sum_+self.dat[k]<x:
sum_+=self.dat[k]
pos+=1<<i
return pos, sum_
N,Q=map(int,input().split())
S,T,X=[0]*N,[0]*N,[0]*N
for i in range(N):
S[i],T[i],X[i]=map(int,input().split())
unique_X=sorted(list(set(X)))
d={unique_X[i]:i for i,x in enumerate(unique_X)}
l=[]
for i in range(N):
l.append((S[i]-X[i],1,d[X[i]]))
l.append((T[i]-X[i],-1,d[X[i]]))
for i in range(Q):
l.append((int(input()),2,0))
l.sort(key=lambda t: t[0])
b=BIT(len(unique_X))
for t,q,x in l:
if q==-1:
b.add(x,-1)
elif q==1:
b.add(x,1)
else:
res,_=b.lower_bound(1)
print(unique_X[res] if res<len(unique_X) else -1)
if __name__ == '__main__':
main()
| p03033 |
from operator import itemgetter
def main():
n, q = list(map(int, input().split()))
stops = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stops.append((s, t, x))
delay = []
for i in range(q):
delay.append([int(eval(input())), False, -1])
stops = sorted(stops, key=itemgetter(2))
for s, t, x in stops:
for idx, item in enumerate(delay):
d, stopped, score = item
if not stopped:
time_at_x = x + d
if s - 0.5 < time_at_x < t - 0.5:
delay[idx][2] = x
delay[idx][1] = True
for item in delay:
print((item[2]))
main() | from operator import itemgetter
from bisect import bisect_left
def main():
n, q = list(map(int, input().split()))
stops = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stops.append((s, t, x))
delay = []
for i in range(q):
delay.append(int(eval(input())))
stops = sorted(stops, key=itemgetter(2))
delay = sorted(delay)
result = [-1] * q
skips = [-1] * q
for s, t, x in stops:
sx = bisect_left(delay, s - x)
tx = bisect_left(delay, t - x)
while sx < tx:
if skips[sx] == -1:
result[sx] = x
skips[sx] = tx
sx += 1
else:
sx = skips[sx]
for r in result:
print(r)
main() | p03033 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
# print("#F")
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
# print(S,number)
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| p03033 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| #!/usr/bin/env python3
import sys
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
# inf = float('inf') ;mod = 10**9+7
# mans = inf ;ans = 0 ;count = 0 ;pro = 1
from heapq import heappush,heappop
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| p03033 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
# inf = float('inf') ;mod = 10**9+7
# mans = inf ;ans = 0 ;count = 0 ;pro = 1
from heapq import heappush,heappop
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| p03033 |
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline()
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=map(int,input().split())
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(input()) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
ans = []
for time, query, number in event:
if query == 0:
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
ans.append(-1)
else:
ans.append(hq[0])
print(*ans,sep="\n")
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect, heapq
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n,q=list(map(int,input().split()))
STX=[tuple(map(int,input().split())) for i in range(n)]
D=[int(eval(input())) for i in range(q)]
event=[]
for si,ti,xi in STX:
event.append((si-xi,0,xi))
event.append((ti-xi,-1,xi))
for di in D:
event.append((di,1,di))
event.sort()
hq=[]; S=set()
for time, query, number in event:
if query == 0:
heapq.heappush(hq,number)
S.add(number)
elif query == -1:
S.remove(number)
else:
while hq and hq[0] not in S:
heapq.heappop(hq)
if not hq:
print((-1))
else:
print((hq[0]))
| p03033 |
# -*- coding: utf-8 -*-
from bisect import bisect_left
from sys import stdin
from heapq import heappush, heappop
readl = stdin.readline
## input
N,Q = list(map(int, readl().rstrip().split()))
STX = [list(map(int, readl().rstrip().split())) for _ in range(N)]
Dn = [None for _ in range(Q+1)]
for i in range(Q):
Dn[i] = int(readl().rstrip())
Dn[Q] = 10**10
Rn = []
## solve
for s,t,x in sorted(STX,key=lambda x:x[2]):
l = r = bisect_left(Dn,s-x)
t -= x
while Dn[r] < t:
Rn.append([Dn[r],x])
r += 1
del Dn[l:r]
for d in Dn[:-1]:
Rn.append([d,-1])
Rn.sort()
## output
for i in range(Q):
print((Rn[i][1])) | import sys
from bisect import bisect_left
N,Q = list(map(int, input().split()))
lines = sys.stdin.readlines()
kkk = []
for line in lines[:N]:
s, t, x = list(map(int, line.split()))
kkk.append((x, s, t))
kkk.sort()
ddd = list(map(int, lines[N:]))
ans = [-1] * Q
skip = [-1] * Q
for x, s, t in kkk:
ss = bisect_left(ddd, s - x)
tt = bisect_left(ddd, t - x)
while ss < tt:
sk = skip[ss]
if sk == -1:
ans[ss] = x
skip[ss] = tt
ss += 1
else:
ss = sk
print(('\n'.join(map(str, ans))))
| p03033 |
import bisect
import sys
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
def main():
N, Q = list(map(int, input().split()))
S, T, X = [0] * N, [0] * N, [0] * N
for i in range(N):
S[i], T[i], X[i] = list(map(int, input().split()))
D = [int(eval(input())) for _ in range(Q)]
event = [] #工事と人を１つのリストで管理: (時間, 出来事の種類, [工事の位置])
#出来事の種類: (0: 工事の終了、1: 工事の開始、2: 人)
working = [] #現在行われている工事のリスト
n = 0 #現在行われている工事の数
for i in range(Q):
event.append((D[i], 2))
for i in range(N):
bisect.insort(event, (S[i] - X[i] - 0.5, 1, X[i]))
bisect.insort(event, (T[i] - X[i] - 0.5, 0, X[i]))
for l in event:
if l[1] == 1:
bisect.insort(working, l[2])
n += 1
elif l[1] == 0:
del working[bisect.bisect(working, l[2]) - 1]
n -= 1
else:
if n > 0:
print((working[0]))
else:
print((-1))
main() | import bisect
import sys
input = sys.stdin.readline
'''
allinputs = iter(input().splitlines())
input = lambda : next(allinputs)
#'''
N, Q = list(map(int, input().split()))
S, T, X = [0] * N, [0] * N, [0] * N
work = []
for i in range(N):
S[i], T[i], X[i] = list(map(int, input().split()))
work.append((X[i], S[i] - X[i], T[i] - X[i]))
D = [int(eval(input())) for _ in range(Q)]
work.sort()
ans = [-1] * Q
skip = [-1] * Q
for i in range(N):
left = bisect.bisect_left(D, work[i][1])
right = bisect.bisect_left(D, work[i][2])
while left < right:
if skip[left] == -1:
skip[left] = right
ans[left] = work[i][0]
left += 1
else:
left = skip[left]
for i in ans:
print(i)
| p03033 |
N,Q = map(int,input().split())
STX = [tuple(map(int,input().split())) for i in range(N)]
D = [int(input()) for i in range(Q)]
starts = []
ends = []
for i,(s,t,x) in enumerate(STX):
starts.append((s-x,i))
ends.append((t-x,i))
starts.sort(key=lambda x:x[0], reverse=True)
ends.sort(key=lambda x:x[0], reverse=True)
import heapq
hq = []
heapq.heapify(hq)
delset = set()
ans = []
for d in D:
while starts and starts[-1][0] <= d:
_,i = starts.pop()
x = STX[i][2]
heapq.heappush(hq, (x,i))
while ends and ends[-1][0] <= d:
_,i = ends.pop()
delset.add(i)
while hq:
_,i = hq[0]
if i in delset:
heapq.heappop(hq)
else:
break
if len(hq)==0:
ans.append(-1)
else:
x,i = hq[0]
ans.append(x)
print(*ans, sep='\n')
| N,Q = map(int,input().split())
STX = [tuple(map(int,input().split())) for i in range(N)]
D = [int(input()) for i in range(Q)]
starts = []
ends = []
for i,(s,t,x) in enumerate(STX):
starts.append((s-x,i))
ends.append((t-x,i))
starts.sort(key=lambda x:x[0], reverse=True)
ends.sort(key=lambda x:x[0], reverse=True)
import heapq
hq = []
heapq.heapify(hq)
delset = set()
ans = []
for d in D:
while starts and starts[-1][0] <= d:
_,i = starts.pop()
x = STX[i][2]
heapq.heappush(hq, x*N+i)
while ends and ends[-1][0] <= d:
_,i = ends.pop()
delset.add(i)
while hq:
i = hq[0]%N
if i in delset:
heapq.heappop(hq)
else:
break
if len(hq)==0:
ans.append(-1)
else:
ans.append(hq[0]//N)
print(*ans, sep='\n')
| p03033 |
import sys
input = sys.stdin.readline
from bisect import bisect_left
# 区間更新 1点取得
class SegmentTree:
def __init__(self, N):
tmp = 1
while tmp < N:
tmp <<= 1
# self.N : 完全二分木の葉の数(N以上の最小の2べき)
self.N = tmp
# 2*self.N - 1 : 完全二分木のノード数
# 1-indexedで管理するので1プラス
self.data = [float('inf') for _ in range(2*self.N)]
# [l, r)
# 入力は0-indexedなので注意
def update(self, l, r, x):
L = l + self.N
R = r + self.N
while L < R:
if L & 1:
self.data[L] = min([self.data[L], x])
L += 1
if R & 1:
R -= 1
self.data[R] = min([self.data[R], x])
L >>= 1
R >>= 1
def query(self, k):
k += self.N
res = self.data[k]
while k != 1:
k >>= 1
res = min(res, self.data[k])
return res
def main():
N, Q = list(map(int, input().split()))
road = []
for _ in range(N):
S, T, X = list(map(int, input().split()))
road.append((S,T,X))
D = [int(eval(input())) for _ in range(Q)]
st = SegmentTree(Q)
for S, T, X in road:
l = bisect_left(D, S - X)
r = bisect_left(D, T - X)
st.update(l, r, X)
for q in range(Q):
ans = st.query(q)
if ans == float('inf'):
print((-1))
else:
print(ans)
if __name__ == "__main__":
main() | from bisect import bisect_left
import sys
input = sys.stdin.readline
class SegmentTree():
def __init__(self,size,func,default):
self.leaf=2**(size-1).bit_length()
self.data=[default]*(2*self.leaf-1)
self.f=func; self.d=default
def rangeupdate(self,l,r,x):
l+=self.leaf-1; r+=self.leaf-1
while l<r:
if not l&1:
self.data[l]=self.f(self.data[l],x)
l+=1
if not r&1:
r-=1
self.data[r]=self.f(self.data[r],x)
l>>=1; r>>=1
def getvalue(self,i):
k=i+self.leaf-1
ret=self.d
while k>=0:
ret=self.f(ret,self.data[k])
k=(k-1)>>1
return ret
#最大値
def segfunc(x,y):
return max(x,y)
#最小値
def segfunc2(x,y):
return min(x,y)
#和
def segfunc3(x,y):
return x | y
def main():
N, Q = list(map(int, input().split()))
construction = []
for _ in range(N):
S, T, X = list(map(int, input().split()))
construction.append([S,T,X])
D = [int(eval(input())) for _ in range(Q)]
seg = SegmentTree(Q,segfunc2,float('inf'))
for i in range(N):
S, T, X = construction[i]
l = bisect_left(D, S - X)
r = bisect_left(D, T - X)
seg.rangeupdate(l, r, X)
for q in range(Q):
ans = seg.getvalue(q)
if ans == float('inf'):
print((-1))
else:
print(ans)
if __name__ == "__main__":
main() | p03033 |
import sys
input=sys.stdin.readline
from bisect import bisect_left
class SegmentTree():
def __init__(self,size,func,default):
self.leaf=2**(size-1).bit_length()
self.data=[default]*(2*self.leaf-1)
self.f=func; self.d=default
def rangeupdate(self,l,r,x):
l+=self.leaf-1; r+=self.leaf-1
while l<r:
if not l&1:
self.data[l]=self.f(self.data[l],x)
l+=1
if not r&1:
r-=1
self.data[r]=self.f(self.data[r],x)
l>>=1; r>>=1
def getvalue(self,i):
k=i+self.leaf-1
ret=self.d
while k>=0:
ret=self.f(ret,self.data[k])
k=(k-1)>>1
return ret
n,q=list(map(int,input().split()))
seg=SegmentTree(q,min,float('inf'))
STX=[list(map(int,input().split())) for _ in range(n)]
D=[int(eval(input())) for _ in range(q)]
for s,t,x in STX:
seg.rangeupdate(bisect_left(D,s-x),bisect_left(D,t-x),x)
for i in range(q):
print((-1 if seg.getvalue(i)==float('inf') else seg.getvalue(i))) | import sys
input=sys.stdin.readline
from bisect import bisect_left
n,q=map(int,input().split())
STX=[tuple(map(int,input().split())) for _ in range(n)]
STX.sort(key=lambda x: x[2])
D=[int(input()) for _ in range(q)]
Ans=[-1]*q; Jump=[-1]*q
for s,t,x in STX:
l=bisect_left(D,s-x)
r=bisect_left(D,t-x)
while l<r:
s=Jump[l]
if s==-1:
Ans[l]=x
Jump[l]=r
l+=1
else:
l=s
print(*Ans,sep='\n')
| p03033 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.