id stringlengths 24 27 | content stringlengths 37 384k | max_stars_repo_path stringlengths 51 51 |
|---|---|---|
condefects-python_data_601 | t = int(input())
for i in range(t):
n, k = map(int, input().split())
if n % 2 != k % 2 or n < k:
print("No")
else:
pre = n
count = 0
while True:
count = pre % 3
pre = pre // 3
if pre < 3:
count += pre
break
if count <= k:
print("Yes")
else:
print("No")
t = int(input())
for i in range(t):
n, k = map(int, input().split())
if n % 2 != k % 2 or n < k:
print("No")
else:
pre = n
count = 0
while True:
count += pre % 3
pre = pre // 3
if pre < 3:
count += pre
break
if count <= k:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/arc164_a/Python/45658155 |
condefects-python_data_602 | # import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N, K = map(int, input().split())
cnt = 0
i = 3**20
while N > 0 and i > 0:
d, m = divmod(N, i)
cnt += d
N = m
i //= 3
if cnt <= K and (K - cnt) % 2 == 0:
print("Yes")
else:
print("No")
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N, K = map(int, input().split())
cnt = 0
i = 3**40
while N > 0 and i > 0:
d, m = divmod(N, i)
cnt += d
N = m
i //= 3
if cnt <= K and (K - cnt) % 2 == 0:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/arc164_a/Python/45556032 |
condefects-python_data_603 | def dt(n):
if n == 0:
return 0
ternary = 0
while n > 0:
remainder = n % 3
ternary+=remainder
n //= 3
return ternary
tc = int(input())
for _ in range(tc):
n,k = map(int, input().split())
print("Yes" if dt(n) <= k and k<=n else "No")
def dt(n):
if n == 0:
return 0
ternary = 0
while n > 0:
remainder = n % 3
ternary+=remainder
n //= 3
return ternary
tc = int(input())
for _ in range(tc):
n,k = map(int, input().split())
print("Yes" if dt(n) <= k <= n and k%2==n%2 else "No")
| ConDefects/ConDefects/Code/arc164_a/Python/45492377 |
condefects-python_data_604 | T = int(input())
for _ in range(T):
N, K = map(int, input().split())
while N > 0:
K -= N % 3
N //= 3
if K >=0:
print("Yes")
else:
print("No")
T = int(input())
for _ in range(T):
N, K = map(int, input().split())
while N > 0:
K -= N % 3
N //= 3
if K >= 0 and K % 2 == 0:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/arc164_a/Python/45000515 |
condefects-python_data_605 | def recur(n):
x=0
for i in range(28,-1,-1):
p=pow(3,i)
x += n // p
n-=p*(n//p)
return x
def solve():
n,k=map(int,input().split())
x=recur(n)
if x>k or k%2!=n%2:
print("No")
else:
print("Yes")
for i in range(int(input())):
solve()
def recur(n):
x=0
for i in range(40,-1,-1):
p=pow(3,i)
x += n // p
n-=p*(n//p)
return x
def solve():
n,k=map(int,input().split())
x=recur(n)
if x>k or k%2!=n%2:
print("No")
else:
print("Yes")
for i in range(int(input())):
solve() | ConDefects/ConDefects/Code/arc164_a/Python/45705547 |
condefects-python_data_606 | T=int(input())
for i in range(T):
ternary=[]
N,K=map(int,input().split())
N2=N
while N2>0:
ternary.append(N2%3)
N2//=3
print(ternary)
print(sum(ternary))
if N%2!=K%2:
print("No")
else:
if K<sum(ternary):
print("No")
else:
print("Yes")
T=int(input())
for i in range(T):
ternary=[]
N,K=map(int,input().split())
N2=N
while N2>0:
ternary.append(N2%3)
N2//=3
if N%2!=K%2:
print("No")
else:
if K<sum(ternary):
print("No")
else:
print("Yes") | ConDefects/ConDefects/Code/arc164_a/Python/45247627 |
condefects-python_data_607 | #ARC164A
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def RI(): return map(int,input().split())
def DI(): return list(input())
def change(N,shinsu):
keta=0
for i in range(10**9):
if N<shinsu**i:
keta+=i
break
ans=[0]*keta
check=0
for i in range(1,keta+1):
j=N//(shinsu**(keta-i))
ans[check]=j
check+=1
N-=(j)*(shinsu**(keta-i))
return ans
t=I()
for _ in range(t):
n,k=RI()
nhen=change(n,3)
#print(sum(nhen))
if (k-sum(nhen))%2==0:
print('Yes')
else:
print('No')
#ARC164A
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def RI(): return map(int,input().split())
def DI(): return list(input())
def change(N,shinsu):
keta=0
for i in range(10**9):
if N<shinsu**i:
keta+=i
break
ans=[0]*keta
check=0
for i in range(1,keta+1):
j=N//(shinsu**(keta-i))
ans[check]=j
check+=1
N-=(j)*(shinsu**(keta-i))
return ans
t=I()
for _ in range(t):
n,k=RI()
nhen=change(n,3)
#print(sum(nhen))
if k-sum(nhen)>=0 and (k-sum(nhen))%2==0:
print('Yes')
else:
print('No')
| ConDefects/ConDefects/Code/arc164_a/Python/45533632 |
condefects-python_data_608 | t = int(input())
for i in range(t):
n, k = map(int, input().split())
l = 0
for i in range(12):
l += (n // 3**i) % 3
if k >= l and (k - l) % 2 == 0:
print("Yes")
else:
print("No")
t = int(input())
for i in range(t):
n, k = map(int, input().split())
l = 0
for i in range(40):
l += (n // 3**i) % 3
if k >= l and (k - l) % 2 == 0:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/arc164_a/Python/46191198 |
condefects-python_data_609 | # import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from sortedcontainers import *
# from math import gcd
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
# from atcoder.dsu import *
# from atcoder.segtree import *
# from random import *
import sys
# sys.setrecursionlimit(10**6) # PyPyは呪文を付ける
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline().replace("\n", "")
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N, K = map(int, input().split())
cnt = 0
for i in range(20, -1, -1):
d, m = divmod(N, 3**i)
cnt += d
N = m
if K >= cnt and (K - cnt) % 2 == 0:
print("Yes")
else:
print("No")
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from sortedcontainers import *
# from math import gcd
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
# from atcoder.dsu import *
# from atcoder.segtree import *
# from random import *
import sys
# sys.setrecursionlimit(10**6) # PyPyは呪文を付ける
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline().replace("\n", "")
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N, K = map(int, input().split())
cnt = 0
for i in range(50, -1, -1):
d, m = divmod(N, 3**i)
cnt += d
N = m
if K >= cnt and (K - cnt) % 2 == 0:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/arc164_a/Python/45517397 |
condefects-python_data_610 | N = int(input())
S = input()
Q = int(input())
TXC = [[i for i in input().split()] for _ in range(Q)]
isupper = -1
islower = -1
lastmodified = [-1]*N
li = [c for c in S]
for i, (t,x,c) in enumerate(TXC):
t = int(t)
if t == 1:
x = int(x)
li[x-1] = c
lastmodified[x-1] = i
elif t == 2:
islower = i
elif t == 3:
isupper = i
ans = []
if islower < isupper:
for c, lm in zip(li, lastmodified):
ans.append(c if lm>isupper else c.upper())
elif islower > isupper:
for c, lm in zip(li, lastmodified):
ans.append(c if lm>islower else c.lower())
else:
for c, lm in zip(li, lastmodified):
ans.append(c if lm>islower else c.lower())
print(''.join(ans))
N = int(input())
S = input()
Q = int(input())
TXC = [[i for i in input().split()] for _ in range(Q)]
isupper = -1
islower = -1
lastmodified = [-1]*N
li = [c for c in S]
for i, (t,x,c) in enumerate(TXC):
t = int(t)
if t == 1:
x = int(x)
li[x-1] = c
lastmodified[x-1] = i
elif t == 2:
islower = i
elif t == 3:
isupper = i
ans = []
if islower < isupper:
for c, lm in zip(li, lastmodified):
ans.append(c if lm>isupper else c.upper())
elif islower > isupper:
for c, lm in zip(li, lastmodified):
ans.append(c if lm>islower else c.lower())
else:
for c, lm in zip(li, lastmodified):
ans.append(c)
print(''.join(ans)) | ConDefects/ConDefects/Code/abc314_d/Python/46143343 |
condefects-python_data_611 |
if __name__ == '__main__':
N = int(input())
S = input()
Q = int(input())
flg = 1
d = dict()
query = []
last = 0
for i in range(Q):
t, x, c = input().split()
query.append([t, x, c])
if t == '2':
flg = 2
last = i
elif t == '3':
flg = 3
last = i
if flg == 2:
S = S.lower()
else:
S = S.upper()
for j in range(Q):
t = query[j][0]
x = query[j][1]
c = query[j][2]
if t == '1':
x = int(x)
if j < last:
if flg == 1:
d[x-1] = c
if flg == 2:
d[x-1] = c.lower()
else:
d[x-1] = c.upper()
else:
d[x-1] = c
for i in range(N):
if i in d:
print(d[i], end='')
else:
print(S[i], end='')
if __name__ == '__main__':
N = int(input())
S = input()
Q = int(input())
flg = 1
d = dict()
query = []
last = 0
for i in range(Q):
t, x, c = input().split()
query.append([t, x, c])
if t == '2':
flg = 2
last = i
elif t == '3':
flg = 3
last = i
if flg == 2:
S = S.lower()
elif flg == 3:
S = S.upper()
for j in range(Q):
t = query[j][0]
x = query[j][1]
c = query[j][2]
if t == '1':
x = int(x)
if j < last:
if flg == 1:
d[x-1] = c
if flg == 2:
d[x-1] = c.lower()
else:
d[x-1] = c.upper()
else:
d[x-1] = c
for i in range(N):
if i in d:
print(d[i], end='')
else:
print(S[i], end='')
| ConDefects/ConDefects/Code/abc314_d/Python/46146276 |
condefects-python_data_612 | N = int(input())
T = [list(map(int,input().split())) for _ in range(N)]
L = [t[0] for t in T]
R = [t[1] for t in T]
L.sort(reverse=True)
R.sort()
ans = 0
for i in range(N):
if L[i] > R[i]:
ans += (L[i]-R[i])*(N-1)
print(ans)
N = int(input())
T = [list(map(int,input().split())) for _ in range(N)]
L = [t[0] for t in T]
R = [t[1] for t in T]
L.sort(reverse=True)
R.sort()
ans = 0
for i in range(N):
if L[i] > R[i]:
ans += (L[i]-R[i])*(N-i*2-1)
print(ans) | ConDefects/ConDefects/Code/arc147_c/Python/43399411 |
condefects-python_data_613 | n = int(input())
l,r = zip(*[list(map(int,input().split())) for i in range(n)])
l = list(l)
r = list(r)
l.sort(reverse=True)
r.sort()
ans = 0
for i in range(n):
ans += max(0,l[i]-r[i])*(n-i-1)
print(ans)
n = int(input())
l,r = zip(*[list(map(int,input().split())) for i in range(n)])
l = list(l)
r = list(r)
l.sort(reverse=True)
r.sort()
ans = 0
for i in range(n):
ans += max(0,l[i]-r[i])*(n-2*i-1)
print(ans) | ConDefects/ConDefects/Code/arc147_c/Python/41820301 |
condefects-python_data_614 | import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
INF = 2**63-1
mod = 998244353
import random
n = ii()
a = li()
def solve(n, a, p):
ans = []
for i in range(random.randint(0, p)):
p = list(range(1, n + 1))
random.shuffle(p)
ans.append(p)
for j in range(n):
a[j] += p[j]
for i in range(10 ** 4):
if sum(a) % n == 0:
break
p = list(range(1, n + 1))
random.shuffle(p)
ans.append(list(range(1, n + 1)))
for j in range(n):
a[j] += p[j]
else:
return []
def add(i):
p = list(range(1, n + 1))
p[i], p[i+1] = p[i+1], p[i]
ans.append(p)
p = list(range(1, n + 1))
q = p[::-1]
ans.append(q)
a[i] += 1
a[i + 1] -= 1
def sub(i):
p = list(range(1, n + 1))
ans.append(p)
q = p[::-1]
q[i], q[i + 1] = q[i + 1], q[i]
ans.append(q)
a[i] -= 1
a[i + 1] += 1
ave = sum(a) // n
for i in range(n):
a[i] -= ave
for i in range(n - 1):
while a[i] > 0:
sub(i)
while a[i] < 0:
add(i)
if max(a) == min(a) == 0 and len(ans) <= 10 ** 4:
return ans
else:
return []
for p in range(14):
ans = solve(n, a[::], p * 10)
if len(ans) > 0:
print('Yes')
print(len(ans))
for v in ans:
print(*v)
exit()
print('No')
import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
INF = 2**63-1
mod = 998244353
import random
n = ii()
a = li()
def solve(n, a, p):
ans = []
for i in range(random.randint(0, p)):
p = list(range(1, n + 1))
random.shuffle(p)
ans.append(p)
for j in range(n):
a[j] += p[j]
for i in range(10 ** 4):
if sum(a) % n == 0:
break
p = list(range(1, n + 1))
random.shuffle(p)
ans.append(p)
for j in range(n):
a[j] += p[j]
else:
return []
def add(i):
p = list(range(1, n + 1))
p[i], p[i+1] = p[i+1], p[i]
ans.append(p)
p = list(range(1, n + 1))
q = p[::-1]
ans.append(q)
a[i] += 1
a[i + 1] -= 1
def sub(i):
p = list(range(1, n + 1))
ans.append(p)
q = p[::-1]
q[i], q[i + 1] = q[i + 1], q[i]
ans.append(q)
a[i] -= 1
a[i + 1] += 1
ave = sum(a) // n
for i in range(n):
a[i] -= ave
for i in range(n - 1):
while a[i] > 0:
sub(i)
while a[i] < 0:
add(i)
if max(a) == min(a) == 0 and len(ans) <= 10 ** 4:
return ans
else:
return []
for p in range(14):
ans = solve(n, a[::], p * 10)
if len(ans) > 0:
print('Yes')
print(len(ans))
for v in ans:
print(*v)
exit()
print('No') | ConDefects/ConDefects/Code/arc159_c/Python/40556226 |
condefects-python_data_615 | from sys import stdin, setrecursionlimit
from collections import deque, defaultdict, Counter
setrecursionlimit(10 ** 9 + 7)
input = stdin.readline
INF = 1 << 61
# DX = (0, 1, 0, -1)
# DY = (-1, 0, 1, 0)
# DX = (0, 1, 1, 1, 0, -1, -1, -1)
# DY = (-1, -1, 0, 1, 1, 1, 0, -1)
class SegTree:
def __init__(self, n, op=max, e=0, array=None):
self.size = 1 << (n - 1).bit_length()
self.op = op
self.e = e
self.dat = [self.e] * (self.size << 1)
if array is not None:
for i in range(n):
self.dat[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.dat[i] = self.op(self.dat[i * 2], self.dat[i * 2 + 1])
def update(self, i, x):
k = self.size + i
self.dat[k] = x
while k > 0:
self.dat[k >> 1] = self.op(self.dat[k], self.dat[k ^ 1])
k >>= 1
def get(self, l, r=None):
if r is None:
r = l + 1
ret = self.e
l += self.size
r += self.size
while l < r:
if l & 1:
ret = self.op(ret, self.dat[l])
l += 1
if r & 1:
ret = self.op(ret, self.dat[r - 1])
l >>= 1
r >>= 1
return ret
def main():
n, c = map(int, input().split())
m = int(input())
cl = SegTree(n, e=-INF)
cr = SegTree(n, e=-INF)
cl.update(0, 0)
ans = 0
for _ in range(m):
t, p = map(int, input().split())
t -= 1
ma = max(cl.get(0, t) - c * t, cr.get(t, n) + c * t) + p
ans = max(ans, ma)
cl.update(t, ma + c * t)
cr.update(t, ma - c * t)
print(ans)
if __name__ == '__main__':
main()
from sys import stdin, setrecursionlimit
from collections import deque, defaultdict, Counter
setrecursionlimit(10 ** 9 + 7)
input = stdin.readline
INF = 1 << 61
# DX = (0, 1, 0, -1)
# DY = (-1, 0, 1, 0)
# DX = (0, 1, 1, 1, 0, -1, -1, -1)
# DY = (-1, -1, 0, 1, 1, 1, 0, -1)
class SegTree:
def __init__(self, n, op=max, e=0, array=None):
self.size = 1 << (n - 1).bit_length()
self.op = op
self.e = e
self.dat = [self.e] * (self.size << 1)
if array is not None:
for i in range(n):
self.dat[self.size + i] = array[i]
for i in range(self.size - 1, 0, -1):
self.dat[i] = self.op(self.dat[i * 2], self.dat[i * 2 + 1])
def update(self, i, x):
k = self.size + i
self.dat[k] = x
while k > 0:
self.dat[k >> 1] = self.op(self.dat[k], self.dat[k ^ 1])
k >>= 1
def get(self, l, r=None):
if r is None:
r = l + 1
ret = self.e
l += self.size
r += self.size
while l < r:
if l & 1:
ret = self.op(ret, self.dat[l])
l += 1
if r & 1:
ret = self.op(ret, self.dat[r - 1])
l >>= 1
r >>= 1
return ret
def main():
n, c = map(int, input().split())
m = int(input())
cl = SegTree(n, e=-INF)
cr = SegTree(n, e=-INF)
cl.update(0, 0)
ans = 0
for _ in range(m):
t, p = map(int, input().split())
t -= 1
ma = max(cl.get(0, t + 1) - c * t, cr.get(t, n) + c * t) + p
ans = max(ans, ma)
cl.update(t, ma + c * t)
cr.update(t, ma - c * t)
print(ans)
if __name__ == '__main__':
main()
| ConDefects/ConDefects/Code/abc353_g/Python/53993648 |
condefects-python_data_616 | #2 3 3 4
#素数列挙
def prime(N):
primes = []
for i in range(2, N + 1):
primes.append(i)
for p in range(2, i):
if i % p == 0:
primes.remove(i)
break
return primes
setx=set(prime(100))
A,B,C,D=map(int,input().split())
for i in range(A,B+1):
q=True
for j in range(C,D+1):
num=i+j
if num in setx:
q=False
break
if q==True:
print("Takahashi")
exit()
print("Aoki")
#2 3 3 4
#素数列挙
def prime(N):
primes = []
for i in range(2, N + 1):
primes.append(i)
for p in range(2, i):
if i % p == 0:
primes.remove(i)
break
return primes
setx=set(prime(200))
A,B,C,D=map(int,input().split())
for i in range(A,B+1):
q=True
for j in range(C,D+1):
num=i+j
if num in setx:
q=False
break
if q==True:
print("Takahashi")
exit()
print("Aoki")
| ConDefects/ConDefects/Code/abc239_d/Python/52953499 |
condefects-python_data_617 | primes=[]
for i in range(2,101):
for j in range(2,i):
if i%j==0:
break
else:
primes.append(i)
a,b,c,d=map(int,input().split())
for i in range(a,b+1):
for j in range(c,d+1):
if i+j in primes:
break
if j==d:
print('Takahashi')
exit()
print('Aoki')
primes=[]
for i in range(2,201):
for j in range(2,i):
if i%j==0:
break
else:
primes.append(i)
a,b,c,d=map(int,input().split())
for i in range(a,b+1):
for j in range(c,d+1):
if i+j in primes:
break
if j==d:
print('Takahashi')
exit()
print('Aoki') | ConDefects/ConDefects/Code/abc239_d/Python/54197752 |
condefects-python_data_618 | from more_itertools import*
a,b,c,d=map(int,input().split())
s={*sieve(205)}
ans=0
for i in range(a,b+1):
t=1
for j in range(c,d+1):
if i+j in s:
t=0
ans|=t
if t:
print('Takahashi')
else:
print('Aoki')
from more_itertools import*
a,b,c,d=map(int,input().split())
s={*sieve(205)}
ans=0
for i in range(a,b+1):
t=1
for j in range(c,d+1):
if i+j in s:
t=0
ans|=t
if ans:
print('Takahashi')
else:
print('Aoki') | ConDefects/ConDefects/Code/abc239_d/Python/54694563 |
condefects-python_data_619 | from atcoder.modint import ModContext, Modint
MOD = 998244353
ModContext.context.append(MOD)
Modint.__repr__ = lambda x: repr(x._v)
A, B = map(int, input().split())
def factorization(N):
from collections import defaultdict
res = defaultdict(int)
x = N
y = 2
while y*y <= x:
while x%y == 0:
res[y] += 1
x //= y
y += 1
if x > 1:
res[x] += 1
return res
fact = factorization(A)
res = Modint(1)
for p, e in fact.items():
res *= (B*e + 1)
res *= B
res *= pow(2, -1, MOD)
print(res)
from atcoder.modint import ModContext, Modint
MOD = 998244353
ModContext.context.append(MOD)
Modint.__repr__ = lambda x: repr(x._v)
A, B = map(int, input().split())
def factorization(N):
from collections import defaultdict
res = defaultdict(int)
x = N
y = 2
while y*y <= x:
while x%y == 0:
res[y] += 1
x //= y
y += 1
if x > 1:
res[x] += 1
return res
fact = factorization(A)
res = Modint(1)
for p, e in fact.items():
res *= (B*e + 1)
res *= B
if B%2 == 1 and all(e%2 == 0 for e in fact.values()):
res -= 1
res *= pow(2, -1, MOD)
print(res)
| ConDefects/ConDefects/Code/arc167_b/Python/49611980 |
condefects-python_data_620 | def prime_factorize(N):
# 答えを表す可変長配列
res = {}
# √N まで試し割っていく
for p in range(2, N):
# p * p <= N の範囲でよい
if p * p > N:
break
# N が p で割り切れないならばスキップ
if N % p != 0:
continue
# N の素因数 p に対する指数を求める
e = 0
while N % p == 0:
# 指数を 1 増やす
e += 1
# N を p で割る
N //= p
# 答えに追加
res[p]=e
# 素数が最後に残ることがありうる
if N != 1:
res[N]=1
return res
A,B=map(int,input().split())
res=prime_factorize(A)
pro=1
for key in res.keys():
pro*=B*res[key]+1
ans=10**30
for key in res.keys():
ans=min(ans,(B*res[key]*pro//2)//res[key])
print(ans%998244353)
def prime_factorize(N):
# 答えを表す可変長配列
res = {}
# √N まで試し割っていく
for p in range(2, N):
# p * p <= N の範囲でよい
if p * p > N:
break
# N が p で割り切れないならばスキップ
if N % p != 0:
continue
# N の素因数 p に対する指数を求める
e = 0
while N % p == 0:
# 指数を 1 増やす
e += 1
# N を p で割る
N //= p
# 答えに追加
res[p]=e
# 素数が最後に残ることがありうる
if N != 1:
res[N]=1
return res
A,B=map(int,input().split())
res=prime_factorize(A)
pro=1
for key in res.keys():
pro*=B*res[key]+1
ans=10**1000
for key in res.keys():
ans=min(ans,(B*res[key]*pro//2)//res[key])
print(ans%998244353)
| ConDefects/ConDefects/Code/arc167_b/Python/51380686 |
condefects-python_data_621 | A, B = map(int, input().split())
degrees = []
at = 2
while at * at <= A:
if A % at == 0:
cnt = 0
while A % at == 0:
cnt += 1
A //= at
degrees.append(cnt)
at += 1
if A != 1:
degrees.append(1)
# print(*degrees)
new_degrees = []
for el in degrees:
new_degrees.append(el)
for i in range(len(new_degrees)):
new_degrees[i] *= B
# print(*new_degrees)
all_pr = 1
for el in new_degrees:
all_pr *= (el + 1)
ANS = 10000000000000000000000000000000000000000000000000000000000000000000000 + 228
for i in range(len(new_degrees)):
el = new_degrees[i]
ANS = min(ANS, (all_pr // (el + 1)) * (el * (1 + el) // 2) // degrees[i])
print(ANS % 998244353)
A, B = map(int, input().split())
degrees = []
at = 2
while at * at <= A:
if A % at == 0:
cnt = 0
while A % at == 0:
cnt += 1
A //= at
degrees.append(cnt)
at += 1
if A != 1:
degrees.append(1)
# print(*degrees)
new_degrees = []
for el in degrees:
new_degrees.append(el)
for i in range(len(new_degrees)):
new_degrees[i] *= B
# print(*new_degrees)
all_pr = 1
for el in new_degrees:
all_pr *= (el + 1)
ANS = 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + 228
for i in range(len(new_degrees)):
el = new_degrees[i]
ANS = min(ANS, (all_pr // (el + 1)) * (el * (1 + el) // 2) // degrees[i])
print(ANS % 998244353)
| ConDefects/ConDefects/Code/arc167_b/Python/50502972 |
condefects-python_data_622 | a, b = map(int, input().split())
md = 998244353
def inv(num):
mo=998244353
return pow(num, mo-2, mo)
def factorization(n):
arr = []
temp = n
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
bun=factorization(a)
ans=1
for i,j in bun:
ans=ans*(j*b+1)%md
if int(a**0.5)*int(a**0.5)==a and b%2==1:
print((ans-1)*b*inv(2)%md)
else:
print(ans*b*inv(2)%md)
a, b = map(int, input().split())
md = 998244353
def inv(num):
mo=998244353
return pow(num, mo-2, mo)
def factorization(n):
arr = []
temp = n
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
bun=factorization(a)
ans=1
for i,j in bun:
ans=ans*(j*b+1)%md
if int(a**0.5)*int(a**0.5)==a and b%2==1:
print((ans*b-1)*inv(2)%md)
else:
print(ans*b*inv(2)%md) | ConDefects/ConDefects/Code/arc167_b/Python/55110212 |
condefects-python_data_623 | a, b = map(int, input().split())
i = 2
c = []
while i * i <= a:
if a % i == 0:
t = 0
while a % i == 0:
t += 1
a //= i
c.append(t)
i += 1
if a > 1:
c.append(1)
M = 998244353
res = 1
for i in c:
res = res * (i * b + 1) % M
res = res * b % M
res = res * (M+1) // 2 % M
print(res)
a, b = map(int, input().split())
i = 2
c = []
while i * i <= a:
if a % i == 0:
t = 0
while a % i == 0:
t += 1
a //= i
c.append(t)
i += 1
if a > 1:
c.append(1)
M = 998244353
res = 1
for i in c:
res = res * (i * b + 1) % M
res = res * b % M
if all(i & 1 == 0 for i in c) and b & 1:
res -= 1
res = res * (M+1) // 2 % M
print(res)
| ConDefects/ConDefects/Code/arc167_b/Python/52183821 |
condefects-python_data_624 | def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC251 D 1463 - At Most 3 (Contestant ver.)
# 整数 W が与えられます。
# あなたは以下の条件をすべて満たすようにいくつかのおもりを用意することにしました。
# ・おもりの個数は 1 個以上 300 個以下である。
# ・おもりの重さは 10^6 以下の正整数である。
# ・1 以上 W 以下のすべての正整数は 良い整数 である。ここで、以下の条件を満たす正整数 n を良い整数と呼ぶ。
# 用意したおもりのうち 3 個以下 の異なるおもりを自由に選んで、選んだおもりの重さの和を n にすることができる。
# 条件を満たすようなおもりの組を 1 つ出力してください。
# ・1 ≤ W ≤ 10^6
W = ip()
A = []
for i in range(1, 101):
A.append(i)
A.append(100*i)
A.append(10000*i)
print(300)
print(A)
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC251 D 1463 - At Most 3 (Contestant ver.)
# 整数 W が与えられます。
# あなたは以下の条件をすべて満たすようにいくつかのおもりを用意することにしました。
# ・おもりの個数は 1 個以上 300 個以下である。
# ・おもりの重さは 10^6 以下の正整数である。
# ・1 以上 W 以下のすべての正整数は 良い整数 である。ここで、以下の条件を満たす正整数 n を良い整数と呼ぶ。
# 用意したおもりのうち 3 個以下 の異なるおもりを自由に選んで、選んだおもりの重さの和を n にすることができる。
# 条件を満たすようなおもりの組を 1 つ出力してください。
# ・1 ≤ W ≤ 10^6
W = ip()
A = []
for i in range(1, 101):
A.append(i)
A.append(100*i)
A.append(10000*i)
print(300)
print(*A) | ConDefects/ConDefects/Code/abc251_d/Python/46009389 |
condefects-python_data_625 | w=int(input())
print(299)
A=[i for i in range(1,100)]+[100*i for i in range(1,100)]+[10000*i for i in range(1,101)]
print(*A)
w=int(input())
print(298)
A=[i for i in range(1,100)]+[100*i for i in range(1,100)]+[10000*i for i in range(1,101)]
print(*A) | ConDefects/ConDefects/Code/abc251_d/Python/44691668 |
condefects-python_data_626 | import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
from itertools import combinations
def main():
W = ii()
A = []
for i in range(1,101):
A.append(i*(100**2))
A.append(i*(100))
A.append(i)
A.sort()
print(len(A))
print(A,sep=" ")
if __name__=="__main__":
main()
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
from itertools import combinations
def main():
W = ii()
A = []
for i in range(1,101):
A.append(i*(100**2))
A.append(i*(100))
A.append(i)
A.sort()
print(len(A))
print(*A,sep=" ")
if __name__=="__main__":
main() | ConDefects/ConDefects/Code/abc251_d/Python/45210558 |
condefects-python_data_627 | import sys
input = sys.stdin.readline
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC251 D 1463 - At Most 3 (Contestant ver.)
W = ip()
A = []
for i in range(1, 101):
A.append(1 + i)
A.append(100 * i)
A.append(10000 * i)
print(300)
print(*A)
import sys
input = sys.stdin.readline
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC251 D 1463 - At Most 3 (Contestant ver.)
W = ip()
A = []
for i in range(1, 101):
A.append(i)
A.append(100 * i)
A.append(10000 * i)
print(300)
print(*A)
| ConDefects/ConDefects/Code/abc251_d/Python/44700899 |
condefects-python_data_628 | H, W, N = map(int,input().split())
grid = []
for i in range(H):
grid.append(["."] * W)
i = 0
j = 0
p = 0
h = [[0,-1],[1,0],[0,1],[-1,0]]
for k in range(N):
if grid[i][j] == ".":
grid[i][j] = "#"
# 時計まわり
p = (p+1) % 4
elif grid[i][j] == "#":
grid[i][j] = "."
# 半時計まわり
p = (p-1+4) % 4
#座標更新
i = (i+h[p][1]+H) % H
j = (j+h[p][0]+W) % W
for t in range(H):
print(*grid[t])
H, W, N = map(int,input().split())
grid = []
for i in range(H):
grid.append(["."] * W)
i = 0
j = 0
p = 0
h = [[0,-1],[1,0],[0,1],[-1,0]]
for k in range(N):
if grid[i][j] == ".":
grid[i][j] = "#"
# 時計まわり
p = (p+1) % 4
elif grid[i][j] == "#":
grid[i][j] = "."
# 半時計まわり
p = (p-1+4) % 4
#座標更新
i = (i+h[p][1]+H) % H
j = (j+h[p][0]+W) % W
for t in range(H):
print(*grid[t],sep="") | ConDefects/ConDefects/Code/abc339_b/Python/54311169 |
condefects-python_data_629 | import sys;sys.setrecursionlimit(100000000)
H,W,N=map(int,sys.stdin.readline().split())
grid=[["."]*W for i in range(H)]
directions=((-1,0),(0,1),(1,0),(0,-1))
dirNum=0
x=0
y=0
for i in range(N):
if grid[y][x]==".":
grid[y][x]="#"
dirNum+=1
y+=directions[dirNum%4][0]
x+=directions[dirNum%4][1]
else:
grid[y][x]="."
dirNum-=1
y+=directions[dirNum%4][0]
x+=directions[dirNum%4][1]
if x==W:
x=0
elif x==-1:
x=W-1
if y==H:
y=0
elif y==-1:
y=H-1
for clm in grid:
print(*clm)
import sys;sys.setrecursionlimit(100000000)
H,W,N=map(int,sys.stdin.readline().split())
grid=[["."]*W for i in range(H)]
directions=((-1,0),(0,1),(1,0),(0,-1))
dirNum=0
x=0
y=0
for i in range(N):
if grid[y][x]==".":
grid[y][x]="#"
dirNum+=1
y+=directions[dirNum%4][0]
x+=directions[dirNum%4][1]
else:
grid[y][x]="."
dirNum-=1
y+=directions[dirNum%4][0]
x+=directions[dirNum%4][1]
if x==W:
x=0
elif x==-1:
x=W-1
if y==H:
y=0
elif y==-1:
y=H-1
for clm in grid:
print("".join(clm)) | ConDefects/ConDefects/Code/abc339_b/Python/54672032 |
condefects-python_data_630 | import cProfile
import math
import sys
import io
import os
import traceback
from bisect import bisect_left, bisect_right
from collections import deque
from functools import lru_cache
from itertools import accumulate
# region IO
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')
def read_int_list():
return list(map(int, input().split()))
def read_int_tuple():
return tuple(map(int, input().split()))
def read_int():
return int(input())
# endregion
# region local test
if 'AW' in os.environ.get('COMPUTERNAME', ''):
test_no = 1
# f = open(os.path.dirname(__file__) + f'\\in{test_no}.txt', 'r')
file = open('inputs')
def input():
return file.readline().rstrip("\r\n")
# endregion
MOD = 998244353
def solve():
n, m = read_int_tuple()
p = m + 1
pp = p * p
ppp = pp * p
dp = [0] * ppp
dp[-1] = 1
for _ in range(n):
np = [0] * ppp
for a in range(p):
for b in range(p):
for c in range(p):
ft = a * pp + b * p + c
if dp[ft] == 0: continue
for x in range(m):
if x > c: continue
if x <= a:
tt = x * pp + b * p + c
elif x <= b:
tt = a * pp + x * p + c
else:
tt = a * pp + b * p + x
# else:
# continue
np[tt] += dp[ft]
np[tt] %= MOD
dp = np
print(sum(dp[a * pp + b * p + c] for a in range(m) for b in range(a + 1, m) for c in range(b + 1, m)))
T = 1
for t in range(T):
solve()
import cProfile
import math
import sys
import io
import os
import traceback
from bisect import bisect_left, bisect_right
from collections import deque
from functools import lru_cache
from itertools import accumulate
# region IO
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')
def read_int_list():
return list(map(int, input().split()))
def read_int_tuple():
return tuple(map(int, input().split()))
def read_int():
return int(input())
# endregion
# region local test
if 'AW' in os.environ.get('COMPUTERNAME', ''):
test_no = 1
# f = open(os.path.dirname(__file__) + f'\\in{test_no}.txt', 'r')
file = open('inputs')
def input():
return file.readline().rstrip("\r\n")
# endregion
MOD = 998244353
def solve():
n, m = read_int_tuple()
p = m + 1
pp = p * p
ppp = pp * p
dp = [0] * ppp
dp[-1] = 1
for _ in range(n):
np = [0] * ppp
for a in range(p):
for b in range(p):
for c in range(p):
ft = a * pp + b * p + c
if dp[ft] == 0: continue
for x in range(m):
if x > c: continue
if x <= a:
tt = x * pp + b * p + c
elif x <= b:
tt = a * pp + x * p + c
else:
tt = a * pp + b * p + x
# else:
# continue
np[tt] += dp[ft]
np[tt] %= MOD
dp = np
print(sum(dp[a * pp + b * p + c] for a in range(m) for b in range(a + 1, m) for c in range(b + 1, m)) % MOD)
T = 1
for t in range(T):
solve()
| ConDefects/ConDefects/Code/abc237_f/Python/35962547 |
condefects-python_data_631 |
def rint():
return list(map(int, input().split()))
H, W = rint()
S = [[a for a in rint()] for _ in range(H)]
G = [[i*W+j+1 for j in range(W)] for i in range(H)]
# print(G)
def op(A, x,y):
for i in range(H-1):
for j in range(W-1):
if i*W+j > (H-1)*(W-1)//2:
return
A[x+i][y+j], A[x+H-2-i][y+W-2-j] = A[x+H-2-i][y+W-2-j], A[x+i][y+j]
# print(*G, sep='\n')
# print()
# op(G, 0,0)
# print(*G, sep='\n')
# exit()
moves = [(0,0),(0,1),(1,0),(1,1)]
def freeze(A):
return tuple(tuple(row) for row in A)
def thaw(A):
return list(list(row) for row in A)
vis = dict()
from collections import deque
q = deque()
q.append((freeze(S), 0))
while q:
A, cost = q.popleft()
# if cost == 2:
# print(*A, sep='\n')
# print()
vis[A] = cost
if cost == 10:
continue
for move in moves:
B = thaw(A)
op(B,*move)
B = freeze(B)
if B not in vis:
q.append((freeze(B), cost+1))
q = deque()
q.append((freeze(G), 0))
vis2 = set()
inf = float('inf')
ans = inf
while q:
A, cost = q.popleft()
vis2.add(A)
if A in vis:
ans = min(ans, vis[A] + cost)
if cost == 10:
continue
for move in moves:
B = thaw(A)
op(B,*move)
B = freeze(B)
if B not in vis2:
q.append((freeze(B), cost+1))
print(ans if ans != inf else -1)
def rint():
return list(map(int, input().split()))
H, W = rint()
S = [[a for a in rint()] for _ in range(H)]
G = [[i*W+j+1 for j in range(W)] for i in range(H)]
# print(G)
def op(A, x,y):
for i in range(H-1):
for j in range(W-1):
if i*(W-1)+j >= (H-1)*(W-1)//2:
return
A[x+i][y+j], A[x+H-2-i][y+W-2-j] = A[x+H-2-i][y+W-2-j], A[x+i][y+j]
# print(*G, sep='\n')
# print()
# op(G, 0,0)
# print(*G, sep='\n')
# exit()
moves = [(0,0),(0,1),(1,0),(1,1)]
def freeze(A):
return tuple(tuple(row) for row in A)
def thaw(A):
return list(list(row) for row in A)
vis = dict()
from collections import deque
q = deque()
q.append((freeze(S), 0))
while q:
A, cost = q.popleft()
# if cost == 2:
# print(*A, sep='\n')
# print()
vis[A] = cost
if cost == 10:
continue
for move in moves:
B = thaw(A)
op(B,*move)
B = freeze(B)
if B not in vis:
q.append((freeze(B), cost+1))
q = deque()
q.append((freeze(G), 0))
vis2 = set()
inf = float('inf')
ans = inf
while q:
A, cost = q.popleft()
vis2.add(A)
if A in vis:
ans = min(ans, vis[A] + cost)
if cost == 10:
continue
for move in moves:
B = thaw(A)
op(B,*move)
B = freeze(B)
if B not in vis2:
q.append((freeze(B), cost+1))
print(ans if ans != inf else -1) | ConDefects/ConDefects/Code/abc336_f/Python/54952831 |
condefects-python_data_632 | N = int(input())
if N < 10:
print("AGC00" + str(N))
elif N >= 42 :
A = N + 1
print("AGC0" + str(A))
N = int(input())
if N < 10:
print("AGC00" + str(N))
elif 10 <= N < 42:
print("AGC0" + str(N))
elif N >= 42 :
A = N + 1
print("AGC0" + str(A)) | ConDefects/ConDefects/Code/abc230_a/Python/44422973 |
condefects-python_data_633 | N = int(input())
if N >= 43:
print(f"AGC{N+1:03}")
else :
print(f"AGC{N:03}")
N = int(input())
if N >= 42:
print(f"AGC{N+1:03}")
else :
print(f"AGC{N:03}") | ConDefects/ConDefects/Code/abc230_a/Python/45743291 |
condefects-python_data_634 | N = int(input())
if N > 42:
N += 1
if N < 10:
z = 2
else:
z = 1
print('AGC'+ '0' * z + str(N))
N = int(input())
if N >= 42:
N += 1
if N < 10:
z = 2
else:
z = 1
print('AGC'+ '0' * z + str(N)) | ConDefects/ConDefects/Code/abc230_a/Python/44349986 |
condefects-python_data_635 | N = int(input())
print(f"AGC{N+1}" if N > 41 else f"AGC{N}")
N = int(input())
print(f"AGC{str(N+1).zfill(3)}" if N > 41 else f"AGC{str(N).zfill(3)}") | ConDefects/ConDefects/Code/abc230_a/Python/45572645 |
condefects-python_data_636 | N = int(input())
if N >= 42:
print(f"AGC{N + 1:03}")
else:
print('AGC' + '0' + str(N))
N = int(input())
if N >= 42:
print(f"AGC{N + 1:03}")
else:
print(f"AGC{N:03}")
| ConDefects/ConDefects/Code/abc230_a/Python/44828138 |
condefects-python_data_637 | N=input()
if int(N) >=42:
Z =(int(N)+1)
print("AGC0"+ str(Z))
elif int(N) <10:
print("AGC00"+ N)
else:
print("AGC00"+ N)
N=input()
if int(N) >=42:
Z =(int(N)+1)
print("AGC0"+ str(Z))
elif int(N) <10:
print("AGC00"+ N)
else:
print("AGC0"+ N)
| ConDefects/ConDefects/Code/abc230_a/Python/45437543 |
condefects-python_data_638 | n = int(input())
x = n
if n >= 42:
x += 1
print(f"AGC0{x}")
n = int(input())
x = n
if n >= 42:
x += 1
print(f"AGC{x:03}")
| ConDefects/ConDefects/Code/abc230_a/Python/45690200 |
condefects-python_data_639 | from collections import Counter
from functools import reduce
N = int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
cnt = 0
for AB in range(1, N // 2 + 1):
CD = N - AB
if AB == 1:
cntAB = 1
else:
cntAB = reduce(lambda x, y: x * (y+1), Counter(prime_factorize(AB)).values(), 1)
if CD == 1:
cntCD = 1
else:
cntCD = reduce(lambda x, y: x * (y+1), Counter(prime_factorize(CD)).values(), 1)
cnt += (cntAB * cntCD * 2) if AB != CD else (cntAB + cntCD)
print(cnt)
from collections import Counter
from functools import reduce
N = int(input())
def prime_factorize(n):
a = []
while n % 2 == 0:
a.append(2)
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
a.append(f)
n //= f
else:
f += 2
if n != 1:
a.append(n)
return a
cnt = 0
for AB in range(1, N // 2 + 1):
CD = N - AB
if AB == 1:
cntAB = 1
else:
cntAB = reduce(lambda x, y: x * (y+1), Counter(prime_factorize(AB)).values(), 1)
if CD == 1:
cntCD = 1
else:
cntCD = reduce(lambda x, y: x * (y+1), Counter(prime_factorize(CD)).values(), 1)
cnt += (cntAB * cntCD * 2) if AB != CD else (cntAB * cntCD)
print(cnt)
| ConDefects/ConDefects/Code/abc292_c/Python/45536157 |
condefects-python_data_640 | # https://qiita.com/LorseKudos/items/9eb560494862c8b4eb56
# https://note.com/kai1023/n/naf4e2ef6f88d
# https://techmath-project.com/2023/03/05/abc292/#C_%E2%80%93_Four_Variables
N = int(input())
def make_divisors(i):
cnt = 0
for range_num in range(1,int(i **0.5)+1):
if i % range_num == 0:
if range_num * range_num < i:
cnt += 2
else:
cnt += 1
return cnt
le = [make_divisors(i) for i in range(1,N)]
print(le)
ans = 0
for i in range(1, N):
ans += le[i - 1] * le[N - i - 1]
print(ans)
# https://qiita.com/LorseKudos/items/9eb560494862c8b4eb56
# https://note.com/kai1023/n/naf4e2ef6f88d
# https://techmath-project.com/2023/03/05/abc292/#C_%E2%80%93_Four_Variables
N = int(input())
def make_divisors(i):
cnt = 0
for range_num in range(1,int(i **0.5)+1):
if i % range_num == 0:
if range_num * range_num < i:
cnt += 2
else:
cnt += 1
return cnt
le = [make_divisors(i) for i in range(1,N)]
# print(le)
ans = 0
for i in range(1, N):
ans += le[i - 1] * le[N - i - 1]
print(ans) | ConDefects/ConDefects/Code/abc292_c/Python/45291809 |
condefects-python_data_641 | import sys
from collections import defaultdict
from typing import TypeVar, Generic, Callable, List
T = TypeVar('T')
U = TypeVar('U')
class LazySegmentTreeInjectable(Generic[T, U]):
def __init__(self,
n: int,
identity_data: Callable[[], T],
identity_lazy: Callable[[], U],
operation: Callable[[T, T], T],
mapping: Callable[[T, U], T],
composition: Callable[[U, U], U],
):
self.n = n
self.depth = n.bit_length()
self.offset = 1 << self.depth
self.identity_data = identity_data
self.identity_lazy = identity_lazy
self.operation = operation
self.mapping = mapping
self.composition = composition
self.data = [identity_data() for _ in range(self.offset << 1)]
self.lazy = [identity_lazy() for _ in range(self.offset)]
@classmethod
def from_array(cls,
arr: List[T],
identity_data: Callable[[], T],
identity_lazy: Callable[[], U],
operation: Callable[[T, T], T],
mapping: Callable[[T, U], T],
composition: Callable[[U, U], U],
):
ins = cls(len(arr), identity_data, identity_lazy, operation, mapping, composition)
ins.data[ins.offset:ins.offset + ins.n] = arr
for i in range(ins.offset - 1, 0, -1):
ins.update(i)
return ins
def push(self, i: int) -> None:
if i < self.offset:
data = self.data
lazy = self.lazy
lz = lazy[i]
lch = i << 1
rch = lch + 1
data[lch] = self.mapping(data[lch], lz)
data[rch] = self.mapping(data[rch], lz)
if lch < self.offset:
lazy[lch] = self.composition(lazy[lch], lz)
lazy[rch] = self.composition(lazy[rch], lz)
lazy[i] = self.identity_lazy()
def update(self, i: int) -> None:
lch = i << 1
rch = lch + 1
self.data[i] = self.operation(self.data[lch], self.data[rch])
def all_apply(self, i: int, d: U) -> None:
self.data[i] = self.mapping(self.data[i], d)
if i < self.offset:
self.lazy[i] = self.composition(self.lazy[i], d)
def propagate(self, l: int, r: int) -> None:
for i in range(self.depth, 0, -1):
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push((r - 1) >> i)
def range_update(self, l: int, r: int, d: U) -> None:
l += self.offset
r += self.offset
self.propagate(l, r)
l2 = l
r2 = r
while l < r:
if (l & 1) == 1:
self.all_apply(l, d)
l += 1
if (r & 1) == 1:
r -= 1
self.all_apply(r, d)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.depth + 1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r - 1) >> i)
def range_query(self, l: int, r: int) -> T:
l += self.offset
r += self.offset
self.propagate(l, r)
sml = self.identity_data()
smr = self.identity_data()
while l < r:
if (l & 1) == 1:
sml = self.operation(sml, self.data[l])
l += 1
if (r & 1) == 1:
r -= 1
smr = self.operation(self.data[r], smr)
l >>= 1
r >>= 1
return self.operation(sml, smr)
def point_set(self, p: int, d: T) -> None:
p += self.offset
for i in range(self.depth, 0, -1):
self.push(p >> i)
self.data[p] = d
for i in range(1, self.depth + 1):
self.update(p >> i)
def point_get(self, p: int) -> T:
p += self.offset
for i in range(self.depth, 0, -1):
self.push(p >> i)
return self.data[p]
def debug_print(self) -> None:
i = 1
while i <= self.offset:
print(*((cnt, xxx[idx] if idx < m else idx) for cnt, idx in self.data[i:i * 2]))
i <<= 1
i = 1
while i <= self.offset:
print(self.lazy[i:i * 2])
i <<= 1
INF = 1 << 60
identity_data = lambda: (0, INF)
identity_lazy = int
def operation(a: T, b: T) -> T:
if a[0] >= b[0]:
return a
return b
def mapping(a: T, b: U) -> T:
return (a[0] + b, a[1])
def composition(a: U, b: U) -> U:
return a + b
input = sys.stdin.buffer.readline
n = int(input())
sections = []
xxx = set()
for _ in range(n):
l, r = map(int, input().split())
sections.append((l, r))
xxx.add(l - 1)
xxx.add(l)
xxx.add(l + 1)
xxx.add(r - 1)
xxx.add(r)
xxx.add(r + 1)
xxx = sorted(xxx)
rev = {x: i for i, x in enumerate(xxx)}
m = len(xxx)
# assert xxx[0] != -1 # 関係ない
# assert xxx[-1] != 1_000_000_001 # 関係ない
init = [(0, i) for i in range(m)]
lst = LazySegmentTreeInjectable.from_array(init, identity_data, identity_lazy, operation, mapping, composition)
sections_l = defaultdict(list)
sections_r = defaultdict(int)
for l, r in sections:
i = rev[l]
j = rev[r]
sections_l[i].append(j)
sections_r[j] += 1
lst.range_update(i + 1, j, 1)
ans_count = 0
ans_l = 0
ans_r = 1
for l in range(m):
if l in sections_l:
for r in sections_l[l]:
lst.range_update(l + 1, r, -1)
if l in sections_r:
lst.range_update(l + 1, lst.offset, -sections_r[l])
cnt, r = lst.data[1]
# print(f'{l=} {cnt=} {r=}')
if ans_count < cnt and 0 <= xxx[l] < xxx[r] <= 1_000_000_000:
ans_count = cnt
ans_l = xxx[l]
ans_r = xxx[r]
if l in sections_l:
for r in sections_l[l]:
lst.range_update(r + 1, lst.offset, 1)
# print(f'{l=} {ans_count=} {ans_l=} {ans_r=}')
cnt, r = lst.data[1]
assert cnt == 0 and r == 0
print(ans_l, ans_r)
import sys
from collections import defaultdict
from typing import TypeVar, Generic, Callable, List
T = TypeVar('T')
U = TypeVar('U')
class LazySegmentTreeInjectable(Generic[T, U]):
def __init__(self,
n: int,
identity_data: Callable[[], T],
identity_lazy: Callable[[], U],
operation: Callable[[T, T], T],
mapping: Callable[[T, U], T],
composition: Callable[[U, U], U],
):
self.n = n
self.depth = n.bit_length()
self.offset = 1 << self.depth
self.identity_data = identity_data
self.identity_lazy = identity_lazy
self.operation = operation
self.mapping = mapping
self.composition = composition
self.data = [identity_data() for _ in range(self.offset << 1)]
self.lazy = [identity_lazy() for _ in range(self.offset)]
@classmethod
def from_array(cls,
arr: List[T],
identity_data: Callable[[], T],
identity_lazy: Callable[[], U],
operation: Callable[[T, T], T],
mapping: Callable[[T, U], T],
composition: Callable[[U, U], U],
):
ins = cls(len(arr), identity_data, identity_lazy, operation, mapping, composition)
ins.data[ins.offset:ins.offset + ins.n] = arr
for i in range(ins.offset - 1, 0, -1):
ins.update(i)
return ins
def push(self, i: int) -> None:
if i < self.offset:
data = self.data
lazy = self.lazy
lz = lazy[i]
lch = i << 1
rch = lch + 1
data[lch] = self.mapping(data[lch], lz)
data[rch] = self.mapping(data[rch], lz)
if lch < self.offset:
lazy[lch] = self.composition(lazy[lch], lz)
lazy[rch] = self.composition(lazy[rch], lz)
lazy[i] = self.identity_lazy()
def update(self, i: int) -> None:
lch = i << 1
rch = lch + 1
self.data[i] = self.operation(self.data[lch], self.data[rch])
def all_apply(self, i: int, d: U) -> None:
self.data[i] = self.mapping(self.data[i], d)
if i < self.offset:
self.lazy[i] = self.composition(self.lazy[i], d)
def propagate(self, l: int, r: int) -> None:
for i in range(self.depth, 0, -1):
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push((r - 1) >> i)
def range_update(self, l: int, r: int, d: U) -> None:
l += self.offset
r += self.offset
self.propagate(l, r)
l2 = l
r2 = r
while l < r:
if (l & 1) == 1:
self.all_apply(l, d)
l += 1
if (r & 1) == 1:
r -= 1
self.all_apply(r, d)
l >>= 1
r >>= 1
l = l2
r = r2
for i in range(1, self.depth + 1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r - 1) >> i)
def range_query(self, l: int, r: int) -> T:
l += self.offset
r += self.offset
self.propagate(l, r)
sml = self.identity_data()
smr = self.identity_data()
while l < r:
if (l & 1) == 1:
sml = self.operation(sml, self.data[l])
l += 1
if (r & 1) == 1:
r -= 1
smr = self.operation(self.data[r], smr)
l >>= 1
r >>= 1
return self.operation(sml, smr)
def point_set(self, p: int, d: T) -> None:
p += self.offset
for i in range(self.depth, 0, -1):
self.push(p >> i)
self.data[p] = d
for i in range(1, self.depth + 1):
self.update(p >> i)
def point_get(self, p: int) -> T:
p += self.offset
for i in range(self.depth, 0, -1):
self.push(p >> i)
return self.data[p]
def debug_print(self) -> None:
i = 1
while i <= self.offset:
print(*((cnt, xxx[idx] if idx < m else idx) for cnt, idx in self.data[i:i * 2]))
i <<= 1
i = 1
while i <= self.offset:
print(self.lazy[i:i * 2])
i <<= 1
INF = 1 << 60
identity_data = lambda: (0, INF)
identity_lazy = int
def operation(a: T, b: T) -> T:
if a[0] >= b[0]:
return a
return b
def mapping(a: T, b: U) -> T:
return (a[0] + b, a[1])
def composition(a: U, b: U) -> U:
return a + b
input = sys.stdin.buffer.readline
n = int(input())
sections = []
xxx = {0}
for _ in range(n):
l, r = map(int, input().split())
sections.append((l, r))
xxx.add(l - 1)
xxx.add(l)
xxx.add(l + 1)
xxx.add(r - 1)
xxx.add(r)
xxx.add(r + 1)
xxx = sorted(xxx)
rev = {x: i for i, x in enumerate(xxx)}
m = len(xxx)
# assert xxx[0] != -1 # 関係ない
# assert xxx[-1] != 1_000_000_001 # 関係ない
init = [(0, i) for i in range(m)]
lst = LazySegmentTreeInjectable.from_array(init, identity_data, identity_lazy, operation, mapping, composition)
sections_l = defaultdict(list)
sections_r = defaultdict(int)
for l, r in sections:
i = rev[l]
j = rev[r]
sections_l[i].append(j)
sections_r[j] += 1
lst.range_update(i + 1, j, 1)
ans_count = 0
ans_l = 0
ans_r = 1
for l in range(m):
if l in sections_l:
for r in sections_l[l]:
lst.range_update(l + 1, r, -1)
if l in sections_r:
lst.range_update(l + 1, lst.offset, -sections_r[l])
cnt, r = lst.data[1]
# print(f'{l=} {cnt=} {r=}')
if ans_count < cnt and 0 <= xxx[l] < xxx[r] <= 1_000_000_000:
ans_count = cnt
ans_l = xxx[l]
ans_r = xxx[r]
if l in sections_l:
for r in sections_l[l]:
lst.range_update(r + 1, lst.offset, 1)
# print(f'{l=} {ans_count=} {ans_l=} {ans_r=}')
cnt, r = lst.data[1]
assert cnt == 0 and r == 0
print(ans_l, ans_r)
| ConDefects/ConDefects/Code/abc360_f/Python/55104098 |
condefects-python_data_642 | n=int(input())
z=[0,1]
q=[]
for i in range(n):
l,r=map(int,input().split())
z+=[l,l-1,l+1,r,r-1,r+1]
q+=[(l+1,0,l-1,-1),(r,0,l-1,1),(r+1,l+1,r-1,-1)]
z=sorted(set(z))
d={v:i for i,v in enumerate(z)}
from atcoder import lazysegtree
st=lazysegtree.LazySegTree(min,(0,10**10),lambda f,x:(x[0]+f,x[1]),lambda g,f:g+f,0,[(0,v) for v in z])
ans=[(0,0,1)]
q.sort()
q.reverse()
while len(q)>0:
y=q[-1][0]
while len(q)>0 and q[-1][0]==y:
_,l,r,p=q.pop()
st.apply(d[l],d[r]+1,p)
p1,p2=st.all_prod()
if 0<=p2<y:
ans+=[(p1,p2,y)]
_,l,r=min(ans)
print(l,r)
n=int(input())
z=[0,1]
q=[]
for i in range(n):
l,r=map(int,input().split())
z+=[l,l-1,l+1,r,r-1,r+1]
q+=[(l+1,0,l-1,-1),(r,0,l-1,1),(r+1,l+1,r-1,-1)]
z=sorted(set(z))
d={v:i for i,v in enumerate(z)}
from atcoder import lazysegtree
st=lazysegtree.LazySegTree(min,(0,10**10),lambda f,x:(x[0]+f,x[1]),lambda g,f:g+f,0,[(0,v) for v in z])
ans=[(0,0,1)]
q.sort()
q.reverse()
while len(q)>0:
y=q[-1][0]
while len(q)>0 and q[-1][0]==y:
_,l,r,p=q.pop()
st.apply(d[l],d[r]+1,p)
p1,p2=st.all_prod()
if 0<=p2<y<=10**9:
ans+=[(p1,p2,y)]
_,l,r=min(ans)
print(l,r) | ConDefects/ConDefects/Code/abc360_f/Python/55104262 |
condefects-python_data_643 | def main():
# write code here.
N = II()
LR = LL(N)
"""
座圧すべき値は l+1,r,r+1,10**9
"""
CAP = 10**9+5
inv = [CAP]
for l,r in LR:
inv+=[l+1,r,r+1]
inv = sorted(set(inv))
D = {e:i for i,e in enumerate(inv)}
# x軸で処理内容をソート.
event = []
for l,r in LR:
event.append((0,+1,l+1,r))
event.append((l,-1,l+1,r))
event.append((l+1,+1,r+1,CAP))
event.append((r,-1,r+1,CAP))
event.sort(key=lambda e:e[0])
from atcoder.lazysegtree import LazySegTree
INF = 1<<60
# data:(最大値, -y(座圧後の値))
op = max
e = (0,-INF)
def mapp(f, d):
# 区間加算.
return (d[0]+f, d[1])
def comp(f, l):
return f+l
ID = 0
# 初期値は、最大値0 argminは自身. 座圧後の空間を確保.
seg = LazySegTree(op, e, mapp, comp, ID, [(0,-i)for i in range(len(D)+5)])
LEN = len(event)
ans = (0, 1)
crr_max = 0
for i in range(LEN):
x,f,L,R = event[i]
# 区間加算を行う.
seg.apply(D[L],D[R],f)
# 次のxも同じなら.
if i+1<LEN and x==event[i+1][0]:
continue
res = seg.all_prod()
# 最大値が更新されるなら. tieは無視で良い.
if res[0] > crr_max:
crr_max = res[0]
if -res[1] >= len(inv):
continue
y = inv[-res[1]]
ans = (x, y)
print(*ans)
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def popcount64(n):
# 63桁まで高速に動く.64桁まで正常に動く.
c=(n&0x5555555555555555)+((n>>1)&0x5555555555555555)
c=(c&0x3333333333333333)+((c>>2)&0x3333333333333333)
c=(c&0x0f0f0f0f0f0f0f0f)+((c>>4)&0x0f0f0f0f0f0f0f0f)
c=(c&0x00ff00ff00ff00ff)+((c>>8)&0x00ff00ff00ff00ff)
c=(c&0x0000ffff0000ffff)+((c>>16)&0x0000ffff0000ffff)
c=(c&0x00000000ffffffff)+((c>>32)&0x00000000ffffffff)
return c
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def prefix_op(lst, op=lambda x,y:(x+y)%998244353, e=0):
N = len(lst)
res = [e]*(N+1)
for i in range(N):
res[i+1] = op(res[i], lst[i])
return res
def suffix_op(lst, op=lambda x,y:(x+y)%998244353, e=0):
N = len(lst)
res = [e]*(N+1)
for i in range(N):
res[N-1-i] = op(lst[N-1-i], res[N-i])
return res
def sigma_LinearFunc(coeff1, coeff0, left, right, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
MODで計算したい場合、区間の引数をMOD取った上で代入しても良い.
そのとき、left > right となってもよい.
"""
if MOD:
# MODが素数でない場合にも対応するように、和公式を適応後に剰余を計算.
return ((coeff0%MOD*((right-left+1)%MOD)%MOD) + (coeff1%MOD*((left+right)*(right-left+1)//2%MOD)%MOD))%MOD
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
""" 矩形の二次元配列を扱う諸関数 """
def copy_table(table):
H,W = len(table), len(table[0])
res = []
for i in range(H):
res.append([])
for j in range(W):
res[-1].append(table[i][j])
return res
def sum_table(table, MOD=None):
H,W = len(table), len(table[0])
res = 0
for i in range(H):
for j in range(W):
res += table[i][j]
if MOD:
res %= MOD
return res
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def convert_table_to_bit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rotate_table(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mul_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mul_matrix(res, mat, mod)
mat = mul_matrix(mat, mat, mod)
exp //= 2
return res
def compress(lst):
D = {e:i for i,e in enumerate(sorted(set(lst)))}
return [D[e] for e in lst]
def highDimCompress(lst):
#(x,y)の配列や,(x,y,z)の配列が与えられたとき,軸ごとに座圧する.
return list(zip(*list(map(compress,list(zip(*lst))))))
#classes
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
def multi_add(self, x, y):
if not self.exist(x):
self.add((x,y))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+y))
def multi_sub(self, x, y):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt <= y:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-y))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def island(self, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
H, W = self.H, self.W
self.island_id = [[-1]*W for _ in range(H)]
self.island_size = [[-1]*W for _ in range(W)]
crr_id = 0
id2size = dict()
for sh in range(H):
for sw in range(W):
if self.table[sh][sw] in self.wall:
continue
if self.island_id[sh][sw] != -1:
continue
deq = deque()
deq.append((sh,sw))
crr_size = 1
self.island_id[sh][sw] = crr_id
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh, nw = h+dh, w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if self.table[nh][nw] in self.wall:
continue
if self.island_id[nh][nw] == -1:
self.island_id[nh][nw] = crr_id
deq.append((nh, nw))
crr_size += 1
id2size[crr_id] = crr_size
crr_id += 1
for h in range(H):
for w in range(W):
if self.table[h][w] in self.wall:
continue
self.island_size[h][w] = id2size[self.island_id[h][w]]
return self.island_id, self.island_size
def distance(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W, tab, wall = self.H, self.W, self.table, self.wall
INF = 1<<60
deq = deque()
deq.append(start)
dist = [[INF]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
# gridの範囲外.
if (not 0<=nh<H) or (not 0<=nw<W):
continue
# wallに設定されている文字なら.
if tab[nh][nw] in wall:
continue
new_dist = dist[h][w] + 1
#goalが引数で与えられていてgoalに達したら終了.
if goal and (nh,nw)==goal:
return new_dist
if dist[nh][nw] > new_dist:
dist[nh][nw] = new_dist
deq.append((nh,nw))
# goalが設定されていていまだreturnされていないなら,
# goalに到達できなかったということ.
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
class RootedTree:
@classmethod
def autobuild(cls, N, input_index=1):
"""
頂点数を受け取り、次のN-1行を読み込み、インスタンスを返す.
対応の型 : (u,v) , (u,v,c)
"""
G = [[] for _ in range(N)]
if N==1: return RootedTree(G)
line1 = list(map(int, input().split()))
assert 2<=len(line1)<=3
# 重み無し.
if len(line1)==2:
u,v = line1
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
for _ in range(N-2):
u,v = map(int, input().split())
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
return RootedTree(G)
else:
u,v,c = line1
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
edge = [(u,v,c)]
for _ in range(N-2):
u,v,c = map(int, input().split())
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
edge.append((u,v,c))
obj = RootedTree(G)
obj.set_weight(edge)
return obj
def __init__(self, G):
self._N = len(G)
self.G = G
self._rooted = False
self._has_weight = False
self._key = 10**7
def set_root(self, root):
""" BFSついでにトポロジカルソート列も求める """
assert self._rooted == False
self.root = root
n, G = self._N, self.G
par, ch, ts = [-1]*n, [[] for _ in range(n)], []
deq = deque([root])
while deq:
v = deq.popleft()
ts.append(v)
for adj in G[v]:
if adj == par[v]: continue
par[adj] = v
ch[v].append(adj)
deq.append(adj)
self.parent, self.children, self.ts_order = par, ch, ts
self._rooted = True
def _encode(self, u, v):
return u*self._key + v
def _decode(self, uv):
return divmod(uv, self._key)
def is_root(self, v):
return v == self.root
def is_leaf(self, v):
return len(self.children[v]) == 0
""" weight """
def set_weight(self, edge):
assert self._has_weight == False
d = {}
for u,v,c in edge:
d[self._encode(u,v)] = d[self._encode(v,u)] = c
self.weight = d
self._has_weight = True
def get_weight(self, u, v):
return self.weight[self._encode(u, v)]
""" depth"""
def get_depth(self, v):
# obj.depth[v] と同じ.
if not hasattr(self, "depth"):
self.build_depth()
return self.depth[v]
def build_depth(self):
assert self._rooted
N, ch, ts = self._N, self.children, self.ts_order
depth = [0]*N
for v in ts:
for c in ch[v]:
depth[c] = depth[v] + 1
self.depth = depth
""" subtree_size """
def build_des_size(self):
assert self._rooted
if hasattr(self, "des_size"):
return
N, ts, par = self._N, self.ts_order, self.parent
des = [1]*N
for i in range(N-1,0,-1):
v = ts[i]
p = par[v]
des[p] += des[v]
self.des_size = des
""" centroid """
def centroid_decomposition(self):
if hasattr(self, "centroid_id"):
return
# 根に依存しないアルゴリズムなので根0にしていい.
if not self._rooted:
self.set_root(0)
if not hasattr(self, "des_size"):
self.build_des_size()
# sizeは書き換えるのでコピーを使用.
N, G, size = self._N, self.G, self.des_size[:]
c_id, c_depth, c_par, c_dfs_order = [-1]*N, [-1]*N, [-1]*N, []
stack = [(self.root, -1, 0)]
# 重心を見つけたら,「重心分解後のその頂点が重心となる部分木」の
# DFS順の順番, 深さ, 重心木における親にあたる部分木の重心を記録
for order in range(N):
v, prev, d = stack.pop()
while True:
for adj in G[v]:
if c_id[adj] == -1 and size[adj]*2 > size[v]:
# adjを今見ている部分木の根にし,sizeを書き換える.
size[v], size[adj], v = size[v]-size[adj], size[v], adj
break
else:
break
c_id[v], c_depth[v], c_par[v] = order, d, prev
c_dfs_order.append(v)
if size[v] > 1:
for adj in G[v]:
if c_id[adj] == -1:
stack.append((adj, v, d+1))
self.centroid_id, self.centroid_depth, self.centroid_parent, self.centroid_dfs_order = c_id, c_depth, c_par, c_dfs_order
def is_member_of_centroid_tree(self, v, c):
# 頂点vが重心cの重心木に属するかを判定 O(logN)
vs = self.get_higher_centroids_with_self(v)
return c in vs
def is_id_larger(self, u, v):
# 重心cからBFSする時に、is_id_larger(adj, c)とすれば重心木内部を探索できる.
return self.centroid_id[u] > self.centroid_id[v]
def get_higher_centroids_with_self(self, c):
# 頂点cが属する重心木の重心をサイズの昇順に列挙. O(logN)
vs = []
for d in range(self.centroid_depth[c], -1, -1):
vs.append(c)
c = self.centroid_parent[c]
return vs
def find_lowest_common_centroid(self, u, v):
# 頂点u,vをどちらも含む最小の重心木を返す. O(logN)
c_depth, c_par = self.centroid_depth, self.centroid_parent
du, dv = c_depth[u], c_depth[v]
if du > dv:
u,v = v,u
du,dv = dv,du
for _ in range(dv - du):
v = c_par[v]
while u != v:
u,v = c_par[u],c_par[v]
return u
""" tree dp """
def dp_from_leaf(self, merge, e, add_root, push=lambda obj,data,dst,src:data):
assert self._rooted
N, ts, par = self._N, self.ts_order, self.parent
sub = [e] * N
for i in range(N-1,-1,-1):
v = ts[i]
sub[v] = add_root(self, sub[v], v)
p = par[v]
if p != -1:
sub[p] = merge(sub[p], push(self, sub[v], p, v))
return sub
def rerooting_dp(self, merge, e, add_root, push=lambda obj,data,dst,src:data):
if self._rooted == False:
self.set_root(0)
sub = self.dp_from_leaf(merge, e, add_root, push)
N = self._N
ts, par, ch = self.ts_order, self.parent, self.children
compl, dp = [e]*N, [e]*N
for i in range(N):
v = ts[i]
p, size = par[v], len(ch[v])
left, right = [e]*size, [e]*size
for j in range(size):
c = ch[v][j]
left[j] = merge(left[j-1] if j>0 else e, push(self, sub[c], v, c))
for j in range(size-1,-1,-1):
c = ch[v][j]
right[j] = merge(right[j+1] if j<size-1 else e, push(self, sub[c], v, c))
for j in range(size):
c = ch[v][j]
compl[c] = merge(compl[c], left[j-1] if j>0 else e)
compl[c] = merge(compl[c], right[j+1] if j<size-1 else e)
if p != -1:
compl[c] = merge(compl[c], push(self, compl[v], v, p))
compl[c] = add_root(self, compl[c], v)
if p != -1:
dp[v] = merge(dp[v], push(self, compl[v], v, p))
dp[v] = merge(dp[v], left[-1] if size else e)
dp[v] = add_root(self, dp[v], v)
return dp
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
# random_checker.
def random_checker():
"""
必要な準備 :
1. main関数の入力をコメントアウトして引数で受け取る.
2. main関数の出力をreturnに変更.
"""
import random
T = 1000
for testcase in range(T):
#--------------------------------------#
N = random.randrange(3,6)
A = []
B = []
for i in range(N):
A.append(random.randrange(1,10**2+1))
B.append(random.randrange(1,10**2+1))
args = (N,A,B)
#--------------------------------------#
res_main = main(*args)
res_naive = naive(*args)
if res_main != res_naive:
print(f"{testcase}回目の実行\n")
print("入力値:")
print(*args, sep="\n")
print("main():")
print(res_main)
print("naive():")
print(res_naive)
return
print(f"{T}回の実行で有効なテストケースを発見できませんでした.")
main()
def main():
# write code here.
N = II()
LR = LL(N)
"""
座圧すべき値は l+1,r,r+1,10**9
"""
CAP = 10**9+1
inv = [CAP]
for l,r in LR:
inv+=[l+1,r,r+1]
inv = sorted(set(inv))
D = {e:i for i,e in enumerate(inv)}
# x軸で処理内容をソート.
event = []
for l,r in LR:
event.append((0,+1,l+1,r))
event.append((l,-1,l+1,r))
event.append((l+1,+1,r+1,CAP))
event.append((r,-1,r+1,CAP))
event.sort(key=lambda e:e[0])
from atcoder.lazysegtree import LazySegTree
INF = 1<<60
# data:(最大値, -y(座圧後の値))
op = max
e = (0,-INF)
def mapp(f, d):
# 区間加算.
return (d[0]+f, d[1])
def comp(f, l):
return f+l
ID = 0
# 初期値は、最大値0 argminは自身. 座圧後の空間を確保.
seg = LazySegTree(op, e, mapp, comp, ID, [(0,-i)for i in range(len(D)+5)])
LEN = len(event)
ans = (0, 1)
crr_max = 0
for i in range(LEN):
x,f,L,R = event[i]
# 区間加算を行う.
seg.apply(D[L],D[R],f)
# 次のxも同じなら.
if i+1<LEN and x==event[i+1][0]:
continue
res = seg.all_prod()
# 最大値が更新されるなら. tieは無視で良い.
if res[0] > crr_max:
crr_max = res[0]
if -res[1] >= len(inv):
continue
y = inv[-res[1]]
ans = (x, y)
print(*ans)
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def popcount64(n):
# 63桁まで高速に動く.64桁まで正常に動く.
c=(n&0x5555555555555555)+((n>>1)&0x5555555555555555)
c=(c&0x3333333333333333)+((c>>2)&0x3333333333333333)
c=(c&0x0f0f0f0f0f0f0f0f)+((c>>4)&0x0f0f0f0f0f0f0f0f)
c=(c&0x00ff00ff00ff00ff)+((c>>8)&0x00ff00ff00ff00ff)
c=(c&0x0000ffff0000ffff)+((c>>16)&0x0000ffff0000ffff)
c=(c&0x00000000ffffffff)+((c>>32)&0x00000000ffffffff)
return c
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def prefix_op(lst, op=lambda x,y:(x+y)%998244353, e=0):
N = len(lst)
res = [e]*(N+1)
for i in range(N):
res[i+1] = op(res[i], lst[i])
return res
def suffix_op(lst, op=lambda x,y:(x+y)%998244353, e=0):
N = len(lst)
res = [e]*(N+1)
for i in range(N):
res[N-1-i] = op(lst[N-1-i], res[N-i])
return res
def sigma_LinearFunc(coeff1, coeff0, left, right, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
MODで計算したい場合、区間の引数をMOD取った上で代入しても良い.
そのとき、left > right となってもよい.
"""
if MOD:
# MODが素数でない場合にも対応するように、和公式を適応後に剰余を計算.
return ((coeff0%MOD*((right-left+1)%MOD)%MOD) + (coeff1%MOD*((left+right)*(right-left+1)//2%MOD)%MOD))%MOD
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
""" 矩形の二次元配列を扱う諸関数 """
def copy_table(table):
H,W = len(table), len(table[0])
res = []
for i in range(H):
res.append([])
for j in range(W):
res[-1].append(table[i][j])
return res
def sum_table(table, MOD=None):
H,W = len(table), len(table[0])
res = 0
for i in range(H):
for j in range(W):
res += table[i][j]
if MOD:
res %= MOD
return res
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def convert_table_to_bit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rotate_table(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mul_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mul_matrix(res, mat, mod)
mat = mul_matrix(mat, mat, mod)
exp //= 2
return res
def compress(lst):
D = {e:i for i,e in enumerate(sorted(set(lst)))}
return [D[e] for e in lst]
def highDimCompress(lst):
#(x,y)の配列や,(x,y,z)の配列が与えられたとき,軸ごとに座圧する.
return list(zip(*list(map(compress,list(zip(*lst))))))
#classes
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
def multi_add(self, x, y):
if not self.exist(x):
self.add((x,y))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+y))
def multi_sub(self, x, y):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt <= y:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-y))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def island(self, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
H, W = self.H, self.W
self.island_id = [[-1]*W for _ in range(H)]
self.island_size = [[-1]*W for _ in range(W)]
crr_id = 0
id2size = dict()
for sh in range(H):
for sw in range(W):
if self.table[sh][sw] in self.wall:
continue
if self.island_id[sh][sw] != -1:
continue
deq = deque()
deq.append((sh,sw))
crr_size = 1
self.island_id[sh][sw] = crr_id
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh, nw = h+dh, w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if self.table[nh][nw] in self.wall:
continue
if self.island_id[nh][nw] == -1:
self.island_id[nh][nw] = crr_id
deq.append((nh, nw))
crr_size += 1
id2size[crr_id] = crr_size
crr_id += 1
for h in range(H):
for w in range(W):
if self.table[h][w] in self.wall:
continue
self.island_size[h][w] = id2size[self.island_id[h][w]]
return self.island_id, self.island_size
def distance(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W, tab, wall = self.H, self.W, self.table, self.wall
INF = 1<<60
deq = deque()
deq.append(start)
dist = [[INF]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
# gridの範囲外.
if (not 0<=nh<H) or (not 0<=nw<W):
continue
# wallに設定されている文字なら.
if tab[nh][nw] in wall:
continue
new_dist = dist[h][w] + 1
#goalが引数で与えられていてgoalに達したら終了.
if goal and (nh,nw)==goal:
return new_dist
if dist[nh][nw] > new_dist:
dist[nh][nw] = new_dist
deq.append((nh,nw))
# goalが設定されていていまだreturnされていないなら,
# goalに到達できなかったということ.
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
class RootedTree:
@classmethod
def autobuild(cls, N, input_index=1):
"""
頂点数を受け取り、次のN-1行を読み込み、インスタンスを返す.
対応の型 : (u,v) , (u,v,c)
"""
G = [[] for _ in range(N)]
if N==1: return RootedTree(G)
line1 = list(map(int, input().split()))
assert 2<=len(line1)<=3
# 重み無し.
if len(line1)==2:
u,v = line1
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
for _ in range(N-2):
u,v = map(int, input().split())
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
return RootedTree(G)
else:
u,v,c = line1
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
edge = [(u,v,c)]
for _ in range(N-2):
u,v,c = map(int, input().split())
u,v = u-input_index, v-input_index
G[u].append(v)
G[v].append(u)
edge.append((u,v,c))
obj = RootedTree(G)
obj.set_weight(edge)
return obj
def __init__(self, G):
self._N = len(G)
self.G = G
self._rooted = False
self._has_weight = False
self._key = 10**7
def set_root(self, root):
""" BFSついでにトポロジカルソート列も求める """
assert self._rooted == False
self.root = root
n, G = self._N, self.G
par, ch, ts = [-1]*n, [[] for _ in range(n)], []
deq = deque([root])
while deq:
v = deq.popleft()
ts.append(v)
for adj in G[v]:
if adj == par[v]: continue
par[adj] = v
ch[v].append(adj)
deq.append(adj)
self.parent, self.children, self.ts_order = par, ch, ts
self._rooted = True
def _encode(self, u, v):
return u*self._key + v
def _decode(self, uv):
return divmod(uv, self._key)
def is_root(self, v):
return v == self.root
def is_leaf(self, v):
return len(self.children[v]) == 0
""" weight """
def set_weight(self, edge):
assert self._has_weight == False
d = {}
for u,v,c in edge:
d[self._encode(u,v)] = d[self._encode(v,u)] = c
self.weight = d
self._has_weight = True
def get_weight(self, u, v):
return self.weight[self._encode(u, v)]
""" depth"""
def get_depth(self, v):
# obj.depth[v] と同じ.
if not hasattr(self, "depth"):
self.build_depth()
return self.depth[v]
def build_depth(self):
assert self._rooted
N, ch, ts = self._N, self.children, self.ts_order
depth = [0]*N
for v in ts:
for c in ch[v]:
depth[c] = depth[v] + 1
self.depth = depth
""" subtree_size """
def build_des_size(self):
assert self._rooted
if hasattr(self, "des_size"):
return
N, ts, par = self._N, self.ts_order, self.parent
des = [1]*N
for i in range(N-1,0,-1):
v = ts[i]
p = par[v]
des[p] += des[v]
self.des_size = des
""" centroid """
def centroid_decomposition(self):
if hasattr(self, "centroid_id"):
return
# 根に依存しないアルゴリズムなので根0にしていい.
if not self._rooted:
self.set_root(0)
if not hasattr(self, "des_size"):
self.build_des_size()
# sizeは書き換えるのでコピーを使用.
N, G, size = self._N, self.G, self.des_size[:]
c_id, c_depth, c_par, c_dfs_order = [-1]*N, [-1]*N, [-1]*N, []
stack = [(self.root, -1, 0)]
# 重心を見つけたら,「重心分解後のその頂点が重心となる部分木」の
# DFS順の順番, 深さ, 重心木における親にあたる部分木の重心を記録
for order in range(N):
v, prev, d = stack.pop()
while True:
for adj in G[v]:
if c_id[adj] == -1 and size[adj]*2 > size[v]:
# adjを今見ている部分木の根にし,sizeを書き換える.
size[v], size[adj], v = size[v]-size[adj], size[v], adj
break
else:
break
c_id[v], c_depth[v], c_par[v] = order, d, prev
c_dfs_order.append(v)
if size[v] > 1:
for adj in G[v]:
if c_id[adj] == -1:
stack.append((adj, v, d+1))
self.centroid_id, self.centroid_depth, self.centroid_parent, self.centroid_dfs_order = c_id, c_depth, c_par, c_dfs_order
def is_member_of_centroid_tree(self, v, c):
# 頂点vが重心cの重心木に属するかを判定 O(logN)
vs = self.get_higher_centroids_with_self(v)
return c in vs
def is_id_larger(self, u, v):
# 重心cからBFSする時に、is_id_larger(adj, c)とすれば重心木内部を探索できる.
return self.centroid_id[u] > self.centroid_id[v]
def get_higher_centroids_with_self(self, c):
# 頂点cが属する重心木の重心をサイズの昇順に列挙. O(logN)
vs = []
for d in range(self.centroid_depth[c], -1, -1):
vs.append(c)
c = self.centroid_parent[c]
return vs
def find_lowest_common_centroid(self, u, v):
# 頂点u,vをどちらも含む最小の重心木を返す. O(logN)
c_depth, c_par = self.centroid_depth, self.centroid_parent
du, dv = c_depth[u], c_depth[v]
if du > dv:
u,v = v,u
du,dv = dv,du
for _ in range(dv - du):
v = c_par[v]
while u != v:
u,v = c_par[u],c_par[v]
return u
""" tree dp """
def dp_from_leaf(self, merge, e, add_root, push=lambda obj,data,dst,src:data):
assert self._rooted
N, ts, par = self._N, self.ts_order, self.parent
sub = [e] * N
for i in range(N-1,-1,-1):
v = ts[i]
sub[v] = add_root(self, sub[v], v)
p = par[v]
if p != -1:
sub[p] = merge(sub[p], push(self, sub[v], p, v))
return sub
def rerooting_dp(self, merge, e, add_root, push=lambda obj,data,dst,src:data):
if self._rooted == False:
self.set_root(0)
sub = self.dp_from_leaf(merge, e, add_root, push)
N = self._N
ts, par, ch = self.ts_order, self.parent, self.children
compl, dp = [e]*N, [e]*N
for i in range(N):
v = ts[i]
p, size = par[v], len(ch[v])
left, right = [e]*size, [e]*size
for j in range(size):
c = ch[v][j]
left[j] = merge(left[j-1] if j>0 else e, push(self, sub[c], v, c))
for j in range(size-1,-1,-1):
c = ch[v][j]
right[j] = merge(right[j+1] if j<size-1 else e, push(self, sub[c], v, c))
for j in range(size):
c = ch[v][j]
compl[c] = merge(compl[c], left[j-1] if j>0 else e)
compl[c] = merge(compl[c], right[j+1] if j<size-1 else e)
if p != -1:
compl[c] = merge(compl[c], push(self, compl[v], v, p))
compl[c] = add_root(self, compl[c], v)
if p != -1:
dp[v] = merge(dp[v], push(self, compl[v], v, p))
dp[v] = merge(dp[v], left[-1] if size else e)
dp[v] = add_root(self, dp[v], v)
return dp
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
# random_checker.
def random_checker():
"""
必要な準備 :
1. main関数の入力をコメントアウトして引数で受け取る.
2. main関数の出力をreturnに変更.
"""
import random
T = 1000
for testcase in range(T):
#--------------------------------------#
N = random.randrange(3,6)
A = []
B = []
for i in range(N):
A.append(random.randrange(1,10**2+1))
B.append(random.randrange(1,10**2+1))
args = (N,A,B)
#--------------------------------------#
res_main = main(*args)
res_naive = naive(*args)
if res_main != res_naive:
print(f"{testcase}回目の実行\n")
print("入力値:")
print(*args, sep="\n")
print("main():")
print(res_main)
print("naive():")
print(res_naive)
return
print(f"{T}回の実行で有効なテストケースを発見できませんでした.")
main() | ConDefects/ConDefects/Code/abc360_f/Python/55118906 |
condefects-python_data_644 | from atcoder.lazysegtree import LazySegTree
from collections import deque
N = int(input())
LR = [list(map(int, input().split())) for _ in range(N)]
sousa = deque()
s = set()
s.add(10 ** 9 + 1)
s.add(0)
for l, r in LR:
if r < 10 ** 9:
sousa.append([l + 1, r + 1, 10 ** 9 + 1, 1])
s.add(l + 1)
s.add(r + 1)
sousa.append([r, r + 1, 10 ** 9 + 1, -1])
s.add(r)
if l >= 1:
sousa.append([0, l + 1, r, 1])
s.add(l - 1)
s.add(l + 1)
s.add(r)
sousa.append([l, l + 1, r, -1])
s.add(l)
comp = dict()
comp_rev = dict()
now = 0
for i in sorted(s):
comp[i] = now
comp_rev[now] = i
now += 1
for i in sousa:
for j in range(3):
i[j] = comp[i[j]]
sousa = deque(sorted(sousa))
INF = 1 << 63
def op(ele1, ele2):
return max(ele1, ele2)
def mapping(func, ele):
return func + ele
def composition(func_upper, func_lower):
return func_upper + func_lower
e = -INF
id_ = 0
lst = [0] * now
seg = LazySegTree(op, e, mapping, composition, id_, lst)
ma = -1
ans = [0, 1]
while len(sousa) != 0:
l, r1, r2, s = sousa.popleft()
seg.apply(r1, r2, s)
while len(sousa) != 0:
l2, r1, r2, s = sousa.popleft()
if l2 != l:
sousa.appendleft([l2, r1, r2, s])
break
seg.apply(r1, r2, s)
val = seg.all_prod()
if val > ma:
ma = val
ans[0] = l
ans[1] = comp_rev[seg.max_right(0, lambda x:x < ma)]
print(ans[0], ans[1])
from atcoder.lazysegtree import LazySegTree
from collections import deque
N = int(input())
LR = [list(map(int, input().split())) for _ in range(N)]
sousa = deque()
s = set()
s.add(10 ** 9 + 1)
s.add(0)
for l, r in LR:
if r < 10 ** 9:
sousa.append([l + 1, r + 1, 10 ** 9 + 1, 1])
s.add(l + 1)
s.add(r + 1)
sousa.append([r, r + 1, 10 ** 9 + 1, -1])
s.add(r)
if l >= 1:
sousa.append([0, l + 1, r, 1])
s.add(l - 1)
s.add(l + 1)
s.add(r)
sousa.append([l, l + 1, r, -1])
s.add(l)
comp = dict()
comp_rev = dict()
now = 0
for i in sorted(s):
comp[i] = now
comp_rev[now] = i
now += 1
for i in sousa:
for j in range(3):
i[j] = comp[i[j]]
sousa = deque(sorted(sousa))
INF = 1 << 63
def op(ele1, ele2):
return max(ele1, ele2)
def mapping(func, ele):
return func + ele
def composition(func_upper, func_lower):
return func_upper + func_lower
e = -INF
id_ = 0
lst = [0] * now
seg = LazySegTree(op, e, mapping, composition, id_, lst)
ma = -1
ans = [0, 1]
while len(sousa) != 0:
l, r1, r2, s = sousa.popleft()
seg.apply(r1, r2, s)
while len(sousa) != 0:
l2, r1, r2, s = sousa.popleft()
if l2 != l:
sousa.appendleft([l2, r1, r2, s])
break
seg.apply(r1, r2, s)
val = seg.all_prod()
if val > ma:
ma = val
ans[0] = comp_rev[l]
ans[1] = comp_rev[seg.max_right(0, lambda x:x < ma)]
print(ans[0], ans[1]) | ConDefects/ConDefects/Code/abc360_f/Python/55105382 |
condefects-python_data_645 | from operator import add
import typing
import sys
input = sys.stdin.readline
def main():
N = int(input())
LR = []
Z = {-1, 0, 1}
for _ in range(N):
l, r = map(int, input().split())
LR.append((l, r))
for d in range(-1, 2):
Z.add(l + d)
Z.add(r + d)
Z = sorted(Z)
D = {z: i for i, z in enumerate(Z)}
M = len(Z)
P = [[] for _ in range(M)]
for l, r in LR:
l, r = D[l], D[r]
P[0].append((l + 1, r, 1))
P[l].append((l + 1, r, -1))
P[l + 1].append((r + 1, M, 1))
P[r].append((r + 1, M, -1))
st = LazySegTree(max, 0, add, add, 0, M)
ans = 0
ans_l = D[0]
ans_r = D[1]
for l, r, t in P[0]:
st.apply(l, r, t)
r_limit = 10**9
for L in range(1, M):
for l, r, t in P[L]:
st.apply(l, r, t)
mx = st.prod(L + 1, M)
if mx > ans:
r = st.max_right(L + 1, lambda x: x < mx)
if r <= r_limit:
ans = mx
ans_l = L
ans_r = r
print(Z[ans_l], Z[ans_r])
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._n.bit_length()
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
self._d[k] = self._mapping(f, self._d[k])
if k < self._size:
self._lz[k] = self._composition(f, self._lz[k])
def _push(self, k: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
if __name__ == '__main__':
main()
from operator import add
import typing
import sys
input = sys.stdin.readline
def main():
N = int(input())
LR = []
Z = {-1, 0, 1}
for _ in range(N):
l, r = map(int, input().split())
LR.append((l, r))
for d in range(-1, 2):
Z.add(l + d)
Z.add(r + d)
Z = sorted(Z)
D = {z: i for i, z in enumerate(Z)}
M = len(Z)
P = [[] for _ in range(M)]
for l, r in LR:
l, r = D[l], D[r]
P[0].append((l + 1, r, 1))
P[l].append((l + 1, r, -1))
P[l + 1].append((r + 1, M, 1))
P[r].append((r + 1, M, -1))
st = LazySegTree(max, 0, add, add, 0, M)
ans = 0
ans_l = D[0]
ans_r = D[1]
for l, r, t in P[0]:
st.apply(l, r, t)
r_limit = 10**9
for L in range(1, M):
for l, r, t in P[L]:
st.apply(l, r, t)
mx = st.prod(L + 1, M)
if mx > ans:
r = st.max_right(L + 1, lambda x: x < mx)
if Z[r] <= r_limit:
ans = mx
ans_l = L
ans_r = r
print(Z[ans_l], Z[ans_r])
class LazySegTree:
def __init__(
self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
mapping: typing.Callable[[typing.Any, typing.Any], typing.Any],
composition: typing.Callable[[typing.Any, typing.Any], typing.Any],
id_: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
self._mapping = mapping
self._composition = composition
self._id = id_
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = self._n.bit_length()
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
self._lz = [self._id] * self._size
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
assert 0 <= p < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
return self._d[p]
def prod(self, left: int, right: int) -> typing.Any:
assert 0 <= left <= right <= self._n
if left == right:
return self._e
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push(right >> i)
sml = self._e
smr = self._e
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def apply(self, left: int, right: typing.Optional[int] = None,
f: typing.Optional[typing.Any] = None):
assert f is not None
if right is None:
p = left
assert 0 <= left < self._n
p += self._size
for i in range(self._log, 0, -1):
self._push(p >> i)
self._d[p] = self._mapping(f, self._d[p])
for i in range(1, self._log + 1):
self._update(p >> i)
else:
assert 0 <= left <= right <= self._n
if left == right:
return
left += self._size
right += self._size
for i in range(self._log, 0, -1):
if ((left >> i) << i) != left:
self._push(left >> i)
if ((right >> i) << i) != right:
self._push((right - 1) >> i)
l2 = left
r2 = right
while left < right:
if left & 1:
self._all_apply(left, f)
left += 1
if right & 1:
right -= 1
self._all_apply(right, f)
left >>= 1
right >>= 1
left = l2
right = r2
for i in range(1, self._log + 1):
if ((left >> i) << i) != left:
self._update(left >> i)
if ((right >> i) << i) != right:
self._update((right - 1) >> i)
def max_right(
self, left: int, g: typing.Callable[[typing.Any], bool]) -> int:
assert 0 <= left <= self._n
assert g(self._e)
if left == self._n:
return self._n
left += self._size
for i in range(self._log, 0, -1):
self._push(left >> i)
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not g(self._op(sm, self._d[left])):
while left < self._size:
self._push(left)
left *= 2
if g(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int, g: typing.Any) -> int:
assert 0 <= right <= self._n
assert g(self._e)
if right == 0:
return 0
right += self._size
for i in range(self._log, 0, -1):
self._push((right - 1) >> i)
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not g(self._op(self._d[right], sm)):
while right < self._size:
self._push(right)
right = 2 * right + 1
if g(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
def _all_apply(self, k: int, f: typing.Any) -> None:
self._d[k] = self._mapping(f, self._d[k])
if k < self._size:
self._lz[k] = self._composition(f, self._lz[k])
def _push(self, k: int) -> None:
self._all_apply(2 * k, self._lz[k])
self._all_apply(2 * k + 1, self._lz[k])
self._lz[k] = self._id
if __name__ == '__main__':
main()
| ConDefects/ConDefects/Code/abc360_f/Python/55163164 |
condefects-python_data_646 | A,B=map(int,input().split())
now=min(A,B)
x=abs(A-B)
ans=0
if A==B:
print(A)
exit()
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]
l= make_divisors(x)
substract=1
for choice in l:
if now%choice==0:
substract=choice
l=l[::-1]
while True:
t_sub= now
for choice in l:
if choice%substract==0 and choice!=substract:
if now%choice<t_sub:
t_sub=now%choice
n_substract= choice
ans+=t_sub//substract
if now==t_sub:
break
now -= t_sub
substract =n_substract
print(ans)
A,B=map(int,input().split())
now=min(A,B)
x=abs(A-B)
ans=0
if A==B:
print(1)
exit()
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]
l= make_divisors(x)
substract=1
for choice in l:
if now%choice==0:
substract=choice
l=l[::-1]
while True:
t_sub= now
for choice in l:
if choice%substract==0 and choice!=substract:
if now%choice<t_sub:
t_sub=now%choice
n_substract= choice
ans+=t_sub//substract
if now==t_sub:
break
now -= t_sub
substract =n_substract
print(ans)
| ConDefects/ConDefects/Code/arc159_b/Python/43997330 |
condefects-python_data_647 | import math
a, b = map(int, input().split())
if a < b:
a, b = b, a
ans = 0
while b > 0:
g = math.gcd(a, b)
a //= g
b //= g
diff = a - b
if diff == 1:
ans += b
break
else:
m = float("inf")
for i in range(1, int(diff**0.5) + 1):
if diff % i == 0:
if i != 1:
m = min(m, b % i)
m = min(m, b % (diff // i))
a -= m
b -= m
ans += m
print(ans)
import math
a, b = map(int, input().split())
if a < b:
a, b = b, a
ans = 0
while b > 0:
g = math.gcd(a, b)
a //= g
b //= g
diff = a - b
if diff <= 1:
ans += b
break
else:
m = float("inf")
for i in range(1, int(diff**0.5) + 1):
if diff % i == 0:
if i != 1:
m = min(m, b % i)
m = min(m, b % (diff // i))
a -= m
b -= m
ans += m
print(ans)
| ConDefects/ConDefects/Code/arc159_b/Python/45431609 |
condefects-python_data_648 | S, T = map(str, input().split())
if S == "AtCoder" and T == "Land":
print("Yes")
else:
print("N")
S, T = map(str, input().split())
if S == "AtCoder" and T == "Land":
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc358_a/Python/55126932 |
condefects-python_data_649 | s,t=input().split()
if s=="Atcoder" and t=="Land":
print("Yes")
else:
print("No")
s,t=input().split()
if s=="AtCoder" and t=="Land":
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc358_a/Python/55110270 |
condefects-python_data_650 | S,T = list(input().split())
if S == "Atcoder" and T == "Land":
print('Yes')
else:
print('No')
S,T = list(input().split())
if S == "AtCoder" and T == "Land":
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc358_a/Python/55031522 |
condefects-python_data_651 | S,T = input().split()
if S == "AtCorder" and T == "Land":
print("Yes")
else:
print("No")
S,T = input().split()
if S == "AtCoder" and T == "Land":
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc358_a/Python/55146983 |
condefects-python_data_652 | s, t = input().split()
if s == 'AtCoder ' and t == 'Land':
print('Yes')
else:
print('No')
s, t = input().split()
if s == 'AtCoder' and t == 'Land':
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc358_a/Python/55148090 |
condefects-python_data_653 |
print("yes" if input() == "AtCoder Land" else "No")
print("Yes" if input() == "AtCoder Land" else "No")
| ConDefects/ConDefects/Code/abc358_a/Python/55029700 |
condefects-python_data_654 | n = int(input())
mod = 998244353
dp = [[0]*10 for _ in range(n)]
for i in range(1, 10):
dp[0][i] = 1
for i in range(n):
for j in range(1, 10):
dp[i][j] += dp[i-1][j]
dp[i][j] %= mod
if j-1 >= 1:
dp[i][j] += dp[i-1][j-1]
dp[i][j] %= mod
if j+1 <= 9:
dp[i][j] += dp[i-1][j+1]
dp[i][j] %= mod
print(sum(dp[n-1]))
n = int(input())
mod = 998244353
dp = [[0]*10 for _ in range(n)]
for i in range(1, 10):
dp[0][i] = 1
for i in range(n):
for j in range(1, 10):
dp[i][j] += dp[i-1][j]
dp[i][j] %= mod
if j-1 >= 1:
dp[i][j] += dp[i-1][j-1]
dp[i][j] %= mod
if j+1 <= 9:
dp[i][j] += dp[i-1][j+1]
dp[i][j] %= mod
print(sum(dp[n-1])%mod) | ConDefects/ConDefects/Code/abc242_c/Python/44896564 |
condefects-python_data_655 | N = int(input())
mod = 998244353
dp = [[0]*11 for _ in range(N)]
for i in range(1,10):
dp[0][i] = 1
for i in range(N-1):
for j in range(1,10):
dp[i+1][j] = (dp[i][j-1] + dp[i][j] + dp[i][j+1])%mod
for d in dp:
print(d)
print(sum(dp[-1])%mod)
N = int(input())
mod = 998244353
dp = [[0]*11 for _ in range(N)]
for i in range(1,10):
dp[0][i] = 1
for i in range(N-1):
for j in range(1,10):
dp[i+1][j] = (dp[i][j-1] + dp[i][j] + dp[i][j+1])%mod
print(sum(dp[-1])%mod) | ConDefects/ConDefects/Code/abc242_c/Python/45475697 |
condefects-python_data_656 | N,M = map(int, input().split())
T0 = []
T1 = []
T2 = []
for i in range(N):
t,x = map(int, input().split())
if t==0:
T0.append(x)
elif t==1:
T1.append(x)
elif t==2:
T2.append(x)
T0.sort(reverse=True)
T1.sort()
T2.sort(reverse=True)
import heapq
ans = 0
que = T0[:min(len(T1),M)]
ans = sum(que)
#print(ans)
now = ans
heapq.heapify(que)
for cnt in T2:
for i in range(cnt):
if len(T1)==0:
break
tmp = T1.pop()
heapq.heappush(que,tmp)
now += tmp
M = max(0,M-1)
while len(que)>M:
now-=heapq.heappop(que)
# print(now,que)
ans = max(now,ans)
print(ans)
N,M = map(int, input().split())
T0 = []
T1 = []
T2 = []
for i in range(N):
t,x = map(int, input().split())
if t==0:
T0.append(x)
elif t==1:
T1.append(x)
elif t==2:
T2.append(x)
T0.sort(reverse=True)
T1.sort()
T2.sort(reverse=True)
import heapq
ans = 0
que = T0[:min(len(T0),M)]
ans = sum(que)
#print(ans)
now = ans
heapq.heapify(que)
for cnt in T2:
for i in range(cnt):
if len(T1)==0:
break
tmp = T1.pop()
heapq.heappush(que,tmp)
now += tmp
M = max(0,M-1)
while len(que)>M:
now-=heapq.heappop(que)
# print(now,que)
ans = max(now,ans)
print(ans)
| ConDefects/ConDefects/Code/abc312_f/Python/46140996 |
condefects-python_data_657 | N,M=map(int,input().split())
open_cans=[]
closed_cans=[]
openers=[]
for _ in range(N):
T,X=map(int,input().split())
if T==0:
open_cans.append(X)
elif T==1:
closed_cans.append(X)
else:
openers.append(X)
open_cans.sort()
closed_cans.sort(reverse=True)
openers.sort(reverse=True)
l1=len(open_cans)
l2=len(closed_cans)
l3=len(openers)
index_1=0
index_2=0
index_3=0
opener_count=0
count=l1
if l1<=M:
tmp=sum(open_cans)
while count<M:
if opener_count==0:
if index_2<l2 and index_3<l3:
opener_count+=openers[index_3]
index_3+=1
else:
break
else:
if index_2<l2:
tmp+=closed_cans[index_2]
else:
break
index_2+=1
opener_count-=1
count+=1
else:
open_cans=open_cans[:M]
tmp=sum(open_cans)
answer=tmp
for i,open_can in enumerate(open_cans):
count-=1
tmp-=open_can
if opener_count==0:
if index_2<l2 and index_3<l3:
opener_count+=openers[index_3]
index_3+=1
else:
break
else:
if index_2<l2:
tmp+=closed_cans[index_2]
else:
break
index_2+=1
opener_count-=1
answer=max(answer,tmp)
answer=max(answer,tmp)
print(answer)
N,M=map(int,input().split())
open_cans=[]
closed_cans=[]
openers=[]
for _ in range(N):
T,X=map(int,input().split())
if T==0:
open_cans.append(X)
elif T==1:
closed_cans.append(X)
else:
openers.append(X)
open_cans.sort()
closed_cans.sort(reverse=True)
openers.sort(reverse=True)
l1=len(open_cans)
l2=len(closed_cans)
l3=len(openers)
index_1=0
index_2=0
index_3=0
opener_count=0
count=l1
if l1<=M:
tmp=sum(open_cans)
while count<M:
if opener_count==0:
if index_2<l2 and index_3<l3:
opener_count+=openers[index_3]
index_3+=1
else:
break
else:
if index_2<l2:
tmp+=closed_cans[index_2]
else:
break
index_2+=1
opener_count-=1
count+=1
else:
open_cans=open_cans[-M:]
tmp=sum(open_cans)
answer=tmp
for i,open_can in enumerate(open_cans):
count-=1
tmp-=open_can
if opener_count==0:
if index_2<l2 and index_3<l3:
opener_count+=openers[index_3]
index_3+=1
else:
break
else:
if index_2<l2:
tmp+=closed_cans[index_2]
else:
break
index_2+=1
opener_count-=1
answer=max(answer,tmp)
answer=max(answer,tmp)
print(answer) | ConDefects/ConDefects/Code/abc312_f/Python/46206445 |
condefects-python_data_658 | class Node:
def __init__(self, value=""):
self.nex = None
self.pre = None
self.value = value
#N = 5
#S = "LRRLR"
N = int(input())
S = input()
nil = Node()
nil.nex = nil
nil.pre = nil
recent_node = Node(0)
recent_node.nex = nil
recent_node.pre = nil
for i in range(1, N+1):
new_node = Node(i)
if S[i-1] == "L":
A = recent_node.pre
A.nex = new_node
new_node.nex = recent_node
new_node.pre = A
recent_node.pre = new_node
else:
B = recent_node.nex
B.pre = new_node
new_node.nex = B
new_node.pre = recent_node
recent_node.nex = new_node
recent_node = new_node
print(recent_node.value)
after_recent = list()
n = recent_node
while(n != nil):
#print(n.value)
after_recent.append(n.value)
n = n.nex
before_recent = list()
n = recent_node
while(n != nil):
#print(n.value)
before_recent.append(n.value)
n = n.pre
before_recent.reverse()
ans = before_recent[:-1] + after_recent
print(*ans)
class Node:
def __init__(self, value=""):
self.nex = None
self.pre = None
self.value = value
#N = 5
#S = "LRRLR"
N = int(input())
S = input()
nil = Node()
nil.nex = nil
nil.pre = nil
recent_node = Node(0)
recent_node.nex = nil
recent_node.pre = nil
for i in range(1, N+1):
new_node = Node(i)
if S[i-1] == "L":
A = recent_node.pre
A.nex = new_node
new_node.nex = recent_node
new_node.pre = A
recent_node.pre = new_node
else:
B = recent_node.nex
B.pre = new_node
new_node.nex = B
new_node.pre = recent_node
recent_node.nex = new_node
recent_node = new_node
#print(recent_node.value)
after_recent = list()
n = recent_node
while(n != nil):
#print(n.value)
after_recent.append(n.value)
n = n.nex
before_recent = list()
n = recent_node
while(n != nil):
#print(n.value)
before_recent.append(n.value)
n = n.pre
before_recent.reverse()
ans = before_recent[:-1] + after_recent
print(*ans)
| ConDefects/ConDefects/Code/abc237_d/Python/54010383 |
condefects-python_data_659 | from itertools import permutations
from collections import defaultdict as dd
N,M = map(int,input().split())
S = [input().rstrip() for n in range(N)]
T = dd(set)
for m in range(M):
t = list(input().rstrip())
if t[0]=="_" or t[-1]=="_" : continue
key = []
val = []
temp = [t[0]]
for i in range(1,len(t)):
if t[i]!="_" and temp[-1]=="_":
val.append(len(temp)-1)
temp = []
elif t[i]=="_" and temp[-1]!="_":
key.append("".join(temp))
temp = []
temp.append(t[i])
T[tuple(key+["".join(temp)])].add(tuple(val))
def recc(surp):
for i in range(surp+1):
temp.append(i)
if len(temp)<N-1 :
recc(surp-i)
else :
if tuple(temp) not in T[key] :
ans = ""
for n in range(N-1):
ans+=key[n]+"_"*(temp[n]+1)
ans+=key[N-1]
exit(print(ans))
temp.pop()
if N==1:
if tuple(S) in T : print(-1)
else : print(S[0])
else :
for ss in permutations(range(N),N):
key = tuple([S[s] for s in ss])
if key not in T :
exit(print("_".join(key)))
else :
surp = 16-(sum(len(k) for k in key)+N-1)
temp = []
recc(surp)
else:
print(-1)
from itertools import permutations
from collections import defaultdict as dd
N,M = map(int,input().split())
S = [input().rstrip() for n in range(N)]
T = dd(set)
for m in range(M):
t = list(input().rstrip())
if t[0]=="_" or t[-1]=="_" : continue
key = []
val = []
temp = [t[0]]
for i in range(1,len(t)):
if t[i]!="_" and temp[-1]=="_":
val.append(len(temp)-1)
temp = []
elif t[i]=="_" and temp[-1]!="_":
key.append("".join(temp))
temp = []
temp.append(t[i])
T[tuple(key+["".join(temp)])].add(tuple(val))
def recc(surp):
for i in range(surp+1):
temp.append(i)
if len(temp)<N-1 :
recc(surp-i)
else :
if tuple(temp) not in T[key] :
ans = ""
for n in range(N-1):
ans+=key[n]+"_"*(temp[n]+1)
ans+=key[N-1]
exit(print(ans))
temp.pop()
if N==1:
if tuple(S) in T or len(S[0])<3 : print(-1)
else : print(S[0])
else :
for ss in permutations(range(N),N):
key = tuple([S[s] for s in ss])
if key not in T :
exit(print("_".join(key)))
else :
surp = 16-(sum(len(k) for k in key)+N-1)
temp = []
recc(surp)
else:
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/45999253 |
condefects-python_data_660 | def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC268 D 1309 - Unique Username
# 高橋君はあるサービスで使うユーザー名を決めるのに困っています。彼を助けるプログラムを書いてください。
# 以下の条件をすべて満たす文字列 X を 1 つ求めてください。
# ・X は次の手順で得られる文字列である。
# N 個の文字列 S1,S2,…,SN を好きな順番で並べたものを S1′,S2′,…,SN′ とする。
# そして、S1′、(1 個以上の _ )、S2′、(1 個以上の _ )、…、(1 個以上の _ )、SN′ をこの順番で連結したものを X とする。
# ・X の文字数は 3 以上 16 以下である。
# ・X は M 個の文字列 T1,T2,…,TM のいずれとも一致しない。
# ただし、条件をすべて満たす文字列 X が存在しない場合は代わりに -1 と出力してください。
# ・1 ≤ N ≤ 8
# ・0 ≤ M ≤ 10^5
# ・1 ≤ |Si| ≤ 16
# ・N-1 + ∑ |Si| ≤ 16
# ・3 ≤ |Ti| ≤ 16
N, M = mp()
S = [input() for _ in range(N)]
T = {input() for _ in range(M)}
from itertools import permutations
if N == 1:
exit(print('-1' if len(S[0]) < 3 or S[0] in T else S[0]))
rem = 16 - sum(len(s) for s in S)
for p in permutations(range(N)):
cnt = [1] * (N+1)
def dfs(i):
# i番目に '_' を追加する関数
if i == N-1:
x = []
for j in range(N):
x.append(S[p[j]])
if j < N-1:
x.append('_' * cnt[j])
x = ''.join(x)
if x not in T:
exit(print(x))
return
r = rem - sum(cnt)
for j in range(r+1):
cnt[i] += j
dfs(i+1)
cnt[i] -= j
dfs(0)
print(-1)
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC268 D 1309 - Unique Username
# 高橋君はあるサービスで使うユーザー名を決めるのに困っています。彼を助けるプログラムを書いてください。
# 以下の条件をすべて満たす文字列 X を 1 つ求めてください。
# ・X は次の手順で得られる文字列である。
# N 個の文字列 S1,S2,…,SN を好きな順番で並べたものを S1′,S2′,…,SN′ とする。
# そして、S1′、(1 個以上の _ )、S2′、(1 個以上の _ )、…、(1 個以上の _ )、SN′ をこの順番で連結したものを X とする。
# ・X の文字数は 3 以上 16 以下である。
# ・X は M 個の文字列 T1,T2,…,TM のいずれとも一致しない。
# ただし、条件をすべて満たす文字列 X が存在しない場合は代わりに -1 と出力してください。
# ・1 ≤ N ≤ 8
# ・0 ≤ M ≤ 10^5
# ・1 ≤ |Si| ≤ 16
# ・N-1 + ∑ |Si| ≤ 16
# ・3 ≤ |Ti| ≤ 16
N, M = mp()
S = [input() for _ in range(N)]
T = {input() for _ in range(M)}
from itertools import permutations
if N == 1:
exit(print('-1' if len(S[0]) < 3 or S[0] in T else S[0]))
rem = 16 - sum(len(s) for s in S)
for p in permutations(range(N)):
cnt = [1] * (N-1)
def dfs(i):
# i番目に '_' を追加する関数
if i == N-1:
x = []
for j in range(N):
x.append(S[p[j]])
if j < N-1:
x.append('_' * cnt[j])
x = ''.join(x)
if x not in T:
exit(print(x))
return
r = rem - sum(cnt)
for j in range(r+1):
cnt[i] += j
dfs(i+1)
cnt[i] -= j
dfs(0)
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/46151794 |
condefects-python_data_661 | N,M = map(int, input().split())
l = [input() for i in range(N)]
s = set([])
for i in range(M):
s.add(input())
pt = []
free = 16
for i in l:
free -= len(i)
free-=N-1
#print(free)
from itertools import permutations
per_all = list(permutations(range(N)))
per = []
def solve(now,free,le):
# print(now,le)
le += l[per[now]]
now+=1
if now == N:
pt.append(le)
return
for i in range(free+1):
solve(now,free-i,le+"_"*(i+1))
return
for per in per_all:
solve(0,free,"")
ans=False
for i in pt:
if i not in s:
print(i)
exit()
print(-1)
N,M = map(int, input().split())
l = [input() for i in range(N)]
s = set([])
for i in range(M):
s.add(input())
pt = []
free = 16
for i in l:
free -= len(i)
free-=N-1
#print(free)
from itertools import permutations
per_all = list(permutations(range(N)))
per = []
def solve(now,free,le):
# print(now,le)
le += l[per[now]]
now+=1
if now == N:
pt.append(le)
return
for i in range(free+1):
solve(now,free-i,le+"_"*(i+1))
return
for per in per_all:
solve(0,free,"")
ans=False
for i in pt:
if i not in s and len(i)>=3:
print(i)
exit()
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/46188576 |
condefects-python_data_662 | # import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = set([input() for _ in range(M)])
total_length = sum([len(i) for i in S])
under = [
["_" * j for j in i]
for i in product(list(range(1, 16 - total_length + 1)), repeat=N - 1)
if 3 <= sum(i) <= 16 - total_length
]
for i in permutations(S):
for j in under:
l = []
for k in range(N):
l.append(i[k])
if k < N - 1:
l.append(j[k])
st = "".join((l))
if st not in T and 3 <= len(st) <= 16:
print(st)
exit()
print(-1)
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = set([input() for _ in range(M)])
total_length = sum([len(i) for i in S])
under = [
["_" * j for j in i]
for i in product(list(range(1, 16 - total_length + 1)), repeat=N - 1)
if sum(i) <= 16 - total_length
]
for i in permutations(S):
for j in under:
l = []
for k in range(N):
l.append(i[k])
if k < N - 1:
l.append(j[k])
st = "".join((l))
if st not in T and 3 <= len(st) <= 16:
print(st)
exit()
print(-1)
| ConDefects/ConDefects/Code/abc268_d/Python/45037018 |
condefects-python_data_663 | from itertools import permutations
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = {input() for _ in range(M)}
stack = []
def rec(i, rest):
if i == N - 1:
for p in permutations(list(range(N)), N):
res = []
for j in range(N):
res.append(S[p[j]])
if j < N - 1: res.append('_' * stack[j])
ans = ''.join(res)
if ans not in T:
print(ans)
exit()
return
for j in range(1, rest - (N - 1 - i) + 2):
stack.append(j)
rec(i + 1, rest - j)
stack.pop()
rec(0, 16 - sum(len(s) for s in S))
print(-1)
from itertools import permutations
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = {input() for _ in range(M)}
stack = []
def rec(i, rest):
if i == N - 1:
for p in permutations(list(range(N)), N):
res = []
for j in range(N):
res.append(S[p[j]])
if j < N - 1: res.append('_' * stack[j])
ans = ''.join(res)
if len(ans) >= 3 and ans not in T:
print(ans)
exit()
return
for j in range(1, rest - (N - 1 - i) + 2):
stack.append(j)
rec(i + 1, rest - j)
stack.pop()
rec(0, 16 - sum(len(s) for s in S))
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/46033322 |
condefects-python_data_664 | import numpy as np
import sys
from functools import lru_cache
import math
sys.setrecursionlimit(int(1e7))
from collections import *
from fractions import Fraction
import heapq
import bisect
import itertools
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
# sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# input = lambda:sys.stdin.readline().rstrip("\r\n")
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar("T")
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [
a[size * i // bucket_size : size * (i + 1) // bucket_size]
for i in range(bucket_size)
]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar("T")
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [
a[size * i // bucket_size : size * (i + 1) // bucket_size]
for i in range(bucket_size)
]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# 宣言方法
# d = [SortedMultiset() for i in range(200001)]
# dv = [SortedSet() for i in range(200001)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x): # 多用すると重い
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return "\n".join(f"{r}: {m}" for r, m in self.all_group_members().items())
# https://raw.githubusercontent.com/shakayami/ACL-for-python/master/segtree.py
class segtree:
n = 1
size = 1
log = 2
d = [0]
op = None
e = 10**15
def __init__(self, V, OP, E):
self.n = len(V)
self.op = OP
self.e = E
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.d = [E for i in range(2 * self.size)]
for i in range(self.n):
self.d[self.size + i] = V[i]
for i in range(self.size - 1, 0, -1):
self.update(i)
def set(self, p, x):
assert 0 <= p and p < self.n
p += self.size
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
assert 0 <= p and p < self.n
return self.d[p + self.size]
def prod(self, l, r):
assert 0 <= l and l <= r and r <= self.n
sml = self.e
smr = self.e
l += self.size
r += self.size
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
smr = self.op(self.d[r - 1], smr)
r -= 1
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def max_right(self, l, f):
assert 0 <= l and l <= self.n
assert f(self.e)
if l == self.n:
return self.n
l += self.size
sm = self.e
while 1:
while l % 2 == 0:
l >>= 1
if not (f(self.op(sm, self.d[l]))):
while l < self.size:
l = 2 * l
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l:
break
return self.n
def min_left(self, r, f):
assert 0 <= r and r <= self.n
assert f(self.e)
if r == 0:
return 0
r += self.size
sm = self.e
while 1:
r -= 1
while r > 1 and (r % 2):
r >>= 1
if not (f(self.op(self.d[r], sm))):
while r < self.size:
r = 2 * r + 1
if f(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r:
break
return 0
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
def get_list(self):
return [self.get(i) for i in range(self.n)] # オリジナルで追加
# RMQのとき
# def op(x, y):
# return x if x < y else y
# seg = segtree([10**9] * N, op, 10**9) # Vの要素とEの値は同じにする #10**9 -> INF
# seg.prod(l, r) # op(a[l],...a[r-1])を返す
class BIT:
def __init__(self, n):
self.n = len(n) if isinstance(n, list) else n
self.size = 1 << (self.n - 1).bit_length()
if isinstance(n, list): # nは1-indexedなリスト
a = [0]
for p in n:
a.append(p + a[-1])
a += [a[-1]] * (self.size - self.n)
self.d = [a[p] - a[p - (p & -p)] for p in range(self.size + 1)]
else: # nは大きさ
self.d = [0] * (self.size + 1)
def __repr__(self):
p = self.size
res = []
while p > 0:
res2 = []
for r in range(p, self.size + 1, p * 2):
l = r - (r & -r) + 1
res2.append(f"[{l}, {r}]:{self.d[r]}")
res.append(" ".join(res2))
p >>= 1
res.append(f"{[self.sum(p + 1) - self.sum(p) for p in range(self.size)]}")
return "\n".join(res)
def add(self, p, x): # O(log(n)), 点pにxを加算
assert p > 0
while p <= self.size:
self.d[p] += x
p += p & -p
def get(self, p, default=None): # O(log(n))
assert p > 0
return (
self.sum(p) - self.sum(p - 1)
if 1 <= p <= self.n or default is None
else default
)
def sum(self, p): # O(log(n)), 閉区間[1, p]の累積和
assert p >= 0
res = 0
while p > 0:
res += self.d[p]
p -= p & -p
return res
def lower_bound(self, x): # O(log(n)), x <= 閉区間[1, p]の累積和 となる最小のp
if x <= 0:
return 0
p, r = 0, self.size
while r > 0:
if p + r <= self.n and self.d[p + r] < x:
x -= self.d[p + r]
p += r
r >>= 1
return p + 1
class MultiSet:
# n: サイズ、compress: 座圧対象list-likeを指定(nは無効)
# multi: マルチセットか通常のOrderedSetか
def __init__(self, n=0, *, compress=[], multi=True):
self.multi = multi
self.inv_compress = (
sorted(set(compress)) if len(compress) > 0 else [i for i in range(n)]
)
self.compress = {k: v for v, k in enumerate(self.inv_compress)}
self.counter_all = 0
self.counter = [0] * len(self.inv_compress)
self.bit = BIT(len(self.inv_compress))
def add(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.counter[x]
if count == 0 or self.multi: # multiなら複数カウントできる
self.bit.add(x + 1, n)
self.counter_all += n
self.counter[x] += n
def remove(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.bit.get(x + 1)
if count < n:
raise KeyError(x)
self.bit.add(x + 1, -n)
self.counter_all -= n
self.counter[x] -= n
def __repr__(self):
return f'MultiSet {{{(", ".join(map(str, list(self))))}}}'
def __len__(self): # oprator len: O(1)
return self.counter_all
def count(self, x): # O(1)
return self.counter[self.compress[x]] if x in self.compress else 0
def __getitem__(self, i): # operator []: O(log n)
if i < 0:
i += len(self)
x = self.bit.lower_bound(i + 1)
if x > self.bit.n:
raise IndexError("list index out of range")
return self.inv_compress[x - 1]
def __contains__(self, x): # operator in: O(1)
return self.count(x) > 0
def bisect_left(self, x): # O(log n)
return self.bit.sum(bisect.bisect_left(self.inv_compress, x))
def bisect_right(self, x): # O(log n)
return self.bit.sum(bisect.bisect_right(self.inv_compress, x))
# 宣言方法
# MultiSet(compress=X,multi=False)
# MultiSet(N+1,multi=True)
# リストを渡すと座標圧縮して返してくれる
def compress(arr):
(*XS,) = set(arr)
XS.sort()
return {cmp_e: cmp_i for cmp_i, cmp_e in enumerate(XS)}
def ctov(c):
return ord(c) - ord("a")
def CTOV(c):
return ord(c) - ord("A")
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]
# ダブリング dp[i][j]:=jから2**i回遷移したときの到達点
# https://atcoder.jp/contests/abc167/submissions/40815296
# N,K=map(int,input().split())
# A=list(map(int,input().split()))
# dp=[[-1]*N for _ in range(60)]
# for j in range(N):
# dp[0][j]=A[j]-1
# for i in range(1,60):
# for j in range(N):
# dp[i][j]=dp[i-1][dp[i-1][j]]
# i=0
# now=0
# while(K>0):
# if (K&1)==1:
# now=dp[i][now]
# i+=1
# K>>=1
# print(now+1)
dxdy1 = ((0, 1), (0, -1), (1, 0), (-1, 0))
dxdy2 = ((0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1))
dxdy3 = ((0, 1), (1, 0))
dxdy4 = ((1, 1), (1, -1), (-1, 1), (-1, -1))
INF = float("inf")
MOD = 998244353
mod = 998244353
# memo : len([a,b,...,z])==26
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = set(input() for _ in range(M))
if N == 1:
if S[0] in T:
print(-1)
exit()
LS = [len(s) for s in S]
add = 16 - (N - 1 + sum(LS))
for s in itertools.permutations(S):
s = list(s)
for i in range(N - 1):
s[i] += "_"
for k in range(add + 1):
for add_place in itertools.product(range(N - 1), repeat=k):
now = s.copy()
for idx in add_place:
now[idx] += "_"
now = "".join(now)
# print(now)
if now not in T:
print(now)
exit()
print(-1)
import numpy as np
import sys
from functools import lru_cache
import math
sys.setrecursionlimit(int(1e7))
from collections import *
from fractions import Fraction
import heapq
import bisect
import itertools
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
# sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# input = lambda:sys.stdin.readline().rstrip("\r\n")
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar("T")
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [
a[size * i // bucket_size : size * (i + 1) // bucket_size]
for i in range(bucket_size)
]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
if not all(a[i] <= a[i + 1] for i in range(len(a) - 1)):
a = sorted(a)
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a = self._find_bucket(x)
insort(a, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar("T")
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [
a[size * i // bucket_size : size * (i + 1) // bucket_size]
for i in range(bucket_size)
]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# 宣言方法
# d = [SortedMultiset() for i in range(200001)]
# dv = [SortedSet() for i in range(200001)]
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x): # 多用すると重い
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return "\n".join(f"{r}: {m}" for r, m in self.all_group_members().items())
# https://raw.githubusercontent.com/shakayami/ACL-for-python/master/segtree.py
class segtree:
n = 1
size = 1
log = 2
d = [0]
op = None
e = 10**15
def __init__(self, V, OP, E):
self.n = len(V)
self.op = OP
self.e = E
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.d = [E for i in range(2 * self.size)]
for i in range(self.n):
self.d[self.size + i] = V[i]
for i in range(self.size - 1, 0, -1):
self.update(i)
def set(self, p, x):
assert 0 <= p and p < self.n
p += self.size
self.d[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def get(self, p):
assert 0 <= p and p < self.n
return self.d[p + self.size]
def prod(self, l, r):
assert 0 <= l and l <= r and r <= self.n
sml = self.e
smr = self.e
l += self.size
r += self.size
while l < r:
if l & 1:
sml = self.op(sml, self.d[l])
l += 1
if r & 1:
smr = self.op(self.d[r - 1], smr)
r -= 1
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self):
return self.d[1]
def max_right(self, l, f):
assert 0 <= l and l <= self.n
assert f(self.e)
if l == self.n:
return self.n
l += self.size
sm = self.e
while 1:
while l % 2 == 0:
l >>= 1
if not (f(self.op(sm, self.d[l]))):
while l < self.size:
l = 2 * l
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if (l & -l) == l:
break
return self.n
def min_left(self, r, f):
assert 0 <= r and r <= self.n
assert f(self.e)
if r == 0:
return 0
r += self.size
sm = self.e
while 1:
r -= 1
while r > 1 and (r % 2):
r >>= 1
if not (f(self.op(self.d[r], sm))):
while r < self.size:
r = 2 * r + 1
if f(self.op(self.d[r], sm)):
sm = self.op(self.d[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r:
break
return 0
def update(self, k):
self.d[k] = self.op(self.d[2 * k], self.d[2 * k + 1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
def get_list(self):
return [self.get(i) for i in range(self.n)] # オリジナルで追加
# RMQのとき
# def op(x, y):
# return x if x < y else y
# seg = segtree([10**9] * N, op, 10**9) # Vの要素とEの値は同じにする #10**9 -> INF
# seg.prod(l, r) # op(a[l],...a[r-1])を返す
class BIT:
def __init__(self, n):
self.n = len(n) if isinstance(n, list) else n
self.size = 1 << (self.n - 1).bit_length()
if isinstance(n, list): # nは1-indexedなリスト
a = [0]
for p in n:
a.append(p + a[-1])
a += [a[-1]] * (self.size - self.n)
self.d = [a[p] - a[p - (p & -p)] for p in range(self.size + 1)]
else: # nは大きさ
self.d = [0] * (self.size + 1)
def __repr__(self):
p = self.size
res = []
while p > 0:
res2 = []
for r in range(p, self.size + 1, p * 2):
l = r - (r & -r) + 1
res2.append(f"[{l}, {r}]:{self.d[r]}")
res.append(" ".join(res2))
p >>= 1
res.append(f"{[self.sum(p + 1) - self.sum(p) for p in range(self.size)]}")
return "\n".join(res)
def add(self, p, x): # O(log(n)), 点pにxを加算
assert p > 0
while p <= self.size:
self.d[p] += x
p += p & -p
def get(self, p, default=None): # O(log(n))
assert p > 0
return (
self.sum(p) - self.sum(p - 1)
if 1 <= p <= self.n or default is None
else default
)
def sum(self, p): # O(log(n)), 閉区間[1, p]の累積和
assert p >= 0
res = 0
while p > 0:
res += self.d[p]
p -= p & -p
return res
def lower_bound(self, x): # O(log(n)), x <= 閉区間[1, p]の累積和 となる最小のp
if x <= 0:
return 0
p, r = 0, self.size
while r > 0:
if p + r <= self.n and self.d[p + r] < x:
x -= self.d[p + r]
p += r
r >>= 1
return p + 1
class MultiSet:
# n: サイズ、compress: 座圧対象list-likeを指定(nは無効)
# multi: マルチセットか通常のOrderedSetか
def __init__(self, n=0, *, compress=[], multi=True):
self.multi = multi
self.inv_compress = (
sorted(set(compress)) if len(compress) > 0 else [i for i in range(n)]
)
self.compress = {k: v for v, k in enumerate(self.inv_compress)}
self.counter_all = 0
self.counter = [0] * len(self.inv_compress)
self.bit = BIT(len(self.inv_compress))
def add(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.counter[x]
if count == 0 or self.multi: # multiなら複数カウントできる
self.bit.add(x + 1, n)
self.counter_all += n
self.counter[x] += n
def remove(self, x, n=1): # O(log n)
if not self.multi and n != 1:
raise KeyError(n)
x = self.compress[x]
count = self.bit.get(x + 1)
if count < n:
raise KeyError(x)
self.bit.add(x + 1, -n)
self.counter_all -= n
self.counter[x] -= n
def __repr__(self):
return f'MultiSet {{{(", ".join(map(str, list(self))))}}}'
def __len__(self): # oprator len: O(1)
return self.counter_all
def count(self, x): # O(1)
return self.counter[self.compress[x]] if x in self.compress else 0
def __getitem__(self, i): # operator []: O(log n)
if i < 0:
i += len(self)
x = self.bit.lower_bound(i + 1)
if x > self.bit.n:
raise IndexError("list index out of range")
return self.inv_compress[x - 1]
def __contains__(self, x): # operator in: O(1)
return self.count(x) > 0
def bisect_left(self, x): # O(log n)
return self.bit.sum(bisect.bisect_left(self.inv_compress, x))
def bisect_right(self, x): # O(log n)
return self.bit.sum(bisect.bisect_right(self.inv_compress, x))
# 宣言方法
# MultiSet(compress=X,multi=False)
# MultiSet(N+1,multi=True)
# リストを渡すと座標圧縮して返してくれる
def compress(arr):
(*XS,) = set(arr)
XS.sort()
return {cmp_e: cmp_i for cmp_i, cmp_e in enumerate(XS)}
def ctov(c):
return ord(c) - ord("a")
def CTOV(c):
return ord(c) - ord("A")
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]
# ダブリング dp[i][j]:=jから2**i回遷移したときの到達点
# https://atcoder.jp/contests/abc167/submissions/40815296
# N,K=map(int,input().split())
# A=list(map(int,input().split()))
# dp=[[-1]*N for _ in range(60)]
# for j in range(N):
# dp[0][j]=A[j]-1
# for i in range(1,60):
# for j in range(N):
# dp[i][j]=dp[i-1][dp[i-1][j]]
# i=0
# now=0
# while(K>0):
# if (K&1)==1:
# now=dp[i][now]
# i+=1
# K>>=1
# print(now+1)
dxdy1 = ((0, 1), (0, -1), (1, 0), (-1, 0))
dxdy2 = ((0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (-1, -1), (1, -1), (-1, 1))
dxdy3 = ((0, 1), (1, 0))
dxdy4 = ((1, 1), (1, -1), (-1, 1), (-1, -1))
INF = float("inf")
MOD = 998244353
mod = 998244353
# memo : len([a,b,...,z])==26
N, M = map(int, input().split())
S = [input() for _ in range(N)]
T = set(input() for _ in range(M))
if N == 1:
if S[0] in T:
print(-1)
exit()
LS = [len(s) for s in S]
add = 16 - (N - 1 + sum(LS))
for s in itertools.permutations(S):
s = list(s)
for i in range(N - 1):
s[i] += "_"
for k in range(add + 1):
for add_place in itertools.product(range(N - 1), repeat=k):
now = s.copy()
for idx in add_place:
now[idx] += "_"
now = "".join(now)
# print(now)
if now not in T and 3 <= len(now) <= 16:
print(now)
exit()
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/45791112 |
condefects-python_data_665 | n,m=map(int,input().split())
s=[input() for _ in range(n)]
t={input() for _ in range(m)}
all=0
for i in range(n):
all+=len(s[i])
und=16-all-(n-1)
add=[]
def dfs1(i,L):
if i==n:
global add
add+=[L[:]]
else:
for j in range(n):
if L[j]==-1:
L[j]=i
dfs1(i+1,L)
L[j]=-1
dfs1(0,[-1]*n)
addund=[]
def dfs2(i,res,L):
if i==n-1:
global addund
addund+=[L[:]]
else:
for j in range(res+1):
L[i]=j
dfs2(i+1,res-j,L)
dfs2(0,und,[0]*(n-1))
for a in add:
for b in addund:
ans=""
for i in range(n-1):
ans+=s[a[i]]+"_"*(1+b[i])
ans+=s[a[-1]]
if ans not in t:
print(ans)
exit()
print(-1)
n,m=map(int,input().split())
s=[input() for _ in range(n)]
t={input() for _ in range(m)}
all=0
for i in range(n):
all+=len(s[i])
und=16-all-(n-1)
add=[]
def dfs1(i,L):
if i==n:
global add
add+=[L[:]]
else:
for j in range(n):
if L[j]==-1:
L[j]=i
dfs1(i+1,L)
L[j]=-1
dfs1(0,[-1]*n)
addund=[]
def dfs2(i,res,L):
if i==n-1:
global addund
addund+=[L[:]]
else:
for j in range(res+1):
L[i]=j
dfs2(i+1,res-j,L)
dfs2(0,und,[0]*(n-1))
for a in add:
for b in addund:
ans=""
for i in range(n-1):
ans+=s[a[i]]+"_"*(1+b[i])
ans+=s[a[-1]]
if ans not in t and 3<=len(ans)<=16:
print(ans)
exit()
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/45092436 |
condefects-python_data_666 | from itertools import permutations
N,M = map(int,input().split())
S = [input().rstrip() for n in range(N)]
T = set([input().rstrip() for m in range(M)])
def recc(surp):
for i in range(surp+1):
temp.append(i)
if len(temp)<N-1 :
recc(surp-i)
else :
ans = ""
for n in range(N-1):
ans+=S[ss[n]]+"_"*(temp[n]+1)
ans+=S[ss[N-1]]
if ans not in T:
exit(print(ans))
temp.pop()
if N==1:
if tuple(S) in T or len(S[0])<3 : print(-1)
else : print(S[0])
else :
for ss in permutations(range(N),N):
surp = 16-(sum(len(S[s]) for s in ss)+N-1)
temp = []
recc(surp)
else:
print(-1)
from itertools import permutations
N,M = map(int,input().split())
S = [input().rstrip() for n in range(N)]
T = set([input().rstrip() for m in range(M)])
def recc(surp):
for i in range(surp+1):
temp.append(i)
if len(temp)<N-1 :
recc(surp-i)
else :
ans = ""
for n in range(N-1):
ans+=S[ss[n]]+"_"*(temp[n]+1)
ans+=S[ss[N-1]]
if ans not in T:
exit(print(ans))
temp.pop()
if N==1:
if S[0] in T or len(S[0])<3 : print(-1)
else : print(S[0])
else :
for ss in permutations(range(N),N):
surp = 16-(sum(len(S[s]) for s in ss)+N-1)
temp = []
recc(surp)
else:
print(-1) | ConDefects/ConDefects/Code/abc268_d/Python/45999403 |
condefects-python_data_667 | import numpy as np
N,X,Y=map(int,input().split())
C=input()
Mod=998244353
def ABmodC(A,B,C):
b=bin(B)[2:]
a=[A]
for i in range(len(b)-1):
a.append((a[-1]**2)%C)
d=1
for i in range(len(b)):
if b[-i-1]=='1':
d=(d*a[i])%C
return d
Xa=(X*ABmodC(100,Mod-2,Mod))%Mod
Ya=(Y*ABmodC(100,Mod-2,Mod))%Mod
q=1
for i in range(24):
if C[i]=='T':
q=(q*(1-Xa))%Mod
elif C[i]=='A':
q=(q*(1-Ya))%Mod
D=np.zeros((24,24),dtype='int64')
for i in range(24):
if C[i]=='T':
D[i,(i-1)%24]=Xa
elif C[i]=='A':
D[i,(i-1)%24]=Ya
for ii in range(1,24):
if C[(i-ii)%24]=='T':
D[i,(i-1-ii)%24]=(D[i,(i-ii)%24]*((1-Xa)%Mod))%Mod
elif C[(i-ii)%24]=='A':
D[i,(i-1-ii)%24]=(D[i,(i-ii)%24]*((1-Ya)%Mod))%Mod
D=D*ABmodC((1-q)%Mod,Mod-2,Mod)
D=D%Mod
Ans=np.zeros((24,1),dtype='int64')
Ans[23,0]=1
def mult(A,B):
if A.shape[1]!=B.shape[0]:
return 0
else:
C=np.zeros((A.shape[0],B.shape[1]),dtype='int64')
for i in range(C.shape[0]):
for ii in range(C.shape[1]):
for iii in range(A.shape[1]):
C[i,ii]=(C[i,ii]+A[i,iii]*B[iii,ii])%Mod
return C
def npABmodC(A,B,C):
#Aは正方行列
#numpy(np)がimportされていること
b=bin(B)[2:]
a=[A]
for i in range(len(b)-1):
a.append(mult(a[-1],a[-1])%C)
d=np.identity(A.shape[0],dtype='int64')
for i in range(len(b)):
if b[-i-1]=='1':
d=np.dot(d,a[i])%C
return d
ans=0
Ans=mult(npABmodC(D,N,Mod),Ans)
for i in range(24):
if C[i]=='A':
ans=(ans+Ans[i,0])%Mod
print(int(ans)%Mod)
import numpy as np
N,X,Y=map(int,input().split())
C=input()
Mod=998244353
def ABmodC(A,B,C):
b=bin(B)[2:]
a=[A]
for i in range(len(b)-1):
a.append((a[-1]**2)%C)
d=1
for i in range(len(b)):
if b[-i-1]=='1':
d=(d*a[i])%C
return d
Xa=(X*ABmodC(100,Mod-2,Mod))%Mod
Ya=(Y*ABmodC(100,Mod-2,Mod))%Mod
q=1
for i in range(24):
if C[i]=='T':
q=(q*(1-Xa))%Mod
elif C[i]=='A':
q=(q*(1-Ya))%Mod
D=np.zeros((24,24),dtype='int64')
for i in range(24):
if C[i]=='T':
D[i,(i-1)%24]=Xa
elif C[i]=='A':
D[i,(i-1)%24]=Ya
for ii in range(1,24):
if C[(i-ii)%24]=='T':
D[i,(i-1-ii)%24]=(D[i,(i-ii)%24]*((1-Xa)%Mod))%Mod
elif C[(i-ii)%24]=='A':
D[i,(i-1-ii)%24]=(D[i,(i-ii)%24]*((1-Ya)%Mod))%Mod
D=D*ABmodC((1-q)%Mod,Mod-2,Mod)
D=D%Mod
Ans=np.zeros((24,1),dtype='int64')
Ans[23,0]=1
def mult(A,B):
if A.shape[1]!=B.shape[0]:
return 0
else:
C=np.zeros((A.shape[0],B.shape[1]),dtype='int64')
for i in range(C.shape[0]):
for ii in range(C.shape[1]):
for iii in range(A.shape[1]):
C[i,ii]=(C[i,ii]+A[i,iii]*B[iii,ii])%Mod
return C
def npABmodC(A,B,C):
#Aは正方行列
#numpy(np)がimportされていること
b=bin(B)[2:]
a=[A]
for i in range(len(b)-1):
a.append(mult(a[-1],a[-1])%C)
d=np.identity(A.shape[0],dtype='int64')
for i in range(len(b)):
if b[-i-1]=='1':
d=mult(d,a[i])%C
return d
ans=0
Ans=mult(npABmodC(D,N,Mod),Ans)
for i in range(24):
if C[i]=='A':
ans=(ans+Ans[i,0])%Mod
print(int(ans)%Mod) | ConDefects/ConDefects/Code/abc271_g/Python/37700812 |
condefects-python_data_668 | #from collections import defaultdict
#d = defaultdict(int)
#from collections import deque
#import math
#import heapq
#from queue import Queue
import numpy as np
#Mo=998244353
#s=input()
n=int(input())
#l,r = list(input().split())
a=list(map(int, input().split()))
#a= [int(input()) for _ in range(n)]
c=0
for i in range(1,n):
c += a[i-1]<a[i]
j=np.argmin(a)
if c == n-1:
print(0)
elif c==0:
print(1)
elif c >1:
an=min(j, n-j+2)
print(an)
else:
an=min(j+1, n-j+1)
print(an)
#print(1) if a+n <= m else print(0)
#print(' '.join(map(str,d)))
#print('Yes') if b else print('No')
#print('YES') if b else print('NO')
#from collections import defaultdict
#d = defaultdict(int)
#from collections import deque
#import math
#import heapq
#from queue import Queue
import numpy as np
#Mo=998244353
#s=input()
n=int(input())
#l,r = list(input().split())
a=list(map(int, input().split()))
#a= [int(input()) for _ in range(n)]
c=0
for i in range(1,n):
c += a[i-1]<a[i]
j=np.argmin(a)
if c == n-1:
print(0)
elif c==0:
print(1)
elif c >1:
an=min(j, n-j+2)
print(an)
else:
an=min(j+2, n-j)
print(an)
#print(1) if a+n <= m else print(0)
#print(' '.join(map(str,d)))
#print('Yes') if b else print('No')
#print('YES') if b else print('NO') | ConDefects/ConDefects/Code/arc132_b/Python/44219174 |
condefects-python_data_669 | import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(dtype=int, split=True):
s = getStr()
if split:
s = s.split()
return list(map(dtype, s))
t = 1
def solve():
n = getInt()
a = getList()
u = a.index(1)
if a[(u+1) % n] == 2:
print(min(u, 2 + n-u))
else:
print(min(u+2, n-u+2))
for _ in range(t):
solve()
import sys
input = sys.stdin.readline
inf = float('inf')
def getInt():
return int(input())
def getStr():
return input().strip()
def getList(dtype=int, split=True):
s = getStr()
if split:
s = s.split()
return list(map(dtype, s))
t = 1
def solve():
n = getInt()
a = getList()
u = a.index(1)
if a[(u+1) % n] == 2:
print(min(u, 2 + n-u))
else:
print(min(u+2, n-u))
for _ in range(t):
solve()
| ConDefects/ConDefects/Code/arc132_b/Python/40304207 |
condefects-python_data_670 | N = int(input())
P = list(map(int, input().split()))
if P[0] == 1:
if P[1] == 2:
print(0)
else:
print(2)
elif P[-1] == 1:
if P[-2] == 2:
print(1)
else:
print(3)
else:
idx = P.index(1)
if P[idx+1] == 2:
print(min(idx, N-idx+2)) # 1を先頭に持ってくる
else:
print(min(idx+1, N-idx-1+2)+1) # 1を末尾に持ってくる
N = int(input())
P = list(map(int, input().split()))
if P[0] == 1:
if P[1] == 2:
print(0)
else:
print(2)
elif P[-1] == 1:
if P[-2] == 2:
print(1)
else:
print(3)
else:
idx = P.index(1)
if P[idx+1] == 2:
print(min(idx, N-idx+2)) # 1を先頭に持ってくる
else:
print(min(idx+1+1, 1+(N-idx-1))) # 1を末尾に持ってくる
| ConDefects/ConDefects/Code/arc132_b/Python/41870393 |
condefects-python_data_671 | N = int(input())
P = list(map(int, input().split()))
if P[0] == 1 and P[1] == 2:
print(0)
exit()
if P[-1] == 1 and P[-2] == 2:
print(1)
exit()
if P[0] == 1 and P[1] != 2:
print(2)
exit()
if P[-1] == 1 and P[-2] != 2:
print(3)
exit()
a = P.index(1)
#print(*[i for i in range(N)])
#print(*P)
#print(a)
if P[a] + 1 == P[a + 1]:
order = "jun"
else:
order = "gyaku"
if order == "jun":
plana = a
planb = N - a + 1
else:
plana = N - a
planb = a + 2
print(min(plana, planb))
N = int(input())
P = list(map(int, input().split()))
if P[0] == 1 and P[1] == 2:
print(0)
exit()
if P[-1] == 1 and P[-2] == 2:
print(1)
exit()
if P[0] == 1 and P[1] != 2:
print(2)
exit()
if P[-1] == 1 and P[-2] != 2:
print(3)
exit()
a = P.index(1)
#print(*[i for i in range(N)])
#print(*P)
#print(a)
if P[a] + 1 == P[a + 1]:
order = "jun"
else:
order = "gyaku"
if order == "jun":
plana = a
planb = N - a + 2
else:
plana = N - a
planb = a + 2
print(min(plana, planb)) | ConDefects/ConDefects/Code/arc132_b/Python/40278857 |
condefects-python_data_672 | n = int(input())
a = list(map(int, input().split()))
b = [a[0]]
for i in range(n-1):
if abs(a[i+1]-a[i]) != 1:
break
b.append(a[i+1])
if b == [1]:
print(2)
elif b[1] > b[0]:
if len(b) == n:
print(0)
else:
print(min(len(b),n-len(b)+2))
else:
if len(b) == n:
print(1)
else:
print(min(len(b)+1,n-len(b)+3))
n = int(input())
a = list(map(int, input().split()))
b = [a[0]]
for i in range(n-1):
if abs(a[i+1]-a[i]) != 1:
break
b.append(a[i+1])
if b == [1]:
print(2)
elif b[1] > b[0]:
if len(b) == n:
print(0)
else:
print(min(len(b),n-len(b)+2))
else:
if len(b) == n:
print(1)
else:
print(min(len(b)+1,n-len(b)+1))
| ConDefects/ConDefects/Code/arc132_b/Python/38109909 |
condefects-python_data_673 | N = int(input())
P = list(map(int, input().split()))
if P[0] == 1 and P[-1] == N:
print(0)
exit()
for i, (l, r) in enumerate(zip(P, P[1:])):
if abs(l - r) == N - 1:
break
ans = 0
if l < r:
ans = min(i + 1 + 1, 1 + N - i)
else:
ans = min(i + 1, 2 + N - i - 1)
print(ans)
N = int(input())
P = list(map(int, input().split()))
if P[0] == 1 and P[-1] == N:
print(0)
exit()
for i, (l, r) in enumerate(zip(P, P[1:])):
if abs(l - r) == N - 1:
break
ans = 0
if l < r:
ans = min(i + 1 + 1, 1 + N - i - 1)
else:
ans = min(i + 1, 2 + N - i - 1)
print(ans)
| ConDefects/ConDefects/Code/arc132_b/Python/37384305 |
condefects-python_data_674 | n=int(input())
p=list(map(int,input().split()))
if p[0]==1:
ans=0
elif p[0]<p[1]:
ans=min(n-p[0]+1,2+p[0]-1)
else:
ans=min(p[0]+1,n-p[0]+1)
print(ans)
n=int(input())
p=list(map(int,input().split()))
if p[0]==1 and p[1]==2:
ans=0
elif p[0]<p[1]:
ans=min(n-p[0]+1,2+p[0]-1)
else:
ans=min(p[0]+1,n-p[0]+1)
print(ans) | ConDefects/ConDefects/Code/arc132_b/Python/40788624 |
condefects-python_data_675 | n = int(input())
p = list(map(int,input().split()))
def isAscending(l):
return l == sorted(l)
ans = []
# pattern1: S,S,...
i = p.index(1)
p2 = p[i:] + p[:i]
if isAscending(p2):
ans.append(i)
# patter2: R,S,S...
p2 = p[::-1]
i = p2.index(1)
p2 = p[i:] + p[:i]
if isAscending(p2):
ans.append(i+1)
# patter3: S,S..., R
i = p.index(n)
p2 = p[i:] + p[:i]
p2 = p2[::-1]
if isAscending(p2):
ans.append(i+1)
# patter4: R,S,S..., R
p2 = p[::-1]
i = p2.index(n)
p2 = p2[i:] + p2[:i]
p2 = p2[::-1]
if isAscending(p2):
ans.append(i+2)
print(min(ans))
n = int(input())
p = list(map(int,input().split()))
def isAscending(l):
return l == sorted(l)
ans = []
# pattern1: S,S,...
i = p.index(1)
p2 = p[i:] + p[:i]
if isAscending(p2):
ans.append(i)
# patter2: R,S,S...
p2 = p[::-1]
i = p2.index(1)
p2 = p2[i:] + p2[:i]
if isAscending(p2):
ans.append(i+1)
# patter3: S,S..., R
i = p.index(n)
p2 = p[i:] + p[:i]
p2 = p2[::-1]
if isAscending(p2):
ans.append(i+1)
# patter4: R,S,S..., R
p2 = p[::-1]
i = p2.index(n)
p2 = p2[i:] + p2[:i]
p2 = p2[::-1]
if isAscending(p2):
ans.append(i+2)
print(min(ans)) | ConDefects/ConDefects/Code/arc132_b/Python/40631011 |
condefects-python_data_676 | S=input()
N=len(S)
if set(S)=={'a'}:
print('Yes')
exit()
left=0
right=N-1
while left<N and S[left]=='a':
left+=1
while 0<=right and S[right]=='a':
right-=1
if left>=N-1-right:
print('No')
exit()
S=S[left:right+1]
def palindrome(string):
length=len(string)
for i in range(length//2):
if string[i]!=string[-(i+1)]:
return False
return True
print('Yes' if palindrome(S) else 'No')
S=input()
N=len(S)
if set(S)=={'a'}:
print('Yes')
exit()
left=0
right=N-1
while left<N and S[left]=='a':
left+=1
while 0<=right and S[right]=='a':
right-=1
if left>N-1-right:
print('No')
exit()
S=S[left:right+1]
def palindrome(string):
length=len(string)
for i in range(length//2):
if string[i]!=string[-(i+1)]:
return False
return True
print('Yes' if palindrome(S) else 'No') | ConDefects/ConDefects/Code/abc237_c/Python/46026874 |
condefects-python_data_677 | import sys
sys.setrecursionlimit(10**6)
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, (1073741824//4, 1073741824//4))
from collections import deque, Counter, defaultdict
from itertools import accumulate, permutations, combinations
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, printable
from operator import itemgetter
from functools import lru_cache, cmp_to_key
from math import gcd, sqrt
from atcoder.dsu import DSU
from atcoder.scc import SCCGraph
from atcoder.segtree import SegTree
from sortedcontainers import SortedList, SortedDict, SortedSet
INFTY = sys.maxsize
MOD10 = 10**9+7
MOD99 = 998244353
MOD = MOD99
YES = 'Yes'
NO = 'No'
DRDC = [[-1, 0], [1, 0], [0, -1], [0, 1]]
DRDC2 = [[1, 1], [-1, 1], [1, -1], [-1, -1]]
def chr2num(c): return printable.index(c)
def num2chr(i): return printable[i]
def bisect_lt(a, x):
'''Return rightmost index less than x, if not exits return -1'''
return bisect_left(a, x) - 1
def bisect_le(a, x):
'''Return rightmost index less than or equal to x, if not exists return -1'''
return bisect_right(a, x) - 1
def bisect_gt(a, x):
'''Return leftmost index greater than x, if not exists return len(a)'''
return bisect_right(a, x)
def bisect_ge(a, x):
'''Return leftmost index greater than or equal to x, if not exists return len(a)'''
return bisect_left(a, x)
def bisect_lecount(a, x): return bisect_right(a, x)
def bisect_ltcount(a, x): return bisect_left(a, x)
def bisect_gecount(a, x): return len(a) - bisect_left(a, x)
def bisect_gtcount(a, x): return len(a) - bisect_right(a, x)
def sc_bisect_lt(sc, x): return sc.bisect_left(x) - 1
def sc_bisect_le(sc, x): return sc.bisect_right(x) - 1
def sc_bisect_gt(sc, x): return sc.bisect_right(x)
def sc_bisect_ge(sc, x): return sc.bisect_left(x)
def sc_bisect_lecount(sc, x): return sc.bisect_right(x)
def sc_bisect_ltcount(sc, x): return sc.bisect_left(x)
def sc_bisect_gecount(sc, x): return len(sc) - sc.bisect_left(x)
def sc_bisect_gtcount(sc, x): return len(sc) - sc.bisect_right(x)
def cmp_for_key(x, y):
'''functools.cmp_to_key()に渡すための比較関数。
タプルのソートなどでは x, y にタプルまるごと渡すようにする（遅くなるので）。
key=cmp_to_key(cmp_for_key)'''
s = x - y # ここを必要に応じて書き換える。
if s < 0: return -1 # x < y (x が y より前)
elif s == 0: return 0 # x == y
else: return 1 # x > y (x が y より後)
# input = sys.stdin.readline
def iinput(): return int(input())
def minput(): return map(int, input().split())
def linput(): return list(map(int, input().split()))
# DEBUG = False
# def printd(*args):
# if DEBUG:
# print(*args)
def readinput():
s = input()
return s
def solve(args):
s=args
n = len(s)
head = 0
for i in range(n):
if s[i] == 'a':
head += 1
else:
break
tail = 0
for i in range(n)[::-1]:
if s[i] == 'a':
tail += 1
else:
break
if head > tail:
return NO
t = 'a'*(tail-head) + s
m = len(t) // 2
if t[:m] == t[-m:][::-1]:
return YES
else:
return NO
def printans(ans):
if isinstance(ans, list) or isinstance(ans, tuple):
print(*ans, sep='\n')
else:
print(ans)
if __name__=='__main__':
args=readinput()
ans=solve(args)
printans(ans)
import sys
sys.setrecursionlimit(10**6)
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, (1073741824//4, 1073741824//4))
from collections import deque, Counter, defaultdict
from itertools import accumulate, permutations, combinations
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
from string import ascii_letters, ascii_lowercase, ascii_uppercase, digits, printable
from operator import itemgetter
from functools import lru_cache, cmp_to_key
from math import gcd, sqrt
from atcoder.dsu import DSU
from atcoder.scc import SCCGraph
from atcoder.segtree import SegTree
from sortedcontainers import SortedList, SortedDict, SortedSet
INFTY = sys.maxsize
MOD10 = 10**9+7
MOD99 = 998244353
MOD = MOD99
YES = 'Yes'
NO = 'No'
DRDC = [[-1, 0], [1, 0], [0, -1], [0, 1]]
DRDC2 = [[1, 1], [-1, 1], [1, -1], [-1, -1]]
def chr2num(c): return printable.index(c)
def num2chr(i): return printable[i]
def bisect_lt(a, x):
'''Return rightmost index less than x, if not exits return -1'''
return bisect_left(a, x) - 1
def bisect_le(a, x):
'''Return rightmost index less than or equal to x, if not exists return -1'''
return bisect_right(a, x) - 1
def bisect_gt(a, x):
'''Return leftmost index greater than x, if not exists return len(a)'''
return bisect_right(a, x)
def bisect_ge(a, x):
'''Return leftmost index greater than or equal to x, if not exists return len(a)'''
return bisect_left(a, x)
def bisect_lecount(a, x): return bisect_right(a, x)
def bisect_ltcount(a, x): return bisect_left(a, x)
def bisect_gecount(a, x): return len(a) - bisect_left(a, x)
def bisect_gtcount(a, x): return len(a) - bisect_right(a, x)
def sc_bisect_lt(sc, x): return sc.bisect_left(x) - 1
def sc_bisect_le(sc, x): return sc.bisect_right(x) - 1
def sc_bisect_gt(sc, x): return sc.bisect_right(x)
def sc_bisect_ge(sc, x): return sc.bisect_left(x)
def sc_bisect_lecount(sc, x): return sc.bisect_right(x)
def sc_bisect_ltcount(sc, x): return sc.bisect_left(x)
def sc_bisect_gecount(sc, x): return len(sc) - sc.bisect_left(x)
def sc_bisect_gtcount(sc, x): return len(sc) - sc.bisect_right(x)
def cmp_for_key(x, y):
'''functools.cmp_to_key()に渡すための比較関数。
タプルのソートなどでは x, y にタプルまるごと渡すようにする（遅くなるので）。
key=cmp_to_key(cmp_for_key)'''
s = x - y # ここを必要に応じて書き換える。
if s < 0: return -1 # x < y (x が y より前)
elif s == 0: return 0 # x == y
else: return 1 # x > y (x が y より後)
# input = sys.stdin.readline
def iinput(): return int(input())
def minput(): return map(int, input().split())
def linput(): return list(map(int, input().split()))
# DEBUG = False
# def printd(*args):
# if DEBUG:
# print(*args)
def readinput():
s = input()
return s
def solve(args):
s=args
n = len(s)
if n == 1:
return YES
head = 0
for i in range(n):
if s[i] == 'a':
head += 1
else:
break
tail = 0
for i in range(n)[::-1]:
if s[i] == 'a':
tail += 1
else:
break
if head > tail:
return NO
t = 'a'*(tail-head) + s
m = len(t) // 2
if t[:m] == t[-m:][::-1]:
return YES
else:
return NO
def printans(ans):
if isinstance(ans, list) or isinstance(ans, tuple):
print(*ans, sep='\n')
else:
print(ans)
if __name__=='__main__':
args=readinput()
ans=solve(args)
printans(ans)
| ConDefects/ConDefects/Code/abc237_c/Python/45967024 |
condefects-python_data_678 | S=input()
N=len(S)
if S=="a"*N:
print("Yes")
exit()
a=0
b=0
s=-1
t=-1
for i in range(N-1,-1,-1):
if S[i]=="a":
a+=1
else:
s=i
break
for i in range(N):
if S[i]=="a":
b+=1
else:
t=i
break
if a<b:
print("No")
exit()
for i in range(s,t+1):
if S[i]!=S[s+t-i]:
print("No")
exit()
print("Yes")
S=input()
N=len(S)
if S=="a"*N:
print("Yes")
exit()
a=0
b=0
s=-1
t=-1
for i in range(N-1,-1,-1):
if S[i]=="a":
a+=1
else:
s=i
break
for i in range(N):
if S[i]=="a":
b+=1
else:
t=i
break
if a<b:
print("No")
exit()
for i in range(t,s+1):
if S[i]!=S[s+t-i]:
print("No")
exit()
print("Yes") | ConDefects/ConDefects/Code/abc237_c/Python/45711395 |
condefects-python_data_679 | s = input()
n = len(s)
i, j = 0, n-1
while j >= 0:
if s[j] == 'a':
j -= 1
else:
break
if j < 0:
print('Yes')
exit(0)
while i < j:
if s[i] == 'a':
i += 1
else:
break
if i == j:
print('Yes')
exit(0)
st, ed = i, n-j
t = s[i : j+1]
if t != t[::-1]:
print('No')
exit(0)
if st <= ed:
print('Yes')
else:
print('No')
s = input()
n = len(s)
i, j = 0, n-1
while j >= 0:
if s[j] == 'a':
j -= 1
else:
break
if j < 0:
print('Yes')
exit(0)
while i < j:
if s[i] == 'a':
i += 1
else:
break
if i == j:
print('Yes')
exit(0)
st, ed = i, n-j-1
t = s[i : j+1]
if t != t[::-1]:
print('No')
exit(0)
if st <= ed:
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc237_c/Python/45275344 |
condefects-python_data_680 | s = input()
count_r = 0
count_l = 0
while s[len(s)-1 - count_r] == "a":
count_r += 1
if count_r == len(s):
break
while s[count_l] == "a":
count_l += 1
if count_l == len(s):
break
sub = count_r - count_l
if sub < 0:
print("No")
exit(0)
l = 0
r = len(s) - 1 - sub
while s[l] == s[r]:
if l >= r:
print("Yes")
exit(0)
l += 1
r -= 1
print("Yes")
s = input()
count_r = 0
count_l = 0
while s[len(s)-1 - count_r] == "a":
count_r += 1
if count_r == len(s):
break
while s[count_l] == "a":
count_l += 1
if count_l == len(s):
break
sub = count_r - count_l
if sub < 0:
print("No")
exit(0)
l = 0
r = len(s) - 1 - sub
while s[l] == s[r]:
if l >= r:
print("Yes")
exit(0)
l += 1
r -= 1
print("No") | ConDefects/ConDefects/Code/abc237_c/Python/45542474 |
condefects-python_data_681 | S = input()
N = len(S)
x,y = 0,0
for i in range(N):
if S[i] != "a":
break
x += 1
for i in reversed(range(N)):
if S[-i] != "a":
break
y += 1
S = "a"*(y-x) + S
if S == S[::-1]:
print('Yes')
else:
print('No')
S = input()
N = len(S)
x,y = 0,0
for i in range(N):
if S[i] != "a":
break
x += 1
for i in range(1,N+1):
if S[-i] != "a":
break
y += 1
S = "a"*(y-x) + S
if S == S[::-1]:
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc237_c/Python/45277332 |
condefects-python_data_682 |
s = input()
t = s.rstrip('a')
suffix = len(s) - len(t)
u = t.lstrip('a')
prefix = len(t) - len(u)
if prefix <= suffix:
print('Yes')
else:
print('No')
s = input()
t = s.rstrip('a')
suffix = len(s) - len(t)
u = t.lstrip('a')
prefix = len(t) - len(u)
if prefix <= suffix and u==u[::-1]:
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc237_c/Python/45766102 |
condefects-python_data_683 | s = input()
tmp1 = s.rstrip("a")
back_a = len(s)-len(tmp1)
tmp2 = tmp1.lstrip("a")
front_a = len(s)-len(tmp2)
if tmp2==tmp2[::-1] and front_a<=back_a:
print("Yes")
else:
print("No")
s = input()
tmp1 = s.rstrip("a")
back_a = len(s)-len(tmp1)
tmp2 = tmp1.lstrip("a")
front_a = len(tmp1)-len(tmp2)
if tmp2==tmp2[::-1] and front_a<=back_a:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc237_c/Python/45766174 |
condefects-python_data_684 | # import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print('\033[33m', end = '', file = sys.stderr)
print(*l, '\033[0m', file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
def __repr__(self): return str(self.hq)
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def __repr__(self): return str([e.val for e in self.hq])
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
n = ii()
for i in range(100000):
if n < i * i * i:
break
v = i * i * i
if list(str(v)) == rev(str(v)):
cnt = v
print(cnt)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def input(): return sys.stdin.readline().rstrip()
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print('\033[33m', end = '', file = sys.stderr)
print(*l, '\033[0m', file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
def __repr__(self): return str(self.hq)
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def __repr__(self): return str([e.val for e in self.hq])
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
n = ii()
for i in range(1, 10 ** 18):
if n < i * i * i:
break
v = i * i * i
if list(str(v)) == rev(str(v)):
cnt = v
print(cnt)
| ConDefects/ConDefects/Code/abc343_c/Python/54882998 |
condefects-python_data_685 | N = int(input())
n = 10**6
for i in range(n, 1, -1):
k = i **3
k_str = str(k)
if (k < N) and (k_str == k_str[::-1]):
print(k)
exit()
print(1)
N = int(input())
n = 10**6
for i in range(n, 1, -1):
k = i **3
k_str = str(k)
if (k <= N) and (k_str == k_str[::-1]):
print(k)
exit()
print(1) | ConDefects/ConDefects/Code/abc343_c/Python/55124093 |
condefects-python_data_686 | def isok(x):
x = str(x)
for i in range(len(x)//2):
if x[i] != x[-i-1]:
return False
return True
n = int(input())
ans = 0
for i in range(n):
if i**3 <= n and isok(i**3):
ans = i**3
elif i**3 > n:
break
print(ans)
def isok(x):
x = str(x)
for i in range(len(x)//2):
if x[i] != x[-i-1]:
return False
return True
n = int(input())
ans = 0
for i in range(n+10):
if i**3 <= n and isok(i**3):
ans = i**3
elif i**3 > n:
break
print(ans) | ConDefects/ConDefects/Code/abc343_c/Python/54879224 |
condefects-python_data_687 | n = int(input())
x = 1
ans = x
while x**3 < n:
s = str(x**3)
l = len(s)
kai = True
for i in range(l//2):
# print(s, i, s[i], s[l-1])
if s[i] != s[l-i-1]:
kai = False
break
if kai:
ans = s
x += 1
print(ans)
n = int(input())
x = 1
ans = x
while x**3 <= n:
s = str(x**3)
l = len(s)
kai = True
for i in range(l//2):
# print(s, i, s[i], s[l-1])
if s[i] != s[l-i-1]:
kai = False
break
if kai:
ans = s
x += 1
print(ans) | ConDefects/ConDefects/Code/abc343_c/Python/54626929 |
condefects-python_data_688 | N = int(input())
ans = 0
for x in range(N):
if x**3 > N:
print(ans)
exit()
else:
s = str(x**3)
str(s)
S = list(s)
P = S.copy()
P.reverse()
if S == P:
if ans < x**3:
ans = x**3
N = int(input())
ans = 0
for x in range(10000000000000):
if x**3 > N:
print(ans)
exit()
else:
s = str(x**3)
str(s)
S = list(s)
P = S.copy()
P.reverse()
if S == P:
if ans < x**3:
ans = x**3
| ConDefects/ConDefects/Code/abc343_c/Python/54944365 |
condefects-python_data_689 | #1603
N = int(input())
A = []
for i in range(0, 10**6+1):
B = i**3
if B >= N:
break
elif str(B) == str(B)[::-1]:
A.append(B)
print(max(A))
#1603
N = int(input())
A = []
for i in range(0, 10**6+1):
B = i**3
if B > N:
break
elif str(B) == str(B)[::-1]:
A.append(B)
print(max(A)) | ConDefects/ConDefects/Code/abc343_c/Python/54781891 |
condefects-python_data_690 | N=int(input())
index=1
s = set()
l=[]
while (True):
flg=0
three=index*index*index
if(three>N):
break
l.append(three)
index+=1
#print(l)
flg=0
for i in reversed(l):
flg=0
strthree=str(i)
if(len(strthree)==1):
#print(i)
break
for j in range(len(strthree)//2):
#print(j)
#print(strthree[j],strthree[len(strthree)-1-j])
if(strthree[j]!=strthree[len(strthree)-1-j]):
flg=1
break
if(flg):
continue
print(i)
break
N=int(input())
index=1
s = set()
l=[]
while (True):
flg=0
three=index*index*index
if(three>N):
break
l.append(three)
index+=1
#print(l)
flg=0
for i in reversed(l):
flg=0
strthree=str(i)
if(len(strthree)==1):
print(i)
break
for j in range(len(strthree)//2):
#print(j)
#print(strthree[j],strthree[len(strthree)-1-j])
if(strthree[j]!=strthree[len(strthree)-1-j]):
flg=1
break
if(flg):
continue
print(i)
break
| ConDefects/ConDefects/Code/abc343_c/Python/54978258 |
condefects-python_data_691 | N = int(input())
import math
n = [i**3 for i in range(math.floor(N**(1/3))+1)]
for i in range(len(n)-1, -1, -1):
x = True
for j in range(len(str(n[i]))//2 + 1):
if str(n[i])[j] != str(n[i])[-j-1]:
x = False
if x:
print(n[i])
exit()
N = int(input())
import math
n = [i**3 for i in range(math.floor(N**(1/3))+2) if i**3 <= N]
for i in range(len(n)-1, -1, -1):
x = True
for j in range(len(str(n[i]))//2 + 1):
if str(n[i])[j] != str(n[i])[-j-1]:
x = False
if x:
print(n[i])
exit() | ConDefects/ConDefects/Code/abc343_c/Python/54772219 |
condefects-python_data_692 | N = int(input())
least_number = 0
for number in range(1000000):
if number**3 <= N:
for_number = str(number**3)
rev_number = str(number**3)[::-1]
for keta in range(int(len(for_number))):
if for_number[keta] != rev_number[keta]:
break
elif keta == int(len(str(number**3))-1):
least_number = number**3
else:
print(least_number)
break
N = int(input())
least_number = 0
for number in range(10000000):
if number**3 <= N:
for_number = str(number**3)
rev_number = str(number**3)[::-1]
for keta in range(int(len(for_number))):
if for_number[keta] != rev_number[keta]:
break
elif keta == int(len(str(number**3))-1):
least_number = number**3
else:
print(least_number)
break | ConDefects/ConDefects/Code/abc343_c/Python/54740731 |
condefects-python_data_693 | N = int(input())
x_max = int(pow(N+1, 1/3))
if pow(x_max, 3) > N:
x_max -= 1
for x in range(x_max, 0, -1):
x_str = str(pow(x,3))
x_half_n = len(x_str)//2
if x_str[:x_half_n] == x_str[::-1][:x_half_n]:
print(pow(x,3))
break
N = int(input())
x_max = round(pow(N+1, 1/3))
if pow(x_max, 3) > N:
x_max -= 1
for x in range(x_max, 0, -1):
x_str = str(pow(x,3))
x_half_n = len(x_str)//2
if x_str[:x_half_n] == x_str[::-1][:x_half_n]:
print(pow(x,3))
break | ConDefects/ConDefects/Code/abc343_c/Python/55032181 |
condefects-python_data_694 | s, a, b, m = input(), 0, 1, 998244353
for c in input()[::-1]:
a += b * (ord(c) - ord('0'))
b = (b * 10 + a) % m
print(a)
s, a, b, m = input(), 0, 1, 998244353
for c in input()[::-1]:
a += b * (ord(c) - ord('0'))
b = (b * 10 + a) % m
print(a % m) | ConDefects/ConDefects/Code/abc288_f/Python/44220093 |
condefects-python_data_695 | n=int(input())
x=input()
mod=998255353
dp=0
s=1
for i in range(n):
k=int(x[i])
dp=(dp*10+s*k)%mod
s+=dp
s%=mod
print(dp)
n=int(input())
x=input()
mod=998244353
dp=0
s=1
for i in range(n):
k=int(x[i])
dp=(dp*10+s*k)%mod
s+=dp
s%=mod
print(dp) | ConDefects/ConDefects/Code/abc288_f/Python/54492440 |
condefects-python_data_696 | import sys
input = lambda: sys.stdin.readline().strip()
MOD = 998244353
def solve():
n = int(input())
s = input()
sum_f = 1
f = 0
for c in s:
x = int(c)
f = (f * 10 + x) % MOD
sum_f += f
print(f)
solve()
import sys
input = lambda: sys.stdin.readline().strip()
MOD = 998244353
def solve():
n = int(input())
s = input()
sum_f = 1
f = 0
for c in s:
x = int(c)
f = (f * 10 + sum_f * x) % MOD
sum_f += f
print(f)
solve()
| ConDefects/ConDefects/Code/abc288_f/Python/44222318 |
condefects-python_data_697 | s, a, b, m = input(), 0, 1, 998244353
for c in input():
a = (a * 10 + b * (ord(c) - ord('0'))) % m
b += a
print(a)
s, a, b, m = input(), 0, 1, 998244353
for c in input():
a = (a * 10 + b * (ord(c) - ord('0'))) % m
b += a
print(a) | ConDefects/ConDefects/Code/abc288_f/Python/44219980 |
condefects-python_data_698 | N,T=map(int,input().split())
result=0
L=[]
for i in range(N):
w,x,v=map(int,input().split())
L.append((w,x,v))
from collections import defaultdict
for q in range(N):
R=set()
score=0
w,x,v=L[q][:]
score+=w
P=defaultdict(int)
for i in range(N):
if i==q:
continue
w2,x2,v2=L[i][:]
if x<=x2<=x+T:
score+=w2
if v2<v:
t1=(x2-x)/(v-v2)
t2=(x2-x-T)/(v-v2)
if t1>-10**(-11):
k=int((10**13)*(t1+10**(-11)))
R.add(k)
P[k]-=w2
if t2>10**(-11):
k=int(t2*10**13)
R.add(k)
P[k]-=w2
elif v2==v:
continue
else:
t1=(x-x2)/(v2-v)
t2=(x-x2+T)/(v2-v)
if t1>10**(-11):
k=int(t1*10**13)
P[k]+=w2
R.add(k)
if t2>-10**(-11):
k=int((10**13)*(t2+10**(-11)))
R.add(k)
P[k]-=w2
R=list(R)
R.sort()
result=max(result,score)
for i in range(len(R)):
y=P[R[i]]
score+=y
result=max(result,score)
print(result)
N,T=map(int,input().split())
result=0
L=[]
for i in range(N):
w,x,v=map(int,input().split())
L.append((w,x,v))
from collections import defaultdict
for q in range(N):
R=set()
score=0
w,x,v=L[q][:]
score+=w
P=defaultdict(int)
for i in range(N):
if i==q:
continue
w2,x2,v2=L[i][:]
if x<=x2<=x+T:
score+=w2
if v2<v:
t1=(x2-x)/(v-v2)
t2=(x2-x-T)/(v-v2)
if t1>-10**(-11):
k=int((10**13)*(t1+10**(-11)))
R.add(k)
P[k]-=w2
if t2>10**(-11):
k=int(t2*10**13)
R.add(k)
P[k]+=w2
elif v2==v:
continue
else:
t1=(x-x2)/(v2-v)
t2=(x-x2+T)/(v2-v)
if t1>10**(-11):
k=int(t1*10**13)
P[k]+=w2
R.add(k)
if t2>-10**(-11):
k=int((10**13)*(t2+10**(-11)))
R.add(k)
P[k]-=w2
R=list(R)
R.sort()
result=max(result,score)
for i in range(len(R)):
y=P[R[i]]
score+=y
result=max(result,score)
print(result) | ConDefects/ConDefects/Code/abc274_f/Python/50475104 |
condefects-python_data_699 | def floor_sum(n, m, a, b):
res = 0
if n == 0:
return 0
if a >= m:
res += n*(n-1)//2*(a//m)
a %= m
if b >= m:
res += n*(b//m)
b %= m
if a == 0:
return res
q = (a*n+b)//m
r = (a*n+b)%m
res += floor_sum(q, a, m, r)
return res
T=int(input())
for i in range(T):
N,M,R=map(int,input().split())
ans=0
X=(N-R)//M+1
d=1
while d<N:
ans+=floor_sum(X,d,M,R)-floor_sum(X,d*2,M,R)*2
d*=2
print(ans)
def floor_sum(n, m, a, b):
res = 0
if n == 0:
return 0
if a >= m:
res += n*(n-1)//2*(a//m)
a %= m
if b >= m:
res += n*(b//m)
b %= m
if a == 0:
return res
q = (a*n+b)//m
r = (a*n+b)%m
res += floor_sum(q, a, m, r)
return res
T=int(input())
for i in range(T):
N,M,R=map(int,input().split())
ans=0
X=(N-R)//M+1
d=1
while d<=N:
ans+=floor_sum(X,d,M,R)-floor_sum(X,d*2,M,R)*2
d*=2
print(ans)
| ConDefects/ConDefects/Code/abc283_h/Python/37533124 |
condefects-python_data_700 | from collections import defaultdict
import sys
import os
sys.setrecursionlimit(int(1e9))
input = lambda: sys.stdin.readline().rstrip("\r\n")
def main() -> None:
def check(mid: int) -> bool:
def dfs(cur: int, pre: int) -> int:
"""(对方最优操作下)子树中权值>=mid的点的个数"""
subtree = 0
for next in adjMap[cur]:
if next == pre:
continue
subtree += dfs(next, cur)
subtree = max(0, subtree - 1) # 被对方移除了一个
subtree += int(values[cur] >= mid) # 根节点是否可以
return subtree
return dfs(0, -1) >= 1
n = int(input())
values = [-1] + list(map(int, input().split()))
adjMap = defaultdict(set)
for _ in range(n - 1):
u, v = map(int, input().split())
u, v = u - 1, v - 1
adjMap[u].add(v)
adjMap[v].add(u)
# !注意这里要离散化权值 不然python过不去
# left, right = 1, int(1e9 + 7)
# while left <= right:
# mid = (left + right) // 2
# if check(mid):
# left = mid + 1
# else:
# right = mid - 1
allValues = sorted(set(values))
left, right = 0, len(allValues) - 1 # !二分答案 allValues里的第几个值是答案
while left <= right:
mid = (left + right) // 2
if check(allValues[mid]):
left = mid + 1
else:
right = mid - 1
print(allValues[right])
if __name__ == "__main__":
if os.environ.get("USERNAME", " ") == "caomeinaixi":
while True:
main()
else:
main()
from collections import defaultdict
import sys
import os
sys.setrecursionlimit(int(1e9))
input = lambda: sys.stdin.readline().rstrip("\r\n")
def main() -> None:
def check(mid: int) -> bool:
def dfs(cur: int, pre: int) -> int:
"""(对方最优操作下)子树中权值>=mid的点的个数"""
subtree = 0
for next in adjMap[cur]:
if next == pre:
continue
subtree += dfs(next, cur)
subtree = max(0, subtree - 1) # 被对方移除了一个
subtree += int(values[cur] >= mid) # 根节点是否可以
return subtree
return dfs(0, -1) >= 1
n = int(input())
values = [0] + list(map(int, input().split()))
adjMap = defaultdict(set)
for _ in range(n - 1):
u, v = map(int, input().split())
u, v = u - 1, v - 1
adjMap[u].add(v)
adjMap[v].add(u)
# !注意这里要离散化权值 不然python过不去
# left, right = 1, int(1e9 + 7)
# while left <= right:
# mid = (left + right) // 2
# if check(mid):
# left = mid + 1
# else:
# right = mid - 1
allValues = sorted(set(values))
left, right = 0, len(allValues) - 1 # !二分答案 allValues里的第几个值是答案
while left <= right:
mid = (left + right) // 2
if check(allValues[mid]):
left = mid + 1
else:
right = mid - 1
print(allValues[right])
if __name__ == "__main__":
if os.environ.get("USERNAME", " ") == "caomeinaixi":
while True:
main()
else:
main()
| ConDefects/ConDefects/Code/abc246_g/Python/33284569 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.