input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
from bisect import bisect, bisect_left
from collections import Counter
from functools import reduce
from itertools import accumulate
from operator import itemgetter, xor
import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
class BIT:
def __init__(self, N):
# Nは入れたい要素の個数
self.size = 2 ** (int.bit_length(N+1))
self.node = [0]*(self.size + 1)
def initialize(self, S):
# S[0] = 0にしておく
# 1-indexed
if len(S) < self.size + 1:
S += [S[-1]] * (self.size+1 - len(S))
for i in range(1, self.size+1):
self.node[i] = S[i] - S[i - (i&-i)]
def sum(self, i):
res = 0
while i:
res += self.node[i]
i -= (i & -(i))
return res
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self.node[i] += x
i += (i & -(i))
def bisect_left(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] < x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
def bisect(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] <= x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
class DammySet:
def __init__(self, counter, INF=2**32):
if type(counter) != Counter:
counter = Counter(counter)
self.bit = BIT(len(counter.keys())+3)
self.key = sorted([-INF, -INF] + sorted(counter.keys()) + [INF])
self.val = [counter[k] for k in self.key]
S = list(accumulate(self.val))
for i in range(len(self.key)):
self.bit.node[i] = S[i] - S[i - (i&-i)]
for i in range(len(self.key), len(self.bit.node)):
j = i - (i&-i)
if j < len(S):
self.bit.node[i] = S[-1] - S[i - (i&-i)]
def add(self, val):
ix = bisect_left(self.key, val)
assert self.key[ix] == val
self.bit.add(ix, 1)
def update(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
self.bit.add(ix, v)
def remove(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
# 空の値を削除しないかのチェック
# 時間が厳しそうなときはコメントアウト
assert self.bit.sum(ix) - self.bit.sum(ix-1) > 0
self.bit.add(ix, -v)
def pop_vals(self, l, r):
assert l <= r
rix = bisect(self.key, r) - 1
lix = bisect_left(self.key, l) - 1
# (lix, rix]になるのに注意
rv = self.bit.sum(rix)
lv = self.bit.sum(lix)
delta = rv - lv
tv = lv+1
tix = lix*1
vix = 0
rmvix = 0
vals = [0]*delta
rmvk = [0]*delta
rmvv = [0]*delta
while delta:
OK = self.bit.bisect_left(tv)
c = self.bit.sum(OK)
d = c - tv + 1
for _ in range(d):
vals[vix] = self.key[OK]
vix += 1
rmvk[rmvix] = OK
rmvv[rmvix] = d
rmvix += 1
tv += d
tix = OK
delta -= d
for i in range(rmvix):
self.bit.add(rmvk[i], -rmvv[i])
return vals
N, M = inpl()
Q = sorted([inpl() for _ in range(N)], key=itemgetter(2))
D = [int(input()) for _ in range(M)]
rD = {v:i for i, v in enumerate(D)}
ans = [-1]*(M)
dmap = DammySet(D)
for s, t, x in Q:
val = dmap.pop_vals(s-x, t-1-x)
for v in val:
ans[rD[v]] = x
print(*ans, sep="\n")
| # -*- coding: utf-8 -*-
from bisect import bisect, bisect_left
from collections import Counter
from functools import reduce
from itertools import accumulate
from operator import itemgetter, xor
import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
class BIT:
def __init__(self, N):
# Nは入れたい要素の個数
self.size = 2 ** (int.bit_length(N+1))
self.node = [0]*(self.size + 1)
def initialize(self, S):
# S[0] = 0にしておく
# 1-indexed
if len(S) < self.size + 1:
S += [S[-1]] * (self.size+1 - len(S))
for i in range(1, self.size+1):
self.node[i] = S[i] - S[i - (i&-i)]
def sum(self, i):
res = 0
while i:
res += self.node[i]
i -= (i & -(i))
return res
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self.node[i] += x
i += (i & -(i))
def bisect_left(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] < x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
def bisect(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] <= x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
class DammySet:
def __init__(self, counter, INF=2**32, counter_is_unique_and_sorted=True):
if not counter_is_unique_and_sorted:
if type(counter) != Counter:
counter = Counter(counter)
self.bit = BIT(len(counter.keys())+3)
self.key = sorted([-INF, -INF] + sorted(counter.keys()) + [INF])
self.val = [counter[k] for k in self.key]
S = list(accumulate(self.val))
self.bit.initialize(S)
else:
self.bit = BIT(len(counter) + 3)
self.key = [-INF, -INF] + counter + [INF]
self.val = [0, 0] + [1]*len(counter) + [0]
S = [0] + list(range(len(counter) + 1)) + [len(counter)]
self.bit.initialize(S)
def add(self, val):
ix = bisect_left(self.key, val)
assert self.key[ix] == val
self.bit.add(ix, 1)
def update(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
self.bit.add(ix, v)
def remove(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
# 空の値を削除しないかのチェック
# 時間が厳しそうなときはコメントアウト
assert self.bit.sum(ix) - self.bit.sum(ix-1) > 0
self.bit.add(ix, -v)
def pop_vals(self, l, r):
assert l <= r
rix = bisect(self.key, r) - 1
lix = bisect_left(self.key, l) - 1
# (lix, rix]になるのに注意
rv = self.bit.sum(rix)
lv = self.bit.sum(lix)
delta = rv - lv
tv = lv+1
tix = lix*1
vix = 0
rmvix = 0
vals = [0]*delta
rmvk = [0]*delta
rmvv = [0]*delta
while delta:
OK = self.bit.bisect_left(tv)
c = self.bit.sum(OK)
d = c - tv + 1
for _ in range(d):
vals[vix] = self.key[OK]
vix += 1
rmvk[rmvix] = OK
rmvv[rmvix] = d
rmvix += 1
tv += d
tix = OK
delta -= d
for i in range(rmvix):
self.bit.add(rmvk[i], -rmvv[i])
return vals
N, M = inpl()
Q = sorted([inpl() for _ in range(N)], key=itemgetter(2))
D = [int(input()) for _ in range(M)]
rD = {v:i for i, v in enumerate(D)}
ans = [-1]*(M)
dmap = DammySet(D)
for s, t, x in Q:
val = dmap.pop_vals(s-x, t-1-x)
for v in val:
ans[rD[v]] = x
print(*ans, sep="\n")
| p03033 |
# -*- coding: utf-8 -*-
from bisect import bisect, bisect_left
from collections import Counter
from functools import reduce
from itertools import accumulate
from operator import itemgetter, xor
import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
class BIT:
def __init__(self, N):
# Nは入れたい要素の個数
self.size = 2 ** (int.bit_length(N+1))
self.node = [0]*(self.size + 1)
def initialize(self, S):
# S[0] = 0にしておく
# 1-indexed
if len(S) < self.size + 1:
S += [S[-1]] * (self.size+1 - len(S))
for i in range(1, self.size+1):
self.node[i] = S[i] - S[i - (i&-i)]
def sum(self, i):
res = 0
while i:
res += self.node[i]
i -= (i & -(i))
return res
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self.node[i] += x
i += (i & -(i))
def bisect_left(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] < x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
def bisect(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] <= x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
class DammySet:
def __init__(self, counter, INF=2**32, counter_is_unique_and_sorted=True):
if not counter_is_unique_and_sorted:
if type(counter) != Counter:
counter = Counter(counter)
self.bit = BIT(len(counter.keys())+3)
self.key = sorted([-INF, -INF] + sorted(counter.keys()) + [INF])
self.val = [counter[k] for k in self.key]
S = list(accumulate(self.val))
self.bit.initialize(S)
else:
self.bit = BIT(len(counter) + 3)
self.key = [-INF, -INF] + counter + [INF]
self.val = [0, 0] + [1]*len(counter) + [0]
S = [0] + list(range(len(counter) + 1)) + [len(counter)]
self.bit.initialize(S)
def add(self, val):
ix = bisect_left(self.key, val)
assert self.key[ix] == val
self.bit.add(ix, 1)
def update(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
self.bit.add(ix, v)
def remove(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
# 空の値を削除しないかのチェック
# 時間が厳しそうなときはコメントアウト
assert self.bit.sum(ix) - self.bit.sum(ix-1) > 0
self.bit.add(ix, -v)
def pop_vals(self, l, r):
assert l <= r
rix = bisect(self.key, r) - 1
lix = bisect_left(self.key, l) - 1
# (lix, rix]になるのに注意
rv = self.bit.sum(rix)
lv = self.bit.sum(lix)
delta = rv - lv
tv = lv+1
tix = lix*1
vix = 0
rmvix = 0
vals = [0]*delta
rmvk = [0]*delta
rmvv = [0]*delta
while delta:
OK = self.bit.bisect_left(tv)
c = self.bit.sum(OK)
d = c - tv + 1
for _ in range(d):
vals[vix] = self.key[OK]
vix += 1
rmvk[rmvix] = OK
rmvv[rmvix] = d
rmvix += 1
tv += d
tix = OK
delta -= d
for i in range(rmvix):
self.bit.add(rmvk[i], -rmvv[i])
return vals
N, M = inpl()
Q = sorted([inpl() for _ in range(N)], key=itemgetter(2))
D = [int(input()) for _ in range(M)]
rD = {v:i for i, v in enumerate(D)}
ans = [-1]*(M)
dmap = DammySet(D)
for s, t, x in Q:
val = dmap.pop_vals(s-x, t-1-x)
for v in val:
ans[rD[v]] = x
print(*ans, sep="\n")
| # -*- coding: utf-8 -*-
from bisect import bisect, bisect_left
from collections import Counter
from functools import reduce
from itertools import accumulate
from operator import itemgetter, xor
import sys
input = sys.stdin.readline
def inpl(): return list(map(int, input().split()))
class BIT:
def __init__(self, N):
# Nは入れたい要素の個数
self.size = 2 ** (int.bit_length(N+1))
self.node = [0]*(self.size + 1)
def initialize(self, S):
# S[0] = 0にしておく
# 1-indexed
if len(S) < self.size + 1:
S += [S[-1]] * (self.size+1 - len(S))
for i in range(1, self.size+1):
self.node[i] = S[i] - S[i - (i&-i)]
def sum(self, i):
res = 0
while i:
res += self.node[i]
i -= (i & -(i))
return res
def add(self, i, x):
if i == 0:
return
while i <= self.size:
self.node[i] += x
i += (i & -(i))
def bisect_left(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] < x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
def bisect(self, x):
res = 0
tmp = 0
b = 2**(int.bit_length(self.size)-2)
while b:
if tmp + self.node[res+b] <= x:
res += b
tmp += self.node[res]
b //= 2
return res + 1
class DammySet:
def __init__(self, counter, INF=2**32, counter_is_unique_and_sorted=True):
if not counter_is_unique_and_sorted:
if type(counter) != Counter:
counter = Counter(counter)
self.bit = BIT(len(counter.keys())+3)
self.key = sorted([-INF, -INF] + sorted(counter.keys()) + [INF])
self.val = [counter[k] for k in self.key]
S = list(accumulate(self.val))
self.bit.initialize(S)
else:
self.bit = BIT(len(counter) + 3)
self.key = [-INF] * (len(counter) + 3)
self.val = [0] * (len(counter) + 3)
S = [0] * (len(counter) + 3)
for i in range(2, len(counter)+2):
self.key[i] = counter[i-2]
self.val[i] = 1
S[i] = i-1
self.key[-1] = INF
S[-1] = len(counter)
self.bit.initialize(S)
def add(self, val):
ix = bisect_left(self.key, val)
assert self.key[ix] == val
self.bit.add(ix, 1)
def update(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
self.bit.add(ix, v)
def remove(self, vals):
for k, v in Counter(vals).items():
ix = bisect_left(self.key, k)
if self.key[ix] != k:
raise KeyError
# 空の値を削除しないかのチェック
# 時間が厳しそうなときはコメントアウト
assert self.bit.sum(ix) - self.bit.sum(ix-1) > 0
self.bit.add(ix, -v)
def pop_vals(self, l, r):
assert l <= r
rix = bisect(self.key, r) - 1
lix = bisect_left(self.key, l) - 1
# (lix, rix]になるのに注意
rv = self.bit.sum(rix)
lv = self.bit.sum(lix)
delta = rv - lv
tv = lv+1
tix = lix*1
vix = 0
rmvix = 0
vals = [0]*delta
rmvk = [0]*delta
rmvv = [0]*delta
while delta:
OK = self.bit.bisect_left(tv)
c = self.bit.sum(OK)
d = c - tv + 1
for _ in range(d):
vals[vix] = self.key[OK]
vix += 1
rmvk[rmvix] = OK
rmvv[rmvix] = d
rmvix += 1
tv += d
tix = OK
delta -= d
for i in range(rmvix):
self.bit.add(rmvk[i], -rmvv[i])
return vals
N, M = inpl()
Q = sorted([inpl() for _ in range(N)], key=itemgetter(2))
D = [int(input()) for _ in range(M)]
rD = {v:i for i, v in enumerate(D)}
ans = [-1]*(M)
dmap = DammySet(D)
for s, t, x in Q:
val = dmap.pop_vals(s-x, t-1-x)
for v in val:
ans[rD[v]] = x
print(*ans, sep="\n")
| p03033 |
###template###
import sys
def input(): return sys.stdin.readline().rstrip()
def mi(): return list(map(int, input().split()))
###template###
N, Q = mi()
Events = []
#イベントを格納する配列
#各要素はタプルで、(s-x or t-x, 1or-1, x)が入っている
#意味は、「時間s-xもしくはt-xに出発する人が」「座標xで」
# 「1:通行止めにぶつかる -1:通行止めにぶつかりそうだったが、助かる」を表す
for _ in range(N):
s, t, x = mi()
#1つめの要素がマイナスになることはないので、max(0, hoge)をとる。
#どちらもマイナスといったコーナーケースでも、「0で通行止めになり0で解除される」となってから時間0に出発する人が処理されるので、影響は出ない
#……と思っていたけど、0になるイベントが複数あると、集合への出し入れがおかしくなる（0を複数入れたあと複数回だそうとするから、無いキーを出そうとしてしまう）
#時間がマイナスでもコード上全く問題無いんだから、外した！
Events.append((s-x, 1, x))
Events.append((t-x, -1, x))
#イベント配列は「影響を受ける人（の出発時間）」で降順ソートする
#降順ソートなので、pop()でとっていく
from operator import itemgetter
Events = sorted(Events, key=lambda x:(-x[0],-x[1]))
#発生タイミング（x[0]）が同じイベントは、集合からのout→inでも並び替える（x[1]について降順）。
#outより先にinが行われると、集合操作がおかしくなる
#イベント配列ができたので、今度は各人について処理していく
#出力する答えはAnss配列に入れていき、最後にfor文で一気に出力する
Anss = []
#制約より、Diは最初から昇順ソートされている
Ds = [int(eval(input())) for _ in range(Q)]
nowkeptout = set() #今通行止めになっている座標を格納するset。常に昇順ソートする
nextevent = Events.pop() #次に見るイベント
minstop = 10**9+1
for d in Ds:
#各ループにおいて、「未処理の人のうち、最も出発時間が早い人」がdに入る
#ということは、時間dまでのEventsを全て処理すれば、その人がぶつかる場所が分かる
while nextevent[0]<=d: #dを越えたら止まるし、イベントがなくなっても番兵で止まる
a, b, c = nextevent
if b==1: #座標xが通行止めになる
nowkeptout.add(c)
minstop = min(c, minstop)
else: #座標xの通行止めが解除される
nowkeptout.remove(c)
if c==minstop and nowkeptout: minstop = min(nowkeptout)
elif not nowkeptout: minstop = 10**9+1
try: nextevent = Events.pop()
except:
nextevent = (10**9+1, 1, 1) #要素がなくなったらもう処理が起きないようにする
break
#この時点で、nowkeptoutに値が入っている場合も、入っていない場合もある
#値が入っていれば、dはその最小値の座標で通行止めにぶつかる
#値が入っていなければ歩き続けるので、-1にする
if nowkeptout: Anss.append(minstop)
else: Anss.append(-1)
for ans in Anss:
print(ans)
| ###template###
import sys
def input(): return sys.stdin.readline().rstrip()
def mi(): return list(map(int, input().split()))
###template###
N, Q = mi()
Events = []
#イベントを格納する配列
#各要素はタプルで、(s-x or t-x, 1or-1, x)が入っている
#意味は、「時間s-xもしくはt-xに出発する人が」「座標xで」
# 「1:通行止めにぶつかる -1:通行止めにぶつかりそうだったが、助かる」を表す
for _ in range(N):
s, t, x = mi()
#1つめの要素がマイナスになることはないので、max(0, hoge)をとる。
#どちらもマイナスといったコーナーケースでも、「0で通行止めになり0で解除される」となってから時間0に出発する人が処理されるので、影響は出ない
#……と思っていたけど、0になるイベントが複数あると、集合への出し入れがおかしくなる（0を複数入れたあと複数回だそうとするから、無いキーを出そうとしてしまう）
#時間がマイナスでもコード上全く問題無いんだから、外した！
Events.append((s-x, 1, x))
Events.append((t-x, -1, x))
#イベント配列は「影響を受ける人（の出発時間）」で降順ソートする
#降順ソートなので、pop()でとっていく
from operator import itemgetter
Events = sorted(Events, key=lambda x:-x[1])
Events = sorted(Events, key=lambda x:-x[0])
#発生タイミング（x[0]）が同じイベントは、集合からのout→inでも並び替える（x[1]について降順）。
#outより先にinが行われると、集合操作がおかしくなる
#イベント配列ができたので、今度は各人について処理していく
#出力する答えはAnss配列に入れていき、最後にfor文で一気に出力する
Anss = []
#制約より、Diは最初から昇順ソートされている
Ds = [int(eval(input())) for _ in range(Q)]
nowkeptout = set() #今通行止めになっている座標を格納するset。常に昇順ソートする
nextevent = Events.pop() #次に見るイベント
minstop = 10**9+1
for d in Ds:
#各ループにおいて、「未処理の人のうち、最も出発時間が早い人」がdに入る
#ということは、時間dまでのEventsを全て処理すれば、その人がぶつかる場所が分かる
while nextevent[0]<=d: #dを越えたら止まるし、イベントがなくなっても番兵で止まる
a, b, c = nextevent
if b==1: #座標xが通行止めになる
nowkeptout.add(c)
minstop = min(c, minstop)
else: #座標xの通行止めが解除される
nowkeptout.remove(c)
if c==minstop and nowkeptout: minstop = min(nowkeptout)
elif not nowkeptout: minstop = 10**9+1
try: nextevent = Events.pop()
except:
nextevent = (10**9+1, 1, 1) #要素がなくなったらもう処理が起きないようにする
break
#この時点で、nowkeptoutに値が入っている場合も、入っていない場合もある
#値が入っていれば、dはその最小値の座標で通行止めにぶつかる
#値が入っていなければ歩き続けるので、-1にする
if nowkeptout: Anss.append(minstop)
else: Anss.append(-1)
for ans in Anss:
print(ans)
| p03033 |
import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
STX = []
D = []
D2 = []
ans = [0]*Q
timer = 0
m = 0
for _ in range(N):
stx = list(map(int, input().split()))
STX.append(stx)
if stx[2] > m:
m = stx[2]
for _ in range(Q):
ds = int(eval(input()))
D.append(-ds)
D2.append(-ds)
while True:
for d in D:
if d > 0:
for s in STX:
if d == s[2] and timer >= s[0] and timer < s[1]:
ans[D2.index(d-timer)] = D.pop(D.index(d))
break
if D == []:
break
elif min(D) >= m:
for a in ans:
if a == 0:
print((-1))
else:
print(a)
break
D = list([x+1 for x in D])
timer += 1 | 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 bisect
class DualSegmentTree():
def __init__(self, n):
INF = float("inf")
self.size = 1
while self.size < n:
self.size *= 2
self.node = [INF] * (2*self.size - 1)
def update(self, begin, end, val):
begin += (self.size - 1)
end += (self.size - 1)
while begin < end:
if (end - 1) & 1:
end -= 1
self.node[end] = min(val, self.node[end])
if (begin - 1) & 1:
self.node[begin] = min(val, self.node[begin])
begin += 1
begin = (begin - 1) // 2
end = (end - 1) // 2
def get_val(self, i):
i += (self.size - 1)
val = self.node[i]
while i > 0:
i = (i - 1) // 2
val = min(val, self.node[i])
return val
n, q = list(map(int, input().split()))
info = [list(map(int, input().split())) for i in range(n)]
d = [int(eval(input())) for i in range(q)]
INF = float("inf")
st = DualSegmentTree(len(d)+1)
for i in range(n):
a, b = info[i][0] - info[i][2], info[i][1] - info[i][2]
l = bisect.bisect_left(d, a)
r = bisect.bisect_left(d, b)
st.update(l, r, info[i][2])
for i in range(q):
tmp = st.get_val(i)
if tmp == float("inf"):
print((-1))
else:
print(tmp) | import sys
import bisect
class DualSegmentTree():
def __init__(self, n):
INF = float("inf")
self.size = 1
while self.size < n:
self.size *= 2
self.node = [INF] * (2*self.size - 1)
def update(self, begin, end, val):
begin += (self.size - 1)
end += (self.size - 1)
while begin < end:
if (end - 1) & 1:
end -= 1
self.node[end] = min(val, self.node[end])
if (begin - 1) & 1:
self.node[begin] = min(val, self.node[begin])
begin += 1
begin = (begin - 1) // 2
end = (end - 1) // 2
def get_val(self, i):
i += (self.size - 1)
val = self.node[i]
while i > 0:
i = (i - 1) // 2
val = min(val, self.node[i])
return val
n, q = list(map(int, input().split()))
info = [list(map(int, sys.stdin.readline().split())) for i in range(n)]
d = [int(sys.stdin.readline()) for i in range(q)]
INF = float("inf")
st = DualSegmentTree(len(d)+1)
for i in range(n):
a, b = info[i][0] - info[i][2], info[i][1] - info[i][2]
l = bisect.bisect_left(d, a)
r = bisect.bisect_left(d, b)
st.update(l, r, info[i][2])
for i in range(q):
tmp = st.get_val(i)
if tmp == float("inf"):
print((-1))
else:
print(tmp)
| p03033 |
from bisect import bisect,bisect_left
import sys
import itertools
input=sys.stdin.readline
def main():
n,q=list(map(int,input().split()))
xst=[]
for i in range(n):
s,t,x=list(map(int,input().split()))
xst.append([x,s,t])
xst.sort()
d=[None]*q
for i in range(q):
d[i]=[int(eval(input())),i]
ans=[-1]*q
for u in xst:
x,s,t=u
left=s-x
right=t-x-1
a=bisect(d,[left])
b=bisect(d,[right,q+1])
for u in d[a:b]:
ans[u[1]]=x
d=list(itertools.chain(d[:a],d[b:]))
for u in ans:
print(u)
if __name__=="__main__":
main() | from bisect import bisect,bisect_left
import sys
input=sys.stdin.readline
def main():
n,q=list(map(int,input().split()))
xst=[]
for i in range(n):
s,t,x=list(map(int,input().split()))
xst.append([x,s-x,t-x])
xst.sort()
d=[None]*q
for i in range(q):
d[i]=int(eval(input()))
ans=[-1]*q
skip=[-1]*q
for u in xst:
x ,left ,right = u
a=bisect_left(d,left)
b=bisect_left(d,right)
while a < b:
if skip[a] == -1:
ans[a]=x
skip[a]=b
a+=1
else:
a=skip[a]
for u in ans:
print(u)
if __name__=="__main__":
main() | p03033 |
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
MOD = 10 ** 9 + 7
INF = 10 ** 18
"""Sorted Containers -- Sorted List, Sorted Dict, Sorted Set
Sorted Containers is an Apache2 licensed containers library, written in
pure-Python, and fast as C-extensions.
Python's standard library is great until you need a sorted collections
type. Many will attest that you can get really far without one, but the moment
you **really need** a sorted list, dict, or set, you're faced with a dozen
different implementations, most using C-extensions without great documentation
and benchmarking.
In Python, we can do better. And we can do it in pure-Python!
::
>>> from sortedcontainers import SortedList
>>> sl = SortedList(['e', 'a', 'c', 'd', 'b'])
>>> sl
SortedList(['a', 'b', 'c', 'd', 'e'])
>>> sl *= 1000000
>>> sl.count('c')
1000000
>>> sl[-3:]
['e', 'e', 'e']
>>> from sortedcontainers import SortedDict
>>> sd = SortedDict({'c': 3, 'a': 1, 'b': 2})
>>> sd
SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> sd.popitem(index=-1)
('c', 3)
>>> from sortedcontainers import SortedSet
>>> ss = SortedSet('abracadabra')
>>> ss
SortedSet(['a', 'b', 'c', 'd', 'r'])
>>> ss.bisect_left('c')
2
Sorted Containers takes all of the work out of Python sorted types - making
your deployment and use of Python easy. There's no need to install a C compiler
or pre-build and distribute custom extensions. Performance is a feature and
testing has 100% coverage with unit tests and hours of stress.
:copyright: (c) 2014-2019 by Grant Jenks.
:license: Apache 2.0, see LICENSE for more details.
from .sortedlist import SortedList, SortedKeyList, SortedListWithKey
from .sortedset import SortedSet
from .sorteddict import (
SortedDict,
SortedKeysView,
SortedItemsView,
SortedValuesView,
)
__all__ = [
'SortedList',
'SortedKeyList',
'SortedListWithKey',
'SortedDict',
'SortedKeysView',
'SortedItemsView',
'SortedValuesView',
'SortedSet',
]
__title__ = 'sortedcontainers'
__version__ = '2.1.0'
__build__ = 0x020100
__author__ = 'Grant Jenks'
__license__ = 'Apache 2.0'
__copyright__ = '2014-2019, Grant Jenks'
"""
"""Sorted List
==============
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
collections library, written in pure-Python, and fast as C-extensions. The
:doc:`introduction<introduction>` is the best way to get started.
Sorted list implementations:
.. currentmodule:: sortedcontainers
* :class:`SortedList`
* :class:`SortedKeyList`
"""
# pylint: disable=too-many-lines
# from __future__ import print_function
from bisect import bisect_left, bisect_right, insort
from itertools import chain, repeat, starmap
from math import log
from operator import add, eq, ne, gt, ge, lt, le, iadd
from textwrap import dedent
###############################################################################
# BEGIN Python 2/3 Shims
###############################################################################
try:
from collections.abc import Sequence, MutableSequence
except ImportError:
from collections import Sequence, MutableSequence
from functools import wraps
from sys import hexversion
if hexversion < 0x03000000:
# pylint: disable=redefined-builtin
# pylint: disable=redefined-builtin
try:
from _thread import get_ident
except ImportError:
from _dummy_thread import get_ident
else:
from functools import reduce
try:
from _thread import get_ident
except ImportError:
from _dummy_thread import get_ident
def recursive_repr(fillvalue='...'):
"Decorator to make a repr function return fillvalue for a recursive call."
# pylint: disable=missing-docstring
# Copied from reprlib in Python 3
# https://hg.python.org/cpython/file/3.6/Lib/reprlib.py
def decorating_function(user_function):
repr_running = set()
@wraps(user_function)
def wrapper(self):
key = id(self), get_ident()
if key in repr_running:
return fillvalue
repr_running.add(key)
try:
result = user_function(self)
finally:
repr_running.discard(key)
return result
return wrapper
return decorating_function
###############################################################################
# END Python 2/3 Shims
###############################################################################
class SortedList(MutableSequence):
"""Sorted list is a sorted mutable sequence.
Sorted list values are maintained in sorted order.
Sorted list values must be comparable. The total ordering of values must
not change while they are stored in the sorted list.
Methods for adding values:
* :func:`SortedList.add`
* :func:`SortedList.update`
* :func:`SortedList.__add__`
* :func:`SortedList.__iadd__`
* :func:`SortedList.__mul__`
* :func:`SortedList.__imul__`
Methods for removing values:
* :func:`SortedList.clear`
* :func:`SortedList.discard`
* :func:`SortedList.remove`
* :func:`SortedList.pop`
* :func:`SortedList.__delitem__`
Methods for looking up values:
* :func:`SortedList.bisect_left`
* :func:`SortedList.bisect_right`
* :func:`SortedList.count`
* :func:`SortedList.index`
* :func:`SortedList.__contains__`
* :func:`SortedList.__getitem__`
Methods for iterating values:
* :func:`SortedList.irange`
* :func:`SortedList.islice`
* :func:`SortedList.__iter__`
* :func:`SortedList.__reversed__`
Methods for miscellany:
* :func:`SortedList.copy`
* :func:`SortedList.__len__`
* :func:`SortedList.__repr__`
* :func:`SortedList._check`
* :func:`SortedList._reset`
Sorted lists use lexicographical ordering semantics when compared to other
sequences.
Some methods of mutable sequences are not supported and will raise
not-implemented error.
"""
DEFAULT_LOAD_FACTOR = 1000
def __init__(self, iterable=None, key=None):
"""Initialize sorted list instance.
Optional `iterable` argument provides an initial iterable of values to
initialize the sorted list.
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList()
>>> sl
SortedList([])
>>> sl = SortedList([3, 1, 2, 5, 4])
>>> sl
SortedList([1, 2, 3, 4, 5])
:param iterable: initial values (optional)
"""
assert key is None
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self._update(iterable)
def __new__(cls, iterable=None, key=None):
"""Create new sorted list or sorted-key list instance.
Optional `key`-function argument will return an instance of subtype
:class:`SortedKeyList`.
>>> sl = SortedList()
>>> isinstance(sl, SortedList)
True
>>> sl = SortedList(key=lambda x: -x)
>>> isinstance(sl, SortedList)
True
>>> isinstance(sl, SortedKeyList)
True
:param iterable: initial values (optional)
:param key: function used to extract comparison key (optional)
:return: sorted list or sorted-key list instance
"""
# pylint: disable=unused-argument
if key is None:
return object.__new__(cls)
else:
if cls is SortedList:
return object.__new__(SortedKeyList)
else:
raise TypeError('inherit SortedKeyList for key argument')
@property
def key(self): # pylint: disable=useless-return
"""Function used to extract comparison key from values.
Sorted list compares values directly so the key function is none.
"""
return None
def _reset(self, load):
"""Reset sorted list load factor.
The `load` specifies the load-factor of the list. The default load
factor of 1000 works well for lists from tens to tens-of-millions of
values. Good practice is to use a value that is the cube root of the
list size. With billions of elements, the best load factor depends on
your usage. It's best to leave the load factor at the default until you
start benchmarking.
See :doc:`implementation` and :doc:`performance-scale` for more
information.
Runtime complexity: `O(n)`
:param int load: load-factor for sorted list sublists
"""
values = reduce(iadd, self._lists, [])
self._clear()
self._load = load
self._update(values)
def clear(self):
"""Remove all values from sorted list.
Runtime complexity: `O(n)`
"""
self._len = 0
del self._lists[:]
del self._maxes[:]
del self._index[:]
self._offset = 0
_clear = clear
def add(self, value):
"""Add `value` to sorted list.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList()
>>> sl.add(3)
>>> sl.add(1)
>>> sl.add(2)
>>> sl
SortedList([1, 2, 3])
:param value: value to add to sorted list
"""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_maxes[pos] = value
else:
insort(_lists[pos], value)
self._expand(pos)
else:
_lists.append([value])
_maxes.append(value)
self._len += 1
def _expand(self, pos):
"""Split sublists with length greater than double the load-factor.
Updates the index when the sublist length is less than double the load
level. This requires incrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
"""
_load = self._load
_lists = self._lists
_index = self._index
if len(_lists[pos]) > (_load << 1):
_maxes = self._maxes
_lists_pos = _lists[pos]
half = _lists_pos[_load:]
del _lists_pos[_load:]
_maxes[pos] = _lists_pos[-1]
_lists.insert(pos + 1, half)
_maxes.insert(pos + 1, half[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
"""Update sorted list by adding all values from `iterable`.
Runtime complexity: `O(k*log(n))` -- approximate.
>>> sl = SortedList()
>>> sl.update([3, 1, 2])
>>> sl
SortedList([1, 2, 3])
:param iterable: iterable of values to add
"""
_lists = self._lists
_maxes = self._maxes
values = sorted(iterable)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort()
self._clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(values[pos:(pos + _load)]
for pos in range(0, len(values), _load))
_maxes.extend(sublist[-1] for sublist in _lists)
self._len = len(values)
del self._index[:]
_update = update
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list.
``sl.__contains__(value)`` <==> ``value in sl``
Runtime complexity: `O(log(n))`
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> 3 in sl
True
:param value: search for value in sorted list
:return: true if `value` in sorted list
"""
_maxes = self._maxes
if not _maxes:
return False
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return False
_lists = self._lists
idx = bisect_left(_lists[pos], value)
return _lists[pos][idx] == value
def discard(self, value):
"""Remove `value` from sorted list if it is a member.
If `value` is not a member, do nothing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> sl.discard(5)
>>> sl.discard(0)
>>> sl == [1, 2, 3, 4]
True
:param value: `value` to discard from sorted list
"""
_maxes = self._maxes
if not _maxes:
return
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member.
If `value` is not a member, raise ValueError.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> sl.remove(5)
>>> sl == [1, 2, 3, 4]
True
>>> sl.remove(0)
Traceback (most recent call last):
...
ValueError: 0 not in list
:param value: `value` to remove from sorted list
:raises ValueError: if `value` is not in sorted list
"""
_maxes = self._maxes
if not _maxes:
raise ValueError('{0!r} not in list'.format(value))
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
raise ValueError('{0!r} not in list'.format(value))
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
else:
raise ValueError('{0!r} not in list'.format(value))
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`.
Combines lists that are less than half the load level.
Updates the index when the sublist length is more than half the load
level. This requires decrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
:param int pos: lists index
:param int idx: sublist index
"""
_lists = self._lists
_maxes = self._maxes
_index = self._index
_lists_pos = _lists[pos]
del _lists_pos[idx]
self._len -= 1
len_lists_pos = len(_lists_pos)
if len_lists_pos > (self._load >> 1):
_maxes[pos] = _lists_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_lists) > 1:
if not pos:
pos += 1
prev = pos - 1
_lists[prev].extend(_lists[pos])
_maxes[prev] = _lists[prev][-1]
del _lists[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_lists_pos:
_maxes[pos] = _lists_pos[-1]
else:
del _lists[pos]
del _maxes[pos]
del _index[:]
def _loc(self, pos, idx):
"""Convert an index pair (lists index, sublist index) into a single
index number that corresponds to the position of the value in the
sorted list.
Many queries require the index be built. Details of the index are
described in ``SortedList._build_index``.
Indexing requires traversing the tree from a leaf node to the root. The
parent of each node is easily computable at ``(pos - 1) // 2``.
Left-child nodes are always at odd indices and right-child nodes are
always at even indices.
When traversing up from a right-child node, increment the total by the
left-child node.
The final index is the sum from traversal and the index in the sublist.
For example, using the index from ``SortedList._build_index``::
_index = 14 5 9 3 2 4 5
_offset = 3
Tree::
14
5 9
3 2 4 5
Converting an index pair (2, 3) into a single index involves iterating
like so:
1. Starting at the leaf node: offset + alpha = 3 + 2 = 5. We identify
the node as a left-child node. At such nodes, we simply traverse to
the parent.
2. At node 9, position 2, we recognize the node as a right-child node
and accumulate the left-child in our total. Total is now 5 and we
traverse to the parent at position 0.
3. Iteration ends at the root.
The index is then the sum of the total and sublist index: 5 + 3 = 8.
:param int pos: lists index
:param int idx: sublist index
:return: index in sorted list
"""
if not pos:
return idx
_index = self._index
if not _index:
self._build_index()
total = 0
# Increment pos to point in the index to len(self._lists[pos]).
pos += self._offset
# Iterate until reaching the root of the index tree at pos = 0.
while pos:
# Right-child nodes are at odd indices. At such indices
# account the total below the left child node.
if not pos & 1:
total += _index[pos - 1]
# Advance pos to the parent node.
pos = (pos - 1) >> 1
return total + idx
def _pos(self, idx):
"""Convert an index into an index pair (lists index, sublist index)
that can be used to access the corresponding lists position.
Many queries require the index be built. Details of the index are
described in ``SortedList._build_index``.
Indexing requires traversing the tree to a leaf node. Each node has two
children which are easily computable. Given an index, pos, the
left-child is at ``pos * 2 + 1`` and the right-child is at ``pos * 2 +
2``.
When the index is less than the left-child, traversal moves to the
left sub-tree. Otherwise, the index is decremented by the left-child
and traversal moves to the right sub-tree.
At a child node, the indexing pair is computed from the relative
position of the child node as compared with the offset and the remaining
index.
For example, using the index from ``SortedList._build_index``::
_index = 14 5 9 3 2 4 5
_offset = 3
Tree::
14
5 9
3 2 4 5
Indexing position 8 involves iterating like so:
1. Starting at the root, position 0, 8 is compared with the left-child
node (5) which it is greater than. When greater the index is
decremented and the position is updated to the right child node.
2. At node 9 with index 3, we again compare the index to the left-child
node with value 4. Because the index is the less than the left-child
node, we simply traverse to the left.
3. At node 4 with index 3, we recognize that we are at a leaf node and
stop iterating.
4. To compute the sublist index, we subtract the offset from the index
of the leaf node: 5 - 3 = 2. To compute the index in the sublist, we
simply use the index remaining from iteration. In this case, 3.
The final index pair from our example is (2, 3) which corresponds to
index 8 in the sorted list.
:param int idx: index in sorted list
:return: (lists index, sublist index) pair
"""
if idx < 0:
last_len = len(self._lists[-1])
if (-idx) <= last_len:
return len(self._lists) - 1, last_len + idx
idx += self._len
if idx < 0:
raise IndexError('list index out of range')
elif idx >= self._len:
raise IndexError('list index out of range')
if idx < len(self._lists[0]):
return 0, idx
_index = self._index
if not _index:
self._build_index()
pos = 0
child = 1
len_index = len(_index)
while child < len_index:
index_child = _index[child]
if idx < index_child:
pos = child
else:
idx -= index_child
pos = child + 1
child = (pos << 1) + 1
return (pos - self._offset, idx)
def _build_index(self):
"""Build a positional index for indexing the sorted list.
Indexes are represented as binary trees in a dense array notation
similar to a binary heap.
For example, given a lists representation storing integers::
0: [1, 2, 3]
1: [4, 5]
2: [6, 7, 8, 9]
3: [10, 11, 12, 13, 14]
The first transformation maps the sub-lists by their length. The
first row of the index is the length of the sub-lists::
0: [3, 2, 4, 5]
Each row after that is the sum of consecutive pairs of the previous
row::
1: [5, 9]
2: [14]
Finally, the index is built by concatenating these lists together::
_index = [14, 5, 9, 3, 2, 4, 5]
An offset storing the start of the first row is also stored::
_offset = 3
When built, the index can be used for efficient indexing into the list.
See the comment and notes on ``SortedList._pos`` for details.
"""
row0 = list(map(len, self._lists))
if len(row0) == 1:
self._index[:] = row0
self._offset = 0
return
head = iter(row0)
tail = iter(head)
row1 = list(starmap(add, list(zip(head, tail))))
if len(row0) & 1:
row1.append(row0[-1])
if len(row1) == 1:
self._index[:] = row1 + row0
self._offset = 1
return
size = 2 ** (int(log(len(row1) - 1, 2)) + 1)
row1.extend(repeat(0, size - len(row1)))
tree = [row0, row1]
while len(tree[-1]) > 1:
head = iter(tree[-1])
tail = iter(head)
row = list(starmap(add, list(zip(head, tail))))
tree.append(row)
reduce(iadd, reversed(tree), self._index)
self._offset = size * 2 - 1
def __delitem__(self, index):
"""Remove value at `index` from sorted list.
``sl.__delitem__(index)`` <==> ``del sl[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> del sl[2]
>>> sl
SortedList(['a', 'b', 'd', 'e'])
>>> del sl[:2]
>>> sl
SortedList(['d', 'e'])
:param index: integer or slice for indexing
:raises IndexError: if index out of range
"""
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return self._clear()
elif self._len <= 8 * (stop - start):
values = self._getitem(slice(None, start))
if stop < self._len:
values += self._getitem(slice(stop, None))
self._clear()
return self._update(values)
indices = list(range(start, stop, step))
# Delete items from greatest index to least so
# that the indices remain valid throughout iteration.
if step > 0:
indices = reversed(indices)
_pos, _delete = self._pos, self._delete
for index in indices:
pos, idx = _pos(index)
_delete(pos, idx)
else:
pos, idx = self._pos(index)
self._delete(pos, idx)
def __getitem__(self, index):
"""Lookup value at `index` in sorted list.
``sl.__getitem__(index)`` <==> ``sl[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl[1]
'b'
>>> sl[-1]
'e'
>>> sl[2:5]
['c', 'd', 'e']
:param index: integer or slice for indexing
:return: value or list of values
:raises IndexError: if index out of range
"""
_lists = self._lists
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return reduce(iadd, self._lists, [])
start_pos, start_idx = self._pos(start)
if stop == self._len:
stop_pos = len(_lists) - 1
stop_idx = len(_lists[stop_pos])
else:
stop_pos, stop_idx = self._pos(stop)
if start_pos == stop_pos:
return _lists[start_pos][start_idx:stop_idx]
prefix = _lists[start_pos][start_idx:]
middle = _lists[(start_pos + 1):stop_pos]
result = reduce(iadd, middle, prefix)
result += _lists[stop_pos][:stop_idx]
return result
if step == -1 and start > stop:
result = self._getitem(slice(stop + 1, start + 1))
result.reverse()
return result
# Return a list because a negative step could
# reverse the order of the items and this could
# be the desired behavior.
indices = list(range(start, stop, step))
return list(self._getitem(index) for index in indices)
else:
if self._len:
if index == 0:
return _lists[0][0]
elif index == -1:
return _lists[-1][-1]
else:
raise IndexError('list index out of range')
if 0 <= index < len(_lists[0]):
return _lists[0][index]
len_last = len(_lists[-1])
if -len_last < index < 0:
return _lists[-1][len_last + index]
pos, idx = self._pos(index)
return _lists[pos][idx]
_getitem = __getitem__
def __setitem__(self, index, value):
"""Raise not-implemented error.
``sl.__setitem__(index, value)`` <==> ``sl[index] = value``
:raises NotImplementedError: use ``del sl[index]`` and
``sl.add(value)`` instead
"""
message = 'use ``del sl[index]`` and ``sl.add(value)`` instead'
raise NotImplementedError(message)
def __iter__(self):
"""Return an iterator over the sorted list.
``sl.__iter__()`` <==> ``iter(sl)``
Iterating the sorted list while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return chain.from_iterable(self._lists)
def __reversed__(self):
"""Return a reverse iterator over the sorted list.
``sl.__reversed__()`` <==> ``reversed(sl)``
Iterating the sorted list while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return chain.from_iterable(list(map(reversed, reversed(self._lists))))
def reverse(self):
"""Raise not-implemented error.
Sorted list maintains values in ascending sort order. Values may not be
reversed in-place.
Use ``reversed(sl)`` for an iterator over values in descending sort
order.
Implemented to override `MutableSequence.reverse` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``reversed(sl)`` instead
"""
raise NotImplementedError('use ``reversed(sl)`` instead')
def islice(self, start=None, stop=None, reverse=False):
"""Return an iterator that slices sorted list from `start` to `stop`.
The `start` and `stop` index are treated inclusive and exclusive,
respectively.
Both `start` and `stop` default to `None` which is automatically
inclusive of the beginning and end of the sorted list.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> sl = SortedList('abcdefghij')
>>> it = sl.islice(2, 6)
>>> list(it)
['c', 'd', 'e', 'f']
:param int start: start index (inclusive)
:param int stop: stop index (exclusive)
:param bool reverse: yield values in reverse order
:return: iterator
"""
_len = self._len
if not _len:
return iter(())
start, stop, _ = slice(start, stop).indices(self._len)
if start >= stop:
return iter(())
_pos = self._pos
min_pos, min_idx = _pos(start)
if stop == _len:
max_pos = len(self._lists) - 1
max_idx = len(self._lists[-1])
else:
max_pos, max_idx = _pos(stop)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def _islice(self, min_pos, min_idx, max_pos, max_idx, reverse):
"""Return an iterator that slices sorted list using two index pairs.
The index pairs are (min_pos, min_idx) and (max_pos, max_idx), the
first inclusive and the latter exclusive. See `_pos` for details on how
an index is converted to an index pair.
When `reverse` is `True`, values are yielded from the iterator in
reverse order.
"""
_lists = self._lists
if min_pos > max_pos:
return iter(())
if min_pos == max_pos:
if reverse:
indices = reversed(list(range(min_idx, max_idx)))
return list(map(_lists[min_pos].__getitem__, indices))
indices = list(range(min_idx, max_idx))
return list(map(_lists[min_pos].__getitem__, indices))
next_pos = min_pos + 1
if next_pos == max_pos:
if reverse:
min_indices = list(range(min_idx, len(_lists[min_pos])))
max_indices = list(range(max_idx))
return chain(
list(map(_lists[max_pos].__getitem__, reversed(max_indices))),
list(map(_lists[min_pos].__getitem__, reversed(min_indices))),
)
min_indices = list(range(min_idx, len(_lists[min_pos])))
max_indices = list(range(max_idx))
return chain(
list(map(_lists[min_pos].__getitem__, min_indices)),
list(map(_lists[max_pos].__getitem__, max_indices)),
)
if reverse:
min_indices = list(range(min_idx, len(_lists[min_pos])))
sublist_indices = list(range(next_pos, max_pos))
sublists = list(map(_lists.__getitem__, reversed(sublist_indices)))
max_indices = list(range(max_idx))
return chain(
list(map(_lists[max_pos].__getitem__, reversed(max_indices))),
chain.from_iterable(list(map(reversed, sublists))),
list(map(_lists[min_pos].__getitem__, reversed(min_indices))),
)
min_indices = list(range(min_idx, len(_lists[min_pos])))
sublist_indices = list(range(next_pos, max_pos))
sublists = list(map(_lists.__getitem__, sublist_indices))
max_indices = list(range(max_idx))
return chain(
list(map(_lists[min_pos].__getitem__, min_indices)),
chain.from_iterable(sublists),
list(map(_lists[max_pos].__getitem__, max_indices)),
)
def irange(self, minimum=None, maximum=None, inclusive=(True, True),
reverse=False):
"""Create an iterator of values between `minimum` and `maximum`.
Both `minimum` and `maximum` default to `None` which is automatically
inclusive of the beginning and end of the sorted list.
The argument `inclusive` is a pair of booleans that indicates whether
the minimum and maximum ought to be included in the range,
respectively. The default is ``(True, True)`` such that the range is
inclusive of both minimum and maximum.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> sl = SortedList('abcdefghij')
>>> it = sl.irange('c', 'f')
>>> list(it)
['c', 'd', 'e', 'f']
:param minimum: minimum value to start iterating
:param maximum: maximum value to stop iterating
:param inclusive: pair of booleans
:param bool reverse: yield values in reverse order
:return: iterator
"""
_maxes = self._maxes
if not _maxes:
return iter(())
_lists = self._lists
# Calculate the minimum (pos, idx) pair. By default this location
# will be inclusive in our calculation.
if minimum is None:
min_pos = 0
min_idx = 0
else:
if inclusive[0]:
min_pos = bisect_left(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_left(_lists[min_pos], minimum)
else:
min_pos = bisect_right(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_right(_lists[min_pos], minimum)
# Calculate the maximum (pos, idx) pair. By default this location
# will be exclusive in our calculation.
if maximum is None:
max_pos = len(_maxes) - 1
max_idx = len(_lists[max_pos])
else:
if inclusive[1]:
max_pos = bisect_right(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_right(_lists[max_pos], maximum)
else:
max_pos = bisect_left(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_left(_lists[max_pos], maximum)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def __len__(self):
"""Return the size of the sorted list.
``sl.__len__()`` <==> ``len(sl)``
:return: size of sorted list
"""
return self._len
def bisect_left(self, value):
"""Return an index to insert `value` in the sorted list.
If the `value` is already present, the insertion point will be before
(to the left of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([10, 11, 12, 13, 14])
>>> sl.bisect_left(12)
2
:param value: insertion index of value in sorted list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_left(self._lists[pos], value)
return self._loc(pos, idx)
def bisect_right(self, value):
"""Return an index to insert `value` in the sorted list.
Similar to `bisect_left`, but if `value` is already present, the
insertion point will be after (to the right of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([10, 11, 12, 13, 14])
>>> sl.bisect_right(12)
3
:param value: insertion index of value in sorted list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], value)
return self._loc(pos, idx)
bisect = bisect_right
_bisect_right = bisect_right
def count(self, value):
"""Return number of occurrences of `value` in the sorted list.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
>>> sl.count(3)
3
:param value: value to count in sorted list
:return: count
"""
_maxes = self._maxes
if not _maxes:
return 0
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
return 0
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
pos_right = bisect_right(_maxes, value)
if pos_right == len(_maxes):
return self._len - self._loc(pos_left, idx_left)
idx_right = bisect_right(_lists[pos_right], value)
if pos_left == pos_right:
return idx_right - idx_left
right = self._loc(pos_right, idx_right)
left = self._loc(pos_left, idx_left)
return right - left
def copy(self):
"""Return a shallow copy of the sorted list.
Runtime complexity: `O(n)`
:return: new sorted list
"""
return self.__class__(self)
__copy__ = copy
def append(self, value):
"""Raise not-implemented error.
Implemented to override `MutableSequence.append` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``sl.add(value)`` instead
"""
raise NotImplementedError('use ``sl.add(value)`` instead')
def extend(self, values):
"""Raise not-implemented error.
Implemented to override `MutableSequence.extend` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``sl.update(values)`` instead
"""
raise NotImplementedError('use ``sl.update(values)`` instead')
def insert(self, index, value):
"""Raise not-implemented error.
:raises NotImplementedError: use ``sl.add(value)`` instead
"""
raise NotImplementedError('use ``sl.add(value)`` instead')
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list.
Raise :exc:`IndexError` if the sorted list is empty or index is out of
range.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl.pop()
'e'
>>> sl.pop(2)
'c'
>>> sl
SortedList(['a', 'b', 'd'])
:param int index: index of value (default -1)
:return: value
:raises IndexError: if index is out of range
"""
if not self._len:
raise IndexError('pop index out of range')
_lists = self._lists
if index == 0:
val = _lists[0][0]
self._delete(0, 0)
return val
if index == -1:
pos = len(_lists) - 1
loc = len(_lists[pos]) - 1
val = _lists[pos][loc]
self._delete(pos, loc)
return val
if 0 <= index < len(_lists[0]):
val = _lists[0][index]
self._delete(0, index)
return val
len_last = len(_lists[-1])
if -len_last < index < 0:
pos = len(_lists) - 1
loc = len_last + index
val = _lists[pos][loc]
self._delete(pos, loc)
return val
pos, idx = self._pos(index)
val = _lists[pos][idx]
self._delete(pos, idx)
return val
def index(self, value, start=None, stop=None):
"""Return first index of value in sorted list.
Raise ValueError if `value` is not present.
Index must be between `start` and `stop` for the `value` to be
considered present. The default value, None, for `start` and `stop`
indicate the beginning and end of the sorted list.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl.index('d')
3
>>> sl.index('z')
Traceback (most recent call last):
...
ValueError: 'z' is not in list
:param value: value in sorted list
:param int start: start index (default None, start of sorted list)
:param int stop: stop index (default None, end of sorted list)
:return: index of value
:raises ValueError: if value is not present
"""
_len = self._len
if not _len:
raise ValueError('{0!r} is not in list'.format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError('{0!r} is not in list'.format(value))
_maxes = self._maxes
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
raise ValueError('{0!r} is not in list'.format(value))
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
if _lists[pos_left][idx_left] != value:
raise ValueError('{0!r} is not in list'.format(value))
stop -= 1
left = self._loc(pos_left, idx_left)
if start <= left:
if left <= stop:
return left
else:
right = self._bisect_right(value) - 1
if start <= right:
return start
raise ValueError('{0!r} is not in list'.format(value))
def __add__(self, other):
"""Return new sorted list containing all values in both sequences.
``sl.__add__(other)`` <==> ``sl + other``
Values in `other` do not need to be in sorted order.
Runtime complexity: `O(n*log(n))`
>>> sl1 = SortedList('bat')
>>> sl2 = SortedList('cat')
>>> sl1 + sl2
SortedList(['a', 'a', 'b', 'c', 't', 't'])
:param other: other iterable
:return: new sorted list
"""
values = reduce(iadd, self._lists, [])
values.extend(other)
return self.__class__(values)
__radd__ = __add__
def __iadd__(self, other):
"""Update sorted list with values from `other`.
``sl.__iadd__(other)`` <==> ``sl += other``
Values in `other` do not need to be in sorted order.
Runtime complexity: `O(k*log(n))` -- approximate.
>>> sl = SortedList('bat')
>>> sl += 'cat'
>>> sl
SortedList(['a', 'a', 'b', 'c', 't', 't'])
:param other: other iterable
:return: existing sorted list
"""
self._update(other)
return self
def __mul__(self, num):
"""Return new sorted list with `num` shallow copies of values.
``sl.__mul__(num)`` <==> ``sl * num``
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList('abc')
>>> sl * 3
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
:param int num: count of shallow copies
:return: new sorted list
"""
values = reduce(iadd, self._lists, []) * num
return self.__class__(values)
__rmul__ = __mul__
def __imul__(self, num):
"""Update the sorted list with `num` shallow copies of values.
``sl.__imul__(num)`` <==> ``sl *= num``
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList('abc')
>>> sl *= 3
>>> sl
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
:param int num: count of shallow copies
:return: existing sorted list
"""
values = reduce(iadd, self._lists, []) * num
self._clear()
self._update(values)
return self
def __make_cmp(seq_op, symbol, doc):
"Make comparator method."
def comparer(self, other):
"Compare method for sorted list and sequence."
if not isinstance(other, Sequence):
return NotImplemented
self_len = self._len
len_other = len(other)
if self_len != len_other:
if seq_op is eq:
return False
if seq_op is ne:
return True
for alpha, beta in zip(self, other):
if alpha != beta:
return seq_op(alpha, beta)
return seq_op(self_len, len_other)
seq_op_name = seq_op.__name__
comparer.__name__ = '__{0}__'.format(seq_op_name)
doc_str = """Return true if and only if sorted list is {0} `other`.
``sl.__{1}__(other)`` <==> ``sl {2} other``
Comparisons use lexicographical order as with sequences.
Runtime complexity: `O(n)`
:param other: `other` sequence
:return: true if sorted list is {0} `other`
"""
comparer.__doc__ = dedent(doc_str.format(doc, seq_op_name, symbol))
return comparer
__eq__ = __make_cmp(eq, '==', 'equal to')
__ne__ = __make_cmp(ne, '!=', 'not equal to')
__lt__ = __make_cmp(lt, '<', 'less than')
__gt__ = __make_cmp(gt, '>', 'greater than')
__le__ = __make_cmp(le, '<=', 'less than or equal to')
__ge__ = __make_cmp(ge, '>=', 'greater than or equal to')
__make_cmp = staticmethod(__make_cmp)
def __reduce__(self):
values = reduce(iadd, self._lists, [])
return (type(self), (values,))
@recursive_repr()
def __repr__(self):
"""Return string representation of sorted list.
``sl.__repr__()`` <==> ``repr(sl)``
:return: string representation
"""
return '{0}({1!r})'.format(type(self).__name__, list(self))
def _check(self):
"""Check invariants of sorted list.
Runtime complexity: `O(n)`
"""
try:
assert self._load >= 4
assert len(self._maxes) == len(self._lists)
assert self._len == sum(len(sublist) for sublist in self._lists)
# Check all sublists are sorted.
for sublist in self._lists:
for pos in range(1, len(sublist)):
assert sublist[pos - 1] <= sublist[pos]
# Check beginning/end of sublists are sorted.
for pos in range(1, len(self._lists)):
assert self._lists[pos - 1][-1] <= self._lists[pos][0]
# Check _maxes index is the last value of each sublist.
for pos in range(len(self._maxes)):
assert self._maxes[pos] == self._lists[pos][-1]
# Check sublist lengths are less than double load-factor.
double = self._load << 1
assert all(len(sublist) <= double for sublist in self._lists)
# Check sublist lengths are greater than half load-factor for all
# but the last sublist.
half = self._load >> 1
for pos in range(0, len(self._lists) - 1):
assert len(self._lists[pos]) >= half
if self._index:
assert self._len == self._index[0]
assert len(self._index) == self._offset + len(self._lists)
# Check index leaf nodes equal length of sublists.
for pos in range(len(self._lists)):
leaf = self._index[self._offset + pos]
assert leaf == len(self._lists[pos])
# Check index branch nodes are the sum of their children.
for pos in range(self._offset):
child = (pos << 1) + 1
if child >= len(self._index):
assert self._index[pos] == 0
elif child + 1 == len(self._index):
assert self._index[pos] == self._index[child]
else:
child_sum = self._index[child] + self._index[child + 1]
assert child_sum == self._index[pos]
except:
import sys
import traceback
traceback.print_exc(file=sys.stdout)
print(('len', self._len))
print(('load', self._load))
print(('offset', self._offset))
print(('len_index', len(self._index)))
print(('index', self._index))
print(('len_maxes', len(self._maxes)))
print(('maxes', self._maxes))
print(('len_lists', len(self._lists)))
print(('lists', self._lists))
raise
def identity(value):
"Identity function."
return value
class SortedKeyList(SortedList):
"""Sorted-key list is a subtype of sorted list.
The sorted-key list maintains values in comparison order based on the
result of a key function applied to every value.
All the same methods that are available in :class:`SortedList` are also
available in :class:`SortedKeyList`.
Additional methods provided:
* :attr:`SortedKeyList.key`
* :func:`SortedKeyList.bisect_key_left`
* :func:`SortedKeyList.bisect_key_right`
* :func:`SortedKeyList.irange_key`
Some examples below use:
>>> from operator import neg
>>> neg
<built-in function neg>
>>> neg(1)
-1
"""
def __init__(self, iterable=None, key=identity):
"""Initialize sorted-key list instance.
Optional `iterable` argument provides an initial iterable of values to
initialize the sorted-key list.
Optional `key` argument defines a callable that, like the `key`
argument to Python's `sorted` function, extracts a comparison key from
each value. The default is the identity function.
Runtime complexity: `O(n*log(n))`
>>> from operator import neg
>>> skl = SortedKeyList(key=neg)
>>> skl
SortedKeyList([], key=<built-in function neg>)
>>> skl = SortedKeyList([3, 1, 2], key=neg)
>>> skl
SortedKeyList([3, 2, 1], key=<built-in function neg>)
:param iterable: initial values (optional)
:param key: function used to extract comparison key (optional)
"""
self._key = key
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._keys = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self._update(iterable)
def __new__(cls, iterable=None, key=identity):
return object.__new__(cls)
@property
def key(self):
"Function used to extract comparison key from values."
return self._key
def clear(self):
"""Remove all values from sorted-key list.
Runtime complexity: `O(n)`
"""
self._len = 0
del self._lists[:]
del self._keys[:]
del self._maxes[:]
del self._index[:]
_clear = clear
def add(self, value):
"""Add `value` to sorted-key list.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList(key=neg)
>>> skl.add(3)
>>> skl.add(1)
>>> skl.add(2)
>>> skl
SortedKeyList([3, 2, 1], key=<built-in function neg>)
:param value: value to add to sorted-key list
"""
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
key = self._key(value)
if _maxes:
pos = bisect_right(_maxes, key)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_keys[pos].append(key)
_maxes[pos] = key
else:
idx = bisect_right(_keys[pos], key)
_lists[pos].insert(idx, value)
_keys[pos].insert(idx, key)
self._expand(pos)
else:
_lists.append([value])
_keys.append([key])
_maxes.append(key)
self._len += 1
def _expand(self, pos):
"""Split sublists with length greater than double the load-factor.
Updates the index when the sublist length is less than double the load
level. This requires incrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
"""
_lists = self._lists
_keys = self._keys
_index = self._index
if len(_keys[pos]) > (self._load << 1):
_maxes = self._maxes
_load = self._load
_lists_pos = _lists[pos]
_keys_pos = _keys[pos]
half = _lists_pos[_load:]
half_keys = _keys_pos[_load:]
del _lists_pos[_load:]
del _keys_pos[_load:]
_maxes[pos] = _keys_pos[-1]
_lists.insert(pos + 1, half)
_keys.insert(pos + 1, half_keys)
_maxes.insert(pos + 1, half_keys[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
"""Update sorted-key list by adding all values from `iterable`.
Runtime complexity: `O(k*log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList(key=neg)
>>> skl.update([3, 1, 2])
>>> skl
SortedKeyList([3, 2, 1], key=<built-in function neg>)
:param iterable: iterable of values to add
"""
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
values = sorted(iterable, key=self._key)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort(key=self._key)
self._clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(values[pos:(pos + _load)]
for pos in range(0, len(values), _load))
_keys.extend(list(map(self._key, _list)) for _list in _lists)
_maxes.extend(sublist[-1] for sublist in _keys)
self._len = len(values)
del self._index[:]
_update = update
def __contains__(self, value):
"""Return true if `value` is an element of the sorted-key list.
``skl.__contains__(value)`` <==> ``value in skl``
Runtime complexity: `O(log(n))`
>>> from operator import neg
>>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg)
>>> 3 in skl
True
:param value: search for value in sorted-key list
:return: true if `value` in sorted-key list
"""
_maxes = self._maxes
if not _maxes:
return False
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return False
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return False
if _lists[pos][idx] == value:
return True
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return False
len_sublist = len(_keys[pos])
idx = 0
def discard(self, value):
"""Remove `value` from sorted-key list if it is a member.
If `value` is not a member, do nothing.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
>>> skl.discard(1)
>>> skl.discard(0)
>>> skl == [5, 4, 3, 2]
True
:param value: `value` to discard from sorted-key list
"""
_maxes = self._maxes
if not _maxes:
return
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return
if _lists[pos][idx] == value:
self._delete(pos, idx)
return
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return
len_sublist = len(_keys[pos])
idx = 0
def remove(self, value):
"""Remove `value` from sorted-key list; `value` must be a member.
If `value` is not a member, raise ValueError.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([1, 2, 3, 4, 5], key=neg)
>>> skl.remove(5)
>>> skl == [4, 3, 2, 1]
True
>>> skl.remove(0)
Traceback (most recent call last):
...
ValueError: 0 not in list
:param value: `value` to remove from sorted-key list
:raises ValueError: if `value` is not in sorted-key list
"""
_maxes = self._maxes
if not _maxes:
raise ValueError('{0!r} not in list'.format(value))
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
raise ValueError('{0!r} not in list'.format(value))
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
raise ValueError('{0!r} not in list'.format(value))
if _lists[pos][idx] == value:
self._delete(pos, idx)
return
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
raise ValueError('{0!r} not in list'.format(value))
len_sublist = len(_keys[pos])
idx = 0
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`.
Combines lists that are less than half the load level.
Updates the index when the sublist length is more than half the load
level. This requires decrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
:param int pos: lists index
:param int idx: sublist index
"""
_lists = self._lists
_keys = self._keys
_maxes = self._maxes
_index = self._index
keys_pos = _keys[pos]
lists_pos = _lists[pos]
del keys_pos[idx]
del lists_pos[idx]
self._len -= 1
len_keys_pos = len(keys_pos)
if len_keys_pos > (self._load >> 1):
_maxes[pos] = keys_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_keys) > 1:
if not pos:
pos += 1
prev = pos - 1
_keys[prev].extend(_keys[pos])
_lists[prev].extend(_lists[pos])
_maxes[prev] = _keys[prev][-1]
del _lists[pos]
del _keys[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_keys_pos:
_maxes[pos] = keys_pos[-1]
else:
del _lists[pos]
del _keys[pos]
del _maxes[pos]
del _index[:]
def irange(self, minimum=None, maximum=None, inclusive=(True, True),
reverse=False):
"""Create an iterator of values between `minimum` and `maximum`.
Both `minimum` and `maximum` default to `None` which is automatically
inclusive of the beginning and end of the sorted-key list.
The argument `inclusive` is a pair of booleans that indicates whether
the minimum and maximum ought to be included in the range,
respectively. The default is ``(True, True)`` such that the range is
inclusive of both minimum and maximum.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> from operator import neg
>>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg)
>>> it = skl.irange(14.5, 11.5)
>>> list(it)
[14, 13, 12]
:param minimum: minimum value to start iterating
:param maximum: maximum value to stop iterating
:param inclusive: pair of booleans
:param bool reverse: yield values in reverse order
:return: iterator
"""
min_key = self._key(minimum) if minimum is not None else None
max_key = self._key(maximum) if maximum is not None else None
return self._irange_key(
min_key=min_key, max_key=max_key,
inclusive=inclusive, reverse=reverse,
)
def irange_key(self, min_key=None, max_key=None, inclusive=(True, True),
reverse=False):
"""Create an iterator of values between `min_key` and `max_key`.
Both `min_key` and `max_key` default to `None` which is automatically
inclusive of the beginning and end of the sorted-key list.
The argument `inclusive` is a pair of booleans that indicates whether
the minimum and maximum ought to be included in the range,
respectively. The default is ``(True, True)`` such that the range is
inclusive of both minimum and maximum.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> from operator import neg
>>> skl = SortedKeyList([11, 12, 13, 14, 15], key=neg)
>>> it = skl.irange_key(-14, -12)
>>> list(it)
[14, 13, 12]
:param min_key: minimum key to start iterating
:param max_key: maximum key to stop iterating
:param inclusive: pair of booleans
:param bool reverse: yield values in reverse order
:return: iterator
"""
_maxes = self._maxes
if not _maxes:
return iter(())
_keys = self._keys
# Calculate the minimum (pos, idx) pair. By default this location
# will be inclusive in our calculation.
if min_key is None:
min_pos = 0
min_idx = 0
else:
if inclusive[0]:
min_pos = bisect_left(_maxes, min_key)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_left(_keys[min_pos], min_key)
else:
min_pos = bisect_right(_maxes, min_key)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_right(_keys[min_pos], min_key)
# Calculate the maximum (pos, idx) pair. By default this location
# will be exclusive in our calculation.
if max_key is None:
max_pos = len(_maxes) - 1
max_idx = len(_keys[max_pos])
else:
if inclusive[1]:
max_pos = bisect_right(_maxes, max_key)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_keys[max_pos])
else:
max_idx = bisect_right(_keys[max_pos], max_key)
else:
max_pos = bisect_left(_maxes, max_key)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_keys[max_pos])
else:
max_idx = bisect_left(_keys[max_pos], max_key)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
_irange_key = irange_key
def bisect_left(self, value):
"""Return an index to insert `value` in the sorted-key list.
If the `value` is already present, the insertion point will be before
(to the left of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
>>> skl.bisect_left(1)
4
:param value: insertion index of value in sorted-key list
:return: index
"""
return self._bisect_key_left(self._key(value))
def bisect_right(self, value):
"""Return an index to insert `value` in the sorted-key list.
Similar to `bisect_left`, but if `value` is already present, the
insertion point will be after (to the right of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedList([5, 4, 3, 2, 1], key=neg)
>>> skl.bisect_right(1)
5
:param value: insertion index of value in sorted-key list
:return: index
"""
return self._bisect_key_right(self._key(value))
bisect = bisect_right
def bisect_key_left(self, key):
"""Return an index to insert `key` in the sorted-key list.
If the `key` is already present, the insertion point will be before (to
the left of) any existing keys.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
>>> skl.bisect_key_left(-1)
4
:param key: insertion index of key in sorted-key list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return self._len
idx = bisect_left(self._keys[pos], key)
return self._loc(pos, idx)
_bisect_key_left = bisect_key_left
def bisect_key_right(self, key):
"""Return an index to insert `key` in the sorted-key list.
Similar to `bisect_key_left`, but if `key` is already present, the
insertion point will be after (to the right of) any existing keys.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedList([5, 4, 3, 2, 1], key=neg)
>>> skl.bisect_key_right(-1)
5
:param key: insertion index of key in sorted-key list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, key)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._keys[pos], key)
return self._loc(pos, idx)
bisect_key = bisect_key_right
_bisect_key_right = bisect_key_right
def count(self, value):
"""Return number of occurrences of `value` in the sorted-key list.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([4, 4, 4, 4, 3, 3, 3, 2, 2, 1], key=neg)
>>> skl.count(2)
2
:param value: value to count in sorted-key list
:return: count
"""
_maxes = self._maxes
if not _maxes:
return 0
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
return 0
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
total = 0
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
return total
if _lists[pos][idx] == value:
total += 1
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
return total
len_sublist = len(_keys[pos])
idx = 0
def copy(self):
"""Return a shallow copy of the sorted-key list.
Runtime complexity: `O(n)`
:return: new sorted-key list
"""
return self.__class__(self, key=self._key)
__copy__ = copy
def index(self, value, start=None, stop=None):
"""Return first index of value in sorted-key list.
Raise ValueError if `value` is not present.
Index must be between `start` and `stop` for the `value` to be
considered present. The default value, None, for `start` and `stop`
indicate the beginning and end of the sorted-key list.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> from operator import neg
>>> skl = SortedKeyList([5, 4, 3, 2, 1], key=neg)
>>> skl.index(2)
3
>>> skl.index(0)
Traceback (most recent call last):
...
ValueError: 0 is not in list
:param value: value in sorted-key list
:param int start: start index (default None, start of sorted-key list)
:param int stop: stop index (default None, end of sorted-key list)
:return: index of value
:raises ValueError: if value is not present
"""
_len = self._len
if not _len:
raise ValueError('{0!r} is not in list'.format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError('{0!r} is not in list'.format(value))
_maxes = self._maxes
key = self._key(value)
pos = bisect_left(_maxes, key)
if pos == len(_maxes):
raise ValueError('{0!r} is not in list'.format(value))
stop -= 1
_lists = self._lists
_keys = self._keys
idx = bisect_left(_keys[pos], key)
len_keys = len(_keys)
len_sublist = len(_keys[pos])
while True:
if _keys[pos][idx] != key:
raise ValueError('{0!r} is not in list'.format(value))
if _lists[pos][idx] == value:
loc = self._loc(pos, idx)
if start <= loc <= stop:
return loc
elif loc > stop:
break
idx += 1
if idx == len_sublist:
pos += 1
if pos == len_keys:
raise ValueError('{0!r} is not in list'.format(value))
len_sublist = len(_keys[pos])
idx = 0
raise ValueError('{0!r} is not in list'.format(value))
def __add__(self, other):
"""Return new sorted-key list containing all values in both sequences.
``skl.__add__(other)`` <==> ``skl + other``
Values in `other` do not need to be in sorted-key order.
Runtime complexity: `O(n*log(n))`
>>> from operator import neg
>>> skl1 = SortedKeyList([5, 4, 3], key=neg)
>>> skl2 = SortedKeyList([2, 1, 0], key=neg)
>>> skl1 + skl2
SortedKeyList([5, 4, 3, 2, 1, 0], key=<built-in function neg>)
:param other: other iterable
:return: new sorted-key list
"""
values = reduce(iadd, self._lists, [])
values.extend(other)
return self.__class__(values, key=self._key)
__radd__ = __add__
def __mul__(self, num):
"""Return new sorted-key list with `num` shallow copies of values.
``skl.__mul__(num)`` <==> ``skl * num``
Runtime complexity: `O(n*log(n))`
>>> from operator import neg
>>> skl = SortedKeyList([3, 2, 1], key=neg)
>>> skl * 2
SortedKeyList([3, 3, 2, 2, 1, 1], key=<built-in function neg>)
:param int num: count of shallow copies
:return: new sorted-key list
"""
values = reduce(iadd, self._lists, []) * num
return self.__class__(values, key=self._key)
def __reduce__(self):
values = reduce(iadd, self._lists, [])
return (type(self), (values, self.key))
@recursive_repr()
def __repr__(self):
"""Return string representation of sorted-key list.
``skl.__repr__()`` <==> ``repr(skl)``
:return: string representation
"""
type_name = type(self).__name__
return '{0}({1!r}, key={2!r})'.format(type_name, list(self), self._key)
def _check(self):
"""Check invariants of sorted-key list.
Runtime complexity: `O(n)`
"""
try:
assert self._load >= 4
assert len(self._maxes) == len(self._lists) == len(self._keys)
assert self._len == sum(len(sublist) for sublist in self._lists)
# Check all sublists are sorted.
for sublist in self._keys:
for pos in range(1, len(sublist)):
assert sublist[pos - 1] <= sublist[pos]
# Check beginning/end of sublists are sorted.
for pos in range(1, len(self._keys)):
assert self._keys[pos - 1][-1] <= self._keys[pos][0]
# Check _keys matches _key mapped to _lists.
for val_sublist, key_sublist in zip(self._lists, self._keys):
assert len(val_sublist) == len(key_sublist)
for val, key in zip(val_sublist, key_sublist):
assert self._key(val) == key
# Check _maxes index is the last value of each sublist.
for pos in range(len(self._maxes)):
assert self._maxes[pos] == self._keys[pos][-1]
# Check sublist lengths are less than double load-factor.
double = self._load << 1
assert all(len(sublist) <= double for sublist in self._lists)
# Check sublist lengths are greater than half load-factor for all
# but the last sublist.
half = self._load >> 1
for pos in range(0, len(self._lists) - 1):
assert len(self._lists[pos]) >= half
if self._index:
assert self._len == self._index[0]
assert len(self._index) == self._offset + len(self._lists)
# Check index leaf nodes equal length of sublists.
for pos in range(len(self._lists)):
leaf = self._index[self._offset + pos]
assert leaf == len(self._lists[pos])
# Check index branch nodes are the sum of their children.
for pos in range(self._offset):
child = (pos << 1) + 1
if child >= len(self._index):
assert self._index[pos] == 0
elif child + 1 == len(self._index):
assert self._index[pos] == self._index[child]
else:
child_sum = self._index[child] + self._index[child + 1]
assert child_sum == self._index[pos]
except:
import sys
import traceback
traceback.print_exc(file=sys.stdout)
print(('len', self._len))
print(('load', self._load))
print(('offset', self._offset))
print(('len_index', len(self._index)))
print(('index', self._index))
print(('len_maxes', len(self._maxes)))
print(('maxes', self._maxes))
print(('len_keys', len(self._keys)))
print(('keys', self._keys))
print(('len_lists', len(self._lists)))
print(('lists', self._lists))
raise
SortedListWithKey = SortedKeyList
"""Sorted Dict
==============
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
collections library, written in pure-Python, and fast as C-extensions. The
:doc:`introduction<introduction>` is the best way to get started.
Sorted dict implementations:
.. currentmodule:: sortedcontainers
* :class:`SortedDict`
* :class:`SortedKeysView`
* :class:`SortedItemsView`
* :class:`SortedValuesView`
"""
import sys
import warnings
# from .sortedlist import SortedList, recursive_repr
# from .sortedset import SortedSet
###############################################################################
# BEGIN Python 2/3 Shims
###############################################################################
try:
from collections.abc import ItemsView, KeysView, ValuesView, Sequence
except ImportError:
from collections import ItemsView, KeysView, ValuesView, Sequence
###############################################################################
# END Python 2/3 Shims
###############################################################################
class SortedDict(dict):
"""Sorted dict is a sorted mutable mapping.
Sorted dict keys are maintained in sorted order. The design of sorted dict
is simple: sorted dict inherits from dict to store items and maintains a
sorted list of keys.
Sorted dict keys must be hashable and comparable. The hash and total
ordering of keys must not change while they are stored in the sorted dict.
Mutable mapping methods:
* :func:`SortedDict.__getitem__` (inherited from dict)
* :func:`SortedDict.__setitem__`
* :func:`SortedDict.__delitem__`
* :func:`SortedDict.__iter__`
* :func:`SortedDict.__len__` (inherited from dict)
Methods for adding items:
* :func:`SortedDict.setdefault`
* :func:`SortedDict.update`
Methods for removing items:
* :func:`SortedDict.clear`
* :func:`SortedDict.pop`
* :func:`SortedDict.popitem`
Methods for looking up items:
* :func:`SortedDict.__contains__` (inherited from dict)
* :func:`SortedDict.get` (inherited from dict)
* :func:`SortedDict.peekitem`
Methods for views:
* :func:`SortedDict.keys`
* :func:`SortedDict.items`
* :func:`SortedDict.values`
Methods for miscellany:
* :func:`SortedDict.copy`
* :func:`SortedDict.fromkeys`
* :func:`SortedDict.__reversed__`
* :func:`SortedDict.__eq__` (inherited from dict)
* :func:`SortedDict.__ne__` (inherited from dict)
* :func:`SortedDict.__repr__`
* :func:`SortedDict._check`
Sorted list methods available (applies to keys):
* :func:`SortedList.bisect_left`
* :func:`SortedList.bisect_right`
* :func:`SortedList.count`
* :func:`SortedList.index`
* :func:`SortedList.irange`
* :func:`SortedList.islice`
* :func:`SortedList._reset`
Additional sorted list methods available, if key-function used:
* :func:`SortedKeyList.bisect_key_left`
* :func:`SortedKeyList.bisect_key_right`
* :func:`SortedKeyList.irange_key`
Sorted dicts may only be compared for equality and inequality.
"""
def __init__(self, *args, **kwargs):
"""Initialize sorted dict instance.
Optional key-function argument defines a callable that, like the `key`
argument to the built-in `sorted` function, extracts a comparison key
from each dictionary key. If no function is specified, the default
compares the dictionary keys directly. The key-function argument must
be provided as a positional argument and must come before all other
arguments.
Optional iterable argument provides an initial sequence of pairs to
initialize the sorted dict. Each pair in the sequence defines the key
and corresponding value. If a key is seen more than once, the last
value associated with it is stored in the new sorted dict.
Optional mapping argument provides an initial mapping of items to
initialize the sorted dict.
If keyword arguments are given, the keywords themselves, with their
associated values, are added as items to the dictionary. If a key is
specified both in the positional argument and as a keyword argument,
the value associated with the keyword is stored in the
sorted dict.
Sorted dict keys must be hashable, per the requirement for Python's
dictionaries. Keys (or the result of the key-function) must also be
comparable, per the requirement for sorted lists.
>>> d = {'alpha': 1, 'beta': 2}
>>> SortedDict([('alpha', 1), ('beta', 2)]) == d
True
>>> SortedDict({'alpha': 1, 'beta': 2}) == d
True
>>> SortedDict(alpha=1, beta=2) == d
True
"""
if args and (args[0] is None or callable(args[0])):
_key = self._key = args[0]
args = args[1:]
else:
_key = self._key = None
self._list = SortedList(key=_key)
# Calls to super() are expensive so cache references to dict methods on
# sorted dict instances.
_dict = super(SortedDict, self)
self._dict_clear = _dict.clear
self._dict_delitem = _dict.__delitem__
self._dict_iter = _dict.__iter__
self._dict_pop = _dict.pop
self._dict_setitem = _dict.__setitem__
self._dict_update = _dict.update
# Reaching through ``self._list`` repeatedly adds unnecessary overhead
# so cache references to sorted list methods.
_list = self._list
self._list_add = _list.add
self._list_clear = _list.clear
self._list_iter = _list.__iter__
self._list_reversed = _list.__reversed__
self._list_pop = _list.pop
self._list_remove = _list.remove
self._list_update = _list.update
# Expose some sorted list methods publicly.
self.bisect_left = _list.bisect_left
self.bisect = _list.bisect_right
self.bisect_right = _list.bisect_right
self.index = _list.index
self.irange = _list.irange
self.islice = _list.islice
self._reset = _list._reset
if _key is not None:
self.bisect_key_left = _list.bisect_key_left
self.bisect_key_right = _list.bisect_key_right
self.bisect_key = _list.bisect_key
self.irange_key = _list.irange_key
self._update(*args, **kwargs)
@property
def key(self):
"""Function used to extract comparison key from keys.
Sorted dict compares keys directly when the key function is none.
"""
return self._key
@property
def iloc(self):
"""Cached reference of sorted keys view.
Deprecated in version 2 of Sorted Containers. Use
:func:`SortedDict.keys` instead.
"""
# pylint: disable=attribute-defined-outside-init
try:
return self._iloc
except AttributeError:
warnings.warn(
'sorted_dict.iloc is deprecated.'
' Use SortedDict.keys() instead.',
DeprecationWarning,
stacklevel=2,
)
_iloc = self._iloc = SortedKeysView(self)
return _iloc
def clear(self):
"""Remove all items from sorted dict.
Runtime complexity: `O(n)`
"""
self._dict_clear()
self._list_clear()
def __delitem__(self, key):
"""Remove item from sorted dict identified by `key`.
``sd.__delitem__(key)`` <==> ``del sd[key]``
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> del sd['b']
>>> sd
SortedDict({'a': 1, 'c': 3})
>>> del sd['z']
Traceback (most recent call last):
...
KeyError: 'z'
:param key: `key` for item lookup
:raises KeyError: if key not found
"""
self._dict_delitem(key)
self._list_remove(key)
def __iter__(self):
"""Return an iterator over the keys of the sorted dict.
``sd.__iter__()`` <==> ``iter(sd)``
Iterating the sorted dict while adding or deleting items may raise a
:exc:`RuntimeError` or fail to iterate over all keys.
"""
return self._list_iter()
def __reversed__(self):
"""Return a reverse iterator over the keys of the sorted dict.
``sd.__reversed__()`` <==> ``reversed(sd)``
Iterating the sorted dict while adding or deleting items may raise a
:exc:`RuntimeError` or fail to iterate over all keys.
"""
return self._list_reversed()
def __setitem__(self, key, value):
"""Store item in sorted dict with `key` and corresponding `value`.
``sd.__setitem__(key, value)`` <==> ``sd[key] = value``
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict()
>>> sd['c'] = 3
>>> sd['a'] = 1
>>> sd['b'] = 2
>>> sd
SortedDict({'a': 1, 'b': 2, 'c': 3})
:param key: key for item
:param value: value for item
"""
if key not in self:
self._list_add(key)
self._dict_setitem(key, value)
_setitem = __setitem__
def copy(self):
"""Return a shallow copy of the sorted dict.
Runtime complexity: `O(n)`
:return: new sorted dict
"""
return self.__class__(self._key, list(self.items()))
__copy__ = copy
@classmethod
def fromkeys(cls, iterable, value=None):
"""Return a new sorted dict initailized from `iterable` and `value`.
Items in the sorted dict have keys from `iterable` and values equal to
`value`.
Runtime complexity: `O(n*log(n))`
:return: new sorted dict
"""
return cls((key, value) for key in iterable)
def keys(self):
"""Return new sorted keys view of the sorted dict's keys.
See :class:`SortedKeysView` for details.
:return: new sorted keys view
"""
return SortedKeysView(self)
def items(self):
"""Return new sorted items view of the sorted dict's items.
See :class:`SortedItemsView` for details.
:return: new sorted items view
"""
return SortedItemsView(self)
def values(self):
"""Return new sorted values view of the sorted dict's values.
See :class:`SortedValuesView` for details.
:return: new sorted values view
"""
return SortedValuesView(self)
if sys.hexversion < 0x03000000:
def __make_raise_attributeerror(original, alternate):
# pylint: disable=no-self-argument
message = (
'SortedDict.{original}() is not implemented.'
' Use SortedDict.{alternate}() instead.'
).format(original=original, alternate=alternate)
def method(self):
# pylint: disable=missing-docstring,unused-argument
raise AttributeError(message)
method.__name__ = original
method.__doc__ = message
return property(method)
iteritems = __make_raise_attributeerror('iteritems', 'items')
iterkeys = __make_raise_attributeerror('iterkeys', 'keys')
itervalues = __make_raise_attributeerror('itervalues', 'values')
viewitems = __make_raise_attributeerror('viewitems', 'items')
viewkeys = __make_raise_attributeerror('viewkeys', 'keys')
viewvalues = __make_raise_attributeerror('viewvalues', 'values')
class _NotGiven(object):
# pylint: disable=too-few-public-methods
def __repr__(self):
return '<not-given>'
__not_given = _NotGiven()
def pop(self, key, default=__not_given):
"""Remove and return value for item identified by `key`.
If the `key` is not found then return `default` if given. If `default`
is not given then raise :exc:`KeyError`.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> sd.pop('c')
3
>>> sd.pop('z', 26)
26
>>> sd.pop('y')
Traceback (most recent call last):
...
KeyError: 'y'
:param key: `key` for item
:param default: `default` value if key not found (optional)
:return: value for item
:raises KeyError: if `key` not found and `default` not given
"""
if key in self:
self._list_remove(key)
return self._dict_pop(key)
else:
if default is self.__not_given:
raise KeyError(key)
return default
def popitem(self, index=-1):
"""Remove and return ``(key, value)`` pair at `index` from sorted dict.
Optional argument `index` defaults to -1, the last item in the sorted
dict. Specify ``index=0`` for the first item in the sorted dict.
If the sorted dict is empty, raises :exc:`KeyError`.
If the `index` is out of range, raises :exc:`IndexError`.
Runtime complexity: `O(log(n))`
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> sd.popitem()
('c', 3)
>>> sd.popitem(0)
('a', 1)
>>> sd.popitem(100)
Traceback (most recent call last):
...
IndexError: list index out of range
:param int index: `index` of item (default -1)
:return: key and value pair
:raises KeyError: if sorted dict is empty
:raises IndexError: if `index` out of range
"""
if not self:
raise KeyError('popitem(): dictionary is empty')
key = self._list_pop(index)
value = self._dict_pop(key)
return (key, value)
def peekitem(self, index=-1):
"""Return ``(key, value)`` pair at `index` in sorted dict.
Optional argument `index` defaults to -1, the last item in the sorted
dict. Specify ``index=0`` for the first item in the sorted dict.
Unlike :func:`SortedDict.popitem`, the sorted dict is not modified.
If the `index` is out of range, raises :exc:`IndexError`.
Runtime complexity: `O(log(n))`
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> sd.peekitem()
('c', 3)
>>> sd.peekitem(0)
('a', 1)
>>> sd.peekitem(100)
Traceback (most recent call last):
...
IndexError: list index out of range
:param int index: index of item (default -1)
:return: key and value pair
:raises IndexError: if `index` out of range
"""
key = self._list[index]
return key, self[key]
def setdefault(self, key, default=None):
"""Return value for item identified by `key` in sorted dict.
If `key` is in the sorted dict then return its value. If `key` is not
in the sorted dict then insert `key` with value `default` and return
`default`.
Optional argument `default` defaults to none.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict()
>>> sd.setdefault('a', 1)
1
>>> sd.setdefault('a', 10)
1
>>> sd
SortedDict({'a': 1})
:param key: key for item
:param default: value for item (default None)
:return: value for item identified by `key`
"""
if key in self:
return self[key]
self._dict_setitem(key, default)
self._list_add(key)
return default
def update(self, *args, **kwargs):
"""Update sorted dict with items from `args` and `kwargs`.
Overwrites existing items.
Optional arguments `args` and `kwargs` may be a mapping, an iterable of
pairs or keyword arguments. See :func:`SortedDict.__init__` for
details.
:param args: mapping or iterable of pairs
:param kwargs: keyword arguments mapping
"""
if not self:
self._dict_update(*args, **kwargs)
self._list_update(self._dict_iter())
return
if not kwargs and len(args) == 1 and isinstance(args[0], dict):
pairs = args[0]
else:
pairs = dict(*args, **kwargs)
if (10 * len(pairs)) > len(self):
self._dict_update(pairs)
self._list_clear()
self._list_update(self._dict_iter())
else:
for key in pairs:
self._setitem(key, pairs[key])
_update = update
def __reduce__(self):
"""Support for pickle.
The tricks played with caching references in
:func:`SortedDict.__init__` confuse pickle so customize the reducer.
"""
items = dict.copy(self)
return (type(self), (self._key, items))
@recursive_repr()
def __repr__(self):
"""Return string representation of sorted dict.
``sd.__repr__()`` <==> ``repr(sd)``
:return: string representation
"""
_key = self._key
type_name = type(self).__name__
key_arg = '' if _key is None else '{0!r}, '.format(_key)
item_format = '{0!r}: {1!r}'.format
items = ', '.join(item_format(key, self[key]) for key in self._list)
return '{0}({1}{{{2}}})'.format(type_name, key_arg, items)
def _check(self):
"""Check invariants of sorted dict.
Runtime complexity: `O(n)`
"""
_list = self._list
_list._check()
assert len(self) == len(_list)
assert all(key in self for key in _list)
def _view_delitem(self, index):
"""Remove item at `index` from sorted dict.
``view.__delitem__(index)`` <==> ``del view[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> view = sd.keys()
>>> del view[0]
>>> sd
SortedDict({'b': 2, 'c': 3})
>>> del view[-1]
>>> sd
SortedDict({'b': 2})
>>> del view[:]
>>> sd
SortedDict({})
:param index: integer or slice for indexing
:raises IndexError: if index out of range
"""
_mapping = self._mapping
_list = _mapping._list
_dict_delitem = _mapping._dict_delitem
if isinstance(index, slice):
keys = _list[index]
del _list[index]
for key in keys:
_dict_delitem(key)
else:
key = _list.pop(index)
_dict_delitem(key)
class SortedKeysView(KeysView, Sequence):
"""Sorted keys view is a dynamic view of the sorted dict's keys.
When the sorted dict's keys change, the view reflects those changes.
The keys view implements the set and sequence abstract base classes.
"""
__slots__ = ()
@classmethod
def _from_iterable(cls, it):
return SortedSet(it)
def __getitem__(self, index):
"""Lookup key at `index` in sorted keys views.
``skv.__getitem__(index)`` <==> ``skv[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> skv = sd.keys()
>>> skv[0]
'a'
>>> skv[-1]
'c'
>>> skv[:]
['a', 'b', 'c']
>>> skv[100]
Traceback (most recent call last):
...
IndexError: list index out of range
:param index: integer or slice for indexing
:return: key or list of keys
:raises IndexError: if index out of range
"""
return self._mapping._list[index]
__delitem__ = _view_delitem
class SortedItemsView(ItemsView, Sequence):
"""Sorted items view is a dynamic view of the sorted dict's items.
When the sorted dict's items change, the view reflects those changes.
The items view implements the set and sequence abstract base classes.
"""
__slots__ = ()
@classmethod
def _from_iterable(cls, it):
return SortedSet(it)
def __getitem__(self, index):
"""Lookup item at `index` in sorted items view.
``siv.__getitem__(index)`` <==> ``siv[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> siv = sd.items()
>>> siv[0]
('a', 1)
>>> siv[-1]
('c', 3)
>>> siv[:]
[('a', 1), ('b', 2), ('c', 3)]
>>> siv[100]
Traceback (most recent call last):
...
IndexError: list index out of range
:param index: integer or slice for indexing
:return: item or list of items
:raises IndexError: if index out of range
"""
_mapping = self._mapping
_mapping_list = _mapping._list
if isinstance(index, slice):
keys = _mapping_list[index]
return [(key, _mapping[key]) for key in keys]
key = _mapping_list[index]
return key, _mapping[key]
__delitem__ = _view_delitem
class SortedValuesView(ValuesView, Sequence):
"""Sorted values view is a dynamic view of the sorted dict's values.
When the sorted dict's values change, the view reflects those changes.
The values view implements the sequence abstract base class.
"""
__slots__ = ()
def __getitem__(self, index):
"""Lookup value at `index` in sorted values view.
``siv.__getitem__(index)`` <==> ``siv[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sd = SortedDict({'a': 1, 'b': 2, 'c': 3})
>>> svv = sd.values()
>>> svv[0]
1
>>> svv[-1]
3
>>> svv[:]
[1, 2, 3]
>>> svv[100]
Traceback (most recent call last):
...
IndexError: list index out of range
:param index: integer or slice for indexing
:return: value or list of values
:raises IndexError: if index out of range
"""
_mapping = self._mapping
_mapping_list = _mapping._list
if isinstance(index, slice):
keys = _mapping_list[index]
return [_mapping[key] for key in keys]
key = _mapping_list[index]
return _mapping[key]
__delitem__ = _view_delitem
"""Sorted Set
=============
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
collections library, written in pure-Python, and fast as C-extensions. The
:doc:`introduction<introduction>` is the best way to get started.
Sorted set implementations:
.. currentmodule:: sortedcontainers
* :class:`SortedSet`
"""
from itertools import chain
from operator import eq, ne, gt, ge, lt, le
from textwrap import dedent
# from .sortedlist import SortedList, recursive_repr
###############################################################################
# BEGIN Python 2/3 Shims
###############################################################################
try:
from collections.abc import MutableSet, Sequence, Set
except ImportError:
from collections import MutableSet, Sequence, Set
###############################################################################
# END Python 2/3 Shims
###############################################################################
class SortedSet(MutableSet, Sequence):
"""Sorted set is a sorted mutable set.
Sorted set values are maintained in sorted order. The design of sorted set
is simple: sorted set uses a set for set-operations and maintains a sorted
list of values.
Sorted set values must be hashable and comparable. The hash and total
ordering of values must not change while they are stored in the sorted set.
Mutable set methods:
* :func:`SortedSet.__contains__`
* :func:`SortedSet.__iter__`
* :func:`SortedSet.__len__`
* :func:`SortedSet.add`
* :func:`SortedSet.discard`
Sequence methods:
* :func:`SortedSet.__getitem__`
* :func:`SortedSet.__delitem__`
* :func:`SortedSet.__reversed__`
Methods for removing values:
* :func:`SortedSet.clear`
* :func:`SortedSet.pop`
* :func:`SortedSet.remove`
Set-operation methods:
* :func:`SortedSet.difference`
* :func:`SortedSet.difference_update`
* :func:`SortedSet.intersection`
* :func:`SortedSet.intersection_update`
* :func:`SortedSet.symmetric_difference`
* :func:`SortedSet.symmetric_difference_update`
* :func:`SortedSet.union`
* :func:`SortedSet.update`
Methods for miscellany:
* :func:`SortedSet.copy`
* :func:`SortedSet.count`
* :func:`SortedSet.__repr__`
* :func:`SortedSet._check`
Sorted list methods available:
* :func:`SortedList.bisect_left`
* :func:`SortedList.bisect_right`
* :func:`SortedList.index`
* :func:`SortedList.irange`
* :func:`SortedList.islice`
* :func:`SortedList._reset`
Additional sorted list methods available, if key-function used:
* :func:`SortedKeyList.bisect_key_left`
* :func:`SortedKeyList.bisect_key_right`
* :func:`SortedKeyList.irange_key`
Sorted set comparisons use subset and superset relations. Two sorted sets
are equal if and only if every element of each sorted set is contained in
the other (each is a subset of the other). A sorted set is less than
another sorted set if and only if the first sorted set is a proper subset
of the second sorted set (is a subset, but is not equal). A sorted set is
greater than another sorted set if and only if the first sorted set is a
proper superset of the second sorted set (is a superset, but is not equal).
"""
def __init__(self, iterable=None, key=None):
"""Initialize sorted set instance.
Optional `iterable` argument provides an initial iterable of values to
initialize the sorted set.
Optional `key` argument defines a callable that, like the `key`
argument to Python's `sorted` function, extracts a comparison key from
each value. The default, none, compares values directly.
Runtime complexity: `O(n*log(n))`
>>> ss = SortedSet([3, 1, 2, 5, 4])
>>> ss
SortedSet([1, 2, 3, 4, 5])
>>> from operator import neg
>>> ss = SortedSet([3, 1, 2, 5, 4], neg)
>>> ss
SortedSet([5, 4, 3, 2, 1], key=<built-in function neg>)
:param iterable: initial values (optional)
:param key: function used to extract comparison key (optional)
"""
self._key = key
# SortedSet._fromset calls SortedSet.__init__ after initializing the
# _set attribute. So only create a new set if the _set attribute is not
# already present.
if not hasattr(self, '_set'):
self._set = set()
self._list = SortedList(self._set, key=key)
# Expose some set methods publicly.
_set = self._set
self.isdisjoint = _set.isdisjoint
self.issubset = _set.issubset
self.issuperset = _set.issuperset
# Expose some sorted list methods publicly.
_list = self._list
self.bisect_left = _list.bisect_left
self.bisect = _list.bisect
self.bisect_right = _list.bisect_right
self.index = _list.index
self.irange = _list.irange
self.islice = _list.islice
self._reset = _list._reset
if key is not None:
self.bisect_key_left = _list.bisect_key_left
self.bisect_key_right = _list.bisect_key_right
self.bisect_key = _list.bisect_key
self.irange_key = _list.irange_key
if iterable is not None:
self._update(iterable)
@classmethod
def _fromset(cls, values, key=None):
"""Initialize sorted set from existing set.
Used internally by set operations that return a new set.
"""
sorted_set = object.__new__(cls)
sorted_set._set = values
sorted_set.__init__(key=key)
return sorted_set
@property
def key(self):
"""Function used to extract comparison key from values.
Sorted set compares values directly when the key function is none.
"""
return self._key
def __contains__(self, value):
"""Return true if `value` is an element of the sorted set.
``ss.__contains__(value)`` <==> ``value in ss``
Runtime complexity: `O(1)`
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> 3 in ss
True
:param value: search for value in sorted set
:return: true if `value` in sorted set
"""
return value in self._set
def __getitem__(self, index):
"""Lookup value at `index` in sorted set.
``ss.__getitem__(index)`` <==> ``ss[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet('abcde')
>>> ss[2]
'c'
>>> ss[-1]
'e'
>>> ss[2:5]
['c', 'd', 'e']
:param index: integer or slice for indexing
:return: value or list of values
:raises IndexError: if index out of range
"""
return self._list[index]
def __delitem__(self, index):
"""Remove value at `index` from sorted set.
``ss.__delitem__(index)`` <==> ``del ss[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet('abcde')
>>> del ss[2]
>>> ss
SortedSet(['a', 'b', 'd', 'e'])
>>> del ss[:2]
>>> ss
SortedSet(['d', 'e'])
:param index: integer or slice for indexing
:raises IndexError: if index out of range
"""
_set = self._set
_list = self._list
if isinstance(index, slice):
values = _list[index]
_set.difference_update(values)
else:
value = _list[index]
_set.remove(value)
del _list[index]
def __make_cmp(set_op, symbol, doc):
"Make comparator method."
def comparer(self, other):
"Compare method for sorted set and set."
if isinstance(other, SortedSet):
return set_op(self._set, other._set)
elif isinstance(other, Set):
return set_op(self._set, other)
return NotImplemented
set_op_name = set_op.__name__
comparer.__name__ = '__{0}__'.format(set_op_name)
doc_str = """Return true if and only if sorted set is {0} `other`.
``ss.__{1}__(other)`` <==> ``ss {2} other``
Comparisons use subset and superset semantics as with sets.
Runtime complexity: `O(n)`
:param other: `other` set
:return: true if sorted set is {0} `other`
"""
comparer.__doc__ = dedent(doc_str.format(doc, set_op_name, symbol))
return comparer
__eq__ = __make_cmp(eq, '==', 'equal to')
__ne__ = __make_cmp(ne, '!=', 'not equal to')
__lt__ = __make_cmp(lt, '<', 'a proper subset of')
__gt__ = __make_cmp(gt, '>', 'a proper superset of')
__le__ = __make_cmp(le, '<=', 'a subset of')
__ge__ = __make_cmp(ge, '>=', 'a superset of')
__make_cmp = staticmethod(__make_cmp)
def __len__(self):
"""Return the size of the sorted set.
``ss.__len__()`` <==> ``len(ss)``
:return: size of sorted set
"""
return len(self._set)
def __iter__(self):
"""Return an iterator over the sorted set.
``ss.__iter__()`` <==> ``iter(ss)``
Iterating the sorted set while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return iter(self._list)
def __reversed__(self):
"""Return a reverse iterator over the sorted set.
``ss.__reversed__()`` <==> ``reversed(ss)``
Iterating the sorted set while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return reversed(self._list)
def add(self, value):
"""Add `value` to sorted set.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet()
>>> ss.add(3)
>>> ss.add(1)
>>> ss.add(2)
>>> ss
SortedSet([1, 2, 3])
:param value: value to add to sorted set
"""
_set = self._set
if value not in _set:
_set.add(value)
self._list.add(value)
_add = add
def clear(self):
"""Remove all values from sorted set.
Runtime complexity: `O(n)`
"""
self._set.clear()
self._list.clear()
def copy(self):
"""Return a shallow copy of the sorted set.
Runtime complexity: `O(n)`
:return: new sorted set
"""
return self._fromset(set(self._set), key=self._key)
__copy__ = copy
def count(self, value):
"""Return number of occurrences of `value` in the sorted set.
Runtime complexity: `O(1)`
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.count(3)
1
:param value: value to count in sorted set
:return: count
"""
return 1 if value in self._set else 0
def discard(self, value):
"""Remove `value` from sorted set if it is a member.
If `value` is not a member, do nothing.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.discard(5)
>>> ss.discard(0)
>>> ss == set([1, 2, 3, 4])
True
:param value: `value` to discard from sorted set
"""
_set = self._set
if value in _set:
_set.remove(value)
self._list.remove(value)
_discard = discard
def pop(self, index=-1):
"""Remove and return value at `index` in sorted set.
Raise :exc:`IndexError` if the sorted set is empty or index is out of
range.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet('abcde')
>>> ss.pop()
'e'
>>> ss.pop(2)
'c'
>>> ss
SortedSet(['a', 'b', 'd'])
:param int index: index of value (default -1)
:return: value
:raises IndexError: if index is out of range
"""
# pylint: disable=arguments-differ
value = self._list.pop(index)
self._set.remove(value)
return value
def remove(self, value):
"""Remove `value` from sorted set; `value` must be a member.
If `value` is not a member, raise :exc:`KeyError`.
Runtime complexity: `O(log(n))` -- approximate.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.remove(5)
>>> ss == set([1, 2, 3, 4])
True
>>> ss.remove(0)
Traceback (most recent call last):
...
KeyError: 0
:param value: `value` to remove from sorted set
:raises KeyError: if `value` is not in sorted set
"""
self._set.remove(value)
self._list.remove(value)
def difference(self, *iterables):
"""Return the difference of two or more sets as a new sorted set.
The `difference` method also corresponds to operator ``-``.
``ss.__sub__(iterable)`` <==> ``ss - iterable``
The difference is all values that are in this sorted set but not the
other `iterables`.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.difference([4, 5, 6, 7])
SortedSet([1, 2, 3])
:param iterables: iterable arguments
:return: new sorted set
"""
diff = self._set.difference(*iterables)
return self._fromset(diff, key=self._key)
__sub__ = difference
def difference_update(self, *iterables):
"""Remove all values of `iterables` from this sorted set.
The `difference_update` method also corresponds to operator ``-=``.
``ss.__isub__(iterable)`` <==> ``ss -= iterable``
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> _ = ss.difference_update([4, 5, 6, 7])
>>> ss
SortedSet([1, 2, 3])
:param iterables: iterable arguments
:return: itself
"""
_set = self._set
_list = self._list
values = set(chain(*iterables))
if (4 * len(values)) > len(_set):
_set.difference_update(values)
_list.clear()
_list.update(_set)
else:
_discard = self._discard
for value in values:
_discard(value)
return self
__isub__ = difference_update
def intersection(self, *iterables):
"""Return the intersection of two or more sets as a new sorted set.
The `intersection` method also corresponds to operator ``&``.
``ss.__and__(iterable)`` <==> ``ss & iterable``
The intersection is all values that are in this sorted set and each of
the other `iterables`.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.intersection([4, 5, 6, 7])
SortedSet([4, 5])
:param iterables: iterable arguments
:return: new sorted set
"""
intersect = self._set.intersection(*iterables)
return self._fromset(intersect, key=self._key)
__and__ = intersection
__rand__ = __and__
def intersection_update(self, *iterables):
"""Update the sorted set with the intersection of `iterables`.
The `intersection_update` method also corresponds to operator ``&=``.
``ss.__iand__(iterable)`` <==> ``ss &= iterable``
Keep only values found in itself and all `iterables`.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> _ = ss.intersection_update([4, 5, 6, 7])
>>> ss
SortedSet([4, 5])
:param iterables: iterable arguments
:return: itself
"""
_set = self._set
_list = self._list
_set.intersection_update(*iterables)
_list.clear()
_list.update(_set)
return self
__iand__ = intersection_update
def symmetric_difference(self, other):
"""Return the symmetric difference with `other` as a new sorted set.
The `symmetric_difference` method also corresponds to operator ``^``.
``ss.__xor__(other)`` <==> ``ss ^ other``
The symmetric difference is all values tha are in exactly one of the
sets.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.symmetric_difference([4, 5, 6, 7])
SortedSet([1, 2, 3, 6, 7])
:param other: `other` iterable
:return: new sorted set
"""
diff = self._set.symmetric_difference(other)
return self._fromset(diff, key=self._key)
__xor__ = symmetric_difference
__rxor__ = __xor__
def symmetric_difference_update(self, other):
"""Update the sorted set with the symmetric difference with `other`.
The `symmetric_difference_update` method also corresponds to operator
``^=``.
``ss.__ixor__(other)`` <==> ``ss ^= other``
Keep only values found in exactly one of itself and `other`.
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> _ = ss.symmetric_difference_update([4, 5, 6, 7])
>>> ss
SortedSet([1, 2, 3, 6, 7])
:param other: `other` iterable
:return: itself
"""
_set = self._set
_list = self._list
_set.symmetric_difference_update(other)
_list.clear()
_list.update(_set)
return self
__ixor__ = symmetric_difference_update
def union(self, *iterables):
"""Return new sorted set with values from itself and all `iterables`.
The `union` method also corresponds to operator ``|``.
``ss.__or__(iterable)`` <==> ``ss | iterable``
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> ss.union([4, 5, 6, 7])
SortedSet([1, 2, 3, 4, 5, 6, 7])
:param iterables: iterable arguments
:return: new sorted set
"""
return self.__class__(chain(iter(self), *iterables), key=self._key)
__or__ = union
__ror__ = __or__
def update(self, *iterables):
"""Update the sorted set adding values from all `iterables`.
The `update` method also corresponds to operator ``|=``.
``ss.__ior__(iterable)`` <==> ``ss |= iterable``
>>> ss = SortedSet([1, 2, 3, 4, 5])
>>> _ = ss.update([4, 5, 6, 7])
>>> ss
SortedSet([1, 2, 3, 4, 5, 6, 7])
:param iterables: iterable arguments
:return: itself
"""
_set = self._set
_list = self._list
values = set(chain(*iterables))
if (4 * len(values)) > len(_set):
_list = self._list
_set.update(values)
_list.clear()
_list.update(_set)
else:
_add = self._add
for value in values:
_add(value)
return self
__ior__ = update
_update = update
def __reduce__(self):
"""Support for pickle.
The tricks played with exposing methods in :func:`SortedSet.__init__`
confuse pickle so customize the reducer.
"""
return (type(self), (self._set, self._key))
@recursive_repr()
def __repr__(self):
"""Return string representation of sorted set.
``ss.__repr__()`` <==> ``repr(ss)``
:return: string representation
"""
_key = self._key
key = '' if _key is None else ', key={0!r}'.format(_key)
type_name = type(self).__name__
return '{0}({1!r}{2})'.format(type_name, list(self), key)
def _check(self):
"""Check invariants of sorted set.
Runtime complexity: `O(n)`
"""
_set = self._set
_list = self._list
_list._check()
assert len(_set) == len(_list)
assert all(value in _set for value in _list)
def main():
N, Q = LI()
events = []
for _ in range(N):
stx = LI()
# events.append((s - x, x, True)) # S-X, X, add_flag
# events.append((t - x, x, False)) # T-X, X, add_flag
events.append((stx[0] - stx[2], stx[2], True)) # S-X, X, add_flag
events.append((stx[1] - stx[2], stx[2], False)) # T-X, X, add_flag
for _ in range(Q):
events.append((II(), INF, -1))
events.sort(key=lambda x:x[0]) # O(N log N), stable
from array import array
ans = array('i')
m = SortedList()
# for time, x, add_flag in events:
change_flag = True
min_ = INF
for txa in events:
if txa[2] == -1:
if not m:
ans.append(-1)
# ans += '-1\n'
else:
if change_flag:
min_ = m[0]
change_flag = False
ans.append(min_)
# ans += str(m[0])+'\n'
elif txa[2]:
m.add(txa[1])
if txa[1] < min_:
min_ = txa[1]
change_flag = False
else:
m.remove(txa[1])
if txa[1] == min_ and m:
min_ = m[0]
change_flag = False
elif not m:
min_ = INF
change_flag = False
# for i in ans: print(i)
# print('\n'.join(map(str, ans)))
print(('\n'.join(map(str, ans.tolist()))))
main() | import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
MOD = 10 ** 9 + 7
INF = 10 ** 18
from collections.abc import Sequence, Set
from bisect import bisect_left
from itertools import chain
from heapq import heappush, heappop
class HeapqSet():
def __init__(self):
self._set = set()
self._list = list()
def add(self, a):
if a in self._set:
return
else:
self._set.add(a)
heappush(self._list, a)
def remove(self, a):
if a not in self._set:
raise ValueError
else:
self._set.remove(a)
def pop_min(self):
if not self._set:
self._list = list()
return None
while True:
a = heappop(self._list)
if a not in self._set:
continue
else:
self._set.remove(a)
break
return a
def peek_min(self):
if not self._set:
self._list = list()
return None
while True:
a = self._list[0]
if a not in self._set:
heappop(self._list)
continue
else:
break
return a
def is_empty(self):
return not self._set
def __bool__(self):
return True if self._set else False
def main():
N, Q = LI()
events = []
for _ in range(N):
stx = LI()
# events.append((s - x, x, True)) # S-X, X, add_flag
# events.append((t - x, x, False)) # T-X, X, add_flag
events.append((stx[0] - stx[2], stx[2], True)) # S-X, X, add_flag
events.append((stx[1] - stx[2], stx[2], False)) # T-X, X, add_flag
for _ in range(Q):
events.append((II(), INF, -1))
# events.sort(key=lambda x:x[0]) # O(N log N), stable
events.sort() # O(N log N), stable, False (==0) < True (==1)
from array import array
ans = array('i')
# m = SortedList()
m = HeapqSet()
# for time, x, add_flag in events:
change_flag = True
min_ = INF
for txa in events:
if txa[2] == -1:
if not m:
ans.append(-1)
# ans += '-1\n'
else:
if change_flag:
min_ = m.peek_min()
change_flag = False
ans.append(min_)
# ans += str(m[0])+'\n'
elif txa[2]:
m.add(txa[1])
if txa[1] < min_:
min_ = txa[1]
change_flag = False
else:
m.remove(txa[1])
if txa[1] == min_ and m:
min_ = m.peek_min()
change_flag = False
elif not m:
min_ = INF
change_flag = False
# for i in ans: print(i)
# print('\n'.join(map(str, ans)))
print(('\n'.join(map(str, ans.tolist()))))
main() | p03033 |
from math import ceil, log2
import sys
class SegmentTree:
def __init__(self, length, init_value=None, aggfunc=min):
self.aggfunc = aggfunc
self.depth = ceil(log2(length))
self.data = [init_value] * (2 ** (1 + self.depth) - 1)
self.origin = 2 ** self.depth - 1
def update(self, idx, value):
i = idx + self.origin
self.data[i] = value
while i > 0:
i = (i - 1) // 2
new_value = self.aggfunc(self.data[i * 2 + 1], self.data[i * 2 + 2])
if self.data[i] != new_value:
self.data[i] = new_value
else:
break
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)]
xs = set()
events = []
for s, t, x in stx:
events.append((s - x, 1, x))
events.append((t - x, -1, x))
xs.add(x)
events.sort()
xs = list(xs)
xs.sort()
zaatsu = dict(list(zip(xs, list(range(len(xs))))))
ub = 10 ** 9 + 1
koujichu = SegmentTree(len(zaatsu), ub, min)
i = 0
for di in d:
while i < len(events) and events[i][0] <= di:
if events[i][1] == 1:
koujichu.update(zaatsu[events[i][2]], events[i][2])
else:
koujichu.update(zaatsu[events[i][2]], ub)
i += 1
if koujichu.data[0] != ub:
print((koujichu.data[0]))
else:
print((-1))
| import sys
from bisect import bisect_left
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)]
stx.sort(key=lambda x: x[2])
ans = [-1] * q
jump = [-1] * q
for s, t, x in stx:
d_start = bisect_left(d, s - x)
d_stop = bisect_left(d, t - x, lo=d_start)
while d_start < d_stop:
if jump[d_start] == -1:
ans[d_start] = x
jump[d_start] = d_stop
d_start += 1
else:
d_start = jump[d_start]
for an in ans:
print(an)
| p03033 |
import sys
from heapq import heappush, heappop
from collections import defaultdict
input = sys.stdin.readline
num, person = list(map(int, input().split()))
arr = []
for i in range(num):
s, t, x = list(map(int, input().split()))
arr.append((s - x - 0.5, 1, x, i))
arr.append((t - x - 0.5, -1, x, i))
for i in range(person):
d = int(eval(input()))
arr.append((d,))
arr.sort()
heap = []
done = set()
for elem in arr:
if len(elem) == 1:
d = elem[0]
while heap and heap[0][1] in done:
heappop(heap)
if heap:
print((heap[0][0]))
else:
print((-1))
continue
time, kind, x, i = elem
if kind == 1:
heappush(heap, (x, i))
elif kind == -1:
done.add(i) | import sys
from heapq import heappush, heappop
input = sys.stdin.readline
num, person = list(map(int, input().split()))
arr = []
for i in range(num):
s, t, x = list(map(int, input().split()))
arr.append((s - x - 0.5, 1, x, i))
arr.append((t - x - 0.5, 0, x, i))
for i in range(person):
d = int(eval(input()))
arr.append((d,))
arr.sort()
heap = []
done = set()
for elem in arr:
if len(elem) == 1:
while heap and heap[0][1] in done:
heappop(heap)
if heap:
print((heap[0][0]))
else:
print((-1))
continue
time, kind, x, i = elem
if kind:
heappush(heap, (x, i))
else:
done.add(i)
| p03033 |
import sys
from collections import deque, defaultdict
import copy
import bisect
#input=sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
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) | import sys
from collections import deque, defaultdict
import copy
import bisect
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
N, Q = list(map(int, input().split()))
STX=[]
D=[]
for i in range(N):
S, T, X = list(map(int, input().split()))
STX.append((X, S, T))
STX = sorted(STX, key=lambda x: x[0])
for i in range(Q):
D.append(int(eval(input())))
skip = [-1]*Q
dist = [-1]*Q
for X, S, T in STX:
s = S - X
t = T - X - 1
a = bisect.bisect_left(D, s)
b = bisect.bisect_right(D, t)
#print(D)
j = a
while j < b:
if skip[j] == -1:
skip[j] = b
dist[j] = X
j+=1
else:
j=skip[j]
for i in range(Q):
print((dist[i])) | p03033 |
import bisect
import heapq
import sys
N,Q = [int(x) for x in sys.stdin.readline().split()]
hitos = []
ans = [-1 for _ in range(Q)]
queries =[]
jump = ans[::]
queries = [[int(x) for x in sys.stdin.readline().split()] for i in range(N)]
hitos = [int(sys.stdin.readline()) for i in range(Q)]
# for i in range(N):
# S,T,X =list(map(int,input().split(" ")))
# lt = S -X -0.5
# rt = T -X -0.5
# queries.append([lt,rt,X]) #-1 → 挿入クエリ lが時間、-1がクエリの種類、Xが場所
queries.sort(key=lambda x:x[2])
for l,r,x in queries:
lind = bisect.bisect_left(hitos,l-x - 0.5)
rind = bisect.bisect_left(hitos,r -x - 0.5)
while lind < rind:
if ans[lind] == -1:
ans[lind] = x
jump[lind] = rind
lind += 1
else:
temp = jump[lind]
jump[lind] = rind
lind = temp
for i in ans:
print(i)
| import bisect
import heapq
import sys
N,Q = [int(x) for x in sys.stdin.readline().split()]
hitos = []
ans = [-1 for _ in range(Q)]
queries =[]
jump = ans[::]
queries = [[int(x) for x in sys.stdin.readline().split()] for i in range(N)]
hitos = [int(sys.stdin.readline()) for i in range(Q)]
# for i in range(N):
# S,T,X =list(map(int,input().split(" ")))
# lt = S -X -0.5
# rt = T -X -0.5
# queries.append([lt,rt,X]) #-1 → 挿入クエリ lが時間、-1がクエリの種類、Xが場所
queries.sort(key=lambda x:x[2])
for l,r,x in queries:
lind = bisect.bisect_left(hitos,l-x - 0.5)
rind = bisect.bisect_left(hitos,r -x - 0.5)
while lind < rind:
if ans[lind] == -1:
ans[lind] = x
jump[lind] = rind
lind += 1
else:
lind = jump[lind]
for i in ans:
print(i)
| p03033 |
import heapq
N,Q = list(map(int,input().split(" ")))
querys = []
START = 1
GOAL = 0
GO = 2
for _ in range(N):
s,t,x = (list(map(int,input().split(" "))))
s -=(x + 0.5)
t -= (x + 0.5)
querys.append( (s,START,x) )
querys.append( (t,GOAL,x) )
for _ in range(Q):
querys.append( (int(eval(input())),GO,-1) )
koji_place = []
koji_um = set([])
heapq.heapify(koji_place)
querys.sort()
for query in querys:
time,qtype,place = query
if qtype == START:
heapq.heappush(koji_place,place)
koji_um.add(place)
elif qtype == GOAL:
koji_um.remove(place)
else:
while koji_place and koji_place[0] not in koji_um: #更新と最近の場所のチェックを同時に行う
heapq.heappop(koji_place) #koji place のpopは最大で place分，つまり合計で10 ** 5回行われるため ここのwhile
# はOに影響を与えない
if koji_place:
print((koji_place[0]))
else:
print((-1))
| import heapq
import sys
input=sys.stdin.readline
N,Q = list(map(int,input().split(" ")))
querys = []
START = 1
GOAL = 0
GO = 2
for _ in range(N):
s,t,x = (list(map(int,input().split(" "))))
s -=(x + 0.5)
t -= (x + 0.5)
querys.append( (s,START,x) )
querys.append( (t,GOAL,x) )
for _ in range(Q):
querys.append( (int(eval(input())),GO,-1) )
koji_place = []
koji_um = set([])
heapq.heapify(koji_place)
querys.sort()
for query in querys:
time,qtype,place = query
if qtype == START:
heapq.heappush(koji_place,place)
koji_um.add(place)
elif qtype == GOAL:
koji_um.remove(place)
else:
while koji_place and koji_place[0] not in koji_um: #更新と最近の場所のチェックを同時に行う
heapq.heappop(koji_place) #koji place のpopは最大で place分，つまり合計で10 ** 5回行われるため ここのwhile
# はOに影響を与えない
if koji_place:
print((koji_place[0]))
else:
print((-1))
| p03033 |
import sys
from collections import deque
from collections import defaultdict
import math
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n,q = list(map(int,input().split()))
x = []
for i in range(n):
x.append(list(map(int,input().split())))
x.sort(key = lambda x : x[2])
dd = []
zaa = []
for i in range(q):
a = int(eval(input()))
dd.append(a)
zaa.append(a)
y = []
for i in range(n):
a = x[i][0]-x[i][2]
b = x[i][1]-1-x[i][2]
y.append([a,b])
zaa.append(a)
zaa.append(b)
import bisect
def press(a):
n = len(a)
b = set(a)
b = list(b)
b.sort()
c = [0] * n
for i in range(n):
c[i] = bisect.bisect_left(b,a[i])
return b,c
zaa.sort()
mo,za = press(zaa)
mo = zaa
d = dict()
for i in range(len(zaa)):
d[mo[i]] = za[i]+1
dg = dict()
for i in range(len(zaa)):
dg[za[i]+1] = mo[i]
INF = 2**38-1
LV = (len(set(za))+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
for i in range(n-1,-1,-1):
update(d[y[i][0]], d[y[i][1]]+1, i+1)
for i in range(q):
ans = query(d[dd[i]],d[dd[i]]+1)
if ans == INF:
print((-1))
else:
print((x[ans-1][2])) | import sys
from collections import deque
from collections import defaultdict
import math
sys.setrecursionlimit(20000000)
input = sys.stdin.readline
n,q = list(map(int,input().split()))
x = []
for i in range(n):
x.append(list(map(int,input().split())))
x.sort(key = lambda x : x[2])
dd = []
zaa = []
for i in range(q):
a = int(eval(input()))
dd.append(a)
zaa.append(a)
y = []
for i in range(n):
a = x[i][0]-x[i][2]
b = x[i][1]-1-x[i][2]
y.append([a,b])
zaa.append(a)
zaa.append(b)
import bisect
ans = [-1]*q
tobi = [-1]*q
#print(dd,y)
for i in range(n):
xx = bisect.bisect_left(dd,y[i][0])
yy = bisect.bisect_left(dd,y[i][1]+1)
j = xx
# print(xx,yy)
# print(ans,tobi)
while j < yy:
if ans[j] == -1:
ans[j] = x[i][2]
tobi[j] = yy
j += 1
else:
j = tobi[j]
for i in ans:
print(i) | p03033 |
import sys
import bisect
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
STX_array = [list(map(int, input().split())) for _ in range(N)]
STX_array = sorted(STX_array, key=lambda x: x[2])
Q_array = [int(eval(input())) for _ in range(Q)]
index_array = [i for i in range(Q)]
ans_array = [-1] * Q
for STX in STX_array:
s, t, x = STX
index_left = bisect.bisect_left(Q_array, s - 0.5 - x)
index_right = bisect.bisect_left(Q_array, t - 0.5 - x)
if index_left != index_right:
for i in index_array[index_left:index_right]:
ans_array[i] = x
del Q_array[index_left:index_right]
del index_array[index_left:index_right]
if len(Q_array) == 0:
break
for ans in ans_array:
print(ans) | import sys
import bisect
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
STX_array = [list(map(int, input().split())) for _ in range(N)]
STX_array = sorted(STX_array, key=lambda x: x[2])
Q_array = [int(eval(input())) for _ in range(Q)]
index_array = [i for i in range(Q)]
ans_array = [-1] * Q
for STX in STX_array:
s, t, x = STX
index_left = bisect.bisect_left(Q_array, s - 0.5 - x)
index_right = bisect.bisect_left(Q_array, t - 0.5 - x)
if index_left != index_right:
now_index = index_left
while now_index < index_right:
if index_array[now_index] == now_index:
ans_array[now_index] = x
index_array[now_index] = index_right
now_index += 1
else:
old_index = now_index
now_index = index_array[now_index]
index_array[old_index] = now_index
for ans in ans_array:
print(ans) | p03033 |
import bisect
class SegTree:
def __init__(self, n):
# supposed that n = 2**m
INF = 10 ** 12
self.n = n
self.val = [INF for _ in range(2 * n + 1)]
def _update(self, a, b, v, k, l, r):
if r <= a or b <= l:
return
if a <= l and r <= b:
self.val[k] = min(v, self.val[k])
else:
self._update(a, b, v, 2 * k + 1, l, (l + r) // 2)
self._update(a, b, v, 2 * k + 2, (l + r) // 2, r)
def update(self, a, b, v):
# 区間[a, b)上の値がvより大きければvに更新
self._update(a, b, v, 0, 0, self.n)
def query(self, x):
# ノードxの値を返す
k = self.n + x - 1
ret = self.val[k]
while k > 0:
k = (k - 1) // 2
ret = min(ret, self.val[k])
return ret
def main():
N, Q = list(map(int, input().split(' ')))
work_list = [list(map(int, input().split(' '))) for _ in range(N)]
# 工事は出発地から近い順に並べておく
work_list.sort(key=lambda work: work[2])
D = [int(eval(input())) for _ in range(Q)]
# 一番最初に引っかかる工事のインデックスを求める
QQ = 1
while QQ < Q:
QQ <<= 1
tree = SegTree(QQ)
for w in range(N):
s, t, x = work_list[w]
# s - x <= d < t - x だと工事に引っかかる
left = bisect.bisect_left(D, s - x)
right = bisect.bisect_left(D, t - x)
tree.update(left, right, w)
for q in range(Q):
w = tree.query(q)
if w >= N:
print((-1))
else:
print((work_list[w][2]))
if __name__ == '__main__':
main()
| import bisect
class SegTree:
def __init__(self, n):
# supposed that n = 2**m
INF = 10 ** 12
self.n = n
self.val = [INF] * (2 * n - 1)
def _update(self, a, b, v, k, l, r):
if r <= a or b <= l:
return
if a <= l and r <= b:
self.val[k] = min(v, self.val[k])
else:
self._update(a, b, v, 2 * k + 1, l, (l + r) // 2)
self._update(a, b, v, 2 * k + 2, (l + r) // 2, r)
def update(self, a, b, v):
# 区間[a, b)上の値がvより大きければvに更新
self._update(a, b, v, 0, 0, self.n)
def query(self, x):
# ノードxの値を返す
k = self.n + x - 1
ret = self.val[k]
while k > 0:
k = (k - 1) // 2
ret = min(ret, self.val[k])
return ret
def main():
N, Q = list(map(int, input().split(' ')))
work_list = [list(map(int, input().split(' '))) for _ in range(N)]
# 工事は出発地から近い順に並べておく
work_list.sort(key=lambda work: work[2])
D = [int(eval(input())) for _ in range(Q)]
# 一番最初に引っかかる工事のインデックスを求める
QQ = 1
while QQ < Q:
QQ <<= 1
tree = SegTree(QQ)
for w, work in enumerate(work_list):
s, t, x = work
# s - x <= d < t - x だと工事に引っかかる
left = bisect.bisect_left(D, s - x)
right = bisect.bisect_left(D, t - x)
tree.update(left, right, w)
for q in range(Q):
w = tree.query(q)
if w >= N:
print((-1))
else:
print((work_list[w][2]))
if __name__ == '__main__':
main() | p03033 |
import bisect
class SegTree:
def __init__(self, n):
# supposed that n = 2**m
INF = 10 ** 12
self.n = n
self.val = [INF] * (2 * n - 1)
def _update(self, a, b, v, k, l, r):
if r <= a or b <= l:
return
if a <= l and r <= b:
self.val[k] = min(v, self.val[k])
else:
self._update(a, b, v, 2 * k + 1, l, (l + r) // 2)
self._update(a, b, v, 2 * k + 2, (l + r) // 2, r)
def update(self, a, b, v):
# 区間[a, b)上の値がvより大きければvに更新
self._update(a, b, v, 0, 0, self.n)
def query(self, x):
# ノードxの値を返す
k = self.n + x - 1
ret = self.val[k]
while k > 0:
k = (k - 1) // 2
ret = min(ret, self.val[k])
return ret
def main():
N, Q = list(map(int, input().split(' ')))
work_list = [list(map(int, input().split(' '))) for _ in range(N)]
# 工事は出発地から近い順に並べておく
work_list.sort(key=lambda work: work[2])
D = [int(eval(input())) for _ in range(Q)]
# 一番最初に引っかかる工事のインデックスを求める
QQ = 1
while QQ < Q:
QQ <<= 1
tree = SegTree(QQ)
for w, work in enumerate(work_list):
s, t, x = work
# s - x <= d < t - x だと工事に引っかかる
left = bisect.bisect_left(D, s - x)
right = bisect.bisect_left(D, t - x)
tree.update(left, right, w)
for q in range(Q):
w = tree.query(q)
if w >= N:
print((-1))
else:
print((work_list[w][2]))
if __name__ == '__main__':
main() | import bisect
class SegTree:
def __init__(self, n):
# supposed that n = 2**m
self.n = n
self.val = [-1] * (2 * n - 1)
def _update(self, a, b, v, k, l, r):
if r <= a or b <= l:
return
if a <= l and r <= b:
self.val[k] = v
else:
self._update(a, b, v, 2 * k + 1, l, (l + r) // 2)
self._update(a, b, v, 2 * k + 2, (l + r) // 2, r)
def update(self, a, b, v):
# 区間[a, b)上の値をvに更新
self._update(a, b, v, 0, 0, self.n)
def query(self, x):
# ノードxの値を返す
k = self.n + x - 1
ret = self.val[k]
while k > 0:
k = (k - 1) // 2
ret = max(ret, self.val[k])
return ret
def main():
N, Q = list(map(int, input().split(' ')))
work_list = [list(map(int, input().split(' '))) for _ in range(N)]
# 工事は出発地から遠い順に並べておく
work_list.sort(key=lambda work: work[2], reverse=True)
D = [int(eval(input())) for _ in range(Q)]
# 一番最初に引っかかる工事のインデックスを求める
QQ = 1
while QQ < Q:
QQ <<= 1
tree = SegTree(QQ)
for w, work in enumerate(work_list):
s, t, x = work
# s - x <= d < t - x だと工事に引っかかる
left = bisect.bisect_left(D, s - x)
right = bisect.bisect_left(D, t - x)
tree.update(left, right, w)
for q in range(Q):
w = tree.query(q)
if w == -1:
print((-1))
else:
print((work_list[w][2]))
if __name__ == '__main__':
main() | p03033 |
from bisect import bisect_right
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)]
INF = 10 ** 9 + 1
li = []
for s, t, x in stx:
li.append([s - x, 1, x])
li.append([t - x, -1, x])
li.sort()
x_st = set([INF])
xxs = []
xs = [INF]
i = 0
for xx, check, x in li:
if check == -1:
x_st.remove(x)
else:
x_st.add(x)
xxs.append(xx)
xs.append(min(x_st))
for e in d:
i = bisect_right(xxs, e)
ans = xs[i]
if ans == INF:
ans = -1
print(ans)
| from bisect import bisect_left
n, q = map(int, input().split())
stx = [list(map(int, input().split())) for _ in range(n)]
d = [int(input()) for _ in range(q)]
INF = 10 ** 9 + 1
stx.sort(key=lambda x: x[2])
nxt = [-1] * q
ans = [-1] * q
for s, t, x in stx:
l = bisect_left(d, s - x)
r = bisect_left(d, t - x)
while l < r:
if nxt[l] == -1:
ans[l] = x
nxt[l] = r
l += 1
else:
l = nxt[l]
print(*ans, sep="\n")
| p03033 |
import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(eval(input()))
def FLIST(n):
res = [1]
for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
return res
def gcd(x, y):
if x < y: x, y = y, x
div = x % y
while div != 0:
x, y = y, div
div = x % y
return y
N,Q=LI()
HQ=[]
EVS=[]
for i in range(N):
S,T,X=LI()
EVS.append((S-0.5-X, 1, X))
EVS.append((T-0.5-X, 0, X))
for i in range(Q):
D=II()
EVS.append((D, 2, D))
EVS.sort()
st=set()
PQ=[]
for time, ev, loc in EVS:
if ev == 1:
heapq.heappush(PQ, loc)
st.add(loc)
elif ev == 0:
st.remove(loc)
else:
while PQ and PQ[0] not in st:
heapq.heappop(PQ)
if PQ:
print((PQ[0]))
else:
print((-1))
| import sys
import math
import heapq
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, m=DVSR): return pow(x, m - 2, m)
def DIV(x, y, m=DVSR): return (x * INV(y, m)) % m
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def FLIST(n):
res = [1]
for i in range(1, n+1): res.append(res[i-1]*i%DVSR)
return res
def gcd(x, y):
if x < y: x, y = y, x
div = x % y
while div != 0:
x, y = y, div
div = x % y
return y
N,Q=LI()
HQ=[]
EVS=[]
for i in range(N):
S,T,X=LI()
EVS.append((S-0.5-X, 1, X))
EVS.append((T-0.5-X, 0, X))
for i in range(Q):
D=II()
EVS.append((D, 2, D))
EVS.sort()
st=set()
PQ=[]
for time, ev, loc in EVS:
if ev == 1:
heapq.heappush(PQ, loc)
st.add(loc)
elif ev == 0:
st.remove(loc)
else:
while PQ and PQ[0] not in st:
heapq.heappop(PQ)
if PQ:
print((PQ[0]))
else:
print((-1))
| p03033 |
# coding: utf-8
import re
import math
import fractions
import random
import heapq
import time
import sys
readline = sys.stdin.readline
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
#main
def solve():
return
#入力
N,Q=list(map(int,input().split()))
E=[]
for a in range(N):
s,t,x=list(map(int,input().split()))
E.append([s-x-0.5,1,x])
E.append([t-x-0.5,-1,x])
for a in range(Q):
E.append([int(eval(input())),0,0])
E.sort(key=lambda x:x[0])
S=set()
H=[]
for a in E:
x=a[2]
type_=a[1]
if type_==1:
S.add(x)
heapq.heappush(H,x)
elif type_==-1:
S.remove(x)
else:
if len(S)==0:
print((-1))
else:
while H[0] not in S:
heapq.heappop(H)
print((H[0]))
| # coding: utf-8
import re
import math
import fractions
import random
import heapq
import time
import sys
input = sys.stdin.readline
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
#main
N,Q=list(map(int,input().split()))
E=[]
for a in range(N):
s,t,x=list(map(int,input().split()))
E.append([s-x-0.5,1,x])
E.append([t-x-0.5,-1,x])
for a in range(Q):
E.append([int(eval(input())),0,0])
E.sort(key=lambda x:x[0])
S=set()
H=[]
for time_,type_,x in E:
if type_==1:
S.add(x)
heapq.heappush(H,x)
elif type_==-1:
if(x in S):S.remove(x)
else:
while H and H[0] not in S:
heapq.heappop(H)
print((H[0] if H else -1)) | p03033 |
# coding: utf-8
import re
import math
import fractions
import random
import heapq
import time
import sys
input = sys.stdin.readline
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
#main
N,Q=list(map(int,input().split()))
E=[]
for a in range(N):
s,t,x=list(map(int,input().split()))
E.append([s-x-0.5,1,x])
E.append([t-x-0.5,-1,x])
for a in range(Q):
E.append([int(eval(input())),0,0])
E.sort(key=lambda x:x[0])
S=set()
H=[]
for time_,type_,x in E:
if type_==1:
S.add(x)
heapq.heappush(H,x)
elif type_==-1:
if(x in S):S.remove(x)
else:
while H and H[0] not in S:
heapq.heappop(H)
print((H[0] if H else -1)) | # coding: utf-8
import re
import math
import fractions
import random
import heapq
import time
import sys
input = sys.stdin.readline
#import numpy as np
mod=int(10**9+7)
inf=int(10**20)
class union_find():
def __init__(self,n):
self.n=n
self.P=[a for a in range(N)]
self.rank=[0]*n
def find(self,x):
if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
return self.P[x]
def same(self,x,y):
return self.find(x)==self.find(y)
def link(self,x,y):
if self.rank[x]<self.rank[y]:
self.P[x]=y
elif self.rank[y]<self.rank[x]:
self.P[y]=x
else:
self.P[x]=y
self.rank[y]+=1
def unite(self,x,y):
self.link(self.find(x),self.find(y))
def size(self):
S=set()
for a in range(self.n):
S.add(self.find(a))
return len(S)
def bin_(num,size):
A=[0]*size
for a in range(size):
if (num>>(size-a-1))&1==1:
A[a]=1
else:
A[a]=0
return A
def comb(n,r):return math.factorial(n)//math.factorial(n-r)//math.factorial(r)
def next_comb(num,size):
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
if(num>=(1<<size)):return False
else:
return num
#main
N,Q=list(map(int,input().split()))
E=[]
for a in range(N):
s,t,x=list(map(int,input().split()))
E.append([s-x-0.5,1,x])
E.append([t-x-0.5,-1,x])
for a in range(Q):
E.append([int(eval(input())),0,0])
E.sort(key=lambda x:x[0])
S=set()
H=[]
for time_,type_,x in E:
if type_==1:
#if(x in S):print(7329847)
S.add(x)
heapq.heappush(H,x)
elif type_==-1:
if(x in S):S.remove(x)
else:
while H and H[0] not in S:
heapq.heappop(H)
print((H[0] if H else -1)) | p03033 |
from heapq import heappush, heappop
n,q=map(int,input().split())
a=[]
for i in range(n):
s,t,x=map(int,input().split())
s-=x
t-=x
a.append([s,t,x])
a=sorted(a,reverse=True)
heap=[]
ans=[]
for i in range(q):
d=int(input())
while a and a[-1][0]<=d:
e=a.pop()
heappush(heap,(e[2],e[1]))
while heap and heap[0][1]<=d:
heappop(heap)
if heap:
ans.append(heap[0][0])
else:
ans.append(-1)
print(*ans, sep='\n')
| import sys
from heapq import heappush, heappop
n,q=map(int,input().split())
a=sorted(((s-x, t-x, x) for _ in range(n) for s, t, x in (map(int, sys.stdin.readline().split()),)), reverse=True)
heap=[]
ans=[]
for i in range(q):
d=int(input())
while a and a[-1][0]<=d:
e=a.pop()
heappush(heap,(e[2],e[1]))
while heap and heap[0][1]<=d:
heappop(heap)
if heap:
ans.append(heap[0][0])
else:
ans.append(-1)
print(*ans, sep='\n')
| p03033 |
from collections import deque
def BinarySearch(x,array):
left=0
right=len(array)-1
while right-left>=0:
mid=(left+right)//2
if array[mid]==x:
return mid
elif array[mid]>x:
right=mid-1
else:
left=mid+1
return False
def main():
ConstNum,PersonNum=list(map(int,input().split()))
S=[]
T=[]
X=[]
for i in range(ConstNum):
s,t,x=list(map(int,input().split()))
S.append(s-0.5)
T.append(t-0.5)
X.append(x)
STX=list(zip(S,T,X))
STX=sorted(STX)
S,T,X=list(zip(*STX))
S=deque(S)
T=deque(T)
X=deque(X)
PersonsDistance=[]
for i in range(PersonNum):
d=int(eval(input()))
PersonsDistance.insert(0,-1*d)
res=[]
time=0
PersonsIndexes=[i for i in range(PersonNum-1,-1,-1)]
while len(PersonsIndexes)>0 and len(X)>0:
start=S.popleft()
end=T.popleft()
x=X.popleft()
if start<time<end:
underPerson=BinarySearch(x,PersonsDistance)
if underPerson!=False:
res.append((PersonsIndexes.pop(underPerson),PersonsDistance.pop(underPerson)))
S.appendleft(start)
T.appendleft(end)
X.appendleft(x)
elif start>time:
S.appendleft(start)
T.appendleft(end)
X.appendleft(x)
else:
continue
time+=1
PersonsDistance=list([x+1 for x in PersonsDistance])
for i in PersonsIndexes:
res.append((i,-1))
res=sorted(res)
for i in res:
print((i[1]))
if __name__=="__main__":
main()
| from bisect import bisect_left
def main():
ConstNum,PersonNum=list(map(int,input().split()))
S=[]
T=[]
X=[]
for i in range(ConstNum):
s,t,x=list(map(int,input().split()))
S.append(s)
T.append(t)
X.append(x)
DepartureTime=[]
for i in range(PersonNum):
d=int(eval(input()))
DepartureTime.append(d)
XST=list(zip(X,S,T))
XST=sorted(XST)
res=[-1]*PersonNum
stop=[-1]*PersonNum
for x,s,t in XST:
left_value=s-x
right_value=t-x
left_index=bisect_left(DepartureTime,left_value)
right_index=bisect_left(DepartureTime,right_value)
while left_index<right_index:
if stop[left_index]==-1:
res[left_index]=x
stop[left_index]=right_index
left_index+=1
else:
left_index=stop[left_index]
for i in range(PersonNum):
print((res[i]))
if __name__=="__main__":
main() | p03033 |
from heapq import heappop, heappush
N, Q = map(int, input().split())
event_list = []
for i in range(N):
s, t, x = map(int, input().split())
event_list.append([s-x, 1, x])
event_list.append([t-x, -1, x])
for i in range(Q):
event_list.append([int(input()), 2, 0])
ans = []
event_list.sort()
x_set = set()
x_list = []
for time, event, x in event_list:
if event == 1:
x_set.add(x)
heappush(x_list, x)
elif event == -1:
x_set.remove(x)
else:
while x_list and x_list[0] not in x_set:
heappop(x_list)
if x_list:
ans.append(x_list[0])
else:
ans.append(-1)
print(*ans, sep='\n')
| import sys
from heapq import heappop, heappush
input = sys.stdin.readline
N, Q = map(int, input().split())
event_list = []
for i in range(N):
s, t, x = map(int, input().split())
event_list.append([s-x, 1, x])
event_list.append([t-x, -1, x])
for i in range(Q):
event_list.append([int(input()), 2, 0])
ans = []
event_list.sort()
x_set = set()
x_list = []
for time, event, x in event_list:
if event == 1:
x_set.add(x)
heappush(x_list, x)
elif event == -1:
x_set.remove(x)
else:
while x_list and x_list[0] not in x_set:
heappop(x_list)
if x_list:
ans.append(x_list[0])
else:
ans.append(-1)
print(*ans, sep='\n')
| p03033 |
import collections
def main():
N, Q = [int(x) for x in input().split()]
updates1 = []
updates2 = []
for i in range(N):
S, T, X = [int(x) for x in input().split()]
updates1.append((S-X, X))
updates2.append((T-X, X))
active = []
to_delete = collections.defaultdict(int)
import heapq
heapq.heapify(updates1)
heapq.heapify(updates2)
for _ in range(Q):
x = int(eval(input()))
while updates1 and updates1[0][0] <= x:
coord, val = heapq.heappop(updates1)
heapq.heappush(active, val)
while updates2 and updates2[0][0] <= x:
coord, val = heapq.heappop(updates2)
to_delete[val] += 1
while active and to_delete[active[0]] > 0:
to_delete[active[0]] -= 1
heapq.heappop(active)
print((active[0] if active else -1))
######## Python 2 and 3 footer by Pajenegod and c1729
# Note because cf runs old PyPy3 version which doesn't have the sped up
# unicode strings, PyPy3 strings will many times be slower than pypy2.
# There is a way to get around this by using binary strings in PyPy3
# but its syntax is different which makes it kind of a mess to use.
# So on cf, use PyPy2 for best string performance.
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'0' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'0' [0]:
A.append(sign*numb)
return A
if __name__== "__main__":
main()
| import collections
def main():
inp = readnumbers()
ii = 0
N = inp[ii]
ii+=1
Q = inp[ii]
ii += 1
updates1 = []
updates2 = []
for i in range(N):
S = inp[ii]
ii += 1
T = inp[ii]
ii += 1
X = inp[ii]
ii += 1
updates1.append((S-X, X))
updates2.append((T-X, X))
active = []
to_delete = collections.defaultdict(int)
import heapq
heapq.heapify(updates1)
heapq.heapify(updates2)
for _ in range(Q):
x = inp[ii]
ii += 1
while updates1 and updates1[0][0] <= x:
coord, val = heapq.heappop(updates1)
heapq.heappush(active, val)
while updates2 and updates2[0][0] <= x:
coord, val = heapq.heappop(updates2)
to_delete[val] += 1
while active and to_delete[active[0]] > 0:
to_delete[active[0]] -= 1
heapq.heappop(active)
print((active[0] if active else -1))
######## Python 2 and 3 footer by Pajenegod and c1729
# Note because cf runs old PyPy3 version which doesn't have the sped up
# unicode strings, PyPy3 strings will many times be slower than pypy2.
# There is a way to get around this by using binary strings in PyPy3
# but its syntax is different which makes it kind of a mess to use.
# So on cf, use PyPy2 for best string performance.
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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')
# Cout implemented in Python
import sys
class ostream:
def __lshift__(self,a):
sys.stdout.write(str(a))
return self
cout = ostream()
endl = '\n'
# Read all remaining integers in stdin, type is given by optional argument, this is fast
def readnumbers(zero = 0):
conv = ord if py2 else lambda x:x
A = []; numb = zero; sign = 1; i = 0; s = sys.stdin.buffer.read()
try:
while True:
if s[i] >= b'0' [0]:
numb = 10 * numb + conv(s[i]) - 48
elif s[i] == b'-' [0]: sign = -1
elif s[i] != b'\r' [0]:
A.append(sign*numb)
numb = zero; sign = 1
i += 1
except:pass
if s and s[-1] >= b'0' [0]:
A.append(sign*numb)
return A
if __name__== "__main__":
main()
| p03033 |
from heapq import heappop,heappush
from collections import defaultdict
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,2,x))
for i in range(Q):
d = int(eval(input()))
event.append((d,3,i))
event.sort()
memo = defaultdict(int)
nowStop = []
ans = [-1]*Q
while event:
t,e,x = heappop(event)
if e == 1:
heappush(nowStop,x)
memo[x] += 1
if e == 2:
memo[x] -= 1
if e == 3:
while nowStop:
s = nowStop[0]
if memo[s] == 0:
heappop(nowStop)
else:
ans[x] = s
break
for a in ans:
print(a) | from heapq import heappop,heappush
from collections import defaultdict
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,2,x))
for i in range(Q):
d = int(eval(input()))
event.append((d,3,i))
event.sort()
memo = defaultdict(int)
nowStop = []
ans = [-1]*Q
for t,e,x in event:
if e == 1:
heappush(nowStop,x)
memo[x] += 1
if e == 2:
memo[x] -= 1
if e == 3:
while nowStop:
s = nowStop[0]
if memo[s] == 0:
heappop(nowStop)
else:
ans[x] = s
break
for a in ans:
print(a) | p03033 |
import sys
from heapq import heappush, heappop
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
N, Q = map(int, rl().split())
events = []
for _ in range(N):
s, t, x = map(int, rl().split())
events.append((t - x, 0, x))
events.append((s - x, 1, x))
for _ in range(Q):
d = int(rl())
events.append((d, 2, -1))
events.sort(key=itemgetter(0, 1))
pos_set = set()
pos_hq = []
ans = []
for _, com, pos in events:
if com == 0:
pos_set.remove(pos)
elif com == 1:
pos_set.add(pos)
heappush(pos_hq, pos)
else:
while pos_hq:
if pos_hq[0] not in pos_set:
heappop(pos_hq)
else:
break
ans.append(pos_hq[0] if pos_hq else -1)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| import sys
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
class SegmentTree:
def __init__(self, init_value: list, segfunc, ide_ele):
n = len(init_value)
self.N0 = 1 << (n - 1).bit_length()
self.ide_ele = ide_ele
self.data = [ide_ele] * (2 * self.N0)
self.segfunc = segfunc
for i, x in enumerate(init_value):
self.data[i + self.N0 - 1] = x
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.segfunc(self.data[2 * i + 1], self.data[2 * i + 2])
def update(self, k: int, x):
k += self.N0 - 1
################################################################
self.data[k] = x
################################################################
while k:
k = (k - 1) // 2
self.data[k] = self.segfunc(self.data[k * 2 + 1], self.data[k * 2 + 2])
def query(self, left: int, right: int):
L = left + self.N0
R = right + self.N0
res = self.ide_ele
################################################################
while L < R:
if L & 1:
res = self.segfunc(res, self.data[L - 1])
L += 1
if R & 1:
R -= 1
res = self.segfunc(res, self.data[R - 1])
L >>= 1
R >>= 1
################################################################
return res
def solve():
N, Q = map(int, rl().split())
events = []
xs = set()
for _ in range(N):
s, t, x = map(int, rl().split())
events.append((t - x, 0, x))
events.append((s - x, 1, x))
xs.add(x)
for _ in range(Q):
d = int(rl())
events.append((d, 2, -1))
events.sort(key=itemgetter(0, 1))
x_to_idx = {x: idx for idx, x in enumerate(sorted(xs))}
M = len(xs)
ide_ele = 10 ** 10
seg_tree = SegmentTree([ide_ele] * M, min, ide_ele)
ans = []
for _, com, pos in events:
if com == 0:
seg_tree.update(x_to_idx[pos], ide_ele)
elif com == 1:
seg_tree.update(x_to_idx[pos], pos)
else:
tmp = seg_tree.data[0]
ans.append(tmp if tmp != ide_ele else -1)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| p03033 |
import sys
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
class SegmentTree:
def __init__(self, n: int, segfunc, ide_ele):
self.N0 = 1 << (n - 1).bit_length()
self.ide_ele = ide_ele
self.data = [ide_ele] * (2 * self.N0)
self.segfunc = segfunc
def build(self, init_value: list):
for i, x in enumerate(init_value):
self.data[i + self.N0 - 1] = x
for i in range(self.N0 - 2, -1, -1):
self.data[i] = self.segfunc(self.data[2 * i + 1], self.data[2 * i + 2])
def update(self, k: int, x):
k += self.N0 - 1
################################################################
self.data[k] = x
################################################################
while k:
k = (k - 1) // 2
self.data[k] = self.segfunc(self.data[k * 2 + 1], self.data[k * 2 + 2])
def query(self, left: int, right: int):
L = left + self.N0
R = right + self.N0
res = self.ide_ele
################################################################
while L < R:
if L & 1:
res = self.segfunc(res, self.data[L - 1])
L += 1
if R & 1:
R -= 1
res = self.segfunc(res, self.data[R - 1])
L >>= 1
R >>= 1
################################################################
return res
def solve():
N, Q = map(int, rl().split())
events = []
xs = set()
for _ in range(N):
s, t, x = map(int, rl().split())
events.append((t - x, 0, x))
events.append((s - x, 1, x))
xs.add(x)
for _ in range(Q):
d = int(rl())
events.append((d, 2, -1))
events.sort(key=itemgetter(0, 1))
x_to_idx = {x: idx for idx, x in enumerate(sorted(xs))}
M = len(xs)
ide_ele = 10 ** 10
seg_tree = SegmentTree(M, min, ide_ele)
ans = []
for _, com, pos in events:
if com == 0:
seg_tree.update(x_to_idx[pos], ide_ele)
elif com == 1:
seg_tree.update(x_to_idx[pos], pos)
else:
tmp = seg_tree.data[0]
ans.append(tmp if tmp != ide_ele else -1)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| import sys
from heapq import heappush, heappop
from operator import itemgetter
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
N, Q = map(int, rl().split())
events = []
for _ in range(N):
s, t, x = map(int, rl().split())
events.append((t - x, 0, x))
events.append((s - x, 1, x))
for _ in range(Q):
d = int(rl())
events.append((d, 2, -1))
events.sort(key=itemgetter(0, 1))
pos_set = set()
pos_hq = []
ans = []
for _, com, pos in events:
if com == 0:
pos_set.remove(pos)
elif com == 1:
pos_set.add(pos)
heappush(pos_hq, pos)
else:
while pos_hq:
if pos_hq[0] not in pos_set:
heappop(pos_hq)
else:
break
ans.append(pos_hq[0] if pos_hq else -1)
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| p03033 |
import sys
class SegTree:
def __init__(self, init_val, n, ide_ele, seg_func):
self.segfunc = seg_func
self.num = 2**(n-1).bit_length()
self.ide_ele = ide_ele
self.seg=[self.ide_ele]*2*self.num
for i in range(n):
self.seg[i+self.num-1]=init_val[i]
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfunc(self.seg[2*i+1],self.seg[2*i+2])
def update(self, k, x):
k += self.num-1
self.seg[k] = x
while k+1:
k = (k-1)//2
self.seg[k] = self.segfunc(self.seg[k*2+1],self.seg[k*2+2])
def query(self, p, q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfunc(res,self.seg[p])
if q&1 == 1:
res = self.segfunc(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfunc(res,self.seg[p])
else:
res = self.segfunc(self.segfunc(res,self.seg[p]),self.seg[q])
return res
#from bisect import bisect_left as bl
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
xs = []
ts = set()
qs = []
for _ in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x), (t-x-0.5,False,x)]
ts.add(x)
for _ in range(Q):
xs.append((int(eval(input())), 2, 0))
xs.sort(key=lambda x:x[0])
mx,XN = 10**9,len(ts)
x2i = {x:i for i,x in enumerate(ts)}
st = SegTree([mx]*XN, XN, mx, min)
for t,r,x in xs:
if r == 2:
c = st.query(0,XN)
print((c if c!= mx else -1))
else:
st.update(x2i[x], x if r else mx)
| import sys
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update( k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
def query():
p = b_num-1
q = n+b_num-2
res=mx
while q-p>1:
if p&1 == 0:
res = min(res,segl[p])
if q&1 == 1:
res = min(res,segl[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,segl[p])
else:
res = min(min(res,segl[p]),segl[q])
return res
input = sys.stdin.readline
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
c = query()
print((c if c!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| p03033 |
import sys
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update( k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
def query():
p = b_num-1
q = n+b_num-2
res=mx
while q-p>1:
if p&1 == 0:
res = min(res,segl[p])
if q&1 == 1:
res = min(res,segl[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,segl[p])
else:
res = min(min(res,segl[p]),segl[q])
return res
input = sys.stdin.readline
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
c = query()
print((c if c!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update( k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
def query():
p = b_num-1
q = n+b_num-2
res=mx
while q-p>1:
if p&1 == 0:
res = min(res,segl[p])
if q&1 == 1:
res = min(res,segl[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,segl[p])
else:
res = min(min(res,segl[p]),segl[q])
return res
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
c = query()
print((c if c!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| p03033 |
import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update( k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
def query():
p = b_num-1
q = n+b_num-2
res=mx
while q-p>1:
if p&1 == 0:
res = min(res,segl[p])
if q&1 == 1:
res = min(res,segl[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = min(res,segl[p])
else:
res = min(min(res,segl[p]),segl[q])
return res
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
c = query()
print((c if c!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update( k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
print((segl[0] if segl[0]!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| p03033 |
import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update(k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort()
for x in xs:
if x[1]==2:
print((segl[0] if segl[0]!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update(k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x-0.4,True,x,i), (t-x-0.5,False,x,i)]
for _ in range(Q):
xs.append((int(eval(input())),2))
xs.sort(key=lambda x:x[0])
for x in xs:
if x[1]==2:
print((segl[0] if segl[0]!= mx else -1))
continue
update(x[3], x[2] if x[1] else mx)
| p03033 |
import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update(k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x,True,x,i), (t-x,False,x,i)]
qs = []
for _ in range(Q):
qs.append(int(eval(input())))
xs.sort(key=lambda x:x[0])
j = 0
for x in xs:
while Q-j:
if qs[j] < x[0]:
print((segl[0] if segl[0]!= mx else -1))
j += 1
continue
break
update(x[3], x[2] if x[1] else mx)
while Q-j:
print((-1))
j+=1
| import sys
input = sys.stdin.readline
n,Q=list(map(int,input().split()))
b_num = 2**(n-1).bit_length()
mx = 10**9
segl=[mx]*2*b_num
def update(k, x):
k += b_num-1
segl[k] = x
while k+1:
k = (k-1)//2
segl[k] = min(segl[k*2+1],segl[k*2+2])
if __name__ == '__main__':
xs = []
for i in range(n):
s,t,x=list(map(int,input().split()))
xs += [(s-x,True,x,i), (t-x,False,x,i)]
qs = []
for _ in range(Q):
qs.append(int(eval(input())))
xs.sort(key=lambda x:x[0])
j = 0
for x in xs:
while Q-j and qs[j] < x[0]:
print((segl[0] if segl[0]!= mx else -1))
j += 1
update(x[3], x[2] if x[1] else mx)
while Q-j:
print((-1))
j+=1
| p03033 |
import sys;input=sys.stdin.readline
N, Q = list(map(int, input().split()))
X = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
X.append((2*s-2*x-1, 0, x))
X.append((2*t-2*x-1, 1, x))
inf = 10**18
X.append((-inf, 0, inf))
X.append((inf, 1, inf))
X.sort(key=lambda x: x[0])
from heapq import *
from collections import defaultdict
#print(X[1:-1])
j = 0
ll = []
vs = set()
d = defaultdict(int)
for _ in range(Q):
q = int(eval(input()))
while 1:
u, f, x = X[j]
if u > 2*q:
break
if f:
d[x] += 1
else:
heappush(ll, x)
j += 1
while 1:
x = heappop(ll)
if d[x] > 0:
d[x] -= 1
continue
heappush(ll, x)
if x == inf:
print((-1))
else:
print(x)
break
|
from heapq import *
def main():
import sys;input=sys.stdin.readline
N, Q = list(map(int, input().split()))
X = []
for _ in range(N):
s, t, x = list(map(int, input().split()))
X.append((2*s-2*x-1, 0, x))
X.append((2*t-2*x-1, 1, x))
inf = 10**18
X.append((-inf, 0, inf))
X.append((inf, 1, inf))
X.sort(key=lambda x: x[0])
j = 0
ll = []
vs = set()
d = dict()
for _ in range(Q):
q = int(eval(input()))
while 1:
u, f, x = X[j]
if u > 2*q:
break
if f:
if x not in d:
d[x] = 0
d[x] += 1
else:
heappush(ll, x)
j += 1
while 1:
x = heappop(ll)
if x in d and d[x] > 0:
d[x] -= 1
continue
heappush(ll, x)
if x == inf:
print((-1))
else:
print(x)
break
if __name__ == '__main__':
main()
| p03033 |
from bisect import bisect_left
inf = float('inf')
class SegmentTree:
def __init__(self, N):
tmp = 1
while tmp < N:
tmp <<= 1
self.N = tmp
self.data = [inf for _ in range(2*self.N-1)]
def update(self, l, r, x):
L = l + self.N
R = r + self.N
while L < R:
if R & 1:
R -= 1
self.data[R] = min(self.data[R], x)
if L & 1:
self.data[L] = min(self.data[L], x)
L += 1
L >>= 1; R >>= 1
def value(self, k):
k += self.N
res = self.data[k]
while k != 0:
k >>= 1
res = min(res, self.data[k])
return res
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)]
st = SegmentTree(Q)
for S, T, X in STX:
l = bisect_left(D, S-X)
r = bisect_left(D, T-X)
st.update(l, r, X)
for k in range(Q):
ans = st.value(k)
if ans == inf:
ans = -1
print(ans) | import sys
input = sys.stdin.readline
from bisect import bisect_left
inf = float('inf')
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)]
res = 1
while res < Q:
res <<= 1
N0 = res
data = [inf for _ in range(2*N0-1)]
def update(l, r, x):
L = l + N0
R = r + N0
while L < R:
if R & 1:
R -= 1
data[R] = min(data[R], x)
if L & 1:
data[L] = min(data[L], x)
L += 1
L >>= 1; R >>= 1
def value(k):
k += N0
res = data[k]
while k != 0:
k >>= 1
res = min(res, data[k])
return res
for S, T, X in STX:
l = bisect_left(D, S-X)
r = bisect_left(D, T-X)
update(l, r, X)
for k in range(Q):
ans = value(k)
if ans == inf:
ans = -1
print(ans) | p03033 |
from heapq import heappush, heappop
n, q = map(int, input().split())
STX = [list(map(int, input().split())) for _ in range(n)]
task = []
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(input())
task.append((d, 2, i))
task.sort()
kouho = set()
kouho_hp = []
ans = [-1] * q
for a, b, c in task:
if b == 0:
kouho.remove(c)
if b == 1:
kouho.add(c)
heappush(kouho_hp, c)
if b == 2:
while kouho_hp and kouho_hp[0] not in kouho:
heappop(kouho_hp)
if not kouho_hp:
continue
else:
ans[c] = kouho_hp[0]
# heapは0-indexが最小値になっているからheapified_list[0]でもよい
print(*ans, sep="\n")
| from heapq import heappush, heappop
import sys
input = sys.stdin.buffer.readline
n, q = map(int, input().split())
STX = [list(map(int, input().split())) for _ in range(n)]
task = []
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(input())
task.append((d, 2, i))
task.sort()
kouho = set()
kouho_hp = []
ans = [-1] * q
for a, b, c in task:
if b == 0:
kouho.remove(c)
if b == 1:
kouho.add(c)
heappush(kouho_hp, c)
if b == 2:
while kouho_hp and kouho_hp[0] not in kouho:
heappop(kouho_hp)
if not kouho_hp:
continue
else:
ans[c] = kouho_hp[0]
# heapは0-indexが最小値になっているからheapified_list[0]でもよい
print(*ans, sep="\n")
| p03033 |
#! /usr/bin/env python3
#! /usr/bin/env python3
import bisect
import sys
sys.setrecursionlimit(10**9)
# Ref: https://qiita.com/takayg1/items/b7b3f7d458915bcc7a4e
class LazySegTree:
def __init__(self, init_val, segfunc, ide_ele = 2**31 - 1):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [None] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.data[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[2 * i] = v
self.lazy[2 * i + 1] = v
self.data[2 * i] = v
self.data[2 * i + 1] = v
self.lazy[i] = None
def update(self, l, r, x): # [l, r)
*ids, = self.gindex(l, r)
self.propagates(*ids)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.data[l] = x
l += 1
if r & 1:
self.lazy[r - 1] = x
self.data[r - 1] = x
r >>= 1
l >>= 1
for i in ids:
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def query(self, l, r): # [l, r)
*ids, = self.gindex(l, r)
self.propagates(*ids)
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.data[l])
l += 1
if r & 1:
res = self.segfunc(res, self.data[r - 1])
l >>= 1
r >>= 1
return res
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def zarts(X): # 座標圧縮
import collections
Y = list(set(X))
Y.sort()
Z = collections.defaultdict(lambda: INF)
for i,y in enumerate(Y):
z = bisect.bisect_left(Y,y)
Z[y] = z
return Z
INF=10**20
def solve(N: int, Q: int, S: "List[int]", T: "List[int]", X: "List[int]", D: "List[int]"):
def segfunc(x,y):
return min(x,y)
for i in range(N):
l = S[i]-X[i]
r = T[i]-X[i]
D.append(l)
D.append(r)
zarts_dict = zarts(D)
v = [INF] * (len(D) + 1)
seg = LazySegTree(v,segfunc,ide_ele=INF)
_X = list(enumerate(X))
_X.sort(key=lambda x:x[1],reverse=True)
for i,x in _X:
l = zarts_dict[S[i]-X[i]]
r = zarts_dict[T[i]-X[i]]
seg.update(l,r,X[i])
for q in range(Q):
d = zarts_dict[D[q]]
# print("d",d)
x = seg.query(d,d+1)
if x == INF:
x = -1
print(x)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
S = [int()] * (N) # type: "List[int]"
T = [int()] * (N) # type: "List[int]"
X = [int()] * (N) # type: "List[int]"
# X = [(int(),int())] * (N) # type: "List[int]"
for i in range(N):
S[i] = int(next(tokens))
T[i] = int(next(tokens))
X[i] = int(next(tokens))
# X[i] = (-1 * int(next(tokens)),i)
D = [int(next(tokens)) for _ in range(Q)] # type: "List[int]"
solve(N, Q, S, T, X, D)
if __name__ == "__main__":
main()
| #! /usr/bin/env python3
import bisect
import sys
sys.setrecursionlimit(10**9)
# Ref: https://qiita.com/takayg1/items/b7b3f7d458915bcc7a4e
class LazySegTree:
def __init__(self, init_val, segfunc, ide_ele = 2**31 - 1):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.data = [ide_ele] * 2 * self.num
self.lazy = [None] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.data[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def propagates(self, *ids):
for i in reversed(ids):
v = self.lazy[i]
if v is None:
continue
self.lazy[2 * i] = v
self.lazy[2 * i + 1] = v
self.data[2 * i] = v
self.data[2 * i + 1] = v
self.lazy[i] = None
def update(self, l, r, x): # [l, r)
*ids, = self.gindex(l, r)
self.propagates(*ids)
l += self.num
r += self.num
while l < r:
if l & 1:
self.lazy[l] = x
self.data[l] = x
l += 1
if r & 1:
self.lazy[r - 1] = x
self.data[r - 1] = x
r >>= 1
l >>= 1
for i in ids:
self.data[i] = self.segfunc(self.data[2 * i], self.data[2 * i + 1])
def query(self, l, r): # [l, r)
*ids, = self.gindex(l, r)
self.propagates(*ids)
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.data[l])
l += 1
if r & 1:
res = self.segfunc(res, self.data[r - 1])
l >>= 1
r >>= 1
return res
def gindex(self, l, r):
l += self.num
r += self.num
lm = l >> (l & -l).bit_length()
rm = r >> (r & -r).bit_length()
while r > l:
if l <= lm:
yield l
if r <= rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def zarts(D,x): # 座標圧縮
return bisect.bisect_left(D,x)
INF=10**20
def solve(N: int, Q: int, S: "List[int]", T: "List[int]", X: "List[int]", D: "List[int]"):
def segfunc(x,y):
return min(x,y)
v = [INF] * (Q+1)
seg = LazySegTree(v,segfunc,ide_ele=INF)
_X = list(enumerate(X))
_X.sort(key=lambda x:x[1],reverse=True)
for i,x in _X:
l = zarts(D,S[i]-X[i])
r = zarts(D,T[i]-X[i])
if l == r: continue
seg.update(l,r,X[i])
for q in range(Q):
d = q
# print("d",d)
x = seg.query(d,d+1)
if x == INF:
x = -1
print(x)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
Q = int(next(tokens)) # type: int
S = [int()] * (N) # type: "List[int]"
T = [int()] * (N) # type: "List[int]"
X = [int()] * (N) # type: "List[int]"
# X = [(int(),int())] * (N) # type: "List[int]"
for i in range(N):
S[i] = int(next(tokens))
T[i] = int(next(tokens))
X[i] = int(next(tokens))
# X[i] = (-1 * int(next(tokens)),i)
D = [int(next(tokens)) for _ in range(Q)] # type: "List[int]"
solve(N, Q, S, T, X, D)
if __name__ == "__main__":
main()
| p03033 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * W for _ in range(H)]
max_width = 0
for m in range(H):
for n in range(W):
dp[m][n] = (int(carpet_info[m][n]) + 1) % 2
max_width |= dp[m][n]
for i in range(1, H):
for j in range(1, W):
if int(carpet_info[i][j]):
dp[i][j] = 0
else:
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
max_width = max(max_width, dp[i][j])
return pow(max_width, 2)
if __name__ == '__main__':
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4 5
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
0 0 0 1 0
output:
4
"""
import sys
def solve():
dp = [[0] * (W + 1) for _ in range(H + 1)]
for i in range(H):
for j in range(W):
if not int(carpet_info[i][j]):
dp[i + 1][j + 1] = min(dp[i][j], dp[i][j + 1], dp[i + 1][j]) + 1
cand = (max(each) for each in dp)
return pow(max(cand), 2)
if __name__ == '__main__':
_input = sys.stdin.readlines()
H, W = list(map(int, _input[0].split()))
carpet_info = list([x.split() for x in _input[1:]])
print((solve())) | p02326 |
import sys
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0 for j in range(w)] for i in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for i in range(h)]
maxWidth = 0
for i in range(0, h):
for j in range(0, w):
dp[i][j] = (G[i][j] + 1) % 2
maxWidth |= dp[i][j]
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
if maxWidth < dp[i][j]:
maxWidth = dp[i][j]
print((maxWidth * maxWidth)) | import sys
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0] * w for _ in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for _ in range(h)]
for i in range(0, h):
for j in range(0, w):
dp[i][j] = (G[i][j] + 1) % 2
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
print((max([max(item) for item in dp])**2)) | p02326 |
import sys
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0] * w for _ in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for _ in range(h)]
for i in range(0, h):
for j in range(0, w):
dp[i][j] = (G[i][j] + 1) % 2
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
print((max([max(item) for item in dp])**2)) | import sys
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0] * w for _ in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for _ in range(h)]
for x in range(h):
dp[x][0] = 1 if G[x][0] == 0 else 0
for y in range(w):
dp[0][y] = 1 if G[0][y] == 0 else 0
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
print((max([max(item) for item in dp])**2)) | p02326 |
import sys
import itertools
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0] * w for _ in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for _ in range(h)]
for x in range(h):
dp[x][0] = 1 if G[x][0] == 0 else 0
for y in range(w):
dp[0][y] = 1 if G[0][y] == 0 else 0
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
print((max(itertools.chain(*dp)) ** 2)) | import sys
import itertools
h, w = list(map(int, sys.stdin.readline().split()))
dp = [[0] * w for _ in range(h)]
G = [[int(j) for j in sys.stdin.readline().split()] for _ in range(h)]
for x in range(h):
dp[x][0] = 1 if G[x][0] == 0 else 0
for y in range(w):
dp[0][y] = 1 if G[0][y] == 0 else 0
for i in range(1, h):
for j in range(1, w):
if(G[i][j] == 0):
dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1
print((max(max(i) for i in dp) ** 2)) | p02326 |
H, W = list(map(int, input().split()))
c = []
for i in range(H):
c.append([int(i) for i in input().split()])
dp = [[0 for i in range(W)] for i in range(H)]
maxwidth = 0
for i in range(H):
for j in range(W):
dp[i][j] = (c[i][j] + 1) % 2
maxwidth |= dp[i][j]
for i in range(1, H):
for j in range(1, W):
if c[i][j]:
dp[i][j] = 0
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-1], dp[i][j-1]) + 1
maxwidth = max(maxwidth,dp[i][j])
print((maxwidth**2))
| H, W = list(map(int, input().split()))
c = []
for i in range(H):
c.append([int(i) for i in input().split()])
dp = [[0 for i in range(W)] for i in range(H)]
maxwidth = 0
for i in range(H):
for j in range(W):
dp[i][j] = (c[i][j] + 1) % 2
maxwidth |= dp[i][j]
for i in range(1, H):
for j in range(1, W):
if c[i][j]:
continue
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-1], dp[i][j-1]) + 1
maxwidth = max(maxwidth, dp[i][j])
print((maxwidth**2))
| p02326 |
def counting(k, v, square):
square += 1
for _ in range(square):
for r in range(k, k + square):
if r > len(matrix) - 1:
return False
for c in range(v, v + square):
if c > len(matrix[k]) - 1:
return False
if matrix[r][c] == '1':
return False
return True
line = input().split(' ')
answer = [[0 for _ in range(int(line[1]))] for _ in range(int(line[0]))]
matrix = []
maximum = 0
is_over = False
ggg = 0
for _ in range(int(line[0])):
row = input().split(' ')
matrix.append(row)
for i in range(len(matrix)):
for j in range(len(matrix[i])):
ggg += 1
for m in range(min(int(line[0]), int(line[1]))):
res = counting(i, j, maximum)
if res:
maximum += 1
else:
break
print((maximum * maximum)) | def solve2():
r, c = list(map(int, input().split(' ')))
ans_matrix = [[0 for _ in range(c + 1)] for _ in range(r + 1)]
input_matrix = []
for _ in range(r):
input_matrix.append(list(map(int, input().split(' '))))
largest_square = 0
for i in range(len(input_matrix)):
for j in range(len(input_matrix[i])):
new_i, new_j = i + 1, j + 1
if input_matrix[i][j] == 0:
ans_matrix[new_i][new_j] = min(ans_matrix[new_i - 1][new_j], ans_matrix[new_i][new_j - 1], ans_matrix[new_i - 1][new_j - 1]) + 1
largest_square = ans_matrix[new_i][new_j] if ans_matrix[new_i][new_j] > largest_square else largest_square
else:
ans_matrix[new_i][new_j] = 0
print((largest_square ** 2))
def main():
solve2()
if __name__ == '__main__':
main() | p02326 |
# -*- coding: utf-8 -*-
result = 0
def dfs(num, dem, k, cur_num, p, q, a, n):
global result
#print num, dem, k, cur_num
#time.sleep(0.5)
if (num * q) == (dem * p):
result += 1
#print "result: " + str(result)
return
if k == n:
return
if (num * q) > (dem * p):
return
i = cur_num
while i * dem <= a:
dfs((num * i) + dem, dem * i, k + 1, i, p, q, a, n)
i += 1
return
def func():
while True:
global result
p, q, a, n = list(map(int, input().split()))
if p == 0 and q == 0 and a == 0 and n == 0:
break
result = 0
dfs(0, 1, 0, 1, p, q, a, n)
print(result)
return None
if __name__ == '__main__':
func()
| # -*- coding: utf-8 -*-
def dfs(num, dem, k, cur_num, prd, p, q, a, n):
#print num, dem, k, cur_num, prd
#time.sleep(0.5)
if num == 0:
#print "result: " + str(result)
return 1
result = 0
i = cur_num
while prd * i <= a:
#print i, num, dem, k, cur_num, prd
if (n - k) * dem < num * i:
break
if num * i < dem:
i += 1
continue
result += dfs((num * i) - dem, dem * i, k + 1, i, prd * i, p, q, a, n)
i += 1
return result
def func():
while True:
p, q, a, n = list(map(int, input().split()))
if p == 0 and q == 0 and a == 0 and n == 0:
break
print(dfs(p, q, 0, 1, 1, p, q, a, n))
return None
if __name__ == '__main__':
func()
| p00712 |
from functools import lru_cache
from fractions import Fraction
@lru_cache(maxsize=1<<10)
def solve(p, q, a, n):
def _solve(f, d, m, s):
if f == 0:
return 1
if d == 0:
return 0
if f < Fraction(1, a//m):
return 0
return sum((_solve(f-Fraction(1, i), d-1, m*i, i)
for i in range(s, min(f.denominator*n//f.numerator, a//m)+1)), 0)
return _solve(Fraction(p, q), n, 1, 1)
if __name__ == "__main__":
while True:
p, q, a, n = [int(i) for i in input().split()]
if p == 0:
break
print((solve(p, q, a, n))) | from functools import lru_cache
@lru_cache(maxsize=1<<10)
def solve(p, q, a, n):
def _solve(num, dem, d, m, s):
if num == 0:
return 1
if d == 0:
return 0
if num * a // m < dem:
return 0
return sum((_solve(num*i-dem, dem*i, d-1, m*i, i)
for i in range(s, min(dem*n//num, a//m)+1)), 0)
return _solve(p, q, n, 1, 1)
if __name__ == "__main__":
ans = []
while True:
p, q, a, n = [int(i) for i in input().split()]
if p == 0:
break
ans.append(solve(p, q, a, n))
print(*ans, sep="\n")
| p00712 |
r ,d, x = list(map(int,input().split()))
xi = 0
for i in range(10):
if i ==0:
xi = r * x - d
else:
xi = r * xi - d
print(xi)
| r ,d, x = list(map(int,input().split()))
for i in range(10):
x = r * x - d
print(x)
| p03036 |
r, d, x = list(map(int, input().split()))
for i in range(10):
x= r*x -d
print(x) | r, d, x = list(map(int, input().split()))
for _ in range(10):
x= r*x -d
print(x)
| p03036 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
r, D, x = list(map(int, input().split()))
for _ in range(10):
x = r * x - D
print(x)
| r, d, x = list(map(int, input().strip().split()))
for i in range(10):
x = r * x - d
print(x)
| p03036 |
#!/usr/bin/env python3
# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
# Failed to predict input format
r,d,x = list(map(int, input().split()))
for i in range(10):
x = r*x-d
print(x)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
def main():
r, D, x2000 = list(map(int, input().split()))
x = x2000
for i in range(1,11):
x = r*x-D
print(x)
if __name__ == '__main__':
main()
| p03036 |
r, D, x_2000 = list(map(int, input().split()))
x = x_2000
for i in range(10):
x = r * x - D
print(x) | r, D, x = list(map(int, input().split()))
for i in range(10):
x = r * x - D
print(x) | p03036 |
r,d,x = list(map(int,input().split()))
for i in range(10):
temp = r*x - d
print(temp)
x = temp | r,d,x=list(map(int,input().split()))
for i in range(10):x=r*x-d;print(x) | p03036 |
R_up, Down, First_number = list(map(int, input().split()))
Tmp_number = First_number
for _ in range(10):
Tmp_number = R_up*Tmp_number-Down
print(Tmp_number) | #B
r, D, x = list(map(int, input().split()))
for i in range(10):
xnew = r*x - D
print(xnew)
x = xnew | p03036 |
r, d, x = list(map(int, input().split()))
tmp = x
for i in range(10):
ans = r * tmp - d
print(ans)
tmp = ans | r, D, x = list(map(int, input().split()))
for i in range(10):
ans = r * x - D
print(ans)
x = ans | p03036 |
r, D, x_2000 = list(map(int, input().split()))
def x(i):
if i == 2000:
return x_2000
elif i >= 2001:
return r * x(i - 1) - D
for i in range(2001, 2011):
print((x(i))) | r, D, x2000 = list(map(int, input().split()))
x = [x2000]
for i in range(10):
x.append(x[i] * r - D)
print((x[i+1])) | p03036 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
M = 7368792
def f(m, n):
g = [None] * M
i = m
while True:
if g[i] is None:
if n == 0:
return i
else:
n -= 1
for j in range(i,M,i):
g[j] = 1
i += 1
while True:
m,n = LI()
if m == 0 and n == 0:
break
rr.append(f(m,n))
return '\n'.join(map(str,rr))
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
class Prime():
def __init__(self, m):
self.M = m + 1
self.A = a = [True] * self.M
a[0] = a[1] = 0
self.T = t = []
sq = int(math.sqrt(self.M))
q = 0
for i in range(2, sq + 1):
if not a[i]:
a[i] = q
continue
t.append(i)
a[i] = q
q += 1
for j in range(i*i,m,i):
a[j] = False
for i in range(sq + 1, self.M):
if a[i]:
a[i] = q
q += 1
t.append(i)
else:
a[i] = q
def is_prime(self, n):
return self.A[n]
def main():
rr = []
M = 7368792
pr = Prime(M)
def f(m, n):
nn = n
g = [None] * (m*m)
for i in range(m, m*m):
if not g[i]:
if n == 0:
return i
n -= 1
for j in range(i, m*m, i):
g[j] = 1
d = pr.A[m*m]
return pr.T[d+n]
while True:
m,n = LI()
if m == 0 and n == 0:
break
rr.append(f(m,n))
return '\n'.join(map(str,rr))
print(main())
| p01095 |
import sys
N = int(sys.stdin.readline().strip())
def factorization(n):
arr = []
temp = n
# sqrtまで
for i in range(2, int(-(-n**0.5 // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
"""
if arr == []:
arr.append([n, 1])
"""
return arr
# 素因数とその出現回数
factors = {}
for i in range(1, N+1):
tmp = factorization(i)
# print(tmp)
for factor, count in tmp:
if factor not in factors:
factors[factor] = 0
factors[factor] += count
# print(factors)
ans = 1
for factor, count in list(factors.items()):
ans *= (count + 1)
ans %= 10**9 + 7
print(ans) | import sys
N = int(sys.stdin.readline())
mod = 10**9 + 7
values = [i for i in range(N+1)]
factors = {}
exists = set()
for i in range(2, N+1):
if i not in factors:
factors[i] = 0
for j in range(i, N+1, i):
tmp = values[j]
while tmp % i == 0:
factors[i] += 1
tmp //= i
values[j] = tmp
# print(values)
# print(factors)
ans = 1
for factor, count in list(factors.items()):
ans *= count + 1
ans %= mod
print(ans) | p03830 |
#!/usr/bin/env python3
n = int(eval(input()))
def count(x):
c = 0
t = n
while t:
c += t//x
t //= x
return c +1
prime = [2]
limit = int(n**0.5)
ans = count(2)
if n < 3:
print(ans)
exit()
data = [i + 1 for i in range(2, n, 2)]
while True:
p = data[0]
if limit < p:
for i in data:
ans *= count(i)
ans %= 10**9+7
break
ans *= count(p)
ans %= 10**9 + 7
data = [e for e in data if e % p != 0]
print(ans)
| #!/usr/bin/env python3
n = int(eval(input()))
def count(x):
c = 0
t = n
while t:
c += t//x
t //= x
return c +1
limit = int(n**0.5)
ans = count(2)
if n < 3:
print(ans)
exit()
data = [i + 1 for i in range(2, n, 2)]
while data:
p = data[0]
ans *= count(p)
ans %= 10**9 + 7
data = [e for e in data if e % p != 0]
print(ans)
| p03830 |
import math
import collections
def primes(n):
a = list(range(2, n+1))
primes = [2]
for i in a:
flag = True
m = math.sqrt(i)
for j in primes:
if j > m:
break
else:
if i % j == 0:
flag = False
break
if flag:
primes.append(i)
return primes
p = primes(10000)
dic = collections.defaultdict(int)
N = int(eval(input()))
mod = 10**9 +7
for i in range(1, N+1):
for j in p:
while i % j == 0:
dic[j] += 1
i = i // j
ans = 1
for c in list(dic.values()):
ans *= (c+1)
ans %= mod
print(ans)
| import math
import collections
# 0以上整数x「未満」の素数をリストに格納して返す
def primes(x):
if x < 2: return []
primes = [i for i in range(x)]
primes[1] = 0 # 1は素数ではない
# エラトステネスのふるい
for prime in primes:
if prime > math.sqrt(x): break
if prime == 0: continue
for non_prime in range(2 * prime, x, prime): primes[non_prime] = 0
return [prime for prime in primes if prime != 0]
p = primes(1000)
dic = collections.defaultdict(int)
N = int(eval(input()))
mod = 10**9 +7
for i in range(1, N+1):
for j in p:
while i % j == 0:
dic[j] += 1
i = i // j
ans = 1
for c in list(dic.values()):
ans *= (c+1)
ans %= mod
print(ans) | p03830 |
from collections import defaultdict
MOD = 1000000007
def prime_generator(limit):
yield 2
n, h = 3, {}
while n <= limit:
m = n
if n in h:
b = h[n]
m += 2 * b
while m in h:
m += 2 * b
h[m] = b
del h[n]
else:
m += 2 * n
while m in h:
m += 2 * n
h[m] = n
yield n
n += 2
def solve(n):
ps = list(prime_generator(n))
prev = defaultdict(int)
for i in range(1, n):
f = prev.copy()
k = i + 1
for p in ps:
while k % p == 0:
k //= p
f[p] += 1
if k == 1:
break
prev = f
ans = 1
for c in list(prev.values()):
ans *= c + 1
ans %= MOD
return ans
print((solve(int(eval(input())))))
| from collections import defaultdict
MOD = 1000000007
def prime_generator(limit):
yield 2
n, h = 3, {}
while n <= limit:
m = n
if n in h:
b = h[n]
m += 2 * b
while m in h:
m += 2 * b
h[m] = b
del h[n]
else:
m += 2 * n
while m in h:
m += 2 * n
h[m] = n
yield n
n += 2
def solve(n):
ps = list(prime_generator(n))
factors = defaultdict(int)
for i in range(1, n):
k = i + 1
for p in ps:
while k % p == 0:
k //= p
factors[p] += 1
if k == 1:
break
ans = 1
for c in list(factors.values()):
ans *= c + 1
ans %= MOD
return ans
print((solve(int(eval(input())))))
| p03830 |
N = int(eval(input()))
m = pow(10,9)+7
A = [1]*(N+1)
for n in range(2,N+1):
k = n
for i in range(2,n+1):
if k%i==0:
while k>1:
k//=i
A[i]+=1
if k%i!=0:break
ans = 1
for a in A:ans*=a
print((ans%m)) | N = int(eval(input()))
mod = pow(10,9)+7
A = [1]*(N+1)
for i in range(1,N+1):
n = i
for j in range(2,i+1):
if j>n:break
while n%j==0:
A[j]+=1
n//=j
cnt = 1
for i in range(N+1):
cnt *= A[i]
print((cnt%mod)) | p03830 |
from math import factorial
n = int(eval(input()))
m = factorial(n)
s = 2
ans = 1
while m != 1:
c = 1
while m % s == 0:
c += 1
m = m // s
ans *= c
s += 1
print((ans % (10**9+7))) | from math import factorial
n = int(eval(input()))
m = factorial(n)
s = 2
ans = 1
while m > 1:
c = 1
while m % s == 0:
c += 1
m = m // s
ans *= c
s += 1
print((ans % (10**9+7))) | p03830 |
n = int(eval(input()))
l = [1,2,4,8,16,30,60,96,160,270,540,792,1584,2592,4032,5376,10752,14688,29376,41040,60800,96000,192000,242880,340032,532224,677376,917280,1834560,2332800,4665600,5529600,7864320,12165120,16422912,19595520,39191040,60466176,85100544,102435840,204871680,258048000,516096000,677376000,819624960,258709753,517419506,876670706,698576619,464046052,210846678,87039944,174079888,559756674,984916319,217548604,16857327,609087587,218175167,106431041,212862082,535421074,139926156,50952999,105219839,195900610,391801220,889436190,472974756,845412639,690825271,891132264,782264521,316684054,31280490,665186745,252135966,764748573,529497139,790600338,524719291,999573608,999147209,522112609,37861883,417241520,775916997,997830958,995661909,729407917,321723976,871170030,520705814,149385219,41956001,988486370,976972733,516785610,158924226,583951250,167902493,687346296,374692585,229757313,549263416,890796057,781592107,875619122,751238237,277966376,130571620,574892396,149784785,921692445,813661707,582700142,400726352,358621292,318642155,250091916,386472265,174406757,151737975,260683867,184202887,320817301,641634602,125034947,201660251,962210566,924421125,489345615,320577061,637208078,196761361,626955546,253911085,389481998,778963996,576273102,309075370,619146484,295106277,464103226,498550267,627180822,788686761,989134263,978268519,902509248,805018489,112903872,32995287,295406792,974343106,721660051,443320095,316385239,778274799,190780502,633014225,727670045,455340083,498164792,15588548,97601235,195202470,569355054,118486597,342752204,135661810,90769804,181539608,519303442,515842850,84989549,696032419,231083385,462166770,150280772,300561544,884472740,641985713,569378318,591770736,690140664,249252882,677627271,850771381,851099110,702198213,111350575,222701150,859360900,670197303,177520684,355041368,643925245,287850483,323688011,476804260,749121574,436195097,100916105,763521317,852472431,566135419,817481112,609114726,316546467,633092934,400461490,516478899,802348580,904410955,621677199,257318500,176522245,676814987,463688019,296329114,264099706,528199412,36178948,424547801,768068647,536137287,180929498,361858996,212858280,424867383,432882564,865765128,720594700,90410365,461821767,203725504,114020002,228040004,637601848,275203689,996048794,816392758,827385828,501246906,502796187,283931071,433357175,368415063,694773670,389547333,672209469,929924926,339805954,823423911,430631131,861262262,912999218,775754185,248442642,92860619,47164638,94329276,560810218,901787221,979102645,727649351,20618968,41237936,409407748,818815496,105871481,565828513,733793480,775394695,826327221,652654435,644963335,70964339,34934197,69868394,21321430,42642860,308165968,66236679,863975191,474703946,965050168,372703124,98935522,622346998,724308287,448616567,387250563,521154852,757291985,756807708,98256492,802531326,949720885,885971876,131412209,981761360,661149918,619958299,331028217,662056434,807561987,320675293,914129701,828259395,37073206,74146412,402841690,54637455,617124544,234249081,751443813,937109749,192721498,402972372,453564416,21903965,219196964,711481873,513083746,252120578,510728243,686346634,854955589,709911171,78596230,269965951,409219288,248271231,873383775,746767543,509852147,174891499,984879786,197881406,237525166,359571994,592280493,443047391,387927598,775855196,487579371,975158742,351882153,147029129,237093507,474187014,233169083,703708683,126101010,198878663,367151757,734303514,558855498,196629758,161317030,573722496,327882255,869789706,71204994,142409988,519330677,658916599,820221123,589765049,882787662,765575317,237538730,765336752,111906311,970555905,547616857,95233707,919602856,913510209,325919347,651838694,787773019,168803670,875276542,263468393,816727867,633455727,500272724,140006678,171663917,920917448,754148927,547298078,412984678,825969356,89434825,653930388,136393590,272787180,276924235,570666519,590968903,696916544,114558109,209914977,987646996,975293985,732105167,207549775,590764498,239710087,413342719,606756472,119222007,227695505,450857281,901714562,192653364,385306728,234022344,31755833,752787939,682129837,972238124,563737250,589527825,729854221,873389836,746779665,973964734,947929461,5202400,320558679,402562062,651932087,438747311,877494622,851938578,595655182,953260474,906520941,610950283,501334286,115901200,458267670,725708035,451416063,34629651,443595068,292992687,984336996,352845142,600659252,738086132,476172257,146298687,742115388,685981689,371963371,5238701,10477402,766426619,741060152,215953758,431907516,900346034,302070357,669584758,46053147,500531147,269366731,835955289,753764439,748101695,586666665,340467085,680934170,993066655,337509515,702294178,689317659,610110893,855932510,718959729,437919451,162052266,591444463,937285062,874570117,577640930,690830665,441136051,234385594,995953016,490091986,701529803,403059599,173749087,571309264,670816347,341632687,12414678,656616799,110230917,555093018,326641735,653283470,841517232,299713801,790165940,55645384,857068605,957840454,891206655,734604192,144312526,317679024,396371648,792743296,423188008,846376016,985116058,646955723,952177710,502929334,92150358,447989522,924790847,549384151,424045976,984526166,194912796,17485470,655375515,480905089,910910739,771660846,177055119,354110238,487461754,533406064,889925808,672895377,471803466,943606932,363992147,457850989,337082821,559633947,903886732,428980584,430095367,52327251,636880607,273761207,706305042,890884144,393016175,748347757,949802139,899604271,310566618,130756774,816805638,605028078,169610267,339220534,575779053,151558099,779861186,564602992,437157814,502964081,478103459,956206918,385872385,383885002,125139522,606176173,727381953,8385703,189534611,657264353,809755457,619510907,607320752,922420555,310951652,461684174,548921957,97843907,729671781,620980721,857109915,25052446,275170024,550340048,495401987,990803974,362448559,60904426,929227965,120741193,257409647,514819294,969108899,560048584,985073824,700527244,680852420,361704833,819310219,589014097,1398831,2797662,533149213,66298419,177289968,605590036,607911651,709970869,953992856,619456719,655319030,644362951,232480867,745680583,590594926,181189845,520817003,742434671,899661005,364907082,733053610,13738009,433804341,236387921,508481622,16963237,232316619,464633238,221314587,887788178,285824818,571649636,737224462,55447552,88454246,798654422,982084080,964168153,247453861,1833862,99268162,659694667,466104507,932209014,864422567,728845127,537854091,599199290,264178678,250863989,574407941,732405085,314042625,489474931,176295562,914244677,852693813,705387619,193242738,892738773,352048555,704097110,771025308,753975129,927527314,542054326,2994361,5988722,142029115,324378674,100232612,267369886,945624300,882384522,416443431,832886862,784668659,985124309,298874953,102595581,589967510,536599545,782218536,77865166,65277123,130554246,660510295,877005583,275946488,615306711,199915845,893431699,154588775,309177550,504746854,864753530,291783330,553114672,78102633,511352330,753667006,152737422,966787467,933574927,743434691,300957143,206901132,971318792,551792353,641951914,887092590,774185173,324319767,296313969,419748261,736668708,125202855,250405710,860306792,120041519,287948500,772974185,72505984,145011968,197340762,319569601,29058411,58116822,503961279,97170670,855412437,719283733,922189282,610817142,981054324,962108641,555626129,721425306,8695797,867937276,204728691,409457382,327387384,796008217,623487493,246974979,808073302,987531151,661621379,619686012,885900428,182865420,604993928,209987849,112149920,982821831,436804698,873609396,249429664,35442337,542946067,435717873,357909594,663354277,349837771,172902187,725024195,626724406,951883201,898886813,611894793,223789579,156249711,953762374,941520348,627312415,732152146,626637375,697801379,928373167,467201812,934403624,300174312,940164327,768557112,666818604,430052749,769678528,637336196,471510530,884736131,405930623,88523589,177047178,741193266,482386525,959636069,420122608,870743513,206500587,931686480,949884867,256838150,936095622,169293108,338586216,20108011,40216022,515421399,752804022,39087839,78175678,170102,340204,946184524,167781729,835787762,903545720,642497069,768924002,848555995,948817436,408127979,816255958,800214847,62298624,211839153,598162116,649248474,550398359,199342730,466361673,327607418,129788111,60519012,181516929,291695327,583390654,933077030,384594463,248685267,497370534,574889090,149778173,508531933,813332884,744233240,488466473,623778584,4368568,996107508,578055173,827804465,735970254,633530545,296440400,68756126,969743180,876576330,723047882,284529056,569058112,955600472,546169433,803429308,606858609,391311257,782622514,544679226,242364688,879318989,758637971,578342645,882174629,300235757,203149792,186638455,197248609,4796039,513889283,888015602,188499605,180716688,503135262,412392718,986465265,744612799,335327753,188776829,910205676,736820167,473640327,438152515,953148782,574653619,149307231,898195178,851342559,30893933,76564644,524487579,530536325,132326487,264652974,436939730,343683655,215324089,564898148,437093697,270599954,464012989,329405798,476278405,952556810,152525842,639543549,539816971,508927499,355269900,826589616,330452844,660905688,53392193,5534060,69632488,139264976,254644395,744092152,539703029,555053484,899170215,798340423,422351818,444892614,151256959,504363114,893778023,787556039,802071847,381737209,85245710,493128509,945208231,475863350,279284954,813432374,905487747,730092313,198445481,573858992,640307357,280614707,780620191,211244466,611704170,223408333,494598748,968788563,176505672,286582450,993252097,986504187,529362547,560946912,386341399,989315317,14725758,29451516,215685422,95948827,463209666,847826556,571585155,357027634,71359521,142719042,128278247,45877819,700894880,39614801,668371163,336742319,338115610,570799830,972926972]
print((l[n-1])) | l = [0,1,2,4,8,16,30,60,96,160,270,540,792,1584,2592,4032,5376,10752,14688,29376,41040,60800,96000,192000,242880,340032,532224,677376,917280,1834560,2332800,4665600,5529600,7864320,12165120,16422912,19595520,39191040,60466176,85100544,102435840,204871680,258048000,516096000,677376000,819624960,258709753,517419506,876670706,698576619,464046052,210846678,87039944,174079888,559756674,984916319,217548604,16857327,609087587,218175167,106431041,212862082,535421074,139926156,50952999,105219839,195900610,391801220,889436190,472974756,845412639,690825271,891132264,782264521,316684054,31280490,665186745,252135966,764748573,529497139,790600338,524719291,999573608,999147209,522112609,37861883,417241520,775916997,997830958,995661909,729407917,321723976,871170030,520705814,149385219,41956001,988486370,976972733,516785610,158924226,583951250,167902493,687346296,374692585,229757313,549263416,890796057,781592107,875619122,751238237,277966376,130571620,574892396,149784785,921692445,813661707,582700142,400726352,358621292,318642155,250091916,386472265,174406757,151737975,260683867,184202887,320817301,641634602,125034947,201660251,962210566,924421125,489345615,320577061,637208078,196761361,626955546,253911085,389481998,778963996,576273102,309075370,619146484,295106277,464103226,498550267,627180822,788686761,989134263,978268519,902509248,805018489,112903872,32995287,295406792,974343106,721660051,443320095,316385239,778274799,190780502,633014225,727670045,455340083,498164792,15588548,97601235,195202470,569355054,118486597,342752204,135661810,90769804,181539608,519303442,515842850,84989549,696032419,231083385,462166770,150280772,300561544,884472740,641985713,569378318,591770736,690140664,249252882,677627271,850771381,851099110,702198213,111350575,222701150,859360900,670197303,177520684,355041368,643925245,287850483,323688011,476804260,749121574,436195097,100916105,763521317,852472431,566135419,817481112,609114726,316546467,633092934,400461490,516478899,802348580,904410955,621677199,257318500,176522245,676814987,463688019,296329114,264099706,528199412,36178948,424547801,768068647,536137287,180929498,361858996,212858280,424867383,432882564,865765128,720594700,90410365,461821767,203725504,114020002,228040004,637601848,275203689,996048794,816392758,827385828,501246906,502796187,283931071,433357175,368415063,694773670,389547333,672209469,929924926,339805954,823423911,430631131,861262262,912999218,775754185,248442642,92860619,47164638,94329276,560810218,901787221,979102645,727649351,20618968,41237936,409407748,818815496,105871481,565828513,733793480,775394695,826327221,652654435,644963335,70964339,34934197,69868394,21321430,42642860,308165968,66236679,863975191,474703946,965050168,372703124,98935522,622346998,724308287,448616567,387250563,521154852,757291985,756807708,98256492,802531326,949720885,885971876,131412209,981761360,661149918,619958299,331028217,662056434,807561987,320675293,914129701,828259395,37073206,74146412,402841690,54637455,617124544,234249081,751443813,937109749,192721498,402972372,453564416,21903965,219196964,711481873,513083746,252120578,510728243,686346634,854955589,709911171,78596230,269965951,409219288,248271231,873383775,746767543,509852147,174891499,984879786,197881406,237525166,359571994,592280493,443047391,387927598,775855196,487579371,975158742,351882153,147029129,237093507,474187014,233169083,703708683,126101010,198878663,367151757,734303514,558855498,196629758,161317030,573722496,327882255,869789706,71204994,142409988,519330677,658916599,820221123,589765049,882787662,765575317,237538730,765336752,111906311,970555905,547616857,95233707,919602856,913510209,325919347,651838694,787773019,168803670,875276542,263468393,816727867,633455727,500272724,140006678,171663917,920917448,754148927,547298078,412984678,825969356,89434825,653930388,136393590,272787180,276924235,570666519,590968903,696916544,114558109,209914977,987646996,975293985,732105167,207549775,590764498,239710087,413342719,606756472,119222007,227695505,450857281,901714562,192653364,385306728,234022344,31755833,752787939,682129837,972238124,563737250,589527825,729854221,873389836,746779665,973964734,947929461,5202400,320558679,402562062,651932087,438747311,877494622,851938578,595655182,953260474,906520941,610950283,501334286,115901200,458267670,725708035,451416063,34629651,443595068,292992687,984336996,352845142,600659252,738086132,476172257,146298687,742115388,685981689,371963371,5238701,10477402,766426619,741060152,215953758,431907516,900346034,302070357,669584758,46053147,500531147,269366731,835955289,753764439,748101695,586666665,340467085,680934170,993066655,337509515,702294178,689317659,610110893,855932510,718959729,437919451,162052266,591444463,937285062,874570117,577640930,690830665,441136051,234385594,995953016,490091986,701529803,403059599,173749087,571309264,670816347,341632687,12414678,656616799,110230917,555093018,326641735,653283470,841517232,299713801,790165940,55645384,857068605,957840454,891206655,734604192,144312526,317679024,396371648,792743296,423188008,846376016,985116058,646955723,952177710,502929334,92150358,447989522,924790847,549384151,424045976,984526166,194912796,17485470,655375515,480905089,910910739,771660846,177055119,354110238,487461754,533406064,889925808,672895377,471803466,943606932,363992147,457850989,337082821,559633947,903886732,428980584,430095367,52327251,636880607,273761207,706305042,890884144,393016175,748347757,949802139,899604271,310566618,130756774,816805638,605028078,169610267,339220534,575779053,151558099,779861186,564602992,437157814,502964081,478103459,956206918,385872385,383885002,125139522,606176173,727381953,8385703,189534611,657264353,809755457,619510907,607320752,922420555,310951652,461684174,548921957,97843907,729671781,620980721,857109915,25052446,275170024,550340048,495401987,990803974,362448559,60904426,929227965,120741193,257409647,514819294,969108899,560048584,985073824,700527244,680852420,361704833,819310219,589014097,1398831,2797662,533149213,66298419,177289968,605590036,607911651,709970869,953992856,619456719,655319030,644362951,232480867,745680583,590594926,181189845,520817003,742434671,899661005,364907082,733053610,13738009,433804341,236387921,508481622,16963237,232316619,464633238,221314587,887788178,285824818,571649636,737224462,55447552,88454246,798654422,982084080,964168153,247453861,1833862,99268162,659694667,466104507,932209014,864422567,728845127,537854091,599199290,264178678,250863989,574407941,732405085,314042625,489474931,176295562,914244677,852693813,705387619,193242738,892738773,352048555,704097110,771025308,753975129,927527314,542054326,2994361,5988722,142029115,324378674,100232612,267369886,945624300,882384522,416443431,832886862,784668659,985124309,298874953,102595581,589967510,536599545,782218536,77865166,65277123,130554246,660510295,877005583,275946488,615306711,199915845,893431699,154588775,309177550,504746854,864753530,291783330,553114672,78102633,511352330,753667006,152737422,966787467,933574927,743434691,300957143,206901132,971318792,551792353,641951914,887092590,774185173,324319767,296313969,419748261,736668708,125202855,250405710,860306792,120041519,287948500,772974185,72505984,145011968,197340762,319569601,29058411,58116822,503961279,97170670,855412437,719283733,922189282,610817142,981054324,962108641,555626129,721425306,8695797,867937276,204728691,409457382,327387384,796008217,623487493,246974979,808073302,987531151,661621379,619686012,885900428,182865420,604993928,209987849,112149920,982821831,436804698,873609396,249429664,35442337,542946067,435717873,357909594,663354277,349837771,172902187,725024195,626724406,951883201,898886813,611894793,223789579,156249711,953762374,941520348,627312415,732152146,626637375,697801379,928373167,467201812,934403624,300174312,940164327,768557112,666818604,430052749,769678528,637336196,471510530,884736131,405930623,88523589,177047178,741193266,482386525,959636069,420122608,870743513,206500587,931686480,949884867,256838150,936095622,169293108,338586216,20108011,40216022,515421399,752804022,39087839,78175678,170102,340204,946184524,167781729,835787762,903545720,642497069,768924002,848555995,948817436,408127979,816255958,800214847,62298624,211839153,598162116,649248474,550398359,199342730,466361673,327607418,129788111,60519012,181516929,291695327,583390654,933077030,384594463,248685267,497370534,574889090,149778173,508531933,813332884,744233240,488466473,623778584,4368568,996107508,578055173,827804465,735970254,633530545,296440400,68756126,969743180,876576330,723047882,284529056,569058112,955600472,546169433,803429308,606858609,391311257,782622514,544679226,242364688,879318989,758637971,578342645,882174629,300235757,203149792,186638455,197248609,4796039,513889283,888015602,188499605,180716688,503135262,412392718,986465265,744612799,335327753,188776829,910205676,736820167,473640327,438152515,953148782,574653619,149307231,898195178,851342559,30893933,76564644,524487579,530536325,132326487,264652974,436939730,343683655,215324089,564898148,437093697,270599954,464012989,329405798,476278405,952556810,152525842,639543549,539816971,508927499,355269900,826589616,330452844,660905688,53392193,5534060,69632488,139264976,254644395,744092152,539703029,555053484,899170215,798340423,422351818,444892614,151256959,504363114,893778023,787556039,802071847,381737209,85245710,493128509,945208231,475863350,279284954,813432374,905487747,730092313,198445481,573858992,640307357,280614707,780620191,211244466,611704170,223408333,494598748,968788563,176505672,286582450,993252097,986504187,529362547,560946912,386341399,989315317,14725758,29451516,215685422,95948827,463209666,847826556,571585155,357027634,71359521,142719042,128278247,45877819,700894880,39614801,668371163,336742319,338115610,570799830,972926972]
print((l[int(eval(input()))])) | p03830 |
MOD = 10 ** 9 + 7
n = int(eval(input()))
res = 1
ex = [0 for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(2, i + 1):
if i % j == 0:
while i % j == 0:
ex[j] += 1
i //= j
ans = 1
for i in range(n + 1):
ans *= (ex[i] + 1)
ans %= MOD
print(ans)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def prime_factorization(n):
res = []
for i in range(2, int(pow(n, 0.5)) + 1):
if n % i == 0:
ex = 0
while n % i == 0:
ex += 1
n //= i
res.append([i, ex])
if n != 1:
res.append([n, 1])
return res
def resolve():
n = int(eval(input()))
P = [0] * 1000
for i in range(1, n + 1):
t = prime_factorization(i)
for num, ex in t:
P[num] += ex
res = 1
for p in P:
res *= p + 1
res % mod
print((res % mod))
if __name__ == '__main__':
resolve()
| p03830 |
a = [True] * 1001
a[0] = False
a[1] = False
b = []
c = {}
for i in range(2, 1001):
if a[i]:
b.append(i)
for j in range(2, 1001, 2):
a[j] = False
d = int(eval(input()))
for j in range(2, d + 1):
temp_j = j
for i in b:
while True:
if temp_j % i != 0:
break
else:
if i not in c:
c[i] = 1
else:
c[i] += 1
temp_j //= i
e = 1
for k in list(c.keys()):
e = (e * (c[k] + 1)) % (10 ** 9 + 7)
print(e)
| z = int(eval(input()))
a = [True] * 1001
a[0] = False
a[1] = False
b = []
for i in range(2, 1001):
if a[i]:
b.append(i)
for j in range(i, 1001, i):
a[j] = False
c = {}
for i in range(1, z + 1):
d = i
while True:
if d == 1:
break
else:
while d != 1:
for j in b:
if d % j == 0:
d //= j
if j not in c:
c[j] = 1
else:
c[j] += 1
e = 1
for v in list(c.values()):
e = (e * (v + 1)) % (10 ** 9 + 7)
print(e)
| p03830 |
import collections
def e(N):
res = []
x = N
y = 2
while y*y <= x:
while x % y == 0:
res.append(y)
x //= y
y += 1
if x > 1:
res.append(x)
return res
MOD = 10**9 + 7
n = int(eval(input()))
chk = [0 for i in range(n+1)]
for i in range(2, n+1):
tmp = collections.Counter(e(i))
for j in tmp:
chk[j] += tmp[j]
ans = 1
for i in chk:
if i:
ans = ans*(i + 1)%MOD
print(ans) | MOD = 10**9 + 7
n = int(eval(input()))
chk = [0 for i in range(n+1)]
for i in range(2, n+1):
y = 2
while y*y <= i:
while i % y == 0:
chk[y] += 1
i //= y
y += 1
if i > 1:
chk[i] += 1
ans = 1
for i in chk:
if i:
ans = ans*(i + 1)%MOD
print(ans) | p03830 |
n=int(eval(input()));a=1;r=range
for x in[i for i in r(2,n+1)if all(i%j for j in r(2,i))]:a*=sum(n//x**i for i in r(1,11))+1
print((a%(10**9+7))) | n=int(eval(input()));a=1;r=range
for x in[i for i in r(2,n+1)if all(i%j for j in r(2,int(i**.5)+1))]:a*=sum(n//x**i for i in r(1,11))+1;a%=10**9+7
print(a) | p03830 |
import math
N = int(eval(input()))
ans=1
x = math.factorial(N)
for i in range(1, x//2+1):
if x%i == 0:
ans += 1
print((ans%(10**9+7))) | import math
N = int(eval(input()))
x = math.factorial(N)
ans = 1
i = 2
while i <= x:
cnt = 1
while x%i == 0:
x //= i
cnt += 1
ans *= cnt
i += 1
print((ans%(10**9+7))) | p03830 |
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
import math
N = int(eval(input()))
l = math.factorial(N)
t = make_divisors(l)
print((len(t)%(10**9+7)))
| N= int(eval(input()))
m = 10**9+7
pri_num = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
dic = {}
for i in range(2,N+1):
for pri in pri_num:
while i>0:
if i % pri == 0:
if pri in dic:
dic[pri] +=1
else:
dic[pri]=1
i = i//pri
else:
break
count = 1
for val in list(dic.values()):
count = (count*(val+1))%m
print(count)
| p03830 |
N= int(eval(input()))
m = 10**9+7
pri_num = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
dic = {}
for i in range(2,N+1):
for pri in pri_num:
while i>0:
if i % pri == 0:
if pri in dic:
dic[pri] +=1
else:
dic[pri]=1
i = i//pri
else:
break
count = 1
for val in list(dic.values()):
count = (count*(val+1))%m
print(count)
| def prime_number(n):
lis= []
for i in range(2,n+1):
j = 2
flag = 0
while j*j <= i:
if i%j ==0:
flag = 1
break
else:
j +=1
if flag ==0:
lis.append(i)
return lis
N= int(eval(input()))
m = 10**9+7
pri_num = prime_number(N)
dic = {}
for i in range(2,N+1):
for pri in pri_num:
while i>0:
if i % pri == 0:
if pri in dic:
dic[pri] +=1
else:
dic[pri]=1
i = i//pri
else:
break
count = 1
for val in list(dic.values()):
count = (count*(val+1))%m
print(count)
| p03830 |
import math
mod = 10 ** 9 + 7
def f(num):
i = 2
d = dict()
while i * i <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i+1
print((ans%mod)) | import math
mod = 10 ** 9 + 7
def f(num):
i = 2
d = dict()
while i ** 2 <= num:
if num % i == 0:
num //= i
d[i] = d.get(i, 0) + 1
else:
i += 1
d[num] = 1
return d
n = int(eval(input()))
if n == 1:
print((1))
exit()
ans = 1
for i in list(f(math.factorial(n)).values()):
ans *= i+1
print((ans%mod)) | p03830 |
from math import factorial
N = factorial(int(eval(input())))
i = 2
ans = dict()
n = N
while i*i <= N:
while n%i ==0:
n = n//i
if i in ans:
ans[i] += 1
else:
ans[i] = 1
i += 1
if n != 1:
ans[n] = 1
cnt = 1
for value in list(ans.values()):
cnt *= value + 1
M = 10**9 + 7
print((cnt%M)) | from math import factorial
N = factorial(int(eval(input())))
mod = 10**9 + 7
ans = 1
i = 2
while i*i <= N:
cnt = 1
while N%i == 0:
cnt += 1
N //= i
ans *= cnt
i += 1
if N != 1:
ans *= 2
print((int(ans%mod)))
| p03830 |
n=int(eval(input()))
k=1
ans=0
for i in range (n):
k=k*(i+1)
for j in range(k):
if k%(j+1)==0:
ans+=1
print((ans%1000000007))
| n=int(eval(input()))
l=[k for k in range(1,n+1)]
phrase=[]
ans=1
a=1
def prime(x):
i=2
while i*i<=x:
if x%i==0:
return False
i+=1
return True
for i in range(2,n+1):
if prime(i):
phrase.append(i)
for j in phrase:
for m in range(n):
while l[m]%j==0:
a+=1
l[m]=l[m]/j
ans=ans*a
a=1
print((ans%1000000007)) | p03830 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n = int(eval(input()))
MOD = 10 ** 9 + 7
factorial = [0] * (n+1)
factorial[0] = 1
for i in range(1, n+1):
factorial[i] = factorial[i-1] * i
prime_factors = []
target = factorial[n]
i = 2
while i ** 2 <= target:
if target % i != 0:
i += 1
continue
ext = 0
while target % i == 0:
ext += 1
target //= i
prime_factors.append((i, ext))
i += 1
if target != 1:
prime_factors.append((target, 1))
ans = 1
for pf in prime_factors:
ans = (ans * (pf[1] + 1)) % MOD
print(ans)
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
n = int(eval(input()))
MOD = 10 ** 9 + 7
factorial = [0] * (n+1)
factorial[0] = 1
for i in range(1, n+1):
factorial[i] = (factorial[i-1] * i)
n = factorial[n]
prime_factors = []
i = 2
while i ** 2 <= n:
ext = 0
while n % i == 0:
ext += 1
n //= i
if ext:
prime_factors.append((i, ext))
i += 1
if n != 1:
prime_factors.append((n, 1))
ans = 1
for pf, num in prime_factors:
ans = (ans * (num + 1)) % MOD
print(ans)
| p03830 |
import math
import collections
N = int(eval(input()))
a = math.factorial(N)
b = []
while a % 2 == 0:
b.append(2)
a//=2
f = 3
while f*f <= a:
if a % f ==0:
b.append(f)
a //= f
else:
f += 2
if a != 1:
b.append(a)
c = collections.Counter(b)
ans = 1
for j,k in list(c.items()):
ans *= (k+1)
print((ans%(10**9+7))) | import math
N=math.factorial(int(eval(input())))
i=2
ans=1
M=10**9+7
while i*i<=N:
cnt=1
while N%i==0:
cnt+=1
N//=i
ans*=cnt
i+=1
if N!=1:ans*=2
print((int(ans%M))) | p03830 |
L = list(input().split())
val = 0
for i in range(len(L)-1):
if L[i][-1] != L[i+1][0]:
print("NO")
quit()
print("YES")
| L = list(input().split())
val = 0
for i in range(len(L)-1):
if L[i][-1] != L[i+1][0]:
print("NO")
break
else:
print("YES")
| p03729 |
a,b,c = input().split()
print(('YES' if a[-1]==b[0] and b[-1]==c[0] else 'NO'))
| a,b,c=list(map(str,input().split()))
print(('YES' if a[-1]==b[0] and b[-1]==c[0] else 'NO')) | p03729 |
A,B,C=input().split()
print(("YES" if A[-1]==B[0]and B[-1]==C[0] else "NO")) | A, B, C = input().split()
if A[-1] == B[0] and B[-1] == C[0]:
print("YES")
else:
print("NO") | p03729 |
s = input().split()
a, b, c = s[0], s[1], s[2]
if b.startswith(a[-1:]) and c.startswith(b[-1:]):
print("YES")
else:
print("NO") | a, b, c = input().split()
if a[-1:] == b[:1] and b[-1:] == c[:1]:
print("YES")
else:
print("NO") | p03729 |
a, b, c = input().split()
if a[len(a)-1] == b[0] and b[len(b)-1] == c[0]:
print("YES")
else:
print("NO") | a, b, c = input().split()
print(("YES" if a[-1] == b[0] and b[-1] == c[0] else "NO")) | p03729 |
a,b,c=input().split()
print(("YES" if a[-1]==b[0] and b[-1]==c[0] else "NO")) | A, B, C = input().split()
print(("YES" if A[-1] == B[0] and B[-1] == C[0] else "NO")) | p03729 |
A, B, C = input().split()
if A[-1] == B[0] and B[-1] == C[0]:
print('YES')
else:
print('NO')
| A, B, C = input().split()
def answer(A: int, B: int, C: int) -> str:
if A[-1] == B[0] and B[-1] == C[0]:
return 'YES'
else:
return 'NO'
print((answer(A, B, C)))
| p03729 |
a,b,c = input().split(' ')
print(('YES' if a[len(a)-1] == b[0] and b[len(b)-1] == c[0] else 'NO')) | a,b,c = input().split(' ')
print(('YES' if a[-1] == b[0] and b[-1] == c[0] else 'NO')) | p03729 |
a,b,c=input().split();print(('YNEOS'[a[::-1][0]!=b[0]or b[::-1][0]!=c[0]::2])) | a,b,c=input().split();print(('YNEOS'[a[-1]!=b[0]or b[-1]!=c[0]::2])) | p03729 |
a, b, c = input().split()
if a[-1] == b[0] and b[-1] == c[0]:
print("YES")
else:
print("NO") | a, b, c = list(map(str, input().split()))
print(("YES" if a[-1] == b[0] and b[-1] == c[0] else "NO")) | p03729 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
1000000
output:
400000
"""
import sys
import math
def is_prime(n):
if n == 2:
return True
elif n < 2 or not n % 2:
return False
k = 3
while k <= math.sqrt(n):
if not n % k:
return False
k += 2
return True
def phi(n):
y = n
for k in range(2, n + 1):
if not n % k and is_prime(k):
y -= y / k
return int(y)
if __name__ == '__main__':
_input = sys.stdin.readlines()
n1 = int(_input[0])
print((phi(n1))) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
1000000
output:
400000
"""
import sys
def soi(n):
k = 2
while True:
if pow(k, 2) > n:
return n
if n % k == 0:
return k
k += 1
def phi(n):
ans = n
while True:
tmp = soi(n)
# print(tmp)
if n == 1:
break
while n % tmp == 0:
n //= tmp
ans *= (1 - 1 / tmp)
return int(ans)
if __name__ == '__main__':
_input = sys.stdin.readlines()
n1 = int(_input[0])
print((phi(n1))) | p02470 |
n=m=int(eval(input()))
i=2
while i<=n and m!=1:
if m%i==0:
n=n*(i-1)//i
while m%i==0: m//=i
i+=1
print(n) | n=m=int(eval(input()))
i=2
while i*i<=n:
if n%i==0:
m=m//i*(i-1)
while n%i==0: n//=i
i+=1
if n!=1:m=m//n*(n-1)
print(m) | p02470 |
a=int(eval(input()))
li=[0]*10000000
count=1
i=2 # ??????????????°
while i<a:
r=0
ta=a
b=i
if li[i]!=1:
while True:
r=ta%b
if r==0:
break
ta=b
b=r
if b==1:
count+=1
else:
temp=i
l=2
while True:
li[temp*l]=1
l+=1
if temp*l>a:
break
i+=1
print(count) | def soi(n): #?´??????°????§£?????¢?????´?????????
i=2
while True:
if i*i>n:
return n
if n%i==0:
return i
i+=1
a=int(eval(input()))
ans=a
count=1
i=2 # ??????????????°
while True:
temp=soi(a)
if a==1: #?´??????°??????????????°
break
while a%temp==0: #?´??????°??§???????¶???????
a/=temp
# print (a)
ans*=(1-1/temp)
#print (ans)
print((int(ans)))
def gcd(a,b): #?????§??¬?´???°???????????°??????
r=0
while True:
r=a%b
if r==0:
break
a=b
b=r
return b | p02470 |
f=lambda x:p*(x-1)//x
p=n=int(eval(input()))
d=2
while d*d<=n:
if n%d==0:
p=f(d)
while n%d==0:n//=d
d+=1
if n>1:p=f(n)
print(p)
| p=n=int(eval(input()))
d=2
while d*d<=n:
if n%d==0:
p=p*(d-1)//d
while n%d==0:n//=d
d+=1
print(([p,p*(n-1)//n][n>1]))
| p02470 |
import sys
def gcd(a,b):
if(b == 0):
return a
else:
c = b
b = a%b
a = c
return(gcd(a,b))
x = int(eval(input()))
count = 0
for y in range(1,x+1):
if gcd(x,y) == 1:
count+=1
print(count) | import sys
def euler(a):
i = 2
res = a
#standard = a
while i * i <= a:
if a % i == 0:
res = res - res//i
while a % i == 0:
a //= i
i += 1
if a != 1:
res = res - res//a
return res
x = int(eval(input()))
print((euler(x))) | p02470 |
input = int(eval(input()))
buf = input
result = 1
for i in range(2,input+1):
if buf%i==0:
result *= (1 - 1/i)
while buf%i==0:
buf /= i
result *= input
print((int(result))) | def phi(n):
r = n
i = 2
while i*i <= n:
if n%i==0:
r -= r/i
while n%i==0:
n /= i
i += 1
if n>1: r-= r/n
return r
n = int(eval(input()))
print((int(phi(n)))) | p02470 |
while 1:
n,m = list(map(int,input().split()))
if n == 0: break
EBY = [input().split() for i in range(n)]
EBY = [[e,int(b),int(y)] for e,b,y in EBY]
for i in range(m):
year = int(input())
for j in range(n):
if EBY[j][2]-EBY[j][1] < year <= EBY[j][2]:
print(EBY[j][0], year-EBY[j][2]+EBY[j][1])
break
else:
print("Unknown") | while 1:
n,m = list(map(int,input().split()))
if n == 0: break
EBY = [input().split() for i in range(n)]
EBY = [[e,int(y)-int(b),int(y)] for e,b,y in EBY]
for i in range(m):
year = int(input())
for j in range(n):
if EBY[j][1] < year <= EBY[j][2]:
print(EBY[j][0], year-EBY[j][1])
break
else:
print("Unknown") | p01359 |
from math import floor,ceil
def f(b,n):
if n < b:
return n
else:
return f(b,floor(n/b))+n%b
n = int(eval(input()))
s = int(eval(input()))
for b in range(2,320000):
if f(b,n)==s:
print(b)
exit()
if n==s:
print((s+1))
exit()
d = {}
for i in range(1,ceil(n**0.5)):
m = f(n//i,n)
if n//i==n//(i+1):
d[i] = (m,m)
else:
M = f(n//(i+1)+1,n)
d[i] = (m,M)
for i in range(ceil(n**0.5)-1,0,-1):
m,M = d[i]
if m<=s<=M and (s-m)%i==0:
print((n//i-(s-m)//i))
exit()
print((-1)) | def f(b,n):
if n < b:
return n
else:
return f(b,n//b)+n%b
def get_divisor(n):
res = []
for i in range(1,int(n**0.5)+1):
if n%i==0:
res.append(i)
res.append(n//i)
res = list(set(res))
res.sort()
return res
n = int(eval(input()))
s = int(eval(input()))
ans = -1
for b in range(2,int(n**0.5)+1):
if f(b,n)==s:
ans = b
break
if ans==-1 and n>=s:
div = get_divisor(n-s)
div.append(n)
for b in div:
b += 1
if f(b,n)==s:
ans = b
break
print(ans) | p04014 |
N = int(eval(input()))
S = int(eval(input()))
def f(b,n):
if n//b==0:
return n
else:
return n%b + f(b,n//b)
ans = -1
if S==N:
ans = N+1
else:
for b in range(2,int(N**.5)+1):
if f(b,N)==S:
ans = b
break
if ans == -1:
for i in range(int(N**.5)+1,0,-1):
b = (N-S)//i + 1
if b>1:
if f(b,N)==S:
ans = b
break
print(ans) | # python3 (3.4.3)
import sys
input = sys.stdin.readline
# main
N = int(eval(input()))
S = int(eval(input()))
def f(b,n):
if n < b:
return n
else:
return f(b, n//b) + n%b
ans = -1
if S==N:
ans = N+1
else:
# bをN^(1/2)まで全探索
for b in range(2, int(N**.5)+1):
if f(b,N)==S:
ans = b
break
# まだ答えが見つからなければ
if ans == -1:
# bがN^(1/2)より大きい可能性が残っており、b進数で表すと2桁
# 1 <= p < b, N = pb+q <= pb < p^2, p > N^(1/2) なので pで全探索
# p+q = S より b = (N-S)/p+1
for p in range(int(N**.5)+1,0,-1):
b = (N-S)//p + 1
# bが1のときは対象外にしないと無限ループ！
if b >= 2 and f(b,N)==S:
ans = b
break
print(ans)
| p04014 |
import math
import sys
n = int(eval(input()))
s = int(eval(input()))
def f(b, n):
if n == 0:
return 0
return f(b, n//b) + n % b
if s > n:
print((-1))
sys.exit(0)
sn = math.ceil(math.sqrt(n))
for i in range(2, sn+1):
if f(i, n) == s:
print(i)
sys.exit(0)
ans = n + 1
for i in range(1, sn+1):
if (n - s) % i == 0:
b = (n-s)//i + 1
if b >= 2 and f(b, b * i + n%b) == s:
ans = min((ans, b))
if s == n:
print((n+1))
elif ans < n + 1:
print(ans)
else:
print((-1))
| import sys
n = int(eval(input()))
s = int(eval(input()))
def f(b, n):
if n < b:
return n
else:
return f(b, n//b) + n % b
if s == n:
print((n+1))
sys.exit(0)
if n < s:
print((-1))
sys.exit(0)
ans = None
for i in range(2, n):
if i * i > n:
break
if f(i, n) == s:
ans = i
break
for i in range(1, n):
if i * i > n:
break
if (n - s) % i == 0:
b = (n - s) // i + 1
if f(b, n) == s:
if ans is None:
ans = (n - s) // i + 1
else:
ans = min((ans, (n - s) // i + 1))
if ans is None:
print((-1))
else:
print(ans)
| p04014 |
n = int(eval(input()))
s = int(eval(input()))
if s == 1 and n == 1:
print((2))
exit()
if s > n:
print((-1))
exit()
if n%2 == 0 and n > s > n//2:
print((-1))
exit()
if n%2 == 1 and n > s > n//2+1:
print((-1))
exit()
ans = float("INF")
for i in range(2,int(n**0.5)+1):
x = n
count = 0
while x >= i:
count += x%i
x //= i
if count + x == s:
print(i)
exit()
now = 2
li = int(n**0.5)+1
while True:
x = n//now
if x < li:
break
count = 0
y = n
while y >= x:
count += y%x
y //= x
count += y
if count <= s and (s-count)%now == 0:
z = x-n//(now+1)
if (s-count)//now < z:
ans = x-(s-count)//now
now += 1
if s == n:
print((min(ans,n+1)))
else:
print((min(ans,n-s+1)))
| n = int(eval(input()))
s = int(eval(input()))
if s == n:
print((n+1))
exit()
if s > n%2+n//2:
print((-1))
exit()
ans = float("INF")
for i in range(2,int(n**0.5)+1):
x = n
count = 0
while x >= i:
count += x%i
x //= i
if count + x == s:
print(i)
exit()
now = 2
li = int(n**0.5)+1
while True:
x = n//now
if x < li:
break
count = 0
y = n
while y >= x:
count += y%x
y //= x
count += y
if count <= s and (s-count)%now == 0:
z = x-n//(now+1)
if (s-count)//now < z:
ans = x-(s-count)//now
now += 1
print((min(ans,n-s+1)))
| p04014 |
import math
import os
import sys
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
N, S = [int(sys.stdin.readline()) for _ in range(2)]
@lru_cache(maxsize=None)
def f(b, n):
if n < b:
return n
return f(b, int(n // b)) + n % b
def bisect_left_callable(fn, x, lo, hi):
"""
lo から hi-1 のうち、fn の結果が x 以上となる、最も左の値
bisect.bisect_left と同じ
https://docs.python.org/ja/3/library/bisect.html
:param callable fn:
:param x:
:param int lo: 最小値
:param int hi: 最大値 + 1
:return: lo <= ret <= hi
"""
while lo < hi:
mid = (lo + hi) // 2
if fn(mid) < x:
lo = mid + 1
else:
hi = mid
return lo
if S > N:
print((-1))
exit()
if S == N:
print((N + 1))
exit()
# #########
# b = 2
# ans = -1
# prev = 0
# while b <= N:
# if f(b, N) > prev:
# print(b, N, f(b, N))
# prev = f(b, N)
# b += 1
# ##########
b = 2
ans = -1
while b <= math.sqrt(N) + 1:
if f(b, N) == S:
ans = b
break
b += 1
if ans >= 0:
print(ans)
exit()
for i in range(1, int(math.sqrt(N)) + 1):
hi = N // i + 1
lo = N // (i + 1) + 1
b = bisect_left_callable(lambda x: -f(x, N), -S, lo, hi)
if f(b, N) == S:
ans = b
print(ans)
| import math
import os
import sys
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
N, S = [int(sys.stdin.readline()) for _ in range(2)]
@lru_cache(maxsize=None)
def f(b, n):
if n < b:
return n
return f(b, int(n // b)) + n % b
if S > N:
print((-1))
exit()
if S == N:
print((N + 1))
exit()
# #########
# b = 2
# ans = -1
# prev = 0
# while b <= N:
# if f(b, N) > prev:
# print(b, N, f(b, N))
# prev = f(b, N)
# b += 1
# ##########
b = 2
ans = -1
while b <= math.sqrt(N) + 1:
if f(b, N) == S:
ans = b
break
b += 1
if ans >= 0:
print(ans)
exit()
ans = INF
# b > sqrt(N) のとき 2 桁になるので上位桁を全探索する
for d2 in range(1, int(math.sqrt(N)) + 1):
if (N - S) % d2 == 0:
b = int(1 + (N - S) // d2)
if b >= 2 and f(b, N) == S:
ans = min(ans, b)
if ans == INF:
print((-1))
else:
print(ans)
| p04014 |
import math
n = int(eval(input()))
s = int(eval(input()))
def c(b):
cur = n
acc = 0
while cur != 0:
div, mod = divmod(cur, b)
acc += mod
cur = div
return acc
def f():
if n == s:
return (n + 1)
if n < s:
return -1
rt = math.ceil(math.sqrt(n))
for b in range(2, rt + 1):
if c(b) == s: return b
for p in range(rt, 0, -1):
q = s - p
x = n - q
b = x // p
# if x % p == 0 and b > q and b > p and q >= 0:
if c(b) == s:
return b
return -1
print((f())) | import math
n = int(eval(input()))
s = int(eval(input()))
def c(b):
cur = n
acc = 0
while cur != 0:
div, mod = divmod(cur, b)
acc += mod
cur = div
return acc
def g(b):
if b > n: return n
return sum(divmod(n,b))
def f():
if n == s:
return (n + 1)
if n < s:
return -1
rt = math.ceil(math.sqrt(n))
for b in range(2, rt + 1):
if c(b) == s: return b
for p in range(rt - 1, 0, -1):
q = s - p
x = n - q
b = x // p
if g(b) == s:
return b
return -1
print((f())) | p04014 |
#!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n = II()
k = II()
x = II()
y = II()
ans = 0
for i in range(n):
if i >= k:
ans += y
else:
ans += x
print(ans)
return
#B
def B():
w = S()
d = defaultdict(int)
for s in w:
d[s] += 1
for di in list(d.values()):
if di % 2:
print("No")
return
print("Yes")
return
#C
def C():
n, a = LI()
x = LI()
sumx = [0] * n
for i in range(n):
sumx[i] = sumx[i - 1] + x[i]
dp = [[[0] * (n+1) for i in range(sumx[-1] + 1)] for i in range(n)]
for i in range(n):
dp[i][x[i]][1] = 1
for i in range(1, n):
for s in range(sumx[i] + 1):
for k in range(1, i + 2):
if s >= x[i]:
dp[i][s][k] += dp[i - 1][s - x[i]][k - 1]
dp[i][s][k] += dp[i - 1][s][k]
ans = 0
for i in range(1, n + 1):
if a * i > sumx[-1]:
break
ans += dp[-1][a * i][i]
print(ans)
return
# D
# 解説AC
# 2 <= b <= √n
# までに関しては全探索すればよくて
# ここで解がない場合はそれ以上を見る
# √n < b <= n
# に関してはb進数表記で2桁になることが確定してて
# n = p*b+qとするなら p + q = s で(1 <= p < b, 0 <= q < b)
# n = p*b+q >= p*b > p**2 → √n > p がわかるからpを全探索
# b = (n-s)/p + 1なのでpを決めればbが決まってあとは調べればいい
# 数学じゃんこれ！
def D():
def f(b, n):
if n < b:
return n
return f(b, n // b) + (n % b)
n, s = IR(2)
if n == s:
print((n + 1))
return
for b in range(2, int(math.sqrt(n)) + 1):
if s == f(b, n):
print(b)
return
for p in range(int(math.sqrt(n)), 0, -1):
b = (n - s) // p + 1
if b <= 0:
continue
if s == f(b, n):
print(b)
return
print((-1))
return
#Solve
if __name__ == '__main__':
D()
| #!/usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')
#A
def A():
n = II()
k = II()
x = II()
y = II()
ans = 0
for i in range(n):
if i >= k:
ans += y
else:
ans += x
print(ans)
return
#B
def B():
w = S()
d = defaultdict(int)
for s in w:
d[s] += 1
for di in list(d.values()):
if di % 2:
print("No")
return
print("Yes")
return
#C
def C():
n, a = LI()
x = LI()
sumx = [0] * n
for i in range(n):
sumx[i] = sumx[i - 1] + x[i]
dp = [[[0] * (n+1) for i in range(sumx[-1] + 1)] for i in range(n)]
for i in range(n):
dp[i][x[i]][1] = 1
for i in range(1, n):
for s in range(sumx[i] + 1):
for k in range(1, i + 2):
if s >= x[i]:
dp[i][s][k] += dp[i - 1][s - x[i]][k - 1]
dp[i][s][k] += dp[i - 1][s][k]
ans = 0
for i in range(1, n + 1):
if a * i > sumx[-1]:
break
ans += dp[-1][a * i][i]
print(ans)
return
# D
# 解説AC
# 2 <= b <= √n
# までに関しては全探索すればよくて
# ここで解がない場合はそれ以上を見る
# √n < b <= n
# に関してはb進数表記で2桁になることが確定してて
# n = p*b+qとするなら p + q = s で(1 <= p < b, 0 <= q < b)
# n = p*b+q >= p*b > p**2 → √n > p がわかるからpを全探索
# b = (n-s)/p + 1なのでpを決めればbが決まってあとは調べればいい
# 数学じゃんこれ！
def D():
def f(b, n):
if n < b:
return n
return f(b, n // b) + (n % b)
n, s = IR(2)
if n == s:
print((n + 1))
return
for b in range(2, int(math.sqrt(n)) + 1):
if s == f(b, n):
print(b)
return
for p in range(int(math.sqrt(n)), 0, -1):
b = (n - s) // p + 1
if b <= 1:
continue
if s == f(b, n):
print(b)
return
print((-1))
return
#Solve
if __name__ == '__main__':
D()
| p04014 |
from math import floor, sqrt
INF = 10 ** 20
def f(b, n):
if n < b:
return n
else:
return f(b, n // b) + (n % b)
def main():
n = int(eval(input()))
s = int(eval(input()))
ans = INF
# 1桁
if n == s:
ans = min(ans, n + 1)
# 2桁
for p in range(1, int(sqrt(n)) + 1):
q = s - p
b = (n - q) // p
if 2 <= b and f(b, n) == s:
ans = min(ans, b)
# 3桁以上
for b in range(2, int(sqrt(n)) + 1):
if f(b, n) == s:
ans = min(ans, b)
print((-1 if ans == INF else ans))
if __name__ == '__main__':
main()
| from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def f(b, n):
if n < b:
return n
return f(b, n // b) + n % b
def main():
N = int(eval(input()))
S = int(eval(input()))
if N == S:
print((N + 1))
return
if N < S:
print((-1))
return
ans = INF
for b in range(2, int(sqrt(N)) + 1):
if f(b, N) == S:
ans = min(ans, b)
bs = set()
t = N - S
for i in range(1, int(sqrt(N)) + 1):
if t % i == 0:
bs.add(i + 1)
bs.add((t // i) + 1)
for b in bs:
if b == 1:
continue
if f(b, N) == S:
ans = min(ans, b)
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
| p04014 |
n=int(eval(input()))
s=int(eval(input()))
if s>n:
print((-1))
elif s==n:
print((n+1))
else:
# 2<=b<=n**0.5 で全探索
for b in range(2,int(n**0.5)+1):
tmp=0
n0=n
while n0>0:
tmp+=n0%b
n0//=b
if tmp==s:
print(b)
exit()
# n**0.5<bについて
for p in range(int(n**0.5)+1,0,-1):
b=(n-s)//p+1
tmp=0
n0=n
while n0>0:
tmp+=n0%b
n0//=b
if tmp==s:
print(b)
exit()
print((-1))
| n=int(eval(input()))
s=int(eval(input()))
if s>n:
print((-1))
elif s==n:
print((n+1))
else:
# 2<=b<=n**0.5 で全探索
for b in range(2,int(n**0.5)+1):
tmp=0
n0=n
while n0>0:
tmp+=n0%b
n0//=b
if tmp==s:
print(b)
exit()
# n**0.5<bについて
for p in range(int(n**0.5)+1,0,-1):
b=(n-s)/p+1
if not b.is_integer():continue
b=int(b)
tmp=0
n0=n
while n0>0:
tmp+=n0%b
n0//=b
if tmp==s:
print(b)
exit()
print((-1))
| p04014 |
import math
n = int(eval(input()))
s = int(eval(input()))
r = 0
if n == s:
print((n + 1))
exit()
elif n < s:
print((-1))
exit()
nn = int(math.sqrt(n)) + 1
for i in range(2, nn):
nt = n
st = 0
while nt > 0:
st += nt % i
nt //= i
if st == s:
print(i)
exit()
for i in range(nn, 0, -1):
nt = n
st = 0
b = (n - s) // i + 1
while nt > 0:
st += nt % b
nt //= b
if st == s:
print(b)
exit()
print((-1)) | import math
n = int(eval(input()))
s = int(eval(input()))
r = 0
if n == s:
print((n + 1))
exit()
elif n < s:
print((-1))
exit()
sq = int(math.sqrt(n))
# 2 <= d <= √n
for i in range(2, sq+1):
nt = n
st = 0
while nt > 0:
st += nt % i
nt //= i
if st == s:
print(i)
exit()
# √n < d <= n
for i in range(sq+1, 0, -1):
b = (n - s) // i + 1
st = n % b + n // b
if n // b != b and st == s:
print(b)
exit()
print((-1)) | p04014 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.