id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_301
|
class SegmentTree:
def __init__(self, a):
self.padding = float('inf')
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.seg_data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.seg_data[(i-1)//2] = min(self.seg_data[i], self.seg_data[i-1])
def __len__(self):
return self.n
def __getitem__(self, i):
return self.seg_data[self.N-1+i]
def update(self, i, x):
idx = self.N - 1 + i
self.seg_data[idx] = x
while idx:
idx = (idx-1) // 2
self.seg_data[idx] = min(self.seg_data[2*idx+1], self.seg_data[2*idx+2])
def query(self, i, j):
# [i, j)
if i == j:
return None
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # 閉区間にする
result = self.padding
while idx1 < idx2 + 1:
if idx1&1 == 0: # idx1が偶数
result = min(result, self.seg_data[idx1])
if idx2&1 == 1: # idx2が奇数
result = min(result, self.seg_data[idx2])
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
return result
N, K = map(int, input().split())
P = list(map(int, input().split()))
if K == 0:
print(*P)
quit()
def solve1(data, k):
if k == 0:
return data
ans = []
n = len(data)
pos = dict(zip(data, range(n)))
st = SegmentTree(data)
left = 0
while k and left<n:
m = st.query(left, min(n, left+k+1))
idx = pos[m]
k -= idx - left
left = idx + 1
if k:
ans.append(m)
else:
ans += data[idx:]
return ans
def solve2(data1, data2, k):
res1 = []
res2 = solve1(data2, k)
if len(data1)==0 or data1[0] > res2[0]:
return res2
if data1:
res1 = [data1[0]]
n = len(data1)
pos = dict(zip(data1, range(n)))
st = SegmentTree(data1)
left = 1
while left < n:
m = st.query(left, n)
if m > res2[0]:
break
res1.append(m)
left = pos[m] + 1
return res1 + res2
ans1 = solve1(P.copy(), K)
i = N - 1
idx = m = N+1
for _ in range(K):
if P[i] < m:
idx = i
m = P[i]
i -= 1
data1 = P[idx:]
data2 = P[:idx]
use = N - idx
remain = K - use
ans2 = solve2(data1, data2, remain)
ans = min(ans1, ans2)
print(*ans)
class SegmentTree:
def __init__(self, a):
self.padding = float('inf')
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.seg_data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.seg_data[(i-1)//2] = min(self.seg_data[i], self.seg_data[i-1])
def __len__(self):
return self.n
def __getitem__(self, i):
return self.seg_data[self.N-1+i]
def update(self, i, x):
idx = self.N - 1 + i
self.seg_data[idx] = x
while idx:
idx = (idx-1) // 2
self.seg_data[idx] = min(self.seg_data[2*idx+1], self.seg_data[2*idx+2])
def query(self, i, j):
# [i, j)
if i == j:
return None
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # 閉区間にする
result = self.padding
while idx1 < idx2 + 1:
if idx1&1 == 0: # idx1が偶数
result = min(result, self.seg_data[idx1])
if idx2&1 == 1: # idx2が奇数
result = min(result, self.seg_data[idx2])
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
return result
N, K = map(int, input().split())
P = list(map(int, input().split()))
if K == 0:
print(*P)
quit()
def solve1(data, k):
if k == 0:
return data
ans = []
n = len(data)
pos = dict(zip(data, range(n)))
st = SegmentTree(data)
left = 0
while k and left<n and n-left>k:
m = st.query(left, min(n, left+k+1))
idx = pos[m]
k -= idx - left
left = idx + 1
if k:
ans.append(m)
else:
ans += data[idx:]
return ans
def solve2(data1, data2, k):
res1 = []
res2 = solve1(data2, k)
if len(data1)==0 or data1[0] > res2[0]:
return res2
if data1:
res1 = [data1[0]]
n = len(data1)
pos = dict(zip(data1, range(n)))
st = SegmentTree(data1)
left = 1
while left < n:
m = st.query(left, n)
if m > res2[0]:
break
res1.append(m)
left = pos[m] + 1
return res1 + res2
ans1 = solve1(P.copy(), K)
i = N - 1
idx = m = N+1
for _ in range(K):
if P[i] < m:
idx = i
m = P[i]
i -= 1
data1 = P[idx:]
data2 = P[:idx]
use = N - idx
remain = K - use
ans2 = solve2(data1, data2, remain)
ans = min(ans1, ans2)
print(*ans)
|
ConDefects/ConDefects/Code/abc262_f/Python/48961945
|
condefects-python_data_302
|
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
class SWAG():
def __init__(self, op, e):
self.op = op
self.e = e
self.top = []
self.bottom = []
self.topfold = [e]
self.bottomfold = [e]
def _pushbottom(self, x):
self.bottom.append(x)
self.bottomfold.append(self.op(self.bottomfold[-1], x))
def _popbottom(self):
self.bottomfold.pop()
return self.bottom.pop()
def _pushtop(self, x):
self.top.append(x)
self.topfold.append(self.op(x, self.topfold[-1]))
def _poptop(self):
self.topfold.pop()
return self.top.pop()
def push(self, x):
self._pushbottom(x)
def fold(self):
return self.op(self.topfold[-1], self.bottomfold[-1])
def pop(self):
if not self.top:
while self.bottom:
x = self._popbottom()
self._pushtop(x)
if not self.top:
return self.e
else:
return self._poptop()
def solve(a, k):
n = len(a)
S = SWAG(min, inf)
for i in range(k - 1):
S.push(a[i])
ans = []
for i in range(k, n):
S.push(a[i])
ans.append(S.fold())
while True:
x = S.pop()
if x == ans[-1]:
break
return ans
def solve2(a, x):
n= len(a)
S = SWAG(min, inf)
for i in range(n):
S.push(a[i])
ans = []
for i in range(n):
if len(S.top) + len(S.bottom) == 0:
break
now = S.fold()
if now < x:
ans.append(now)
while True:
to = S.pop()
if to == ans[-1]:
break
else:
break
return ans
n, k = mi()
p = li()
if k == 0:
print(*p)
exit()
ans1 = solve(p, k)
mini = min(p[n - k:])
x = p.index(mini)
p2 = p[x:]
p3 = p[:x]
ansy = solve(p3, k - (n - x))
ansx = solve2(p2, ansy[0])
ans2 = ansx + ansy
print(*min(ans1, ans2))
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
class SWAG():
def __init__(self, op, e):
self.op = op
self.e = e
self.top = []
self.bottom = []
self.topfold = [e]
self.bottomfold = [e]
def _pushbottom(self, x):
self.bottom.append(x)
self.bottomfold.append(self.op(self.bottomfold[-1], x))
def _popbottom(self):
self.bottomfold.pop()
return self.bottom.pop()
def _pushtop(self, x):
self.top.append(x)
self.topfold.append(self.op(x, self.topfold[-1]))
def _poptop(self):
self.topfold.pop()
return self.top.pop()
def push(self, x):
self._pushbottom(x)
def fold(self):
return self.op(self.topfold[-1], self.bottomfold[-1])
def pop(self):
if not self.top:
while self.bottom:
x = self._popbottom()
self._pushtop(x)
if not self.top:
return self.e
else:
return self._poptop()
def solve(a, k):
n = len(a)
S = SWAG(min, inf)
for i in range(k):
S.push(a[i])
ans = []
for i in range(k, n):
S.push(a[i])
ans.append(S.fold())
while True:
x = S.pop()
if x == ans[-1]:
break
return ans
def solve2(a, x):
n= len(a)
S = SWAG(min, inf)
for i in range(n):
S.push(a[i])
ans = []
for i in range(n):
if len(S.top) + len(S.bottom) == 0:
break
now = S.fold()
if now < x:
ans.append(now)
while True:
to = S.pop()
if to == ans[-1]:
break
else:
break
return ans
n, k = mi()
p = li()
if k == 0:
print(*p)
exit()
ans1 = solve(p, k)
mini = min(p[n - k:])
x = p.index(mini)
p2 = p[x:]
p3 = p[:x]
ansy = solve(p3, k - (n - x))
ansx = solve2(p2, ansy[0])
ans2 = ansx + ansy
print(*min(ans1, ans2))
|
ConDefects/ConDefects/Code/abc262_f/Python/35966715
|
condefects-python_data_303
|
N,K = map(int,input().split())
P = list(map(int,input().split()))
d = {}
for i in range(N):
d[P[i]] = i
for p in range(1,N+1):
k = d[p]
kk = N - k
if min(k,kk) > K:
continue
Q = P[:k]
R = P[k:]
ans = []
n = kk
if n > K:
ans = P
else:
for r in R:
if len(ans) == 0:
ans.append((r,0))
continue
while ans[-1][0] > r:
ans.pop()
if len(ans) == 0:
break
ans.append((r,0))
for q in Q:
while ans[-1][0] > q and n < K:
r,cc = ans.pop()
n += cc
ans.append((q,1))
while n < K:
r,c = ans.pop()
n += c
for i in range(len(ans)):
ans[i] = ans[i][0]
ans_ = []
n = k
if n > K:
ans_ = P
else:
for r in R:
if len(ans_) == 0:
ans_.append(r)
continue
while ans_[-1] > r and n < K:
ans_.pop()
n += 1
if len(ans_) == 0:
break
ans_.append(r)
while n < K:
n += 1
ans_.pop()
ans = min(ans,ans_)
print(*ans)
exit()
print(*P)
N,K = map(int,input().split())
P = list(map(int,input().split()))
d = {}
for i in range(N):
d[P[i]] = i
for p in range(1,N+1):
k = d[p]
kk = N - k
if min(k,kk) > K:
continue
Q = P[:k]
R = P[k:]
ans = []
n = kk
if n > K:
ans = P
else:
for r in R:
if len(ans) == 0:
ans.append((r,0))
continue
while ans[-1][0] > r:
ans.pop()
if len(ans) == 0:
break
ans.append((r,0))
for q in Q:
while ans[-1][0] > q and not(n == K and ans[-1][1] == 1):
r,cc = ans.pop()
n += cc
ans.append((q,1))
while n < K:
r,c = ans.pop()
n += c
for i in range(len(ans)):
ans[i] = ans[i][0]
ans_ = []
n = k
if n > K:
ans_ = P
else:
for r in R:
if len(ans_) == 0:
ans_.append(r)
continue
while ans_[-1] > r and n < K:
ans_.pop()
n += 1
if len(ans_) == 0:
break
ans_.append(r)
while n < K:
n += 1
ans_.pop()
ans = min(ans,ans_)
print(*ans)
exit()
print(*P)
|
ConDefects/ConDefects/Code/abc262_f/Python/47638667
|
condefects-python_data_304
|
import itertools
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def get_root(s):
if s ^ root[s]:
root[s] = get_root(root[s])
return root[s]
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
root[rt] = rs
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
def f(u, v):
return u * pow2[m] + v
n, m = map(int, input().split())
pow2 = [1]
for _ in range(m):
pow2.append(2 * pow2[-1])
d = [[]]
for x in range(1, 5):
d0 = []
for p0 in itertools.product([i for i in range(x)], repeat = x):
p = list(p0)
u, ok = -1, 1
for i in p:
if not i <= u + 1:
ok = 0
break
u = max(u, i)
if ok:
d0.append(p)
d.append(d0)
u1 = dict()
u = []
ro, si = [], []
for i in range(1, pow2[m]):
v = []
for j in range(m):
if i & pow2[j]:
v.append(j)
c = 0
la = -2
for j in v:
if (la + 1) ^ j:
c += 1
la = j
for d0 in d[c]:
u0 = [0] * m
k = -1
la = -2
for j in v:
if (la + 1) ^ j:
k += 1
la = j
u0[j] = d0[k] + 1
u.append(u0)
x = 0
for i in u0:
x = 10 * x + i
u1[x] = len(u) - 1
root = [k for k in range(2 * m)]
size = [1 for _ in range(2 * m)]
for j in v:
for k in v:
if u0[j] == u0[k]:
unite(j + m, k + m)
ro.append(root)
si.append(size)
l = len(u)
s = [list(input().rstrip()) for _ in range(n)]
for _ in range(2):
while not min(s[-1]) & 1:
s.pop()
s.reverse()
inf = pow(10, 9) + 1
dp = [inf] * l
s0 = s.pop()
for i in range(l):
u0 = u[i]
v = []
ok, c = 1, 0
for j, k in zip(s0, u0):
if j & 1 and not k:
ok = 0
break
elif not j & 1 and k:
c += 1
la, k = -2, 0
for j in range(m):
if u0[j] and (la + 1) ^ j:
k += 1
if u0[j] and u0[j] ^ k:
ok = 0
break
if u0[j]:
la = j
if ok:
dp[i] = c
r1, s1 = [[] for _ in range(l * pow2[m])], [[] for _ in range(l * pow2[m])]
while s:
s0 = s.pop()
c0 = s0.count(35)
dp0 = [inf] * l
mi = min(dp)
for i in range(l):
if dp[i] > mi + 4:
continue
ui = u[i]
v = []
for j in range(m):
if ui[j]:
v.append(j + m)
for j in range(pow2[m]):
ok = 1
for k in range(m):
if not j & pow2[k] and s0[k] & 1:
ok = 0
break
if not ok:
continue
if not r1[f(i, j)]:
root = list(ro[i])
size = list(si[i])
for k in range(m - 1):
if j & pow2[k] and j & pow2[k + 1]:
unite(k, k + 1)
for k in range(m):
if j & pow2[k] and ui[k]:
unite(k, k + m)
r1[f(i, j)], s1[f(i, j)] = root, size
root, size = r1[f(i, j)], s1[f(i, j)]
ok = 1
for k in v:
ok = 0
for x in range(m):
if j & pow2[x] and same(x, k):
ok = 1
if not ok:
break
if not ok:
continue
u0 = [0] * m
d1, z, c = dict(), 1, -c0
for k in range(m):
if j & pow2[k] and not get_root(k) in d1:
d1[get_root(k)] = z
z += 1
if j & pow2[k]:
u0[k] = d1[get_root(k)]
c += 1
x = 0
for k in u0:
x = 10 * x + k
k = u1[x]
dp0[k] = min(dp0[k], dp[i] + c)
dp = dp0
ans = inf
for i in range(l):
if max(u[i]) == 1:
ans = min(ans, dp[i])
print(ans)
import itertools
import sys, os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def get_root(s):
if s ^ root[s]:
root[s] = get_root(root[s])
return root[s]
return s
def unite(s, t):
rs, rt = get_root(s), get_root(t)
if not rs ^ rt:
return
root[rt] = rs
return
def same(s, t):
return True if get_root(s) == get_root(t) else False
def f(u, v):
return u * pow2[m] + v
n, m = map(int, input().split())
pow2 = [1]
for _ in range(m):
pow2.append(2 * pow2[-1])
d = [[]]
for x in range(1, 5):
d0 = []
for p0 in itertools.product([i for i in range(x)], repeat = x):
p = list(p0)
u, ok = -1, 1
for i in p:
if not i <= u + 1:
ok = 0
break
u = max(u, i)
if ok:
d0.append(p)
d.append(d0)
u1 = dict()
u = []
ro, si = [], []
for i in range(1, pow2[m]):
v = []
for j in range(m):
if i & pow2[j]:
v.append(j)
c = 0
la = -2
for j in v:
if (la + 1) ^ j:
c += 1
la = j
for d0 in d[c]:
u0 = [0] * m
k = -1
la = -2
for j in v:
if (la + 1) ^ j:
k += 1
la = j
u0[j] = d0[k] + 1
u.append(u0)
x = 0
for i in u0:
x = 10 * x + i
u1[x] = len(u) - 1
root = [k for k in range(2 * m)]
size = [1 for _ in range(2 * m)]
for j in v:
for k in v:
if u0[j] == u0[k]:
unite(j + m, k + m)
ro.append(root)
si.append(size)
l = len(u)
s = [list(input().rstrip()) for _ in range(n)]
for _ in range(2):
while not min(s[-1]) & 1:
s.pop()
s.reverse()
inf = pow(10, 9) + 1
dp = [inf] * l
s0 = s.pop()
for i in range(l):
u0 = u[i]
v = []
ok, c = 1, 0
for j, k in zip(s0, u0):
if j & 1 and not k:
ok = 0
break
elif not j & 1 and k:
c += 1
la, k = -2, 0
for j in range(m):
if u0[j] and (la + 1) ^ j:
k += 1
if u0[j] and u0[j] ^ k:
ok = 0
break
if u0[j]:
la = j
if ok:
dp[i] = c
r1, s1 = [[] for _ in range(l * pow2[m])], [[] for _ in range(l * pow2[m])]
while s:
s0 = s.pop()
c0 = s0.count(35)
dp0 = [inf] * l
mi = min(dp)
for i in range(l):
if dp[i] > mi + 5:
continue
ui = u[i]
v = []
for j in range(m):
if ui[j]:
v.append(j + m)
for j in range(pow2[m]):
ok = 1
for k in range(m):
if not j & pow2[k] and s0[k] & 1:
ok = 0
break
if not ok:
continue
if not r1[f(i, j)]:
root = list(ro[i])
size = list(si[i])
for k in range(m - 1):
if j & pow2[k] and j & pow2[k + 1]:
unite(k, k + 1)
for k in range(m):
if j & pow2[k] and ui[k]:
unite(k, k + m)
r1[f(i, j)], s1[f(i, j)] = root, size
root, size = r1[f(i, j)], s1[f(i, j)]
ok = 1
for k in v:
ok = 0
for x in range(m):
if j & pow2[x] and same(x, k):
ok = 1
if not ok:
break
if not ok:
continue
u0 = [0] * m
d1, z, c = dict(), 1, -c0
for k in range(m):
if j & pow2[k] and not get_root(k) in d1:
d1[get_root(k)] = z
z += 1
if j & pow2[k]:
u0[k] = d1[get_root(k)]
c += 1
x = 0
for k in u0:
x = 10 * x + k
k = u1[x]
dp0[k] = min(dp0[k], dp[i] + c)
dp = dp0
ans = inf
for i in range(l):
if max(u[i]) == 1:
ans = min(ans, dp[i])
print(ans)
|
ConDefects/ConDefects/Code/abc296_h/Python/40275095
|
condefects-python_data_305
|
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
import sys
sys.setrecursionlimit(10**8)
N=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
if A[0]!=1:
print(-1)
exit()
result=[[0]*2 for i in range(N+1)]
place=[0]*(N+1)
for i in range(N):
place[B[i]]=i
def dfs(l1,r1,l2,r2):
if l1>r1:
return
if l1==r1:
if A[l1]!=B[l2]:
print(-1)
exit()
return
pos=place[A[l1]]
if pos<l2 or pos>r2:
print('No')
exit()
count=pos-l2
if count>0:
result[A[l1]][0]=A[l1+1]
dfs(l1+1,l1+count,l2,l2+count-1)
if l1+count+1<=r1:
result[A[l1]][1]=A[l1+count+1]
dfs(l1+count+1,r1,l2+count+1,r2)
dfs(0,N-1,0,N-1)
k=0
for B in result:
k+=1
if k==1:
continue
print(B[0],B[1])
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
import sys
sys.setrecursionlimit(10**8)
N=int(input())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
if A[0]!=1:
print(-1)
exit()
result=[[0]*2 for i in range(N+1)]
place=[0]*(N+1)
for i in range(N):
place[B[i]]=i
def dfs(l1,r1,l2,r2):
if l1>r1:
return
if l1==r1:
if A[l1]!=B[l2]:
print(-1)
exit()
return
pos=place[A[l1]]
if pos<l2 or pos>r2:
print(-1)
exit()
count=pos-l2
if count>0:
result[A[l1]][0]=A[l1+1]
dfs(l1+1,l1+count,l2,l2+count-1)
if l1+count+1<=r1:
result[A[l1]][1]=A[l1+count+1]
dfs(l1+count+1,r1,l2+count+1,r2)
dfs(0,N-1,0,N-1)
k=0
for B in result:
k+=1
if k==1:
continue
print(B[0],B[1])
|
ConDefects/ConDefects/Code/abc255_f/Python/50474364
|
condefects-python_data_306
|
def main():
# write code here.
N = II()
P = LM_1()
I = LM_1()
inv = [0]*N
for i,e in enumerate(I):
inv[e] = i
left_child = [0]*N
right_child = [0]*N
if P[0]!=0:
print(-1)
return
def rec(PL, PR, IL, IR):
root = P[PL]
idx = inv[root]
if idx<IL or IR<=idx:
print(-1)
exit()
if idx==IL:
pass
else:
left_child[root] = P[PL+1] + 1
rec(PL+1,PL+1+(idx-IL),IL,idx)
if idx==IR-1:
pass
else:
right_child[root] = I[idx+1] + 1
rec(PL+1+(idx-IL),PR,idx+1,IR)
rec(0,N,0,N)
for i in range(N):
print(left_child[i], right_child[i])
# 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 bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
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 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 expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(coeff1, coeff0, bound_included1, bound_included2, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
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 makeTableBit(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 rot(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 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
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# 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
# wotsushiさん作成 : https://qiita.com/wotsushi/items/c936838df992b706084c
# global MOD を定義.
# ModIntとintの結果はModInt.
# a**b , a/b といった演算も可能.
# 配列などの添え字には利用できない. intに変換はできない.
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
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 = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*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
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
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])
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"
main()
def main():
# write code here.
N = II()
P = LM_1()
I = LM_1()
inv = [0]*N
for i,e in enumerate(I):
inv[e] = i
left_child = [0]*N
right_child = [0]*N
if P[0]!=0:
print(-1)
return
def rec(PL, PR, IL, IR):
root = P[PL]
idx = inv[root]
if idx<IL or IR<=idx:
print(-1)
exit()
if idx==IL:
pass
else:
left_child[root] = P[PL+1] + 1
rec(PL+1,PL+1+(idx-IL),IL,idx)
if idx==IR-1:
pass
else:
right_child[root] = P[PL+1+(idx-IL)] + 1
rec(PL+1+(idx-IL),PR,idx+1,IR)
rec(0,N,0,N)
for i in range(N):
print(left_child[i], right_child[i])
# 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 bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
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 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 expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(coeff1, coeff0, bound_included1, bound_included2, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
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 makeTableBit(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 rot(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 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
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# 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
# wotsushiさん作成 : https://qiita.com/wotsushi/items/c936838df992b706084c
# global MOD を定義.
# ModIntとintの結果はModInt.
# a**b , a/b といった演算も可能.
# 配列などの添え字には利用できない. intに変換はできない.
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
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 = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*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
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
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])
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"
main()
|
ConDefects/ConDefects/Code/abc255_f/Python/53267275
|
condefects-python_data_307
|
import sys
input = lambda: sys.stdin.readline().strip()
h, w = map(int, input().split())
rc = [input() for _ in range(h)]
snuke = 'snuke'
# 横
for i in range(h):
for j in range(w-4):
if rc[i][j:j+5] == snuke:
for k in range(j, j+5):
print(i+1, k+1)
if ''.join(list(reversed(rc[i][j:j+5]))) == snuke:
for k in reversed(range(j, j+5)):
print(i+1, k+1)
# 縦
for i in range(w):
for j in range(h-4):
if rc[j][i]+rc[j+1][i]+rc[j+2][i]+rc[j+3][i]+rc[j+4][i] == snuke:
for k in range(5):
print(j+k+1, i+1)
if ''.join(list(reversed(rc[j][i]+rc[j+1][i]+rc[j+2][i]+rc[j+3][i]+rc[j+4][i]))) == snuke:
for k in reversed(range(5)):
print(j+k+1, i+1)
# 右下斜め
for i in range(h-4):
for j in range(w-4):
if rc[i][j]+rc[i+1][j+1]+rc[i+2][j+2]+rc[i+3][j+3]+rc[i+4][j+4] == snuke:
for k in range(5):
print(i+k+1, j+k+1)
if ''.join(list(reversed(rc[i][j]+rc[i+1][j+1]+rc[i+2][j+2]+rc[i+3][j+3]+rc[i+4][j+4]))) == snuke:
for k in reversed(range(5)):
print(i+k+1, j+k+1)
# 右上斜め
for i in range(5, h):
for j in range(w-4):
if rc[i][j]+rc[i-1][j+1]+rc[i-2][j+2]+rc[i-3][j+3]+rc[i-4][j+4] == snuke:
for k in range(5):
print(i-k+1, j+k+1)
if ''.join(list(reversed(rc[i][j]+rc[i-1][j+1]+rc[i-2][j+2]+rc[i-3][j+3]+rc[i-4][j+4]))) == snuke:
for k in reversed(range(5)):
print(i-k+1, j+k+1)
import sys
input = lambda: sys.stdin.readline().strip()
h, w = map(int, input().split())
rc = [input() for _ in range(h)]
snuke = 'snuke'
# 横
for i in range(h):
for j in range(w-4):
if rc[i][j:j+5] == snuke:
for k in range(j, j+5):
print(i+1, k+1)
if ''.join(list(reversed(rc[i][j:j+5]))) == snuke:
for k in reversed(range(j, j+5)):
print(i+1, k+1)
# 縦
for i in range(w):
for j in range(h-4):
if rc[j][i]+rc[j+1][i]+rc[j+2][i]+rc[j+3][i]+rc[j+4][i] == snuke:
for k in range(5):
print(j+k+1, i+1)
if ''.join(list(reversed(rc[j][i]+rc[j+1][i]+rc[j+2][i]+rc[j+3][i]+rc[j+4][i]))) == snuke:
for k in reversed(range(5)):
print(j+k+1, i+1)
# 右下斜め
for i in range(h-4):
for j in range(w-4):
if rc[i][j]+rc[i+1][j+1]+rc[i+2][j+2]+rc[i+3][j+3]+rc[i+4][j+4] == snuke:
for k in range(5):
print(i+k+1, j+k+1)
if ''.join(list(reversed(rc[i][j]+rc[i+1][j+1]+rc[i+2][j+2]+rc[i+3][j+3]+rc[i+4][j+4]))) == snuke:
for k in reversed(range(5)):
print(i+k+1, j+k+1)
# 右上斜め
for i in range(4, h):
for j in range(w-4):
if rc[i][j]+rc[i-1][j+1]+rc[i-2][j+2]+rc[i-3][j+3]+rc[i-4][j+4] == snuke:
for k in range(5):
print(i-k+1, j+k+1)
if ''.join(list(reversed(rc[i][j]+rc[i-1][j+1]+rc[i-2][j+2]+rc[i-3][j+3]+rc[i-4][j+4]))) == snuke:
for k in reversed(range(5)):
print(i-k+1, j+k+1)
|
ConDefects/ConDefects/Code/abc302_b/Python/45763953
|
condefects-python_data_308
|
import sys
readline = sys.stdin.readline
def gcd(a,b):
while b:
a, b = b, a%b
return abs(a)
def lcm(a, b):
return a*b//gcd(a, b)
class UFP():
def __init__(self, num, N):
self.par = [-1]*num
self.dist = [0]*num
self.gg = [N]*num
def find(self, x):
if self.par[x] < 0:
return x
else:
res = 0
xo = x
while self.par[x] >= 0:
res += self.dist[x]
x = self.par[x]
self.dist[xo] = res
self.par[xo] = x
return x
def union(self, x, y, d):
rx = self.find(x)
ry = self.find(y)
if rx != ry:
if self.par[rx] > self.par[ry]:
rx, ry = ry, rx
x, y = y, x
d = -d
self.par[rx] += self.par[ry]
self.par[ry] = rx
self.dist[ry] = d + self.dist[x] - self.dist[y]
pre = self.gg[rx] + self.gg[ry]
self.gg[rx] = gcd(self.gg[rx], self.gg[ry])
return self.gg[rx] - pre
else:
pre = self.gg[rx]
self.gg[rx] = gcd(self.gg[rx], gcd(d, self.dist[x] - self.dist[y]))
return self.gg[rx] - pre
def calc(a, b):
if b > a:
b -= N
X, Y = a, a-b
assert (a-b) >= 0
return X, Y
N, Q = map(int, readline().split())
ans = N*N
Ans = [ans]
T = UFP(N, N)
for _ in range(Q):
a, b, c, d = map(int, readline().split())
X, Y = calc(a, b)
Z, W = calc(c, d)
Ans.append(Ans[-1] + T.union(Y, W, X-Z))
print('\n'.join(map(str, Ans[1:])))
import sys
readline = sys.stdin.readline
def gcd(a,b):
while b:
a, b = b, a%b
return abs(a)
def lcm(a, b):
return a*b//gcd(a, b)
class UFP():
def __init__(self, num, N):
self.par = [-1]*num
self.dist = [0]*num
self.gg = [N]*num
def find(self, x):
if self.par[x] < 0:
return x
else:
res = 0
xo = x
while self.par[x] >= 0:
res += self.dist[x]
x = self.par[x]
self.dist[xo] = res
self.par[xo] = x
return x
def union(self, x, y, d):
rx = self.find(x)
ry = self.find(y)
if rx != ry:
if self.par[rx] > self.par[ry]:
rx, ry = ry, rx
x, y = y, x
d = -d
self.par[rx] += self.par[ry]
self.par[ry] = rx
self.dist[ry] = d + self.dist[x] - self.dist[y]
pre = self.gg[rx] + self.gg[ry]
self.gg[rx] = gcd(self.gg[rx], self.gg[ry])
return self.gg[rx] - pre
else:
pre = self.gg[rx]
self.gg[rx] = gcd(self.gg[rx], d + (self.dist[x] - self.dist[y]))
return self.gg[rx] - pre
def calc(a, b):
if b > a:
b -= N
X, Y = a, a-b
assert (a-b) >= 0
return X, Y
N, Q = map(int, readline().split())
ans = N*N
Ans = [ans]
T = UFP(N, N)
for _ in range(Q):
a, b, c, d = map(int, readline().split())
X, Y = calc(a, b)
Z, W = calc(c, d)
Ans.append(Ans[-1] + T.union(Y, W, X-Z))
print('\n'.join(map(str, Ans[1:])))
|
ConDefects/ConDefects/Code/arc141_e/Python/32093401
|
condefects-python_data_309
|
P, B, N, M = map(int, input().split())
N += 1
G = [[False] * N for _ in range(N)]
for _ in range(M):
l, r = map(int, input().split())
l -= 1
G[l][r] = G[r][l] = True
INF = 10**18
dp = [INF] * (1 << N)
for msk in range(1 << N):
cnt = 0
for i in range(N):
for j in range(i + 1, N):
if msk & (1 << i) and msk & (1 << j) and G[i][j]:
cnt += 1
if cnt == 0:
dp[msk] = 1
continue
msk2 = msk
while msk2 > 0:
cmsk = msk - msk2
dp[msk] = min(dp[msk], dp[msk2] + dp[cmsk])
msk2 = (msk2 - 1) & msk2
if dp[-1] <= P:
print("Yes")
else:
print("No")
P, B, N, M = map(int, input().split())
N += 1
G = [[False] * N for _ in range(N)]
for _ in range(M):
l, r = map(int, input().split())
l -= 1
G[l][r] = G[r][l] = True
INF = 10**18
dp = [INF] * (1 << N)
for msk in range(1 << N):
cnt = 0
for i in range(N):
for j in range(i + 1, N):
if msk & (1 << i) and msk & (1 << j) and G[i][j]:
cnt += 1
if cnt == 0:
dp[msk] = 1
continue
msk2 = msk
while msk2 > 0:
cmsk = msk - msk2
dp[msk] = min(dp[msk], dp[msk2] + dp[cmsk])
msk2 = (msk2 - 1) & msk
if dp[-1] <= P:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/arc171_d/Python/51665861
|
condefects-python_data_310
|
import sys, time, random
from collections import deque, Counter, defaultdict
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
def popcount(x):
x = ((x >> 1) & 0x55555555) + (x & 0x55555555)
x = ((x >> 2) & 0x33333333) + (x & 0x33333333)
x = ((x >> 4) & 0x0f0f0f0f) + (x & 0x0f0f0f0f)
x = ((x >> 8) & 0x00ff00ff) + (x & 0x00ff00ff)
x = ((x >> 16) & 0x0000ffff) + (x & 0x0000ffff)
return x
def bit_reverse(x):
x = (x >> 16) | (x << 16)
x = ((x >> 8) & 0x00FF00FF) | ((x << 8) & 0xFF00FF00)
x = ((x >> 4) & 0x0F0F0F0F) | ((x << 4) & 0xF0F0F0F0)
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xCCCCCCCC)
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xAAAAAAAA)
return x
def ctz(x): return popcount(~x & (x - 1))
def clz(x): return ctz(bit_reverse(x))
def chromatic_number(n, uvs):
edge = [0] * n
for uv in uvs:
u, v = uv
edge[u] |= 1 << v
edge[v] |= 1 << u
dp = [0] * (1 << n)
dp[0] = 1
cur = [0] * (1 << n)
for bit in range(1, 1 << n):
v = ctz(bit)
dp[bit] = dp[bit ^ (1 << v)] + dp[(bit ^ (1 << v)) & (~edge[v])]
for bit in range(1 << n):
if (n - popcount(bit)) & 1:
cur[bit] = -1
else:
cur[bit] = 1
for k in range(1, n):
tmp = 0
for bit in range(1 << n):
cur[bit] *= dp[bit]
tmp += cur[bit]
if tmp != 0:
res = k
break
else:
res = n
return res
p, b, n, m = mi()
uvs = [li() for _ in range(m)]
for i in range(m):
uvs[i][0] -= 1
print('Yes' if chromatic_number(n + 1, uvs) < p else 'No')
import sys, time, random
from collections import deque, Counter, defaultdict
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
def popcount(x):
x = ((x >> 1) & 0x55555555) + (x & 0x55555555)
x = ((x >> 2) & 0x33333333) + (x & 0x33333333)
x = ((x >> 4) & 0x0f0f0f0f) + (x & 0x0f0f0f0f)
x = ((x >> 8) & 0x00ff00ff) + (x & 0x00ff00ff)
x = ((x >> 16) & 0x0000ffff) + (x & 0x0000ffff)
return x
def bit_reverse(x):
x = (x >> 16) | (x << 16)
x = ((x >> 8) & 0x00FF00FF) | ((x << 8) & 0xFF00FF00)
x = ((x >> 4) & 0x0F0F0F0F) | ((x << 4) & 0xF0F0F0F0)
x = ((x >> 2) & 0x33333333) | ((x << 2) & 0xCCCCCCCC)
x = ((x >> 1) & 0x55555555) | ((x << 1) & 0xAAAAAAAA)
return x
def ctz(x): return popcount(~x & (x - 1))
def clz(x): return ctz(bit_reverse(x))
def chromatic_number(n, uvs):
edge = [0] * n
for uv in uvs:
u, v = uv
edge[u] |= 1 << v
edge[v] |= 1 << u
dp = [0] * (1 << n)
dp[0] = 1
cur = [0] * (1 << n)
for bit in range(1, 1 << n):
v = ctz(bit)
dp[bit] = dp[bit ^ (1 << v)] + dp[(bit ^ (1 << v)) & (~edge[v])]
for bit in range(1 << n):
if (n - popcount(bit)) & 1:
cur[bit] = -1
else:
cur[bit] = 1
for k in range(1, n):
tmp = 0
for bit in range(1 << n):
cur[bit] *= dp[bit]
tmp += cur[bit]
if tmp != 0:
res = k
break
else:
res = n
return res
p, b, n, m = mi()
uvs = [li() for _ in range(m)]
for i in range(m):
uvs[i][0] -= 1
print('Yes' if chromatic_number(n + 1, uvs) <= p else 'No')
|
ConDefects/ConDefects/Code/arc171_d/Python/50018799
|
condefects-python_data_311
|
p, b, n, m = map(int, input().split())
lr = [list(map(int, input().split())) for i in range(m)]
if p > 16:
print("Yes")
exit()
n += 1
ok = []
for i in range(1 << n):
for l, r in lr:
if (1 << (l - 1)) & i and (1 << r) & i:
ok.append(False)
break
else:
ok.append(True)
t = [1 << 30] * (1 << n)
t[0] = 1
msk = (1 << n) - 1
for i in range((1 << n) - 1):
j = msk ^ i
k = j
while j:
if ok[j]:
t[i ^ j] = min(t[i ^ j], t[i] + 1)
j = (j - 1) & k
print("Yes" if t[-1] <= p else "No")
p, b, n, m = map(int, input().split())
lr = [list(map(int, input().split())) for i in range(m)]
if p > 16:
print("Yes")
exit()
n += 1
ok = []
for i in range(1 << n):
for l, r in lr:
if (1 << (l - 1)) & i and (1 << r) & i:
ok.append(False)
break
else:
ok.append(True)
t = [1 << 30] * (1 << n)
t[0] = 0
msk = (1 << n) - 1
for i in range((1 << n) - 1):
j = msk ^ i
k = j
while j:
if ok[j]:
t[i ^ j] = min(t[i ^ j], t[i] + 1)
j = (j - 1) & k
print("Yes" if t[-1] <= p else "No")
|
ConDefects/ConDefects/Code/arc171_d/Python/50321760
|
condefects-python_data_312
|
P,B,N,M = map(int,input().split())
LR = [tuple(map(int,input().split())) for _ in range(M)]
if P >= N:
exit(print('Yes'))
INF = 10**18
N += 1
_dp = [INF] * (1<<N)
_dp[0] = 0
for b in range(1,1<<N):
for l,r in LR:
l -= 1
if b&(1<<l) and b&(1<<r):
break
else:
_dp[b] = 1
dp = _dp[:]
for b in range(1<<N):
a = (b-1) & b
while a > 0:
dp[b] = min(dp[b], _dp[a] + dp[a^b])
a = (a-1) & b
print('No' if dp[-1] > P else 'Yes')
P,B,N,M = map(int,input().split())
LR = [tuple(map(int,input().split())) for _ in range(M)]
if P >= N+1:
exit(print('Yes'))
INF = 10**18
N += 1
_dp = [INF] * (1<<N)
_dp[0] = 0
for b in range(1,1<<N):
for l,r in LR:
l -= 1
if b&(1<<l) and b&(1<<r):
break
else:
_dp[b] = 1
dp = _dp[:]
for b in range(1<<N):
a = (b-1) & b
while a > 0:
dp[b] = min(dp[b], _dp[a] + dp[a^b])
a = (a-1) & b
print('No' if dp[-1] > P else 'Yes')
|
ConDefects/ConDefects/Code/arc171_d/Python/50985599
|
condefects-python_data_313
|
N,a,b = map(int,input().split())
A = list(map(int,input().split()))
left = 0
right = 10**9
while right-left>1:
mid = (left+right)//2
plus_cnt = 0
minus_cnt = 0
for i in range(N):
if A[i]<mid:
plus_cnt += (mid-A[i]+a-1)//a
else:
minus_cnt += (A[i]-mid)//b
if plus_cnt <= minus_cnt:
left = mid
else:
right = mid
print(left)
N,a,b = map(int,input().split())
A = list(map(int,input().split()))
left = 0
right = 10**9+1
while right-left>1:
mid = (left+right)//2
plus_cnt = 0
minus_cnt = 0
for i in range(N):
if A[i]<mid:
plus_cnt += (mid-A[i]+a-1)//a
else:
minus_cnt += (A[i]-mid)//b
if plus_cnt <= minus_cnt:
left = mid
else:
right = mid
print(left)
|
ConDefects/ConDefects/Code/arc144_b/Python/42258051
|
condefects-python_data_314
|
def check(m, al, a, b):
a_cnt = 0
b_cnt = 0
for num in al:
diff = abs(num - m)
if num < diff:
cnt = diff // a
if diff % a != 0:
cnt += 1
a_cnt += cnt
else:
cnt = diff // b
b_cnt += cnt
return a_cnt <= b_cnt
def job():
n, a, b = map(int, input().split())
al = list(map(int, input().split()))
left = 0
right = 10 ** 9 + 100
while right - left > 1:
mid = (right + left) // 2
# もっと答えを大きくできるかも
if check(mid, al, a, b):
left = mid
else:
# もっとちいさく
right = mid
print(left)
job()
def check(m, al, a, b):
a_cnt = 0
b_cnt = 0
for num in al:
diff = abs(num - m)
if num < m:
cnt = diff // a
if diff % a != 0:
cnt += 1
a_cnt += cnt
else:
cnt = diff // b
b_cnt += cnt
return a_cnt <= b_cnt
def job():
n, a, b = map(int, input().split())
al = list(map(int, input().split()))
left = 0
right = 10 ** 9 + 100
while right - left > 1:
mid = (right + left) // 2
# もっと答えを大きくできるかも
if check(mid, al, a, b):
left = mid
else:
# もっとちいさく
right = mid
print(left)
job()
|
ConDefects/ConDefects/Code/arc144_b/Python/41927392
|
condefects-python_data_315
|
N,a,b=map(int,input().split())
A=list(map(int,input().split()))
def is_ok(mid):
lcnt=0
hcnt=0
for i in A:
if mid>i:
if (mid-i)%a==0:
lcnt+=(mid-i)//a
else:
lcnt+=(mid-i)//a+1
else:
hcnt+=(i-mid)//b
if lcnt<=hcnt:
return True
else:
return False
def binary_search(ok, ng):
"""二分探索
Parameters
----------
ok : int
ng : int
Returns
-------
ok : int
"""
while abs(ng - ok) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return (ok+ng)//2
print(binary_search(1,10**9))
N,a,b=map(int,input().split())
A=list(map(int,input().split()))
def is_ok(mid):
lcnt=0
hcnt=0
for i in A:
if mid>i:
if (mid-i)%a==0:
lcnt+=(mid-i)//a
else:
lcnt+=(mid-i)//a+1
else:
hcnt+=(i-mid)//b
if lcnt<=hcnt:
return True
else:
return False
def binary_search(ok, ng):
"""二分探索
Parameters
----------
ok : int
ng : int
Returns
-------
ok : int
"""
while abs(ng - ok) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return (ok+ng)//2
print(binary_search(0,10**10))
|
ConDefects/ConDefects/Code/arc144_b/Python/37994644
|
condefects-python_data_316
|
from sys import stdin
n, d = map(int, stdin.readline().split())
e = n*d
if e > (n*(n-1))//2:
print('No')
exit()
edge = []
u = 1
while e:
for i in range(1, n-u+1):
if e == 0:
break
if u+i > n:
edge.append([u, u+i-n])
else:
edge.append([u, u+i])
e -= 1
u += 1
print('Yes')
for u, v in edge:
print(u, v)
from sys import stdin
n, d = map(int, stdin.readline().split())
e = n*d
if e > (n*(n-1))//2:
print('No')
exit()
edge = []
u = 1
while e:
for i in range(1, d+1):
if e == 0:
break
if u+i > n:
edge.append([u, u+i-n])
else:
edge.append([u, u+i])
e -= 1
u += 1
print('Yes')
for u, v in edge:
print(u, v)
|
ConDefects/ConDefects/Code/arc161_d/Python/43311492
|
condefects-python_data_317
|
from collections import deque, defaultdict
from math import log, asin, acos, cos, sin, tan, atan2, floor, gcd, sqrt, pi
# from math import *
from heapq import *
from bisect import bisect, bisect_left
import sys
from itertools import combinations, permutations, count
from functools import lru_cache, cmp_to_key
from operator import add, mul, sub, xor
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
# atan2(y, x) :=
# artan(y/x) ([-pi, pi] -> if theta < 0 -> theta += 2pi -> [0, 2pi])
def ceil(m, n):
if n == 0:
return INF
return (m + n - 1) // n
INF = 10**20
BASE = 31
CONST = 10 ** 9
MAX = 10 ** 6
MOD = 998244353
N, D = map(int, input().split())
if D * 2 > N * (N - 1):
print('No')
else:
print('Yes')
for i in range(N):
for j in range(D):
k = (i + j + 2) % N
if k == 0:
k = N
print(i+1, k)
from collections import deque, defaultdict
from math import log, asin, acos, cos, sin, tan, atan2, floor, gcd, sqrt, pi
# from math import *
from heapq import *
from bisect import bisect, bisect_left
import sys
from itertools import combinations, permutations, count
from functools import lru_cache, cmp_to_key
from operator import add, mul, sub, xor
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)
# atan2(y, x) :=
# artan(y/x) ([-pi, pi] -> if theta < 0 -> theta += 2pi -> [0, 2pi])
def ceil(m, n):
if n == 0:
return INF
return (m + n - 1) // n
INF = 10**20
BASE = 31
CONST = 10 ** 9
MAX = 10 ** 6
MOD = 998244353
N, D = map(int, input().split())
if D * 2 > (N - 1):
print('No')
else:
print('Yes')
for i in range(N):
for j in range(D):
k = (i + j + 2) % N
if k == 0:
k = N
print(i+1, k)
|
ConDefects/ConDefects/Code/arc161_d/Python/42021171
|
condefects-python_data_318
|
N, D = map(int, input().split())
if 2 * D > N - 1:
print("No")
exit()
print("Yes")
ans = set()
for i in range(N):
for j in range(1, N):
if (i, (i+j) % N) in ans or ((i + j) % N, i) in ans:
continue
ans.add((i, (i + j) % N))
if len(ans) == N * D:
break
if len(ans) == N * D:
break
for x in ans:
print(*map(lambda p: p + 1, x))
N, D = map(int, input().split())
if 2 * D > N - 1:
print("No")
exit()
print("Yes")
ans = set()
for i in range(N):
for j in range(1, D+1):
if (i, (i+j) % N) in ans or ((i + j) % N, i) in ans:
continue
ans.add((i, (i + j) % N))
if len(ans) == N * D:
break
if len(ans) == N * D:
break
for x in ans:
print(*map(lambda p: p + 1, x))
|
ConDefects/ConDefects/Code/arc161_d/Python/43182082
|
condefects-python_data_319
|
# import sys
# sys.setrecursionlimit(10**7)
# input = sys.stdin.readline
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
def mp():return map(int,input().split())
def lmp():return list(map(int,input().split()))
def lm1(LIST): return list(map(lambda x:x-1, LIST))
def mps(A):return [tuple(map(int, input().split())) for _ in range(A)]
def stoi(LIST):return list(map(int,LIST))
def itos(LIST):return list(map(str,LIST))
def atoi(LIST): return [ord(i)-ord("a") for i in LIST]
def Atoi(LIST): return [ord(i)-ord("A") for i in LIST]
def LT(LIST,N): return LIST[bisect.bisect_left(LIST,N)-1]
def LE(LIST,N): return LIST[bisect.bisect_right(LIST,N)-1]
def GT(LIST,N): return LIST[bisect.bisect_right(LIST,N)]
def GE(LIST,N): return LIST[bisect.bisect_left(LIST,N)]
def bitA(X,A):return X & 1<<A == 1<<A
import math
import bisect
import heapq
import time
from copy import copy as cc
from copy import deepcopy as dc
from itertools import accumulate, product
from collections import Counter, defaultdict, deque
def ceil(U,V):return (U+V-1)//V
def modf1(N,MOD):return (N-1)%MOD+1
inf = (1<<63)-1
mod = 998244353
n,d = mp()
if n*(n-1)//2 < n*d:
print("No")
exit()
print("Yes")
for i in range(1,d+1):
for j in range(1,n+1):
print(j,modf1(j+d,n))
# import sys
# sys.setrecursionlimit(10**7)
# input = sys.stdin.readline
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
def mp():return map(int,input().split())
def lmp():return list(map(int,input().split()))
def lm1(LIST): return list(map(lambda x:x-1, LIST))
def mps(A):return [tuple(map(int, input().split())) for _ in range(A)]
def stoi(LIST):return list(map(int,LIST))
def itos(LIST):return list(map(str,LIST))
def atoi(LIST): return [ord(i)-ord("a") for i in LIST]
def Atoi(LIST): return [ord(i)-ord("A") for i in LIST]
def LT(LIST,N): return LIST[bisect.bisect_left(LIST,N)-1]
def LE(LIST,N): return LIST[bisect.bisect_right(LIST,N)-1]
def GT(LIST,N): return LIST[bisect.bisect_right(LIST,N)]
def GE(LIST,N): return LIST[bisect.bisect_left(LIST,N)]
def bitA(X,A):return X & 1<<A == 1<<A
import math
import bisect
import heapq
import time
from copy import copy as cc
from copy import deepcopy as dc
from itertools import accumulate, product
from collections import Counter, defaultdict, deque
def ceil(U,V):return (U+V-1)//V
def modf1(N,MOD):return (N-1)%MOD+1
inf = (1<<63)-1
mod = 998244353
n,d = mp()
if n*(n-1)//2 < n*d:
print("No")
exit()
print("Yes")
for i in range(1,d+1):
for j in range(1,n+1):
print(j,modf1(j+i,n))
|
ConDefects/ConDefects/Code/arc161_d/Python/44101361
|
condefects-python_data_320
|
n,d=map(int,input().split())
if (n*(n-1))//2<n*d:
print("No")
exit()
print("Yes")
for i in range(1,d+1):
for j in range(n):
print(j+1,(j+d)%n+1)
n,d=map(int,input().split())
if (n*(n-1))//2<n*d:
print("No")
exit()
print("Yes")
for i in range(1,d+1):
for j in range(n):
print(j+1,(j+i)%n+1)
|
ConDefects/ConDefects/Code/arc161_d/Python/41819669
|
condefects-python_data_321
|
ii = lambda: int(input())
li = lambda: list(map(int, input().split()))
ldi = lambda: list(map(lambda x: int(x) - 1, input().split()))
n, d = li()
if n - 1 < 2 * d:
print('No')
else:
print('Yes')
for i in range(n):
for j in range(1, d + 1):
print(i + 1, (i + d) % n + 1)
ii = lambda: int(input())
li = lambda: list(map(int, input().split()))
ldi = lambda: list(map(lambda x: int(x) - 1, input().split()))
n, d = li()
if n - 1 < 2 * d:
print('No')
else:
print('Yes')
for i in range(n):
for j in range(1, d + 1):
print(i + 1, (i + j) % n + 1)
|
ConDefects/ConDefects/Code/arc161_d/Python/42297972
|
condefects-python_data_322
|
from heapq import heappush, heappop
from math import inf
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class Dijkstra:
def __init__(self):
return
@staticmethod
def get_shortest_path(dct, src: int, initial=0):
"""template of shortest path by dijkstra"""
# which can to changed to be the longest path problem by opposite number
n = len(dct)
dis = [inf] * n
stack = [(initial, src)]
dis[src] = initial
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = d + w
if dj < dis[j]:
dis[j] = dj
heappush(stack, (dj, j))
return dis
@staticmethod
def get_longest_path(dct, src: int, initial=0):
"""template of shortest path by dijkstra"""
# which can to changed to be the longest path problem by opposite number
n = len(dct)
dis = [inf] * n
stack = [(-initial, src)]
dis[src] = -initial
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = d - w
if dj < dis[j]:
dis[j] = dj
heappush(stack, (dj, j))
return [-x for x in dis]
@staticmethod
def get_cnt_of_shortest_path(dct, src: int):
"""number of shortest path"""
n = len(dct)
dis = [inf] * n
stack = [(0, src)]
dis[src] = 0
cnt = [0] * n
cnt[src] = 1
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = w + d
if dj < dis[j]:
dis[j] = dj
cnt[j] = cnt[i]
# smaller than the shortest path
heappush(stack, (dj, j))
elif dj == dis[j]:
# equal to the shortest path
cnt[j] += cnt[i]
return cnt, dis
class Floyd:
def __init__(self):
return
@staticmethod
def get_cnt_of_shortest_path(edges, n): # undirected
dis = [[inf] * n for _ in range(n)]
cnt = [[0] * n for _ in range(n)]
for i in range(n):
dis[i][i] = 0
cnt[i][i] = 1
for x, y, w in edges:
dis[x][y] = dis[y][x] = w + 1
cnt[x][y] = cnt[y][x] = 1
for k in range(n): # mid point
for i in range(n): # start point
if dis[i][k] == inf or i == k:
continue
for j in range(i + 1, n): # end point
if j == k:
continue
if dis[i][k] + dis[k][j] < dis[j][i]:
dis[i][j] = dis[j][i] = dis[i][k] + dis[k][j]
cnt[i][j] = cnt[j][i] = cnt[i][k] * cnt[k][j]
elif dis[i][k] + dis[k][j] == dis[j][i]:
cnt[i][j] += cnt[i][k] * cnt[k][j]
cnt[j][i] += cnt[i][k] * cnt[k][j]
return cnt, dis
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n, m = ac.read_list_ints()
edges = []
dct = [[] for _ in range(n)]
for _ in range(m):
x, y, w = ac.read_list_ints_minus_one()
edges.append((x, y, w + 1))
dct[x].append((y, w + 1))
dct[y].append((x, w + 1))
dis = []
cnt = []
for i in range(n):
cur_cnt, cur_dis = Dijkstra().get_cnt_of_shortest_path(dct, i)
dis.append(cur_dis)
cnt.append(cur_cnt)
ans = sum(cnt[x][y] > 1 or dis[x][y] < w for x, y, w in edges)
ac.st(ans)
return
@staticmethod
def main2(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n, m = ac.read_list_ints()
edges = []
for _ in range(m):
x, y, w = ac.read_list_ints_minus_one()
edges.append((x, y, w + 1))
cnt, dis = Floyd().get_cnt_of_shortest_path(edges, n)
ans = sum(cnt[x][y] > 1 or dis[x][y] < w for x, y, w in edges)
ac.st(ans)
return
Solution().main2()
from heapq import heappush, heappop
from math import inf
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class Dijkstra:
def __init__(self):
return
@staticmethod
def get_shortest_path(dct, src: int, initial=0):
"""template of shortest path by dijkstra"""
# which can to changed to be the longest path problem by opposite number
n = len(dct)
dis = [inf] * n
stack = [(initial, src)]
dis[src] = initial
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = d + w
if dj < dis[j]:
dis[j] = dj
heappush(stack, (dj, j))
return dis
@staticmethod
def get_longest_path(dct, src: int, initial=0):
"""template of shortest path by dijkstra"""
# which can to changed to be the longest path problem by opposite number
n = len(dct)
dis = [inf] * n
stack = [(-initial, src)]
dis[src] = -initial
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = d - w
if dj < dis[j]:
dis[j] = dj
heappush(stack, (dj, j))
return [-x for x in dis]
@staticmethod
def get_cnt_of_shortest_path(dct, src: int):
"""number of shortest path"""
n = len(dct)
dis = [inf] * n
stack = [(0, src)]
dis[src] = 0
cnt = [0] * n
cnt[src] = 1
while stack:
d, i = heappop(stack)
if dis[i] < d:
continue
for j, w in dct[i]:
dj = w + d
if dj < dis[j]:
dis[j] = dj
cnt[j] = cnt[i]
# smaller than the shortest path
heappush(stack, (dj, j))
elif dj == dis[j]:
# equal to the shortest path
cnt[j] += cnt[i]
return cnt, dis
class Floyd:
def __init__(self):
return
@staticmethod
def get_cnt_of_shortest_path(edges, n): # undirected
dis = [[inf] * n for _ in range(n)]
cnt = [[0] * n for _ in range(n)]
for i in range(n):
dis[i][i] = 0
cnt[i][i] = 1
for x, y, w in edges:
dis[x][y] = dis[y][x] = w
cnt[x][y] = cnt[y][x] = 1
for k in range(n): # mid point
for i in range(n): # start point
if dis[i][k] == inf or i == k:
continue
for j in range(i + 1, n): # end point
if j == k:
continue
if dis[i][k] + dis[k][j] < dis[j][i]:
dis[i][j] = dis[j][i] = dis[i][k] + dis[k][j]
cnt[i][j] = cnt[j][i] = cnt[i][k] * cnt[k][j]
elif dis[i][k] + dis[k][j] == dis[j][i]:
cnt[i][j] += cnt[i][k] * cnt[k][j]
cnt[j][i] += cnt[i][k] * cnt[k][j]
return cnt, dis
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n, m = ac.read_list_ints()
edges = []
dct = [[] for _ in range(n)]
for _ in range(m):
x, y, w = ac.read_list_ints_minus_one()
edges.append((x, y, w + 1))
dct[x].append((y, w + 1))
dct[y].append((x, w + 1))
dis = []
cnt = []
for i in range(n):
cur_cnt, cur_dis = Dijkstra().get_cnt_of_shortest_path(dct, i)
dis.append(cur_dis)
cnt.append(cur_cnt)
ans = sum(cnt[x][y] > 1 or dis[x][y] < w for x, y, w in edges)
ac.st(ans)
return
@staticmethod
def main2(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n, m = ac.read_list_ints()
edges = []
for _ in range(m):
x, y, w = ac.read_list_ints_minus_one()
edges.append((x, y, w + 1))
cnt, dis = Floyd().get_cnt_of_shortest_path(edges, n)
ans = sum(cnt[x][y] > 1 or dis[x][y] < w for x, y, w in edges)
ac.st(ans)
return
Solution().main2()
|
ConDefects/ConDefects/Code/abc243_e/Python/52524531
|
condefects-python_data_323
|
import sys
input = sys.stdin.readline
INF = 10**18
N, M = map(int, input().split())
dist = [[(INF, 0)] * N for _ in range(N)]
dist2 = [[(INF, 0)] * N for _ in range(N)]
for i in range(N):
dist[i][i] = (0, 0)
edges = []
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
dist[a][b] = dist[b][a] = (c, -1)
edges.append((a, b, c))
for k in range(N):
for i in range(N):
for j in range(N):
d1, c1 = dist[i][k]
d2, c2 = dist[k][j]
dist[i][j] = min(dist[i][j], (d1 + d2, c1 + c2))
ans = 0
for a, b, c in edges:
if dist[a][b][0] < c or dist[a][b][0] == c and dist[a][b][1] > 1:
ans += 1
print(ans)
import sys
input = sys.stdin.readline
INF = 10**18
N, M = map(int, input().split())
dist = [[(INF, 0)] * N for _ in range(N)]
dist2 = [[(INF, 0)] * N for _ in range(N)]
for i in range(N):
dist[i][i] = (0, 0)
edges = []
for _ in range(M):
a, b, c = map(int, input().split())
a -= 1
b -= 1
dist[a][b] = dist[b][a] = (c, -1)
edges.append((a, b, c))
for k in range(N):
for i in range(N):
for j in range(N):
d1, c1 = dist[i][k]
d2, c2 = dist[k][j]
dist[i][j] = min(dist[i][j], (d1 + d2, c1 + c2))
ans = 0
for a, b, c in edges:
if dist[a][b] < (c, -1):
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc243_e/Python/49785483
|
condefects-python_data_324
|
A,B = (map(int,input().split()))
if A==1 and B==2:
print(3)
elif A==1 and B==3:
print(2)
elif A==2 and B==1:
print(3)
elif A==1 and B==2:
print(3)
elif A==3 and B==2:
print(1)
elif A==2 and B==3:
print(1)
else:
print(-1)
A,B = (map(int,input().split()))
if A==1 and B==2:
print(3)
elif A==3 and B==1:
print(2)
elif A==1 and B==3:
print(2)
elif A==2 and B==1:
print(3)
elif A==1 and B==2:
print(3)
elif A==3 and B==2:
print(1)
elif A==2 and B==3:
print(1)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc355_a/Python/55137190
|
condefects-python_data_325
|
A,B = map(int,input().split())
if A + B == 3:
print("3")
elif A + B == 4:
print("2")
elif A + B == 5:
print("1")
else:
print("-1")
A,B = map(int,input().split())
if A + B == 3:
print("3")
elif A + B == 4 and A != B:
print("2")
elif A + B == 5:
print("1")
else:
print("-1")
|
ConDefects/ConDefects/Code/abc355_a/Python/54910949
|
condefects-python_data_326
|
s = str(input())
t = str(input())
pre = [False for i in range(len(t)+1)]
back = [False for i in range(len(t)+1)]
pre[0] = True
for i in range(1,len(t)+1):
if s[i-1] == t[i-1] or (s[i-1] == "?" or t[i-1] == "?"):
pre[i] = True
else:
break
back[len(t)] = True
for i in range(1,len(t)+1):
if s[-i] == t[-i] or (s[-i] == "?" or t[-i] == "?"):
back[i-1] = True
else:
break
for i in range(len(t)+1):
if pre[i]&back[i] == True:
print("Yes")
else:
print("No")
s = str(input())
t = str(input())
pre = [False for i in range(len(t)+1)]
back = [False for i in range(len(t)+1)]
pre[0] = True
for i in range(1,len(t)+1):
if s[i-1] == t[i-1] or (s[i-1] == "?" or t[i-1] == "?"):
pre[i] = True
else:
break
back[len(t)] = True
for i in range(1,len(t)+1):
if s[-i] == t[-i] or (s[-i] == "?" or t[-i] == "?"):
back[-i-1] = True
else:
break
for i in range(len(t)+1):
if pre[i]&back[i] == True:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc287_d/Python/45092019
|
condefects-python_data_327
|
S = input()
T = input()
# 前/後からnケタ一致する場合は front_match[n], back_match[n]
front_match = [False] * (len(T) + 1)
back_match = [False] * (len(T) + 1)
front_match[0] = True
back_match[0] = True
for idx, st in enumerate(zip(S[:len(T)], T)):
s, t = st
now = idx + 1
if s == '?' or t == '?' or s == t:
if front_match[now-1]:
front_match[now] = True
for idx, st in enumerate(zip(S[len(S) - len(T):], T)):
s, t = st
now = idx + 1
if s == '?' or t == '?' or s == t:
if back_match[now-1]:
back_match[now] = True
for x in range(len(T)+1):
if front_match[x] and back_match[len(T) - x]:
print("Yes")
else:
print("No")
S = input()
T = input()
# 前/後からnケタ一致する場合は front_match[n], back_match[n]
front_match = [False] * (len(T) + 1)
back_match = [False] * (len(T) + 1)
front_match[0] = True
back_match[0] = True
for idx, st in enumerate(zip(S[:len(T)], T)):
s, t = st
now = idx + 1
if s == '?' or t == '?' or s == t:
if front_match[now-1]:
front_match[now] = True
for idx, st in enumerate(zip(reversed(S[len(S) - len(T):]), reversed(T))):
s, t = st
now = idx + 1
if s == '?' or t == '?' or s == t:
if back_match[now-1]:
back_match[now] = True
for x in range(len(T)+1):
if front_match[x] and back_match[len(T) - x]:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc287_d/Python/46181501
|
condefects-python_data_328
|
# import sys
# sys.setrecursionlimit(1000000)
import re
import copy
import bisect
import math
import itertools
import more_itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().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])
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
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])
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 rmwh(a):
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 comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
# 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 cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = 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 = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
# 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 = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __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]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, 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(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, 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.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, 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 a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, 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 = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __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]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, 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(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, 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 a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, 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
def dijkstra(g, st):
vi = set()
res = [inf for i in range(len(g))]
res[st] = 0
s = SortedSet([])
s.add((0, st))
while len(s) != 0:
dis, now = s.pop(0)
vi.add(now)
# print(s, res, now, dis)
for to in g[now].keys():
if to in vi:
continue
w = g[now][to]
if dis + w <= res[to]:
if res[to] == inf:
s.add((dis + w, to))
res[to] = dis + w
else:
r = s.discard((res[to], to))
if r == False:
print('discard error')
print(s)
print(res[to], to)
s.add((dis + w, to))
res[to] = dis + w
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 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
v = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
ans = []
s = input()
t = input()
a = [True for i in range(len(t))]
if s[0] == t[0] or s[0] == '?' or t[0] == '?':
a[0] = True
else:
a[0] = False
for i in range(1, len(t)):
if a[i-1] and (s[i] == t[i] or s[i] == '?' or t[i] == '?'):
a[i] = True
else:
a[i] = False
b = [True for i in range(len(t))]
if s[-1] == t[-1] or s[-1] == '?' or t[-1] == '?':
b[-1] = True
else:
b[-1] = False
for i in range(1, len(t)):
if b[-i] and (s[-(i+1)] == t[-(i+1)] or s[-(i+1)] == '?' or t[-(i+1)] == '?'):
b[-(i+1)] = True
else:
b[-(i+1)] = False
for i in range(len(t)+1):
if i == 0:
if b[0]:
ans.append('Yes')
else:
ans.append('No')
elif i == len(t):
if a[-1]:
ans.append('Yes')
else:
ans.append('No')
else:
if a[i] and b[i-1]:
ans.append('Yes')
else:
ans.append('No')
for e in ans:
print(e)
# import sys
# sys.setrecursionlimit(1000000)
import re
import copy
import bisect
import math
import itertools
import more_itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
import functools
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
def ii():
return int(input())
def gl():
return list(map(int, input().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])
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())
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h,w):
a = []
for i in range(h):
a.append(input())
return a
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def next_perm(a):
l = copy.copy(a)
l = list(l)
i = len(l) - 2
while 0 <= i and l[i] >= l[i+1]:
i -= 1
if i == 1:
return False
j = len(l) - 1
while not (l[i] < l[j]):
j -= 1
l[i], l[j] = l[j], l[i]
return l[:i+1] + rev(l[i+1:])
def yaku(n):
ans = []
for i in range(1, int(math.sqrt(n)) + 1):
if n % i == 0:
ans.append(i)
ans.append(n // i)
return ans
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def rev(a):
a = a[:]
return list(reversed(a))
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd3(*ints):
return functools.reduce(math.gcd, ints)
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
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])
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 rmwh(a):
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 comb_cnt(n, k):
return math.factorial(n) // (math.factorial(n - k) * math.factorial(k))
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
# 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 cnt_com(l1, r1, l2, r2):
if l1 > l2:
l1, l2, r1, r2 = l2, l1, r2, r1
if l1 <= l2 and l2 <= r2 and r2 <= r1:
return r2 - l2
elif l1 <= l2 and l2 <= r1 and r1 <= r2:
return r1 - l2
elif r1 <= l2:
return 0
def cut_yoko(a, y):
a_copy = 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 = copy.deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def zalg(s):
n = len(s)
a = [0] * n
i = 1
j = 0
a[0] = len(s)
l = len(s)
while i < l:
while i + j < l and s[j] == s[i+j]:
j += 1
if not j:
i += 1
continue
a[i] = j
k = 1
while l-i > k < j - a[k]:
a[i+k] = a[k]
k += 1
i += k
j -= k
return a
# 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 = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __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]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, 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(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, 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.REBUILD_RATIO:
self._build()
return True
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, 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 a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, 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 = 50
REBUILD_RATIO = 170
def _build(self, a: Optional[List[T]] = None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(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)
self.size = len(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 __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]:
"Find the bucket and position which x should be inserted. self must not be empty."
for a in self.a:
if x <= a[-1]: break
return (a, 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(竏哢)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
def _pop(self, a: List[T], i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: self._build()
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(竏哢)"
if self.size == 0: return False
a, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, 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 a in reversed(self.a):
i += len(a)
if i >= 0: return self._pop(a, i)
else:
for a in self.a:
if i < len(a): return self._pop(a, 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
def dijkstra(g, st):
vi = set()
res = [inf for i in range(len(g))]
res[st] = 0
s = SortedSet([])
s.add((0, st))
while len(s) != 0:
dis, now = s.pop(0)
vi.add(now)
# print(s, res, now, dis)
for to in g[now].keys():
if to in vi:
continue
w = g[now][to]
if dis + w <= res[to]:
if res[to] == inf:
s.add((dis + w, to))
res[to] = dis + w
else:
r = s.discard((res[to], to))
if r == False:
print('discard error')
print(s)
print(res[to], to)
s.add((dis + w, to))
res[to] = dis + w
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 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
v = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
ay="Yes"
an="No"
#main
ans = []
s = input()
t = input()
a = [True for i in range(len(t))]
if s[0] == t[0] or s[0] == '?' or t[0] == '?':
a[0] = True
else:
a[0] = False
for i in range(1, len(t)):
if a[i-1] and (s[i] == t[i] or s[i] == '?' or t[i] == '?'):
a[i] = True
else:
a[i] = False
b = [True for i in range(len(t))]
if s[-1] == t[-1] or s[-1] == '?' or t[-1] == '?':
b[-1] = True
else:
b[-1] = False
for i in range(1, len(t)):
if b[-i] and (s[-(i+1)] == t[-(i+1)] or s[-(i+1)] == '?' or t[-(i+1)] == '?'):
b[-(i+1)] = True
else:
b[-(i+1)] = False
for i in range(len(t)+1):
if i == 0:
if b[0]:
ans.append('Yes')
else:
ans.append('No')
elif i == len(t):
if a[-1]:
ans.append('Yes')
else:
ans.append('No')
else:
if a[i] and b[i]:
ans.append('Yes')
else:
ans.append('No')
for e in ans:
print(e)
|
ConDefects/ConDefects/Code/abc287_d/Python/45345625
|
condefects-python_data_329
|
s=input()
t=input()
m=len(s)
n=len(t)
ng=set()
for i in range(n):
if s[i-n+m]!=t[i] and s[i-n+m]!="?"!=t[i]:
ng.add(i)
print("Yes" if len(ng)==0 else "No")
for j in range(n):
if t[j]!="?" and s[j]!=t[j]:
ng.add(j)
else:
ng.discard(j)
print("Yes" if len(ng)==0 else "No")
s=input()
t=input()
m=len(s)
n=len(t)
ng=set()
for i in range(n):
if s[i-n+m]!=t[i] and s[i-n+m]!="?"!=t[i]:
ng.add(i)
print("Yes" if len(ng)==0 else "No")
for j in range(n):
if s[j]!=t[j] and s[j]!="?"!=t[j]:
ng.add(j)
else:
ng.discard(j)
print("Yes" if len(ng)==0 else "No")
|
ConDefects/ConDefects/Code/abc287_d/Python/45271287
|
condefects-python_data_330
|
s = input()
t = input()
head, tail = 0, 0
for i in range(len(t)):
if s[i] != "?" and t[i] != "?" and s[i] != t[i]:
break
head += 1
for i in range(len(t)):
if s[i + len(s) - len(t)] != "?" and t[i] != "?" and s[i + len(s) - len(t)] != t[i]:
break
tail += 1
for i in range(len(t) + 1):
hd = i
tl = len(t) - i
if hd <= head and tl <= tail:
print("Yes")
else:
print("No")
s = input()
t = input()
head, tail = 0, 0
for i in range(len(t)):
if s[i] != "?" and t[i] != "?" and s[i] != t[i]:
break
head += 1
for i in range(len(t))[::-1]:
if s[i + len(s) - len(t)] != "?" and t[i] != "?" and s[i + len(s) - len(t)] != t[i]:
break
tail += 1
for i in range(len(t) + 1):
hd = i
tl = len(t) - i
if hd <= head and tl <= tail:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc287_d/Python/45342192
|
condefects-python_data_331
|
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC287 D 796 - Match or Not
# 英小文字と ? からなる文字列 S,T が与えられます。
# ここで、|S| > |T| が成り立ちます(文字列 X に対し、|X| で X の長さを表します)。
# また、|X| = |Y| を満たす文字列 X,Y は、次の条件を満たすとき及びそのときに限りマッチするといいます。
# ・X,Y に含まれる ? をそれぞれ独立に好きな英小文字に置き換えることで X と Y を一致させることができる
# x=0,1,…,|T| に対して次の問題を解いてください。
# S の先頭の x 文字と末尾の |T|-x 文字を順番を保ったまま連結することで得られる長さ |T| の文字列を S' とする。
# S' と T がマッチするならば Yes と、そうでなければ No と出力せよ。
# ・1 ≤ |T| < |S| ≤ 3×10^5
S = list(input())
T = list(input())
N = len(S)
M = len(T)
ind = -1
for i in range(M):
if S[-M+i] != T[i] and S[-M+i] != '?' and T[i] != '?':
ind = i
print('Yes' if ind == -1 else 'No')
chk = True
for i in range(M):
if S[i] != T[i] and S[i] != '?' and T[i] != '?':
chk = False
print('Yes' if chk and N - M + i >= ind else 'No')
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC287 D 796 - Match or Not
# 英小文字と ? からなる文字列 S,T が与えられます。
# ここで、|S| > |T| が成り立ちます(文字列 X に対し、|X| で X の長さを表します)。
# また、|X| = |Y| を満たす文字列 X,Y は、次の条件を満たすとき及びそのときに限りマッチするといいます。
# ・X,Y に含まれる ? をそれぞれ独立に好きな英小文字に置き換えることで X と Y を一致させることができる
# x=0,1,…,|T| に対して次の問題を解いてください。
# S の先頭の x 文字と末尾の |T|-x 文字を順番を保ったまま連結することで得られる長さ |T| の文字列を S' とする。
# S' と T がマッチするならば Yes と、そうでなければ No と出力せよ。
# ・1 ≤ |T| < |S| ≤ 3×10^5
S = list(input())
T = list(input())
N = len(S)
M = len(T)
ind = -1
for i in range(M):
if S[-M+i] != T[i] and S[-M+i] != '?' and T[i] != '?':
ind = i
print('Yes' if ind == -1 else 'No')
chk = True
for i in range(M):
if S[i] != T[i] and S[i] != '?' and T[i] != '?':
chk = False
print('Yes' if chk and i >= ind else 'No')
|
ConDefects/ConDefects/Code/abc287_d/Python/45533288
|
condefects-python_data_332
|
N, K = map(int, input().split())
A = set(map(int, input().split()))
M = 400001
fact = [1] * M
mod = 998244353
for i in range(1, M):
fact[i] = fact[i-1]*i
fact[i] %= mod
inv_fact = [1] * M
inv_fact[-1] = pow(fact[-1], mod-2, mod)
for i in range(M-1, 0, -1):
inv_fact[i-1] = inv_fact[i]*i
inv_fact[i-1] %= mod
def C(n, k):
if k < 0:
return 0
value = fact[n]*inv_fact[k]*inv_fact[n-k]
value %= mod
return value
cnt = 0
total = 0
ans = 1
for i in range(1, M):
if i in A:
cnt += 1
continue
total += 1
ans += C(K+cnt-1, i-1)
ans %= mod
if total == K:
break
print(ans)
N, K = map(int, input().split())
A = set(map(int, input().split()))
M = 400001
fact = [1] * M
mod = 998244353
for i in range(1, M):
fact[i] = fact[i-1]*i
fact[i] %= mod
inv_fact = [1] * M
inv_fact[-1] = pow(fact[-1], mod-2, mod)
for i in range(M-1, 0, -1):
inv_fact[i-1] = inv_fact[i]*i
inv_fact[i-1] %= mod
def C(n, k):
if k < 0:
return 0
value = fact[n]*inv_fact[k]*inv_fact[n-k]
value %= mod
return value
cnt = 0
total = 0
ans = 1
for i in range(M):
if i in A:
cnt += 1
continue
total += 1
ans += C(K+cnt-1, i-1)
ans %= mod
if total == K:
break
print(ans)
|
ConDefects/ConDefects/Code/arc156_b/Python/40932797
|
condefects-python_data_333
|
from collections import defaultdict, deque, Counter
from itertools import combinations, permutations, product, accumulate
from heapq import heapify, heappop, heappush
import math
import bisect
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def seil_div(x, y): return -(-x//y)
#################################################
def cmb(n, r):
if r < 0 or r > n:
return 0
r = min(r, n-r)
return fact[n]*factinv[r]%p*factinv[n-r]%p
p = mod2
N = 10**6 #Nは必要分だけ用意する
fact = [1, 1] #fact[n]: n! mod p
factinv = [1, 1] #factinv[n]: n!^(-1) mod p
inv = [0, 1] #inv[n]: n^(-1) mod p
for i in range(2, N+1):
fact.append((fact[-1]*i)%p)
inv.append((-inv[p%i]*(p//i))%p)
factinv.append((factinv[-1]*inv[-1])%p)
N, K = map(int, input().split())
A = set(map(int, input().split()))
m = 0
ans = 0
for x in range(2*10**5+1):
ans += cmb(K-m-1+x, x)
ans %= mod2
m += x not in A
if m > K: break
print(ans)
from collections import defaultdict, deque, Counter
from itertools import combinations, permutations, product, accumulate
from heapq import heapify, heappop, heappush
import math
import bisect
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def seil_div(x, y): return -(-x//y)
#################################################
def cmb(n, r):
if r < 0 or r > n:
return 0
r = min(r, n-r)
return fact[n]*factinv[r]%p*factinv[n-r]%p
p = mod2
N = 10**6 #Nは必要分だけ用意する
fact = [1, 1] #fact[n]: n! mod p
factinv = [1, 1] #factinv[n]: n!^(-1) mod p
inv = [0, 1] #inv[n]: n^(-1) mod p
for i in range(2, N+1):
fact.append((fact[-1]*i)%p)
inv.append((-inv[p%i]*(p//i))%p)
factinv.append((factinv[-1]*inv[-1])%p)
N, K = map(int, input().split())
A = set(map(int, input().split()))
m = 0
ans = 0
for x in range(4*10**5+1):
ans += cmb(K-m-1+x, x)
ans %= mod2
m += x not in A
if m > K: break
print(ans)
|
ConDefects/ConDefects/Code/arc156_b/Python/39326078
|
condefects-python_data_334
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
from collections import defaultdict as df
d=df(int)
for i in range(n):
d[a[i]]+=1
mex=[0]*(k+1)
now=0
for i in range(k+1):
while d[now]>0:
now+=1
mex[i]=now
now+=1
ans=0
fib=[1]*(n+k)
mod=998244353
for i in range(n+k-1):
fib[i+1]=fib[i]*(i+2)%mod
def comb(a,b):
if b<=0:
return 1
elif a<b:
return 0
return fib[a-1]*pow(fib[a-b-1],-1,mod)%mod*pow(fib[b-1],-1,mod)%mod
ans=0
for i in range(k+1):
ans+=comb(mex[i]+k-i-1,k-i)
ans%=mod
print(ans)
n,k=map(int,input().split())
a=list(map(int,input().split()))
from collections import defaultdict as df
d=df(int)
for i in range(n):
d[a[i]]+=1
mex=[0]*(k+1)
now=0
for i in range(k+1):
while d[now]>0:
now+=1
mex[i]=now
now+=1
ans=0
fib=[1]*(n+k)
mod=998244353
for i in range(n+k-1):
fib[i+1]=fib[i]*(i+2)%mod
def comb(a,b):
if b<=0:
return 1
elif a<b:
return 0
elif a==b:
return 1
return fib[a-1]*pow(fib[a-b-1],-1,mod)%mod*pow(fib[b-1],-1,mod)%mod
ans=0
for i in range(k+1):
ans+=comb(mex[i]+k-i-1,k-i)
ans%=mod
print(ans)
|
ConDefects/ConDefects/Code/arc156_b/Python/45544495
|
condefects-python_data_335
|
MOD = 998244353
IMAG = 911660635
IIMAG = 86583718
rate2 = (0, 911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601, 842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0)
irate2 = (0, 86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0)
rate3 = (0, 372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099, 183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204, 0)
irate3 = (0, 509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500, 771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681, 0)
def butterfly(a):
n = len(a)
h = (n - 1).bit_length()
le = 0
while le < h:
if h - le == 1:
p = 1 << (h - le - 1)
rot = 1
for s in range(1 << le):
offset = s << (h - le)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) % MOD
rot *= rate2[(~s & -~s).bit_length()]
rot %= MOD
le += 1
else:
p = 1 << (h - le - 2)
rot = 1
for s in range(1 << le):
rot2 = rot * rot % MOD
rot3 = rot2 * rot % MOD
offset = s << (h - le)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p] * rot
a2 = a[i + offset + p * 2] * rot2
a3 = a[i + offset + p * 3] * rot3
a1na3imag = (a1 - a3) % MOD * IMAG
a[i + offset] = (a0 + a2 + a1 + a3) % MOD
a[i + offset + p] = (a0 + a2 - a1 - a3) % MOD
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % MOD
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % MOD
rot *= rate3[(~s & -~s).bit_length()]
rot %= MOD
le += 2
def butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
le = h
while le:
if le == 1:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 1)):
offset = s << (h - le + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) * irot % MOD
irot *= irate2[(~s & -~s).bit_length()]
irot %= MOD
le -= 1
else:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 2)):
irot2 = irot * irot % MOD
irot3 = irot2 * irot % MOD
offset = s << (h - le + 2)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p]
a2 = a[i + offset + p * 2]
a3 = a[i + offset + p * 3]
a2na3iimag = (a2 - a3) * IIMAG % MOD
a[i + offset] = (a0 + a1 + a2 + a3) % MOD
a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % MOD
a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % MOD
a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % MOD
irot *= irate3[(~s & -~s).bit_length()]
irot %= MOD
le -= 2
def multiply(s, t):
n = len(s)
m = len(t)
if min(n, m) <= 60:
a = [0] * (n + m - 1)
for i in range(n):
if i % 8 == 0:
for j in range(m):
a[i + j] += s[i] * t[j]
a[i + j] %= MOD
else:
for j in range(m):
a[i + j] += s[i] * t[j]
return [x % MOD for x in a]
a = s.copy()
b = t.copy()
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
b += [0] * (z - m)
butterfly(a)
butterfly(b)
for i in range(z):
a[i] *= b[i]
a[i] %= MOD
butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, MOD - 2, MOD)
return [v * iz % MOD for v in a]
mod=998244353
M=(10**5)*4+10
fac=[1]*M
ninv=[1]*M
finv=[1]*M
for i in range(2,M):
fac[i]=fac[i-1]*i%mod
ninv[i]=(-(mod//i)*ninv[mod%i])%mod
finv[i]=finv[i-1]*ninv[i]%mod
def binom(n,k):
if n<0 or k<0:
return 0
if k>n:
return 0
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def calc1(n):
A=[1]+[0]*n
for i in range(1,n+1):
A[i]=binom(n+i,2*i)
return A
def calc2(d):
A=[0]*(d)
for i in range(1,d+1):
A[i-1]=binom(d+i-1,2*i-1)
return A
from heapq import heappop, heappush
N,M,K=map(int,input().split())
a=list(map(int,input().split()))
if K==0:
ans=0
for n in range(1,N):
res=binom(n+M-2,2*M-3)
ans+=res*(N-n)
print(ans%mod)
exit()
hq=[]
heappush(hq,(a[0]-1,calc1(a[0]-1)))
heappush(hq,(N-a[-1],calc1(N-a[-1])))
for i in range(K-1):
d=a[i+1]-a[i]
heappush(hq,(d-1,calc2(d)))
while len(hq)>=2:
_,p1=heappop(hq)
_,p2=heappop(hq)
q=multiply(p1,p2)
heappush(hq,(len(q)-1,q))
ans=hq[0][1][M-K]*fac[M-K]
print(ans%mod)
MOD = 998244353
IMAG = 911660635
IIMAG = 86583718
rate2 = (0, 911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601, 842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0)
irate2 = (0, 86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0)
rate3 = (0, 372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099, 183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204, 0)
irate3 = (0, 509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500, 771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681, 0)
def butterfly(a):
n = len(a)
h = (n - 1).bit_length()
le = 0
while le < h:
if h - le == 1:
p = 1 << (h - le - 1)
rot = 1
for s in range(1 << le):
offset = s << (h - le)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) % MOD
rot *= rate2[(~s & -~s).bit_length()]
rot %= MOD
le += 1
else:
p = 1 << (h - le - 2)
rot = 1
for s in range(1 << le):
rot2 = rot * rot % MOD
rot3 = rot2 * rot % MOD
offset = s << (h - le)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p] * rot
a2 = a[i + offset + p * 2] * rot2
a3 = a[i + offset + p * 3] * rot3
a1na3imag = (a1 - a3) % MOD * IMAG
a[i + offset] = (a0 + a2 + a1 + a3) % MOD
a[i + offset + p] = (a0 + a2 - a1 - a3) % MOD
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % MOD
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % MOD
rot *= rate3[(~s & -~s).bit_length()]
rot %= MOD
le += 2
def butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
le = h
while le:
if le == 1:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 1)):
offset = s << (h - le + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % MOD
a[i + offset + p] = (l - r) * irot % MOD
irot *= irate2[(~s & -~s).bit_length()]
irot %= MOD
le -= 1
else:
p = 1 << (h - le)
irot = 1
for s in range(1 << (le - 2)):
irot2 = irot * irot % MOD
irot3 = irot2 * irot % MOD
offset = s << (h - le + 2)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p]
a2 = a[i + offset + p * 2]
a3 = a[i + offset + p * 3]
a2na3iimag = (a2 - a3) * IIMAG % MOD
a[i + offset] = (a0 + a1 + a2 + a3) % MOD
a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % MOD
a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % MOD
a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % MOD
irot *= irate3[(~s & -~s).bit_length()]
irot %= MOD
le -= 2
def multiply(s, t):
n = len(s)
m = len(t)
if min(n, m) <= 60:
a = [0] * (n + m - 1)
for i in range(n):
if i % 8 == 0:
for j in range(m):
a[i + j] += s[i] * t[j]
a[i + j] %= MOD
else:
for j in range(m):
a[i + j] += s[i] * t[j]
return [x % MOD for x in a]
a = s.copy()
b = t.copy()
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
b += [0] * (z - m)
butterfly(a)
butterfly(b)
for i in range(z):
a[i] *= b[i]
a[i] %= MOD
butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, MOD - 2, MOD)
return [v * iz % MOD for v in a]
mod=998244353
M=(10**5)*4+10
fac=[1]*M
ninv=[1]*M
finv=[1]*M
for i in range(2,M):
fac[i]=fac[i-1]*i%mod
ninv[i]=(-(mod//i)*ninv[mod%i])%mod
finv[i]=finv[i-1]*ninv[i]%mod
def binom(n,k):
if n<0 or k<0:
return 0
if k>n:
return 0
return (fac[n]*finv[k]%mod)*finv[n-k]%mod
def calc1(n):
A=[1]+[0]*n
for i in range(1,n+1):
A[i]=binom(n+i,2*i)
return A
def calc2(d):
A=[0]*(d)
for i in range(1,d+1):
A[i-1]=binom(d+i-1,2*i-1)
return A
from heapq import heappop, heappush
N,M,K=map(int,input().split())
a=list(map(int,input().split()))
if K==0:
ans=0
for n in range(1,N):
res=binom(n+M-2,2*M-3)
ans+=res*(N-n)
ans%=mod
ans*=fac[M]
print(ans%mod)
exit()
hq=[]
heappush(hq,(a[0]-1,calc1(a[0]-1)))
heappush(hq,(N-a[-1],calc1(N-a[-1])))
for i in range(K-1):
d=a[i+1]-a[i]
heappush(hq,(d-1,calc2(d)))
while len(hq)>=2:
_,p1=heappop(hq)
_,p2=heappop(hq)
q=multiply(p1,p2)
heappush(hq,(len(q)-1,q))
ans=hq[0][1][M-K]*fac[M-K]
print(ans%mod)
|
ConDefects/ConDefects/Code/abc225_h/Python/40522843
|
condefects-python_data_336
|
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
import time
from collections import Counter,deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
write=sys.stdout.write
def Tonelli_Shanks(N,p):
if pow(N,p>>1,p)==p-1:
retu=None
elif p%4==3:
retu=pow(N,(p+1)//4,p)
else:
for nonresidue in range(1,p):
if pow(nonresidue,p>>1,p)==p-1:
break
pp=p-1
cnt=0
while pp%2==0:
pp//=2
cnt+=1
s=pow(N,pp,p)
retu=pow(N,(pp+1)//2,p)
for i in range(cnt-2,-1,-1):
if pow(s,1<<i,p)==p-1:
s*=pow(nonresidue,p>>1+i,p)
s%=p
retu*=pow(nonresidue,p>>2+i,p)
retu%=p
return retu
mod = 998244353
imag = 911660635
iimag = 86583718
rate2 = (911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601,
842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899)
irate2 = (86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960,
354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235)
rate3 = (372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099,
183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204)
irate3 = (509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500,
771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681)
def butterfly(a):
n = len(a)
h = (n - 1).bit_length()
len_ = 0
while len_ < h:
if h - len_ == 1:
p = 1 << (h - len_ - 1)
rot = 1
for s in range(1 << len_):
offset = s << (h - len_)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot % mod
a[i + offset] = (l + r) % mod
a[i + offset + p] = (l - r) % mod
if s + 1 != 1 << len_:
rot *= rate2[(~s & -~s).bit_length() - 1]
rot %= mod
len_ += 1
else:
p = 1 << (h - len_ - 2)
rot = 1
for s in range(1 << len_):
rot2 = rot * rot % mod
rot3 = rot2 * rot % mod
offset = s << (h - len_)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p] * rot
a2 = a[i + offset + p * 2] * rot2
a3 = a[i + offset + p * 3] * rot3
a1na3imag = (a1 - a3) % mod * imag
a[i + offset] = (a0 + a2 + a1 + a3) % mod
a[i + offset + p] = (a0 + a2 - a1 - a3) % mod
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % mod
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % mod
if s + 1 != 1 << len_:
rot *= rate3[(~s & -~s).bit_length() - 1]
rot %= mod
len_ += 2
def butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
len_ = h
while len_:
if len_ == 1:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 1)):
offset = s << (h - len_ + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % mod
a[i + offset + p] = (l - r) * irot % mod
if s + 1 != (1 << (len_ - 1)):
irot *= irate2[(~s & -~s).bit_length() - 1]
irot %= mod
len_ -= 1
else:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 2)):
irot2 = irot * irot % mod
irot3 = irot2 * irot % mod
offset = s << (h - len_ + 2)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p]
a2 = a[i + offset + p * 2]
a3 = a[i + offset + p * 3]
a2na3iimag = (a2 - a3) * iimag % mod
a[i + offset] = (a0 + a1 + a2 + a3) % mod
a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % mod
a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % mod
a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % mod
if s + 1 != (1 << (len_ - 2)):
irot *= irate3[(~s & -~s).bit_length() - 1]
irot %= mod
len_ -= 2
def integrate(a):
a=a.copy()
n = len(a)
assert n > 0
a.pop()
a.insert(0, 0)
inv = [1, 1]
for i in range(2, n):
inv.append(-inv[mod%i] * (mod//i) % mod)
a[i] = a[i] * inv[i] % mod
return a
def differentiate(a):
n = len(a)
assert n > 0
for i in range(2, n):
a[i] = a[i] * i % mod
a.pop(0)
a.append(0)
return a
def convolution_naive(a, b):
n = len(a)
m = len(b)
ans = [0] * (n + m - 1)
if n < m:
for j in range(m):
for i in range(n):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % mod
else:
for i in range(n):
for j in range(m):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % mod
return ans
def convolution_ntt(a, b):
a = a.copy()
b = b.copy()
n = len(a)
m = len(b)
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
butterfly(a)
b += [0] * (z - m)
butterfly(b)
for i in range(z):
a[i] = a[i] * b[i] % mod
butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, mod - 2, mod)
for i in range(n + m - 1):
a[i] = a[i] * iz % mod
return a
def convolution_square(a):
a = a.copy()
n = len(a)
z = 1 << (2 * n - 2).bit_length()
a += [0] * (z - n)
butterfly(a)
for i in range(z):
a[i] = a[i] * a[i] % mod
butterfly_inv(a)
a = a[:2 * n - 1]
iz = pow(z, mod - 2, mod)
for i in range(2 * n - 1):
a[i] = a[i] * iz % mod
return a
def convolution(a, b):
"""It calculates (+, x) convolution in mod 998244353.
Given two arrays a[0], a[1], ..., a[n - 1] and b[0], b[1], ..., b[m - 1],
it calculates the array c of length n + m - 1, defined by
> c[i] = sum(a[j] * b[i - j] for j in range(i + 1)) % 998244353.
It returns an empty list if at least one of a and b are empty.
Complexity
----------
> O(n log n), where n = len(a) + len(b).
"""
n = len(a)
m = len(b)
if n == 0 or m == 0:
return []
if min(n, m) <= 60:
return convolution_naive(a, b)
if a is b:
return convolution_square(a)
return convolution_ntt(a, b)
def inverse(a):
n = len(a)
assert n > 0 and a[0] != 0
res = [pow(a[0], mod - 2, mod)]
m = 1
while m < n:
f = a[:min(n,2*m)] + [0]*(2*m-min(n,2*m))
g = res + [0]*m
butterfly(f)
butterfly(g)
for i in range(2*m):
f[i] = f[i] * g[i] % mod
butterfly_inv(f)
f = f[m:] + [0]*m
butterfly(f)
for i in range(2*m):
f[i] = f[i] * g[i] % mod
butterfly_inv(f)
iz = pow(2*m, mod-2, mod)
iz = (-iz*iz) % mod
for i in range(m):
f[i] = f[i] * iz % mod
res += f[:m]
m <<= 1
return res[:n]
def log(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 1
a_inv = inverse(a)
a=differentiate(a)
a = convolution(a, a_inv)[:n]
a=integrate(a)
return a
def exp(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 0
g = [1]
a[0] = 1
h_drv = a.copy()
h_drv=differentiate(h_drv)
m = 1
while m < n:
f_fft = a[:m] + [0] * m
butterfly(f_fft)
if m > 1:
_f = [f_fft[i] * g_fft[i] % mod for i in range(m)]
butterfly_inv(_f)
_f = _f[m // 2:] + [0] * (m // 2)
butterfly(_f)
for i in range(m):
_f[i] = _f[i] * g_fft[i] % mod
butterfly_inv(_f)
_f = _f[:m//2]
iz = pow(m, mod - 2, mod)
iz *= -iz
iz %= mod
for i in range(m//2):
_f[i] = _f[i] * iz % mod
g.extend(_f)
t = a[:m]
t=differentiate(t)
r = h_drv[:m - 1]
r.append(0)
butterfly(r)
for i in range(m):
r[i] = r[i] * f_fft[i] % mod
butterfly_inv(r)
im = pow(-m, mod - 2, mod)
for i in range(m):
r[i] = r[i] * im % mod
for i in range(m):
t[i] = (t[i] + r[i]) % mod
t = [t[-1]] + t[:-1]
t += [0] * m
butterfly(t)
g_fft = g + [0] * (2 * m - len(g))
butterfly(g_fft)
for i in range(2 * m):
t[i] = t[i] * g_fft[i] % mod
butterfly_inv(t)
t = t[:m]
i2m = pow(2 * m, mod - 2, mod)
for i in range(m):
t[i] = t[i] * i2m % mod
v = a[m:min(n, 2 * m)]
v += [0] * (m - len(v))
t = [0] * (m - 1) + t + [0]
t=integrate(t)
for i in range(m):
v[i] = (v[i] - t[m + i]) % mod
v += [0] * m
butterfly(v)
for i in range(2 * m):
v[i] = v[i] * f_fft[i] % mod
butterfly_inv(v)
v = v[:m]
i2m = pow(2 * m, mod - 2, mod)
for i in range(m):
v[i] = v[i] * i2m % mod
for i in range(min(n - m, m)):
a[m + i] = v[i]
m *= 2
return a
def power(a,k):
n = len(a)
assert n>0
if k==0:
return [1]+[0]*(n-1)
l = 0
while l < len(a) and not a[l]:
l += 1
if l * k >= n:
return [0] * n
ic = pow(a[l], mod - 2, mod)
pc = pow(a[l], k, mod)
a = log([a[i] * ic % mod for i in range(l, len(a))])
for i in range(len(a)):
a[i] = a[i] * k % mod
a = exp(a)
for i in range(len(a)):
a[i] = a[i] * pc % mod
a = [0] * (l * k) + a[:n - l * k]
return a
def sqrt(a):
if len(a) == 0:
return []
if a[0] == 0:
for d in range(1, len(a)):
if a[d]:
if d & 1:
return None
if len(a) - 1 < d // 2:
break
res=sqrt(a[d:]+[0]*(d//2))
if res == None:
return None
res = [0]*(d//2)+res
return res
return [0]*len(a)
sqr = Tonelli_Shanks(a[0],mod)
if sqr == None:
return None
T = [0] * (len(a))
T[0] = sqr
res = T.copy()
T[0] = pow(sqr,mod-2,mod) #T:res^{-1}
m = 1
two_inv = (mod + 1) // 2
F = [sqr]
while m <= len(a) - 1:
for i in range(m):
F[i] *= F[i]
F[i] %= mod
butterfly_inv(F)
iz = pow(m, mod-2, mod)
for i in range(m):
F[i] = F[i] * iz % mod
delta = [0] * (2 * m)
for i in range(m):
delta[i + m] = F[i] - a[i] - (a[i + m] if i+m<len(a) else 0)
butterfly(delta)
G = [0] * (2 * m)
for i in range(m):
G[i] = T[i]
butterfly(G)
for i in range(2 * m):
delta[i] *= G[i]
delta[i] %= mod
butterfly_inv(delta)
iz = pow(2*m, mod-2, mod)
for i in range(2*m):
delta[i] = delta[i] * iz % mod
for i in range(m, min(2 * m, len(a))):
res[i] = -delta[i] * two_inv%mod
res[i]%=mod
if 2 * m > len(a) - 1:
break
F = res[:2 * m]
butterfly(F)
eps = [F[i] * G[i] % mod for i in range(2 * m)]
butterfly_inv(eps)
for i in range(m):
eps[i] = 0
iz = pow(2*m, mod-2, mod)
for i in range(m,2*m):
eps[i] = eps[i] * iz % mod
butterfly(eps)
for i in range(2 * m):
eps[i] *= G[i]
eps[i] %= mod
butterfly_inv(eps)
for i in range(m, 2 * m):
T[i] = -eps[i]*iz
T[i]%=mod
iz = iz*iz % mod
m <<= 1
return res
def Extended_Euclid(n,m):
stack=[]
while m:
stack.append((n,m))
n,m=m,n%m
if n>=0:
x,y=1,0
else:
x,y=-1,0
for i in range(len(stack)-1,-1,-1):
n,m=stack[i]
x,y=y,x-(n//m)*y
return x,y
class MOD:
def __init__(self,p,e=None):
self.p=p
self.e=e
if self.e==None:
self.mod=self.p
else:
self.mod=self.p**self.e
def Pow(self,a,n):
a%=self.mod
if n>=0:
return pow(a,n,self.mod)
else:
assert math.gcd(a,self.mod)==1
x=Extended_Euclid(a,self.mod)[0]
return pow(x,-n,self.mod)
def Build_Fact(self,N):
assert N>=0
self.factorial=[1]
if self.e==None:
for i in range(1,N+1):
self.factorial.append(self.factorial[-1]*i%self.mod)
else:
self.cnt=[0]*(N+1)
for i in range(1,N+1):
self.cnt[i]=self.cnt[i-1]
ii=i
while ii%self.p==0:
ii//=self.p
self.cnt[i]+=1
self.factorial.append(self.factorial[-1]*ii%self.mod)
self.factorial_inve=[None]*(N+1)
self.factorial_inve[-1]=self.Pow(self.factorial[-1],-1)
for i in range(N-1,-1,-1):
ii=i+1
while ii%self.p==0:
ii//=self.p
self.factorial_inve[i]=(self.factorial_inve[i+1]*ii)%self.mod
def Fact(self,N):
if N<0:
return 0
retu=self.factorial[N]
if self.e!=None and self.cnt[N]:
retu*=pow(self.p,self.cnt[N],self.mod)%self.mod
retu%=self.mod
return retu
def Fact_Inve(self,N):
if self.e!=None and self.cnt[N]:
return None
return self.factorial_inve[N]
def Comb(self,N,K,divisible_count=False):
if K<0 or K>N:
return 0
retu=self.factorial[N]*self.factorial_inve[K]%self.mod*self.factorial_inve[N-K]%self.mod
if self.e!=None:
cnt=self.cnt[N]-self.cnt[N-K]-self.cnt[K]
if divisible_count:
return retu,cnt
else:
retu*=pow(self.p,cnt,self.mod)
retu%=self.mod
return retu
class Polynomial:
def __init__(self,polynomial,max_degree=-1,eps=0,mod=0):
self.max_degree=max_degree
if self.max_degree!=-1 and len(polynomial)>self.max_degree+1:
self.polynomial=polynomial[:self.max_degree+1]
else:
self.polynomial=polynomial
self.mod=mod
self.eps=eps
def __eq__(self,other):
if type(other)!=Polynomial:
return False
if len(self.polynomial)!=len(other.polynomial):
return False
for i in range(len(self.polynomial)):
if self.eps<abs(self.polynomial[i]-other.polynomial[i]):
return False
return True
def __ne__(self,other):
if type(other)!=Polynomial:
return True
if len(self.polynomial)!=len(other.polynomial):
return True
for i in range(len(self.polynomial)):
if self.eps<abs(self.polynomial[i]-other.polynomial[i]):
return True
return False
def __add__(self,other):
if type(other)==Polynomial:
summ=[0]*max(len(self.polynomial),len(other.polynomial))
for i in range(len(self.polynomial)):
summ[i]+=self.polynomial[i]
for i in range(len(other.polynomial)):
summ[i]+=other.polynomial[i]
if self.mod:
for i in range(len(summ)):
summ[i]%=self.mod
else:
summ=[x for x in self.polynomial] if self.polynomial else [0]
summ[0]+=other
if self.mod:
summ[0]%=self.mod
while summ and abs(summ[-1])<=self.eps:
summ.pop()
summ=Polynomial(summ,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return summ
def __sub__(self,other):
if type(other)==Polynomial:
diff=[0]*max(len(self.polynomial),len(other.polynomial))
for i in range(len(self.polynomial)):
diff[i]+=self.polynomial[i]
for i in range(len(other.polynomial)):
diff[i]-=other.polynomial[i]
if self.mod:
for i in range(len(diff)):
diff[i]%=self.mod
else:
diff=[x for x in self.polynomial] if self.polynomial else [0]
diff[0]-=other
if self.mod:
diff[0]%=self.mod
while diff and abs(diff[-1])<=self.eps:
diff.pop()
diff=Polynomial(diff,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return diff
def __mul__(self,other):
if type(other)==Polynomial:
if self.max_degree==-1:
prod=[0]*(len(self.polynomial)+len(other.polynomial)-1)
for i in range(len(self.polynomial)):
for j in range(len(other.polynomial)):
prod[i+j]+=self.polynomial[i]*other.polynomial[j]
else:
prod=[0]*min(len(self.polynomial)+len(other.polynomial)-1,self.max_degree+1)
for i in range(len(self.polynomial)):
for j in range(min(len(other.polynomial),self.max_degree+1-i)):
prod[i+j]+=self.polynomial[i]*other.polynomial[j]
if self.mod:
for i in range(len(prod)):
prod[i]%=self.mod
else:
if self.mod:
prod=[x*other%self.mod for x in self.polynomial]
else:
prod=[x*other for x in self.polynomial]
while prod and abs(prod[-1])<=self.eps:
prod.pop()
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __matmul__(self,other):
assert type(other)==Polynomial
if self.mod:
prod=NTT(self.polynomial,other.polynomial)
else:
prod=FFT(self.polynomial,other.polynomial)
if self.max_degree!=-1 and len(prod)>self.max_degree+1:
prod=prod[:self.max_degree+1]
while prod and abs(prod[-1])<=self.eps:
prod.pop()
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __pow__(self,other):
if other==0:
prod=Polynomial([1],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
elif other==1:
prod=Polynomial([x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
prod=[1]
doub=self.polynomial
if self.mod:
convolve=NTT
convolve_Pow=NTT_Pow
else:
convolve=FFT
convolve_Pow=FFT_Pow
while other>=2:
if other&1:
prod=convolve(prod,doub)
if self.max_degree!=-1:
prod=prod[:self.max_degree+1]
doub=convolve_Pow(doub,2)
if self.max_degree!=-1:
doub=doub[:self.max_degree+1]
other>>=1
prod=convolve(prod,doub)
if self.max_degree!=-1:
prod=prod[:self.max_degree+1]
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __truediv__(self,other):
if type(other)==Polynomial:
assert other.polynomial
for n in range(len(other.polynomial)):
if self.eps<abs(other.polynomial[n]):
break
assert len(self.polynomial)>n
for i in range(n):
assert abs(self.polynomial[i])<=self.eps
self_polynomial=self.polynomial[n:]
other_polynomial=other.polynomial[n:]
if self.mod:
inve=MOD(self.mod).Pow(other_polynomial[0],-1)
else:
inve=1/other_polynomial[0]
quot=[]
for i in range(len(self_polynomial)-len(other_polynomial)+1):
if self.mod:
quot.append(self_polynomial[i]*inve%self.mod)
else:
quot.append(self_polynomial[i]*inve)
for j in range(len(other_polynomial)):
self_polynomial[i+j]-=other_polynomial[j]*quot[-1]
if self.mod:
self_polynomial[i+j]%=self.mod
for i in range(max(0,len(self_polynomial)-len(other_polynomial)+1),len(self_polynomial)):
if self.eps<abs(self_polynomial[i]):
assert self.max_degree!=-1
self_polynomial=self_polynomial[-len(other_polynomial)+1:]+[0]*(len(other_polynomial)-1-len(self_polynomial))
while len(quot)<=self.max_degree:
self_polynomial.append(0)
if self.mod:
quot.append(self_polynomial[0]*inve%self.mod)
self_polynomial=[(self_polynomial[i]-other_polynomial[i]*quot[-1])%self.mod for i in range(1,len(self_polynomial))]
else:
quot.append(self_polynomial[0]*inve)
self_polynomial=[(self_polynomial[i]-other_polynomial[i]*quot[-1]) for i in range(1,len(self_polynomial))]
break
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
assert self.eps<abs(other)
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
quot=Polynomial([x*inve%self.mod for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
quot=Polynomial([x/other for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def __floordiv__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def __mod__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
while rema and abs(rema[-1])<=self.eps:
rema.pop()
rema=Polynomial(rema,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return rema
def __divmod__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
while rema and abs(rema[-1])<=self.eps:
rema.pop()
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
rema=Polynomial(rema,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot,rema
def __neg__(self):
if self.mod:
nega=Polynomial([(-x)%self.mod for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
nega=Polynomial([-x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return nega
def __pos__(self):
posi=Polynomial([x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return posi
def __bool__(self):
return self.polynomial
def __getitem__(self,n):
if type(n)==int:
if n<=len(self.polynomial)-1:
return self.polynomial[n]
else:
return 0
else:
return Polynomial(polynomial=self.polynomial[n],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def __setitem__(self,n,a):
if self.mod:
a%=self.mod
if self.max_degree==-1 or n<=self.max_degree:
if n<=len(self.polynomial)-1:
self.polynomial[n]=a
elif self.eps<abs(a):
self.polynomial+=[0]*(n-len(self.polynomial))+[a]
def __iter__(self):
for x in self.polynomial:
yield x
def __call__(self,x):
retu=0
pow_x=1
for i in range(len(self.polynomial)):
retu+=pow_x*self.polynomial[i]
pow_x*=x
if self.mod:
retu%=self.mod
pow_x%=self.mod
return retu
def __str__(self):
return "["+", ".join(map(str,self.polynomial))+"]"
def __len__(self):
return len(self.polynomial)
def differentiate(self):
if self.mod:
differential=[x*i%self.mod for i,x in enumerate(self.polynomial[1:],1)]
else:
differential=[x*i for i,x in enumerate(self.polynomial[1:],1)]
return Polynomial(differential,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def integrate(self):
if self.mod:
integral=[0]+[x*MOD(mod).Pow(i+1,-1)%self.mod for i,x in enumerate(self.polynomial)]
else:
integral=[0]+[x/(i+1) for i,x in enumerate(self.polynomial)]
while integral and abs(integral[-1])<=self.eps:
integral.pop()
return Polynomial(integral,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def inverse(self):
assert self.polynomial and self.eps<self.polynomial[0]
assert self.max_degree!=-1
if self.mod:
quot=[MOD(self.mod).Pow(self.polynomial[0],-1)]
if self.mod==998244353:
prim_root=3
prim_root_inve=332748118
else:
prim_root=Primitive_Root(self.mod)
prim_root_inve=MOD(self.mod).Pow(prim_root,-1)
def DFT(polynomial,n,inverse=False):
polynomial=polynomial+[0]*((1<<n)-len(polynomial))
if inverse:
for bit in range(1,n+1):
a=1<<bit-1
x=pow(prim_root,self.mod-1>>bit,self.mod)
U=[1]
for _ in range(a):
U.append(U[-1]*x%self.mod)
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=(polynomial[s]+polynomial[t]*U[j])%self.mod,(polynomial[s]-polynomial[t]*U[j])%self.mod
x=pow((self.mod+1)//2,n,self.mod)
for i in range(1<<n):
polynomial[i]*=x
polynomial[i]%=self.mod
else:
for bit in range(n,0,-1):
a=1<<bit-1
x=pow(prim_root_inve,self.mod-1>>bit,self.mod)
U=[1]
for _ in range(a):
U.append(U[-1]*x%self.mod)
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=(polynomial[s]+polynomial[t])%self.mod,U[j]*(polynomial[s]-polynomial[t])%self.mod
return polynomial
else:
quot=[1/self.polynomial[0]]
def DFT(polynomial,n,inverse=False):
N=len(polynomial)
if inverse:
primitive_root=[math.cos(-i*2*math.pi/(1<<n))+math.sin(-i*2*math.pi/(1<<n))*1j for i in range(1<<n)]
else:
primitive_root=[math.cos(i*2*math.pi/(1<<n))+math.sin(i*2*math.pi/(1<<n))*1j for i in range(1<<n)]
polynomial=polynomial+[0]*((1<<n)-N)
if inverse:
for bit in range(1,n+1):
a=1<<bit-1
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=polynomial[s]+polynomial[t]*primitive_root[j<<n-bit],polynomial[s]-polynomial[t]*primitive_root[j<<n-bit]
for i in range(1<<n):
polynomial[i]=round((polynomial[i]/(1<<n)).real)
else:
for bit in range(n,0,-1):
a=1<<bit-1
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=polynomial[s]+polynomial[t],primitive_root[j<<n-bit]*(polynomial[s]-polynomial[t])
return polynomial
for n in range(self.max_degree.bit_length()):
prev=quot
DFT_prev=DFT(prev,n+1)
if self.mod:
quot=[x*y%self.mod for x,y in zip(DFT_prev,DFT(self.polynomial[:1<<n+1],n+1))]
else:
quot=[x*y for x,y in zip(DFT_prev,DFT(self.polynomial[:1<<n+1],n+1))]
quot=DFT([0]*(1<<n)+DFT(quot,n+1,inverse=True)[1<<n:],n+1)
if self.mod:
quot=[(-x*y)%self.mod for x,y in zip(DFT_prev,quot)]
else:
quot=[-x*y for x,y in zip(DFT_prev,quot)]
quot=prev+DFT(quot,n+1,inverse=True)[1<<n:]
quot=quot[:self.max_degree+1]
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def log(self):
assert self.max_degree!=-1
assert self.polynomial and abs(self.polynomial[0]-1)<=self.eps
log=self.inverse()
if self.mod:
log=Polynomial(NTT(self.differentiate().polynomial,log.polynomial),max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
log=Polynomial(FFT(self.differentiate().polynomial,log.polynomial),max_degree=self.max_degree,eps=self.eps,mod=self.mod)
log=log.integrate()
return log
def Newton(self,n0,f,differentiated_f=None):
newton=[n0]
while len(newton)<self.max_degree+1:
prev=newton
if differentiated_f==None:
newton=f(prev,self.polynomial)
else:
newton=f(prev)
for i in range(min(len(self.polynomial),len(newton))):
newton[i]-=self.polynomial[i]
newton[i]%=self.mod
if self.mod:
newton=NTT(newton,Polynomial(differentiated_f(prev),max_degree=len(newton)-1,eps=self.eps,mod=self.mod).inverse().polynomial)[:len(newton)]
else:
newton=FFT(newton,Polynomial(differentiated_f(prev),max_degree=len(newton)-1,eps=self.eps,mod=self.mod).inverse().polynomial)[:len(newton)]
for i in range(len(newton)):
newton[i]=-newton[i]
newton[i]%=self.mod
for i in range(len(prev)):
newton[i]+=prev[i]
newton[i]%=self.mod
newton=newton[:self.max_degree+1]
while newton and newton[-1]<=self.eps:
newton.pop()
return Polynomial(newton,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def sqrt(self):
if self.polynomial:
for cnt0 in range(len(self.polynomial)):
if self.polynomial[cnt0]:
break
if cnt0%2:
sqrt=None
else:
if self.mod:
n0=Tonelli_Shanks(self.polynomial[cnt0],self.mod)
else:
if self.polynomial[cnt0]>=self.eps:
n0=self.polynomial[cnt0]**.5
if n0==None:
sqrt=None
else:
def f(prev):
if self.mod:
return NTT_Pow(prev,2)+[0]
else:
return FFT_Pow(prev,2)+[0]
def differentiated_f(prev):
retu=[0]*(2*len(prev)-1)
for i in range(len(prev)):
retu[i]+=2*prev[i]
if self.mod:
retu[i]%self.mod
return retu
sqrt=[0]*(cnt0//2)+Polynomial(self.polynomial[cnt0:],max_degree=self.max_degree-cnt0//2,mod=self.mod).Newton(n0,f,differentiated_f).polynomial
sqrt=Polynomial(sqrt,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
sqrt=Polynomial([],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return sqrt
def exp(self):
assert not self.polynomial or abs(self.polynomial[0])<=self.eps
def f(prev,poly):
newton=Polynomial(prev,max_degree=2*len(prev)-1,eps=self.eps,mod=self.mod).log().polynomial
newton+=[0]*(2*len(prev)-len(newton))
for i in range(min(len(poly),len(newton))):
newton[i]-=poly[i]
if self.mod:
for i in range(len(newton)):
newton[i]%=self.mod
if self.mod:
return NTT(prev,newton)[:2*len(prev)]
else:
return FFT(prev,newton)[:2*len(prev)]
return Polynomial(self.polynomial,max_degree=self.max_degree,mod=self.mod).Newton(1,f)
def Degree(self):
return len(self.polynomial)-1
N,M,K=map(int,readline().split())
A=list(map(int,readline().split()))
mod=998244353
MD=MOD(mod)
MD.Build_Fact(2*N)
if K==0:
ans=MD.Comb(N+M-1,2*M-1)
else:
queue=[]
for k in range(K):
A[k]-=1
for k in range(K-1):
poly=[MD.Comb(A[k+1]-A[k]+c,2*c+1) for c in range(A[k+1]-A[k])]
queue.append((len(poly)-1,poly))
if A[0]:
poly=[MD.Comb(A[0]+c,2*c) for c in range(A[0]+1)]
queue.append((len(poly)-1,poly))
if A[K-1]<N-1:
poly=[MD.Comb(N-1-A[K-1]+c,2*c) for c in range(N-A[K-1])]
queue.append((len(poly)-1,poly))
while len(queue)>=2:
le0,poly0=heappop(queue)
le1,poly1=heappop(queue)
heappush(queue,(le0+le1,convolution(poly0,poly1)))
poly=queue[0][1]
ans=poly[M-K]*MD.Fact(M-K)%mod
print(ans)
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
import time
from collections import Counter,deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
write=sys.stdout.write
def Tonelli_Shanks(N,p):
if pow(N,p>>1,p)==p-1:
retu=None
elif p%4==3:
retu=pow(N,(p+1)//4,p)
else:
for nonresidue in range(1,p):
if pow(nonresidue,p>>1,p)==p-1:
break
pp=p-1
cnt=0
while pp%2==0:
pp//=2
cnt+=1
s=pow(N,pp,p)
retu=pow(N,(pp+1)//2,p)
for i in range(cnt-2,-1,-1):
if pow(s,1<<i,p)==p-1:
s*=pow(nonresidue,p>>1+i,p)
s%=p
retu*=pow(nonresidue,p>>2+i,p)
retu%=p
return retu
mod = 998244353
imag = 911660635
iimag = 86583718
rate2 = (911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601,
842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899)
irate2 = (86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960,
354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235)
rate3 = (372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099,
183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204)
irate3 = (509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500,
771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681)
def butterfly(a):
n = len(a)
h = (n - 1).bit_length()
len_ = 0
while len_ < h:
if h - len_ == 1:
p = 1 << (h - len_ - 1)
rot = 1
for s in range(1 << len_):
offset = s << (h - len_)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * rot % mod
a[i + offset] = (l + r) % mod
a[i + offset + p] = (l - r) % mod
if s + 1 != 1 << len_:
rot *= rate2[(~s & -~s).bit_length() - 1]
rot %= mod
len_ += 1
else:
p = 1 << (h - len_ - 2)
rot = 1
for s in range(1 << len_):
rot2 = rot * rot % mod
rot3 = rot2 * rot % mod
offset = s << (h - len_)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p] * rot
a2 = a[i + offset + p * 2] * rot2
a3 = a[i + offset + p * 3] * rot3
a1na3imag = (a1 - a3) % mod * imag
a[i + offset] = (a0 + a2 + a1 + a3) % mod
a[i + offset + p] = (a0 + a2 - a1 - a3) % mod
a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % mod
a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % mod
if s + 1 != 1 << len_:
rot *= rate3[(~s & -~s).bit_length() - 1]
rot %= mod
len_ += 2
def butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
len_ = h
while len_:
if len_ == 1:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 1)):
offset = s << (h - len_ + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % mod
a[i + offset + p] = (l - r) * irot % mod
if s + 1 != (1 << (len_ - 1)):
irot *= irate2[(~s & -~s).bit_length() - 1]
irot %= mod
len_ -= 1
else:
p = 1 << (h - len_)
irot = 1
for s in range(1 << (len_ - 2)):
irot2 = irot * irot % mod
irot3 = irot2 * irot % mod
offset = s << (h - len_ + 2)
for i in range(p):
a0 = a[i + offset]
a1 = a[i + offset + p]
a2 = a[i + offset + p * 2]
a3 = a[i + offset + p * 3]
a2na3iimag = (a2 - a3) * iimag % mod
a[i + offset] = (a0 + a1 + a2 + a3) % mod
a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % mod
a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % mod
a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % mod
if s + 1 != (1 << (len_ - 2)):
irot *= irate3[(~s & -~s).bit_length() - 1]
irot %= mod
len_ -= 2
def integrate(a):
a=a.copy()
n = len(a)
assert n > 0
a.pop()
a.insert(0, 0)
inv = [1, 1]
for i in range(2, n):
inv.append(-inv[mod%i] * (mod//i) % mod)
a[i] = a[i] * inv[i] % mod
return a
def differentiate(a):
n = len(a)
assert n > 0
for i in range(2, n):
a[i] = a[i] * i % mod
a.pop(0)
a.append(0)
return a
def convolution_naive(a, b):
n = len(a)
m = len(b)
ans = [0] * (n + m - 1)
if n < m:
for j in range(m):
for i in range(n):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % mod
else:
for i in range(n):
for j in range(m):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % mod
return ans
def convolution_ntt(a, b):
a = a.copy()
b = b.copy()
n = len(a)
m = len(b)
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
butterfly(a)
b += [0] * (z - m)
butterfly(b)
for i in range(z):
a[i] = a[i] * b[i] % mod
butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, mod - 2, mod)
for i in range(n + m - 1):
a[i] = a[i] * iz % mod
return a
def convolution_square(a):
a = a.copy()
n = len(a)
z = 1 << (2 * n - 2).bit_length()
a += [0] * (z - n)
butterfly(a)
for i in range(z):
a[i] = a[i] * a[i] % mod
butterfly_inv(a)
a = a[:2 * n - 1]
iz = pow(z, mod - 2, mod)
for i in range(2 * n - 1):
a[i] = a[i] * iz % mod
return a
def convolution(a, b):
"""It calculates (+, x) convolution in mod 998244353.
Given two arrays a[0], a[1], ..., a[n - 1] and b[0], b[1], ..., b[m - 1],
it calculates the array c of length n + m - 1, defined by
> c[i] = sum(a[j] * b[i - j] for j in range(i + 1)) % 998244353.
It returns an empty list if at least one of a and b are empty.
Complexity
----------
> O(n log n), where n = len(a) + len(b).
"""
n = len(a)
m = len(b)
if n == 0 or m == 0:
return []
if min(n, m) <= 60:
return convolution_naive(a, b)
if a is b:
return convolution_square(a)
return convolution_ntt(a, b)
def inverse(a):
n = len(a)
assert n > 0 and a[0] != 0
res = [pow(a[0], mod - 2, mod)]
m = 1
while m < n:
f = a[:min(n,2*m)] + [0]*(2*m-min(n,2*m))
g = res + [0]*m
butterfly(f)
butterfly(g)
for i in range(2*m):
f[i] = f[i] * g[i] % mod
butterfly_inv(f)
f = f[m:] + [0]*m
butterfly(f)
for i in range(2*m):
f[i] = f[i] * g[i] % mod
butterfly_inv(f)
iz = pow(2*m, mod-2, mod)
iz = (-iz*iz) % mod
for i in range(m):
f[i] = f[i] * iz % mod
res += f[:m]
m <<= 1
return res[:n]
def log(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 1
a_inv = inverse(a)
a=differentiate(a)
a = convolution(a, a_inv)[:n]
a=integrate(a)
return a
def exp(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 0
g = [1]
a[0] = 1
h_drv = a.copy()
h_drv=differentiate(h_drv)
m = 1
while m < n:
f_fft = a[:m] + [0] * m
butterfly(f_fft)
if m > 1:
_f = [f_fft[i] * g_fft[i] % mod for i in range(m)]
butterfly_inv(_f)
_f = _f[m // 2:] + [0] * (m // 2)
butterfly(_f)
for i in range(m):
_f[i] = _f[i] * g_fft[i] % mod
butterfly_inv(_f)
_f = _f[:m//2]
iz = pow(m, mod - 2, mod)
iz *= -iz
iz %= mod
for i in range(m//2):
_f[i] = _f[i] * iz % mod
g.extend(_f)
t = a[:m]
t=differentiate(t)
r = h_drv[:m - 1]
r.append(0)
butterfly(r)
for i in range(m):
r[i] = r[i] * f_fft[i] % mod
butterfly_inv(r)
im = pow(-m, mod - 2, mod)
for i in range(m):
r[i] = r[i] * im % mod
for i in range(m):
t[i] = (t[i] + r[i]) % mod
t = [t[-1]] + t[:-1]
t += [0] * m
butterfly(t)
g_fft = g + [0] * (2 * m - len(g))
butterfly(g_fft)
for i in range(2 * m):
t[i] = t[i] * g_fft[i] % mod
butterfly_inv(t)
t = t[:m]
i2m = pow(2 * m, mod - 2, mod)
for i in range(m):
t[i] = t[i] * i2m % mod
v = a[m:min(n, 2 * m)]
v += [0] * (m - len(v))
t = [0] * (m - 1) + t + [0]
t=integrate(t)
for i in range(m):
v[i] = (v[i] - t[m + i]) % mod
v += [0] * m
butterfly(v)
for i in range(2 * m):
v[i] = v[i] * f_fft[i] % mod
butterfly_inv(v)
v = v[:m]
i2m = pow(2 * m, mod - 2, mod)
for i in range(m):
v[i] = v[i] * i2m % mod
for i in range(min(n - m, m)):
a[m + i] = v[i]
m *= 2
return a
def power(a,k):
n = len(a)
assert n>0
if k==0:
return [1]+[0]*(n-1)
l = 0
while l < len(a) and not a[l]:
l += 1
if l * k >= n:
return [0] * n
ic = pow(a[l], mod - 2, mod)
pc = pow(a[l], k, mod)
a = log([a[i] * ic % mod for i in range(l, len(a))])
for i in range(len(a)):
a[i] = a[i] * k % mod
a = exp(a)
for i in range(len(a)):
a[i] = a[i] * pc % mod
a = [0] * (l * k) + a[:n - l * k]
return a
def sqrt(a):
if len(a) == 0:
return []
if a[0] == 0:
for d in range(1, len(a)):
if a[d]:
if d & 1:
return None
if len(a) - 1 < d // 2:
break
res=sqrt(a[d:]+[0]*(d//2))
if res == None:
return None
res = [0]*(d//2)+res
return res
return [0]*len(a)
sqr = Tonelli_Shanks(a[0],mod)
if sqr == None:
return None
T = [0] * (len(a))
T[0] = sqr
res = T.copy()
T[0] = pow(sqr,mod-2,mod) #T:res^{-1}
m = 1
two_inv = (mod + 1) // 2
F = [sqr]
while m <= len(a) - 1:
for i in range(m):
F[i] *= F[i]
F[i] %= mod
butterfly_inv(F)
iz = pow(m, mod-2, mod)
for i in range(m):
F[i] = F[i] * iz % mod
delta = [0] * (2 * m)
for i in range(m):
delta[i + m] = F[i] - a[i] - (a[i + m] if i+m<len(a) else 0)
butterfly(delta)
G = [0] * (2 * m)
for i in range(m):
G[i] = T[i]
butterfly(G)
for i in range(2 * m):
delta[i] *= G[i]
delta[i] %= mod
butterfly_inv(delta)
iz = pow(2*m, mod-2, mod)
for i in range(2*m):
delta[i] = delta[i] * iz % mod
for i in range(m, min(2 * m, len(a))):
res[i] = -delta[i] * two_inv%mod
res[i]%=mod
if 2 * m > len(a) - 1:
break
F = res[:2 * m]
butterfly(F)
eps = [F[i] * G[i] % mod for i in range(2 * m)]
butterfly_inv(eps)
for i in range(m):
eps[i] = 0
iz = pow(2*m, mod-2, mod)
for i in range(m,2*m):
eps[i] = eps[i] * iz % mod
butterfly(eps)
for i in range(2 * m):
eps[i] *= G[i]
eps[i] %= mod
butterfly_inv(eps)
for i in range(m, 2 * m):
T[i] = -eps[i]*iz
T[i]%=mod
iz = iz*iz % mod
m <<= 1
return res
def Extended_Euclid(n,m):
stack=[]
while m:
stack.append((n,m))
n,m=m,n%m
if n>=0:
x,y=1,0
else:
x,y=-1,0
for i in range(len(stack)-1,-1,-1):
n,m=stack[i]
x,y=y,x-(n//m)*y
return x,y
class MOD:
def __init__(self,p,e=None):
self.p=p
self.e=e
if self.e==None:
self.mod=self.p
else:
self.mod=self.p**self.e
def Pow(self,a,n):
a%=self.mod
if n>=0:
return pow(a,n,self.mod)
else:
assert math.gcd(a,self.mod)==1
x=Extended_Euclid(a,self.mod)[0]
return pow(x,-n,self.mod)
def Build_Fact(self,N):
assert N>=0
self.factorial=[1]
if self.e==None:
for i in range(1,N+1):
self.factorial.append(self.factorial[-1]*i%self.mod)
else:
self.cnt=[0]*(N+1)
for i in range(1,N+1):
self.cnt[i]=self.cnt[i-1]
ii=i
while ii%self.p==0:
ii//=self.p
self.cnt[i]+=1
self.factorial.append(self.factorial[-1]*ii%self.mod)
self.factorial_inve=[None]*(N+1)
self.factorial_inve[-1]=self.Pow(self.factorial[-1],-1)
for i in range(N-1,-1,-1):
ii=i+1
while ii%self.p==0:
ii//=self.p
self.factorial_inve[i]=(self.factorial_inve[i+1]*ii)%self.mod
def Fact(self,N):
if N<0:
return 0
retu=self.factorial[N]
if self.e!=None and self.cnt[N]:
retu*=pow(self.p,self.cnt[N],self.mod)%self.mod
retu%=self.mod
return retu
def Fact_Inve(self,N):
if self.e!=None and self.cnt[N]:
return None
return self.factorial_inve[N]
def Comb(self,N,K,divisible_count=False):
if K<0 or K>N:
return 0
retu=self.factorial[N]*self.factorial_inve[K]%self.mod*self.factorial_inve[N-K]%self.mod
if self.e!=None:
cnt=self.cnt[N]-self.cnt[N-K]-self.cnt[K]
if divisible_count:
return retu,cnt
else:
retu*=pow(self.p,cnt,self.mod)
retu%=self.mod
return retu
class Polynomial:
def __init__(self,polynomial,max_degree=-1,eps=0,mod=0):
self.max_degree=max_degree
if self.max_degree!=-1 and len(polynomial)>self.max_degree+1:
self.polynomial=polynomial[:self.max_degree+1]
else:
self.polynomial=polynomial
self.mod=mod
self.eps=eps
def __eq__(self,other):
if type(other)!=Polynomial:
return False
if len(self.polynomial)!=len(other.polynomial):
return False
for i in range(len(self.polynomial)):
if self.eps<abs(self.polynomial[i]-other.polynomial[i]):
return False
return True
def __ne__(self,other):
if type(other)!=Polynomial:
return True
if len(self.polynomial)!=len(other.polynomial):
return True
for i in range(len(self.polynomial)):
if self.eps<abs(self.polynomial[i]-other.polynomial[i]):
return True
return False
def __add__(self,other):
if type(other)==Polynomial:
summ=[0]*max(len(self.polynomial),len(other.polynomial))
for i in range(len(self.polynomial)):
summ[i]+=self.polynomial[i]
for i in range(len(other.polynomial)):
summ[i]+=other.polynomial[i]
if self.mod:
for i in range(len(summ)):
summ[i]%=self.mod
else:
summ=[x for x in self.polynomial] if self.polynomial else [0]
summ[0]+=other
if self.mod:
summ[0]%=self.mod
while summ and abs(summ[-1])<=self.eps:
summ.pop()
summ=Polynomial(summ,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return summ
def __sub__(self,other):
if type(other)==Polynomial:
diff=[0]*max(len(self.polynomial),len(other.polynomial))
for i in range(len(self.polynomial)):
diff[i]+=self.polynomial[i]
for i in range(len(other.polynomial)):
diff[i]-=other.polynomial[i]
if self.mod:
for i in range(len(diff)):
diff[i]%=self.mod
else:
diff=[x for x in self.polynomial] if self.polynomial else [0]
diff[0]-=other
if self.mod:
diff[0]%=self.mod
while diff and abs(diff[-1])<=self.eps:
diff.pop()
diff=Polynomial(diff,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return diff
def __mul__(self,other):
if type(other)==Polynomial:
if self.max_degree==-1:
prod=[0]*(len(self.polynomial)+len(other.polynomial)-1)
for i in range(len(self.polynomial)):
for j in range(len(other.polynomial)):
prod[i+j]+=self.polynomial[i]*other.polynomial[j]
else:
prod=[0]*min(len(self.polynomial)+len(other.polynomial)-1,self.max_degree+1)
for i in range(len(self.polynomial)):
for j in range(min(len(other.polynomial),self.max_degree+1-i)):
prod[i+j]+=self.polynomial[i]*other.polynomial[j]
if self.mod:
for i in range(len(prod)):
prod[i]%=self.mod
else:
if self.mod:
prod=[x*other%self.mod for x in self.polynomial]
else:
prod=[x*other for x in self.polynomial]
while prod and abs(prod[-1])<=self.eps:
prod.pop()
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __matmul__(self,other):
assert type(other)==Polynomial
if self.mod:
prod=NTT(self.polynomial,other.polynomial)
else:
prod=FFT(self.polynomial,other.polynomial)
if self.max_degree!=-1 and len(prod)>self.max_degree+1:
prod=prod[:self.max_degree+1]
while prod and abs(prod[-1])<=self.eps:
prod.pop()
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __pow__(self,other):
if other==0:
prod=Polynomial([1],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
elif other==1:
prod=Polynomial([x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
prod=[1]
doub=self.polynomial
if self.mod:
convolve=NTT
convolve_Pow=NTT_Pow
else:
convolve=FFT
convolve_Pow=FFT_Pow
while other>=2:
if other&1:
prod=convolve(prod,doub)
if self.max_degree!=-1:
prod=prod[:self.max_degree+1]
doub=convolve_Pow(doub,2)
if self.max_degree!=-1:
doub=doub[:self.max_degree+1]
other>>=1
prod=convolve(prod,doub)
if self.max_degree!=-1:
prod=prod[:self.max_degree+1]
prod=Polynomial(prod,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return prod
def __truediv__(self,other):
if type(other)==Polynomial:
assert other.polynomial
for n in range(len(other.polynomial)):
if self.eps<abs(other.polynomial[n]):
break
assert len(self.polynomial)>n
for i in range(n):
assert abs(self.polynomial[i])<=self.eps
self_polynomial=self.polynomial[n:]
other_polynomial=other.polynomial[n:]
if self.mod:
inve=MOD(self.mod).Pow(other_polynomial[0],-1)
else:
inve=1/other_polynomial[0]
quot=[]
for i in range(len(self_polynomial)-len(other_polynomial)+1):
if self.mod:
quot.append(self_polynomial[i]*inve%self.mod)
else:
quot.append(self_polynomial[i]*inve)
for j in range(len(other_polynomial)):
self_polynomial[i+j]-=other_polynomial[j]*quot[-1]
if self.mod:
self_polynomial[i+j]%=self.mod
for i in range(max(0,len(self_polynomial)-len(other_polynomial)+1),len(self_polynomial)):
if self.eps<abs(self_polynomial[i]):
assert self.max_degree!=-1
self_polynomial=self_polynomial[-len(other_polynomial)+1:]+[0]*(len(other_polynomial)-1-len(self_polynomial))
while len(quot)<=self.max_degree:
self_polynomial.append(0)
if self.mod:
quot.append(self_polynomial[0]*inve%self.mod)
self_polynomial=[(self_polynomial[i]-other_polynomial[i]*quot[-1])%self.mod for i in range(1,len(self_polynomial))]
else:
quot.append(self_polynomial[0]*inve)
self_polynomial=[(self_polynomial[i]-other_polynomial[i]*quot[-1]) for i in range(1,len(self_polynomial))]
break
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
assert self.eps<abs(other)
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
quot=Polynomial([x*inve%self.mod for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
quot=Polynomial([x/other for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def __floordiv__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def __mod__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
while rema and abs(rema[-1])<=self.eps:
rema.pop()
rema=Polynomial(rema,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return rema
def __divmod__(self,other):
assert type(other)==Polynomial
quot=[0]*(len(self.polynomial)-len(other.polynomial)+1)
rema=[x for x in self.polynomial]
if self.mod:
inve=MOD(self.mod).Pow(other.polynomial[-1],-1)
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve%self.mod
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
rema[i+j]%=self.mod
else:
inve=1/other.polynomial[-1]
for i in range(len(self.polynomial)-len(other.polynomial),-1,-1):
quot[i]=rema[i+len(other.polynomial)-1]*inve
for j in range(len(other.polynomial)):
rema[i+j]-=quot[i]*other.polynomial[j]
while rema and abs(rema[-1])<=self.eps:
rema.pop()
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
rema=Polynomial(rema,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot,rema
def __neg__(self):
if self.mod:
nega=Polynomial([(-x)%self.mod for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
nega=Polynomial([-x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return nega
def __pos__(self):
posi=Polynomial([x for x in self.polynomial],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return posi
def __bool__(self):
return self.polynomial
def __getitem__(self,n):
if type(n)==int:
if n<=len(self.polynomial)-1:
return self.polynomial[n]
else:
return 0
else:
return Polynomial(polynomial=self.polynomial[n],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def __setitem__(self,n,a):
if self.mod:
a%=self.mod
if self.max_degree==-1 or n<=self.max_degree:
if n<=len(self.polynomial)-1:
self.polynomial[n]=a
elif self.eps<abs(a):
self.polynomial+=[0]*(n-len(self.polynomial))+[a]
def __iter__(self):
for x in self.polynomial:
yield x
def __call__(self,x):
retu=0
pow_x=1
for i in range(len(self.polynomial)):
retu+=pow_x*self.polynomial[i]
pow_x*=x
if self.mod:
retu%=self.mod
pow_x%=self.mod
return retu
def __str__(self):
return "["+", ".join(map(str,self.polynomial))+"]"
def __len__(self):
return len(self.polynomial)
def differentiate(self):
if self.mod:
differential=[x*i%self.mod for i,x in enumerate(self.polynomial[1:],1)]
else:
differential=[x*i for i,x in enumerate(self.polynomial[1:],1)]
return Polynomial(differential,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def integrate(self):
if self.mod:
integral=[0]+[x*MOD(mod).Pow(i+1,-1)%self.mod for i,x in enumerate(self.polynomial)]
else:
integral=[0]+[x/(i+1) for i,x in enumerate(self.polynomial)]
while integral and abs(integral[-1])<=self.eps:
integral.pop()
return Polynomial(integral,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def inverse(self):
assert self.polynomial and self.eps<self.polynomial[0]
assert self.max_degree!=-1
if self.mod:
quot=[MOD(self.mod).Pow(self.polynomial[0],-1)]
if self.mod==998244353:
prim_root=3
prim_root_inve=332748118
else:
prim_root=Primitive_Root(self.mod)
prim_root_inve=MOD(self.mod).Pow(prim_root,-1)
def DFT(polynomial,n,inverse=False):
polynomial=polynomial+[0]*((1<<n)-len(polynomial))
if inverse:
for bit in range(1,n+1):
a=1<<bit-1
x=pow(prim_root,self.mod-1>>bit,self.mod)
U=[1]
for _ in range(a):
U.append(U[-1]*x%self.mod)
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=(polynomial[s]+polynomial[t]*U[j])%self.mod,(polynomial[s]-polynomial[t]*U[j])%self.mod
x=pow((self.mod+1)//2,n,self.mod)
for i in range(1<<n):
polynomial[i]*=x
polynomial[i]%=self.mod
else:
for bit in range(n,0,-1):
a=1<<bit-1
x=pow(prim_root_inve,self.mod-1>>bit,self.mod)
U=[1]
for _ in range(a):
U.append(U[-1]*x%self.mod)
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=(polynomial[s]+polynomial[t])%self.mod,U[j]*(polynomial[s]-polynomial[t])%self.mod
return polynomial
else:
quot=[1/self.polynomial[0]]
def DFT(polynomial,n,inverse=False):
N=len(polynomial)
if inverse:
primitive_root=[math.cos(-i*2*math.pi/(1<<n))+math.sin(-i*2*math.pi/(1<<n))*1j for i in range(1<<n)]
else:
primitive_root=[math.cos(i*2*math.pi/(1<<n))+math.sin(i*2*math.pi/(1<<n))*1j for i in range(1<<n)]
polynomial=polynomial+[0]*((1<<n)-N)
if inverse:
for bit in range(1,n+1):
a=1<<bit-1
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=polynomial[s]+polynomial[t]*primitive_root[j<<n-bit],polynomial[s]-polynomial[t]*primitive_root[j<<n-bit]
for i in range(1<<n):
polynomial[i]=round((polynomial[i]/(1<<n)).real)
else:
for bit in range(n,0,-1):
a=1<<bit-1
for i in range(1<<n-bit):
for j in range(a):
s=i*2*a+j
t=s+a
polynomial[s],polynomial[t]=polynomial[s]+polynomial[t],primitive_root[j<<n-bit]*(polynomial[s]-polynomial[t])
return polynomial
for n in range(self.max_degree.bit_length()):
prev=quot
DFT_prev=DFT(prev,n+1)
if self.mod:
quot=[x*y%self.mod for x,y in zip(DFT_prev,DFT(self.polynomial[:1<<n+1],n+1))]
else:
quot=[x*y for x,y in zip(DFT_prev,DFT(self.polynomial[:1<<n+1],n+1))]
quot=DFT([0]*(1<<n)+DFT(quot,n+1,inverse=True)[1<<n:],n+1)
if self.mod:
quot=[(-x*y)%self.mod for x,y in zip(DFT_prev,quot)]
else:
quot=[-x*y for x,y in zip(DFT_prev,quot)]
quot=prev+DFT(quot,n+1,inverse=True)[1<<n:]
quot=quot[:self.max_degree+1]
quot=Polynomial(quot,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return quot
def log(self):
assert self.max_degree!=-1
assert self.polynomial and abs(self.polynomial[0]-1)<=self.eps
log=self.inverse()
if self.mod:
log=Polynomial(NTT(self.differentiate().polynomial,log.polynomial),max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
log=Polynomial(FFT(self.differentiate().polynomial,log.polynomial),max_degree=self.max_degree,eps=self.eps,mod=self.mod)
log=log.integrate()
return log
def Newton(self,n0,f,differentiated_f=None):
newton=[n0]
while len(newton)<self.max_degree+1:
prev=newton
if differentiated_f==None:
newton=f(prev,self.polynomial)
else:
newton=f(prev)
for i in range(min(len(self.polynomial),len(newton))):
newton[i]-=self.polynomial[i]
newton[i]%=self.mod
if self.mod:
newton=NTT(newton,Polynomial(differentiated_f(prev),max_degree=len(newton)-1,eps=self.eps,mod=self.mod).inverse().polynomial)[:len(newton)]
else:
newton=FFT(newton,Polynomial(differentiated_f(prev),max_degree=len(newton)-1,eps=self.eps,mod=self.mod).inverse().polynomial)[:len(newton)]
for i in range(len(newton)):
newton[i]=-newton[i]
newton[i]%=self.mod
for i in range(len(prev)):
newton[i]+=prev[i]
newton[i]%=self.mod
newton=newton[:self.max_degree+1]
while newton and newton[-1]<=self.eps:
newton.pop()
return Polynomial(newton,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
def sqrt(self):
if self.polynomial:
for cnt0 in range(len(self.polynomial)):
if self.polynomial[cnt0]:
break
if cnt0%2:
sqrt=None
else:
if self.mod:
n0=Tonelli_Shanks(self.polynomial[cnt0],self.mod)
else:
if self.polynomial[cnt0]>=self.eps:
n0=self.polynomial[cnt0]**.5
if n0==None:
sqrt=None
else:
def f(prev):
if self.mod:
return NTT_Pow(prev,2)+[0]
else:
return FFT_Pow(prev,2)+[0]
def differentiated_f(prev):
retu=[0]*(2*len(prev)-1)
for i in range(len(prev)):
retu[i]+=2*prev[i]
if self.mod:
retu[i]%self.mod
return retu
sqrt=[0]*(cnt0//2)+Polynomial(self.polynomial[cnt0:],max_degree=self.max_degree-cnt0//2,mod=self.mod).Newton(n0,f,differentiated_f).polynomial
sqrt=Polynomial(sqrt,max_degree=self.max_degree,eps=self.eps,mod=self.mod)
else:
sqrt=Polynomial([],max_degree=self.max_degree,eps=self.eps,mod=self.mod)
return sqrt
def exp(self):
assert not self.polynomial or abs(self.polynomial[0])<=self.eps
def f(prev,poly):
newton=Polynomial(prev,max_degree=2*len(prev)-1,eps=self.eps,mod=self.mod).log().polynomial
newton+=[0]*(2*len(prev)-len(newton))
for i in range(min(len(poly),len(newton))):
newton[i]-=poly[i]
if self.mod:
for i in range(len(newton)):
newton[i]%=self.mod
if self.mod:
return NTT(prev,newton)[:2*len(prev)]
else:
return FFT(prev,newton)[:2*len(prev)]
return Polynomial(self.polynomial,max_degree=self.max_degree,mod=self.mod).Newton(1,f)
def Degree(self):
return len(self.polynomial)-1
N,M,K=map(int,readline().split())
A=list(map(int,readline().split()))
mod=998244353
MD=MOD(mod)
MD.Build_Fact(2*N)
if K==0:
ans=MD.Comb(N+M-1,2*M-1)*MD.Fact(M-K)%mod
else:
queue=[]
for k in range(K):
A[k]-=1
for k in range(K-1):
poly=[MD.Comb(A[k+1]-A[k]+c,2*c+1) for c in range(A[k+1]-A[k])]
queue.append((len(poly)-1,poly))
if A[0]:
poly=[MD.Comb(A[0]+c,2*c) for c in range(A[0]+1)]
queue.append((len(poly)-1,poly))
if A[K-1]<N-1:
poly=[MD.Comb(N-1-A[K-1]+c,2*c) for c in range(N-A[K-1])]
queue.append((len(poly)-1,poly))
while len(queue)>=2:
le0,poly0=heappop(queue)
le1,poly1=heappop(queue)
heappush(queue,(le0+le1,convolution(poly0,poly1)))
poly=queue[0][1]
ans=poly[M-K]*MD.Fact(M-K)%mod
print(ans)
|
ConDefects/ConDefects/Code/abc225_h/Python/41061041
|
condefects-python_data_337
|
N = int(input())
log_table = [0]*(N+1)
a = 1
cnt = 0
for i in range(1,N+1):
if i == a*2:
a += 2
cnt += 1
log_table[i] = cnt
K = log_table[N]
table = [[-1]*(K+1) for _ in range(N)]
M = 0
for i in range(N):
table[i][0] = M
M += 1
for k in range(1,K+1):
for i in range(N):
if i+(1<<k)-1 >= N:
continue
table[i][k] = M
M += 1
print(M)
for k in range(K+1):
for i in range(N):
if table[i][k] == -1:
continue
l,r = i,i+(1<<k)-1
print(l+1,r+1)
Q = int(input())
for i in range(Q):
l,r = map(int,input().split())
l,r = l-1,r-1
k = log_table[r-l+1]
print(table[l][k]+1,table[r-(1<<k)+1][k]+1)
N = int(input())
log_table = [0]*(N+1)
a = 1
cnt = 0
for i in range(1,N+1):
if i == a*2:
a *= 2
cnt += 1
log_table[i] = cnt
K = log_table[N]
table = [[-1]*(K+1) for _ in range(N)]
M = 0
for i in range(N):
table[i][0] = M
M += 1
for k in range(1,K+1):
for i in range(N):
if i+(1<<k)-1 >= N:
continue
table[i][k] = M
M += 1
print(M)
for k in range(K+1):
for i in range(N):
if table[i][k] == -1:
continue
l,r = i,i+(1<<k)-1
print(l+1,r+1)
Q = int(input())
for i in range(Q):
l,r = map(int,input().split())
l,r = l-1,r-1
k = log_table[r-l+1]
print(table[l][k]+1,table[r-(1<<k)+1][k]+1)
|
ConDefects/ConDefects/Code/abc282_f/Python/45960750
|
condefects-python_data_338
|
import sys
sys.setrecursionlimit(10**8)
N=int(input())
graph=[[] for _ in range(N)]
inf=10**18
for _ in range(N-1):
u,v=map(int,input().split())
graph[u-1].append(v-1)
graph[v-1].append(u-1)
visited=[0 for _ in range(N)]
answers=[[inf,0] for _ in range(N)]
number=1
def dfs(v):
global number
if len(graph[v])==1 and visited[v]:
answers[v]=[number,number]
number+=1
for to in graph[v]:
if visited[to]:
continue
visited[to]=1
dfs(to)
answers[v][0]=min(answers[v][0],answers[to][0])
answers[v][1]=max(answers[v][1],answers[to][1])
visited[0]=1
dfs(0)
for answer in answers:
print(*answer)
import sys
sys.setrecursionlimit(10**8)
N=int(input())
graph=[[] for _ in range(N)]
inf=10**18
for _ in range(N-1):
u,v=map(int,input().split())
graph[u-1].append(v-1)
graph[v-1].append(u-1)
visited=[0 for _ in range(N)]
answers=[[inf,0] for _ in range(N)]
number=1
def dfs(v):
global number
if len(graph[v])==1 and visited[graph[v][0]]:
answers[v]=[number,number]
number+=1
for to in graph[v]:
if visited[to]:
continue
visited[to]=1
dfs(to)
answers[v][0]=min(answers[v][0],answers[to][0])
answers[v][1]=max(answers[v][1],answers[to][1])
visited[0]=1
dfs(0)
for answer in answers:
print(*answer)
|
ConDefects/ConDefects/Code/abc240_e/Python/45982558
|
condefects-python_data_339
|
n,m,*E=map(int,open(0).read().split())
*X,=*D,=C=[0]*2**n
*F,P=1,998244353
while m:m-=1;C[1<<E[m]-1]+=1;D[1<<E[~m]-1]+=1;F+=F[-1]*len(F)%P,
for i in range(1<<n):
j=k=i-1&i;c=C[i]=C[j]+C[i^j];d=D[i]=D[j]+D[i^j];x=F[c]
while j:x-=X[i^j]*F[C[j]];j=j-1&k
X[i]=x*(c==d)%P
print(sum(x*F[c]for x,c in zip(X,C[::-1]))*pow(F[-1],P-2,P)%P)
n,m,*E=map(int,open(0).read().split())
*X,=*D,=C=[0]*2**n
*F,P=1,998244353
while m:m-=1;C[1<<E[m]-1]+=1;D[1<<E[~m]-1]+=1;F+=F[-1]*len(F)%P,
for i in range(1<<n):
j=k=i-1&i;c=C[i]=C[j]+C[i^j];d=D[i]=D[j]+D[i^j];x=F[c]
while j:x-=X[i^j]*F[C[j]];j=j-1&k
X[i]=x*(c==d)%P
print(sum(x*F[c]for x,c in zip(X,C[::-1]))*pow(F[-1],P-2,P)%P-1)
|
ConDefects/ConDefects/Code/abc321_g/Python/45920869
|
condefects-python_data_340
|
n,m,p=map(int,input().split())
count=0
while m<n:
m+=p
count+=1
print(count)
n,m,p=map(int,input().split())
count=0
while m<=n:
m+=p
count+=1
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/45771932
|
condefects-python_data_341
|
#入力
n, m, p = map(int, input().split())
ans = 1
while m <= n:
ans += 1
m += p
print(ans)
#入力
n, m, p = map(int, input().split())
ans = 0
while m <= n:
ans += 1
m += p
print(ans)
|
ConDefects/ConDefects/Code/abc318_a/Python/45742364
|
condefects-python_data_342
|
n,m,p=map(int,input().split())
print((n-m)//p)
n,m,p=map(int,input().split())
print((n-m)//p+1)
|
ConDefects/ConDefects/Code/abc318_a/Python/45804770
|
condefects-python_data_343
|
n,m,p = input().split()
n,m,p = int(n),int(m),int(p)
count = 0
for i in range(n):
temp = m + (i*p)
if (i==temp):
count+=1
print(count)
n,m,p = input().split()
n,m,p = int(n),int(m),int(p)
count = 0
for i in range(n):
temp = m + (i*p)
if (temp<=n):
count+=1
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/45737474
|
condefects-python_data_344
|
N, M, P = map(int, input().split())
count = 0
for i in range(1, N + 1):
if(i == M):
count += 1
M = M + P * count
print(count)
N, M, P = map(int, input().split())
count = 0
for i in range(1, N + 1):
if(i == M):
count += 1
M = M + P
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/46049626
|
condefects-python_data_345
|
# スタックサイズの変更
import sys
sys.setrecursionlimit(10**6)
a, b ,c = map(int, input().split())
if(a-b>0):
print((a-b)//c+1)
else:
print(0)
# スタックサイズの変更
import sys
sys.setrecursionlimit(10**6)
a, b ,c = map(int, input().split())
if(a-b>0):
print((a-b)//c+1)
elif(a==b):
print(1)
else:
print(0)
|
ConDefects/ConDefects/Code/abc318_a/Python/46140133
|
condefects-python_data_346
|
N, M, P = map(int, input().split())
ans = 0
if N > M:
ans += 1 + int((N - M) / P)
print(ans)
N, M, P = map(int, input().split())
ans = 0
if N >= M:
ans += 1 + int((N - M) / P)
print(ans)
|
ConDefects/ConDefects/Code/abc318_a/Python/45733281
|
condefects-python_data_347
|
N,M,P = map(int,input().split())
count = 0
while M < N:
count += 1
M += P
print(count)
N,M,P = map(int,input().split())
count = 0
while M <= N:
count += 1
M += P
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/45771132
|
condefects-python_data_348
|
N,M,P=map(int,input().split())
print((N-M)//P+1 if N>M else 0)
N,M,P=map(int,input().split())
print((N-M)//P+1 if N>=M else 0)
|
ConDefects/ConDefects/Code/abc318_a/Python/45803682
|
condefects-python_data_349
|
moon = list(map(int, input().split()))
N = moon[0]
M = moon[1]
P = moon[2]
count = 0
while M < N:
count = count + 1
M = M + P
print(count)
moon = list(map(int, input().split()))
N = moon[0]
M = moon[1]
P = moon[2]
count = 0
while M <= N:
count = count + 1
M = M + P
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/45807403
|
condefects-python_data_350
|
n, m, p = map(int, input().split())
ans = 0
day = m
for i in range(2*(10**5)):
if day > n:
ans = i
break
day += p
print(ans)
n, m, p = map(int, input().split())
ans = 0
day = m
for i in range(3*(10**5)):
if day > n:
ans = i
break
day += p
print(ans)
|
ConDefects/ConDefects/Code/abc318_a/Python/45920497
|
condefects-python_data_351
|
n, m, p = map(int, input().split())
print((n - m + 1) // p)
n, m, p = map(int, input().split())
print(((n - m + 1) + p - 1) // p)
|
ConDefects/ConDefects/Code/abc318_a/Python/46036999
|
condefects-python_data_352
|
N,M,P = map(int,input().split())
count = 0
while M < N:
M +=P
count+=1
print(count)
N,M,P = map(int,input().split())
count = 0
while M <= N:
M +=P
count+=1
print(count)
|
ConDefects/ConDefects/Code/abc318_a/Python/45773988
|
condefects-python_data_353
|
X,Y = map(int, input().split())
def di(a,b,mod): #b/a ax≡b(mod mod)
d=pow(a,-1,mod)
return b*d%mod
if X==0:
if abs(Y)==1 : print("2 0")
elif abs(Y)==2 : print("1 0")
else : print(-1)
elif Y==0:
if abs(X)==1 : print("0 2")
elif abs(X)==2 : print("0 1")
else : print(-1)
else:
import math
g=math.gcd(X,Y)
if 2<g : print(-1)
else:
X//=g ; Y//=g
ansx=di(Y,2//g,X)
ansy=(ansx*Y-2)//X
print(ansx,ansy)
X,Y = map(int, input().split())
def di(a,b,mod): #b/a ax≡b(mod mod)
d=pow(a,-1,mod)
return b*d%mod
if X==0:
if abs(Y)==1 : print("2 0")
elif abs(Y)==2 : print("1 0")
else : print(-1)
elif Y==0:
if abs(X)==1 : print("0 2")
elif abs(X)==2 : print("0 1")
else : print(-1)
else:
import math
g=math.gcd(X,Y)
if 2<g : print(-1)
else:
X//=g ; Y//=g
ansx=di(Y,2//g,X)
ansy=(ansx*Y-2//g)//X
print(ansx,ansy)
|
ConDefects/ConDefects/Code/abc340_f/Python/52406082
|
condefects-python_data_354
|
def extgcd(a,b,c):
if a==0:
if b==0 or c%b:return (0,0,0)
else:return(1,0,c//b)
if b==0:
if a==0 or c%a:return(0,0,0)
else:return(1,c//a,0)
if b<0:
a=-a
b=-b
c=-c
x1,y1=a%b,c%b
x2,y2=b-x1,b-y1
if x1<x2:
x1,x2=x2,x1
y1,y2=y2,y1
while x2:x1,y1,x2,y2=x2,y2,x1%x2,(y1-y2*(x1//x2))%b
if (c-a*y1//x1)%b:return (0,0,0)
return (1,y1//x1,(c-a*y1//x1)//b)
x,y=map(int,input().split())
f,a,b=extgcd(x,-y,2)
assert max(abs(a),abs(b))<=10**18
if f:print(b,a)
else:print(-1)
def extgcd(a,b,c):
if a==0:
if b==0 or c%b:return (0,0,0)
else:return(1,0,c//b)
if b==0:
if a==0 or c%a:return(0,0,0)
else:return(1,c//a,0)
if b<0:
a=-a
b=-b
c=-c
x1,y1=a%b,c%b
x2,y2=b-x1,b-y1
if x1<x2:
x1,x2=x2,x1
y1,y2=y2,y1
while x2:x1,y1,x2,y2=x2,y2,x1%x2,(y1-y2*(x1//x2))%b
if y1%x1:return (0,0,0)
return (1,y1//x1,(c-a*y1//x1)//b)
x,y=map(int,input().split())
f,a,b=extgcd(x,-y,2)
assert max(abs(a),abs(b))<=10**18
if f:print(b,a)
else:print(-1)
|
ConDefects/ConDefects/Code/abc340_f/Python/53251643
|
condefects-python_data_355
|
def extended_euclid(a, b):
c, d, e, f = 1, 0, 0, 1
while b != 0:
c, d = d, c - a // b * d
e, f = f, e - a // b * f
a, b = b, a % b
return (c, e)
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
X,Y=list(map(int,input().split()))
if X==0:
if abs(Y)==1 or abs(Y)==2:
print(2//abs(Y),0)
else:
print(-1)
elif Y==0:
if abs(X)==1 or abs(X)==2:
print(0,2//abs(X))
else:
print(-1)
elif gcd(abs(X),abs(Y))>2:
print(-1)
else:
a,b=extended_euclid(X,-Y)
print(2*b,2*a)
def extended_euclid(a, b):
c, d, e, f = 1, 0, 0, 1
while b != 0:
c, d = d, c - a // b * d
e, f = f, e - a // b * f
a, b = b, a % b
return (c, e)
def gcd(a,b):
if a%b==0:
return b
else:
return gcd(b,a%b)
X,Y=list(map(int,input().split()))
if X==0:
if abs(Y)==1 or abs(Y)==2:
print(2//abs(Y),0)
else:
print(-1)
elif Y==0:
if abs(X)==1 or abs(X)==2:
print(0,2//abs(X))
else:
print(-1)
elif gcd(abs(X),abs(Y))>2:
print(-1)
else:
a,b=extended_euclid(X,-Y)
print((2*b)//gcd(abs(X),abs(Y)),(2*a)//gcd(abs(X),abs(Y)))
|
ConDefects/ConDefects/Code/abc340_f/Python/52511513
|
condefects-python_data_356
|
def extended_gcd(a, b):
"""拡張ユークリッドの互除法を使用して ax + by = gcd(a, b) の解を求める"""
if a == 0:
return b, 0, 1
gcd, x1, y1 = extended_gcd(b % a, a)
x = y1 - (b // a) * x1
y = x1
return gcd, x, y
def find_integer_solution(X, Y):
gcd, A, B = extended_gcd(X, Y)
if 2 % gcd != 0:
return None # 解なし
factor = 2 // gcd
A *= factor
B *= factor
return A, -B # Yの係数が -B になるように調整
# 例として X=1, Y=2 を与える
X,Y = list(map(int,input().split()))
solution = find_integer_solution(X, Y)
if solution:
A, B = solution
print(A,B)
else:
print(-1)
def extended_gcd(a, b):
"""拡張ユークリッドの互除法を使用して ax + by = gcd(a, b) の解を求める"""
if a == 0:
return b, 0, 1
gcd, x1, y1 = extended_gcd(b % a, a)
x = y1 - (b // a) * x1
y = x1
return gcd, x, y
def find_integer_solution(X, Y):
gcd, A, B = extended_gcd(X, Y)
if 2 % gcd != 0:
return None # 解なし
factor = 2 // gcd
A *= factor
B *= factor
return A, -B # Yの係数が -B になるように調整
# 例として X=1, Y=2 を与える
X,Y = list(map(int,input().split()))
solution = find_integer_solution(X, Y)
if solution:
A, B = solution
print(B,A)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc340_f/Python/55112719
|
condefects-python_data_357
|
def tridiv(n):
pf, f = dict(), 2
while f*f<=n:
if n%f == 0 :
if f not in pf : pf[f]=0
pf[f]+=1
n//=f
else : f = f+2 if f>2 else 3
if n>1 :
if n not in pf : pf[n]=0
pf[n]+=1
return [k**v for k,v in pf.items()]
mod = 998244353
N,M = map(int,input().split())
A = [*map(int,input().split())]
d = tridiv(M)
K = len(d)
cnt = [0]*(1<<K)
for n in range(N):
if M%A[n] : continue
cnt[sum(int(A[n]%d[k]==0)*(1<<k) for k in range(K))] += 1
dp = [0 for n in range(1<<K)]
dp[0] = 1
p2 = [pow(2,k,mod) for k in range(max(cnt)+1)]
for i in range(1<<K):
ndp = [0 for n in range(1<<K)]
for j in range(1<<K):
ndp[j] += dp[j]
ndp[j] %= mod
ndp[i|j] += dp[j]*(p2[cnt[i]]-1)
ndp[i|j] %= mod
dp = ndp
print(dp[(1<<K)-1])
def tridiv(n):
pf, f = dict(), 2
while f*f<=n:
if n%f == 0 :
if f not in pf : pf[f]=0
pf[f]+=1
n//=f
else : f = f+2 if f>2 else 3
if n>1 :
if n not in pf : pf[n]=0
pf[n]+=1
return [k**v for k,v in pf.items()]
mod = 998244353
N,M = map(int,input().split())
A = [*map(int,input().split())]
d = tridiv(M)
K = len(d)
cnt = [0]*(1<<K)
for n in range(N):
if M%A[n] : continue
cnt[sum(int(A[n]%d[k]==0)*(1<<k) for k in range(K))] += 1
dp = [0 for n in range(1<<K)]
dp[0] = 1
p2 = [pow(2,k,mod) for k in range(max(cnt)+1)]
for i in range(1<<K):
ndp = [0 for n in range(1<<K)]
for j in range(1<<K):
ndp[j] += dp[j]
ndp[j] %= mod
ndp[i|j] += dp[j]*(p2[cnt[i]]-1)
ndp[i|j] %= mod
dp = ndp
print(dp[(1<<K)-1]) if M>1 else print((dp[(1<<K)-1]-1)%mod)
|
ConDefects/ConDefects/Code/abc349_f/Python/53462819
|
condefects-python_data_358
|
S = list(input())
L = len(S)
count = [0] * 26
flag = False
for i in range(L):
count[ord(S[i]) - ord('a')] += 1
ans = 0
for i in range(25):
for j in range(i+1, 26):
ans += count[i] * count[j]
if count[i] > 1:
flag = True
if flag:
ans += 1
print(ans)
S = list(input())
L = len(S)
count = [0] * 26
flag = False
for i in range(L):
count[ord(S[i]) - ord('a')] += 1
ans = 0
for i in range(25):
for j in range(i+1, 26):
ans += count[i] * count[j]
if count[i] > 1 or count[j] > 1:
flag = True
if flag:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc345_c/Python/54753666
|
condefects-python_data_359
|
N=int(input())
cnt=[0]*3
div=[2,3,5]
for i in range(3):
x=div[i]
while True:
if N%x:
break
cnt[i]+=1
N//=x
if N>1:
print(0)
else:
a,b,c=cnt
dp=[[[0]*(c+1) for j in range(b+1)] for i in range(a+1)]
mod=998244353
dp[0][0][0]=1
inv=pow(5,mod-2,mod)
for i in range(a+1):
for j in range(b+1):
for k in range(c+1):
dp[i][j][k]%=mod
if i+1<=a:
dp[i+1][j][k]+=dp[i][j][k]*inv%mod
if j+1<=b:
dp[i][j+1][k]+=dp[i][j][k]*inv%mod
if i+2<=a:
dp[i+2][j][k]+=dp[i][j][k]*inv%mod
if k+1<=c:
dp[i][j][k+1]=dp[i][j][k]*inv%mod
if i+1<=a and j+1<=b:
dp[i+1][j+1][k]+=dp[i][j][k]*inv%mod
print(dp[a][b][c])
N=int(input())
cnt=[0]*3
div=[2,3,5]
for i in range(3):
x=div[i]
while True:
if N%x:
break
cnt[i]+=1
N//=x
if N>1:
print(0)
else:
a,b,c=cnt
dp=[[[0]*(c+1) for j in range(b+1)] for i in range(a+1)]
mod=998244353
dp[0][0][0]=1
inv=pow(5,mod-2,mod)
for i in range(a+1):
for j in range(b+1):
for k in range(c+1):
dp[i][j][k]%=mod
if i+1<=a:
dp[i+1][j][k]+=dp[i][j][k]*inv%mod
if j+1<=b:
dp[i][j+1][k]+=dp[i][j][k]*inv%mod
if i+2<=a:
dp[i+2][j][k]+=dp[i][j][k]*inv%mod
if k+1<=c:
dp[i][j][k+1]+=dp[i][j][k]*inv%mod
if i+1<=a and j+1<=b:
dp[i+1][j+1][k]+=dp[i][j][k]*inv%mod
print(dp[a][b][c])
|
ConDefects/ConDefects/Code/abc300_e/Python/45250612
|
condefects-python_data_360
|
def ezpow(a, b):
c = 1
for i in range(b):
c = c * a
return c
class PowMod:
def __init__(self, A, m=998244353):
self.memory = {}
self.A = A
self.m = m
def pow(self, b):
if (b == 0):
return 1
if (b == 1):
return self.A
if (b in self.memory):
return self.memory[b]
m = self.m
bdiv2 = b//2
lf = self.pow(bdiv2)
rg = self.pow(b-bdiv2)
self.memory[b] = ((lf % m) * (rg % m)) % m
return ((lf % m) * (rg % m)) % m
def reciprocalMod(a, p=998244353):
# a**(p-2)を返す。a と p は互いに素であるのが普通。そうでないと答えが出ない可能性が大きい。
powMod = PowMod(a, p)
return powMod.pow(p-2)
N = int(input())
# N を 2, 3, 5で割って割り切れなければ当然確率は0。
# まず素因数を求める。
curN = N
factors = {2: 0, 3: 0, 5: 0}
while (True):
if (curN == 1):
break
divided = False
for p in [2, 3, 5]:
if (curN % p == 0):
curN /= p
factors[p] += 1
divided = True
break
if (not divided):
print(0)
exit()
#X,Y,Zは2,3,5の指数。
# スタート地点は1(x,y,z=0,0,0)。
# そこから1/5の確率で、x+=1, y+=1, x+=2, z+=1, x,y+=1 と遷移する。
# x,y,zどれか1つでもオーバーしていたらそれ以降の確率は0なので計算しなくてよい。
# 小さい順から取り出して調べていけば、正常に値を計算できる。
# /5は、 5の 逆数をmod BIGPRIMEで掛けるという動作で正しく計算できる（ABC297-Eより)
# x2の場合: dp[x+1][y][z] = dp[x][y][z] / 5 = dp[x][y][z] * mod.reciprocalMod(5) if x+1 <= X else 0
# 結局、データ量は (X-1)(Y-1)(Z-1)個使い、N <= 10^18なので Xは10^6レベル、よってXの数は20くらい。最大は20^3となるので8000くらい。
# DPの数的にメモリ・計算量ともに制約を満たす。
# 求めるのは、dp[X][Y][Z]
# 入れる順番は、予めXYZで3重ループしてlistを作っておく。
X = factors[2]
Y = factors[3]
Z = factors[5]
BIGPRIME = 998244353
recip5 = reciprocalMod(5, BIGPRIME)
order = [] # 0 ～ XYZまでを小さい順で並べる。すると後から前の値を更新ということが起こらない。
for x in range(X+1):
for y in range(Y+1):
for z in range(Z+1):
order.append((ezpow(2, x) * ezpow(3, y) * ezpow(5, z), x, y, z))
order.sort()
dp = [[[0 for _ in range(Z+1)] for _ in range(Y+1)] for _ in range(X+1)]
dp[0][0][0] = 1
#print(factors)
#print(order)
for num, x, y, z in order:
if (x + 1 <= X): # 2
dp[x+1][y][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (x + 2 <= X): # 4
dp[x+2][y][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (x + 1 <= X and y + 1 <= Y): # 6
dp[x+1][y+1][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (y + 1 <= Y): # 3
dp[x][y+1][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (z + 1 <= Z): # 5
dp[x][y][z+1] += (dp[x][y][z] * recip5) % BIGPRIME
print(dp[X][Y][Z] % BIGPRIME)
def ezpow(a, b):
c = 1
for i in range(b):
c = c * a
return c
class PowMod:
def __init__(self, A, m=998244353):
self.memory = {}
self.A = A
self.m = m
def pow(self, b):
if (b == 0):
return 1
if (b == 1):
return self.A
if (b in self.memory):
return self.memory[b]
m = self.m
bdiv2 = b//2
lf = self.pow(bdiv2)
rg = self.pow(b-bdiv2)
self.memory[b] = ((lf % m) * (rg % m)) % m
return ((lf % m) * (rg % m)) % m
def reciprocalMod(a, p=998244353):
# a**(p-2)を返す。a と p は互いに素であるのが普通。そうでないと答えが出ない可能性が大きい。
powMod = PowMod(a, p)
return powMod.pow(p-2)
N = int(input())
# N を 2, 3, 5で割って割り切れなければ当然確率は0。
# まず素因数を求める。
curN = N
factors = {2: 0, 3: 0, 5: 0}
while (True):
if (curN == 1):
break
divided = False
for p in [2, 3, 5]:
if (curN % p == 0):
curN //= p
factors[p] += 1
divided = True
break
if (not divided):
print(0)
exit()
#X,Y,Zは2,3,5の指数。
# スタート地点は1(x,y,z=0,0,0)。
# そこから1/5の確率で、x+=1, y+=1, x+=2, z+=1, x,y+=1 と遷移する。
# x,y,zどれか1つでもオーバーしていたらそれ以降の確率は0なので計算しなくてよい。
# 小さい順から取り出して調べていけば、正常に値を計算できる。
# /5は、 5の 逆数をmod BIGPRIMEで掛けるという動作で正しく計算できる（ABC297-Eより)
# x2の場合: dp[x+1][y][z] = dp[x][y][z] / 5 = dp[x][y][z] * mod.reciprocalMod(5) if x+1 <= X else 0
# 結局、データ量は (X-1)(Y-1)(Z-1)個使い、N <= 10^18なので Xは10^6レベル、よってXの数は20くらい。最大は20^3となるので8000くらい。
# DPの数的にメモリ・計算量ともに制約を満たす。
# 求めるのは、dp[X][Y][Z]
# 入れる順番は、予めXYZで3重ループしてlistを作っておく。
X = factors[2]
Y = factors[3]
Z = factors[5]
BIGPRIME = 998244353
recip5 = reciprocalMod(5, BIGPRIME)
order = [] # 0 ～ XYZまでを小さい順で並べる。すると後から前の値を更新ということが起こらない。
for x in range(X+1):
for y in range(Y+1):
for z in range(Z+1):
order.append((ezpow(2, x) * ezpow(3, y) * ezpow(5, z), x, y, z))
order.sort()
dp = [[[0 for _ in range(Z+1)] for _ in range(Y+1)] for _ in range(X+1)]
dp[0][0][0] = 1
#print(factors)
#print(order)
for num, x, y, z in order:
if (x + 1 <= X): # 2
dp[x+1][y][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (x + 2 <= X): # 4
dp[x+2][y][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (x + 1 <= X and y + 1 <= Y): # 6
dp[x+1][y+1][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (y + 1 <= Y): # 3
dp[x][y+1][z] += (dp[x][y][z] * recip5) % BIGPRIME
if (z + 1 <= Z): # 5
dp[x][y][z+1] += (dp[x][y][z] * recip5) % BIGPRIME
print(dp[X][Y][Z] % BIGPRIME)
|
ConDefects/ConDefects/Code/abc300_e/Python/45218169
|
condefects-python_data_361
|
N, M = map(int, input().split())
graph = [[] for _ in range(N+M+1)]
for i in range(N):
A = int(input())
S = set(map(int, input().split()))
for j in S:
graph[j].append(i+M+1)
graph[i+M+1].append(j)
from collections import deque
q = deque([])
q.append(1)
D = [1<<61] * (N+M+1)
D[1] = 0
while q:
u = q.popleft()
d = D[u]
for v in graph[u]:
if D[v] <= d + 1:
continue
if v == N + M:
print(d//2)
exit()
D[v] = d + 1
q.append(v)
print(-1)
N, M = map(int, input().split())
graph = [[] for _ in range(N+M+1)]
for i in range(N):
A = int(input())
S = set(map(int, input().split()))
for j in S:
graph[j].append(i+M+1)
graph[i+M+1].append(j)
from collections import deque
q = deque([])
q.append(1)
D = [1<<61] * (N+M+1)
D[1] = 0
while q:
u = q.popleft()
d = D[u]
for v in graph[u]:
if D[v] <= d + 1:
continue
if v == M:
print(d//2)
exit()
D[v] = d + 1
q.append(v)
print(-1)
|
ConDefects/ConDefects/Code/abc302_f/Python/45576163
|
condefects-python_data_362
|
import math
import numpy
N,M = input().split()
N = int(N)
K = int(M)
#print(N+K)
list1 = list(map(int, input().split()))
list2 = []
counter1 = 0
counter2 = 0
counter3 = 0
counter4 = 0
counter5 = 0
#print(list1)
for a in range(N-1):
if list1[a] <= list1[a+1]:
counter1 += 1
counter2 = max(counter1, counter2)
else:
counter1 = 0
if counter2+1 >= K:
for b in range(N):
print(list1[b], end = " ")
else:
"""for c in range(1, K+1):
#比較する cの時、N-K-c+2からN-cの最小値とN-K-c+1の値を比較。後者が最小値以下なら1個ずらせる。ずらせなくなるまでやる。
if c == 1:#特別な処理、最小値比較
for d in range(N-K-c+1, N-c):
if list1[N-K-c] > list1[d]:#ずらせない
counter3 = 1
if counter3 == 1:#１個ずらせない場合
counter4 = 0#ずらせる個数カウント
break
else:#一個ずらせる
counter4 += 1
#全部通過してc=2のループに入るやつは１個ずらせるやつ
else:#c>=2の処理
if list1[N-K-c] > list1[N-K-c+1]:#ずれせない場合
break
else:
counter4 += 1
#この時点でcounter4にいくらずらせるかの情報が入っているはず
#print(counter4)←確認用"""
for c in range(K-1):
if list1[N-K-c] >= list1[N-K-c-1]:#昇順連続記録を調べる
counter3 += 1
else:
break
#この時点でcounter3に連続昇順記録-1の値が入ってるはず
print(counter3)
for g in range(N-K, N-counter3):
if list1[N-K-1] > list1[g]:#list1[N-K]が最小値でない場合
counter5 = 1
if counter5 == 1:#リストの一番最後の身を入れ替える。
counter4 = 0
elif counter5 == 0:
counter4 = counter3
else:
print("エラー")
for d in range(K):
list2.append(list1[N-K-counter4+d])
#print(list2)
sorted_list2 = numpy.sort(list2, axis=-1, kind='quicksort', order=None)
#print(sorted_list2)
for e in range(K):
list1[N-K-counter4+e] = sorted_list2[e]
for f in range(N):
print(list1[f], end = " ")
import math
import numpy
N,M = input().split()
N = int(N)
K = int(M)
#print(N+K)
list1 = list(map(int, input().split()))
list2 = []
counter1 = 0
counter2 = 0
counter3 = 0
counter4 = 0
counter5 = 0
#print(list1)
for a in range(N-1):
if list1[a] <= list1[a+1]:
counter1 += 1
counter2 = max(counter1, counter2)
else:
counter1 = 0
if counter2+1 >= K:
for b in range(N):
print(list1[b], end = " ")
else:
"""for c in range(1, K+1):
#比較する cの時、N-K-c+2からN-cの最小値とN-K-c+1の値を比較。後者が最小値以下なら1個ずらせる。ずらせなくなるまでやる。
if c == 1:#特別な処理、最小値比較
for d in range(N-K-c+1, N-c):
if list1[N-K-c] > list1[d]:#ずらせない
counter3 = 1
if counter3 == 1:#１個ずらせない場合
counter4 = 0#ずらせる個数カウント
break
else:#一個ずらせる
counter4 += 1
#全部通過してc=2のループに入るやつは１個ずらせるやつ
else:#c>=2の処理
if list1[N-K-c] > list1[N-K-c+1]:#ずれせない場合
break
else:
counter4 += 1
#この時点でcounter4にいくらずらせるかの情報が入っているはず
#print(counter4)←確認用"""
for c in range(K-1):
if list1[N-K-c] >= list1[N-K-c-1]:#昇順連続記録を調べる
counter3 += 1
else:
break
#この時点でcounter3に連続昇順記録-1の値が入ってるはず
#print(counter3)
for g in range(N-K, N-counter3):
if list1[N-K-1] > list1[g]:#list1[N-K]が最小値でない場合
counter5 = 1
if counter5 == 1:#リストの一番最後の身を入れ替える。
counter4 = 0
elif counter5 == 0:
counter4 = counter3
else:
print("エラー")
for d in range(K):
list2.append(list1[N-K-counter4+d])
#print(list2)
sorted_list2 = numpy.sort(list2, axis=-1, kind='quicksort', order=None)
#print(sorted_list2)
for e in range(K):
list1[N-K-counter4+e] = sorted_list2[e]
for f in range(N):
print(list1[f], end = " ")
|
ConDefects/ConDefects/Code/arc165_b/Python/45995987
|
condefects-python_data_363
|
import sys
input = sys.stdin.readline
from random import randint
N,M,K=map(int,input().split())
if N<=K<=N*M and K%2==N%2:
print("Yes")
else:
print("No")
exit()
ANS=[["+"]*(2*M+1) for i in range(2*N+1)]
for i in range(1,2*N):
for j in range(1,2*M):
if i%2==1 and j%2==1:
ANS[i][j]="o"
elif i%2==1:
ANS[i][j]="|"
elif j%2==1:
ANS[i][j]="-"
ANS[0][-2]="S"
ANS[-1][-2]="G"
x=1
y=2*M-2
K-=N
while True:
#for ans in ANS:
# print("".join(ans))
#print("...",x,y)
if K>=2:
if x!=2*N-1:
ANS[x][y]="."
ANS[x+2][y]="."
K-=2
y-=2
else:
K-=2
ANS[x-1][y]="."
ANS[x-1][y+2]="."
ANS[x-2][y+1]="|"
ANS[x][y+1]="."
y+=4
#for ans in ANS:
# print("".join(ans))
#print(x,y,K)
if K==0:
#print(x,y)
ANS[x+1][y+1]="."
if y==2*M-2:
for i in range(x+1,2*N,2):
ANS[i][-2]="."
else:
for i in range(x+3,2*N,2):
ANS[i][-2]="."
break
else:
if y==0:
ANS[x+1][y+1]="."
ANS[x+3][-2]="."
x+=4
if x!=2*N-1:
y=2*M-2
else:
y=1
for ans in ANS:
print("".join(ans))
import sys
input = sys.stdin.readline
from random import randint
N,M,K=map(int,input().split())
if N<=K<=N*M and K%2==N%2:
print("Yes")
else:
print("No")
exit()
ANS=[["+"]*(2*M+1) for i in range(2*N+1)]
for i in range(1,2*N):
for j in range(1,2*M):
if i%2==1 and j%2==1:
ANS[i][j]="o"
elif i%2==1:
ANS[i][j]="|"
elif j%2==1:
ANS[i][j]="-"
ANS[0][-2]="S"
ANS[-1][-2]="G"
x=1
y=2*M-2
K-=N
while True:
#for ans in ANS:
# print("".join(ans))
#print("...",x,y)
if K>=2:
if x!=2*N-1:
ANS[x][y]="."
ANS[x+2][y]="."
K-=2
y-=2
else:
K-=2
ANS[x-1][y]="."
ANS[x-1][y+2]="."
ANS[x-2][y+1]="|"
ANS[x][y+1]="."
y+=4
#for ans in ANS:
# print("".join(ans))
#print(x,y,K)
if K==0:
if x==2*N-1:
break
#print(x,y)
ANS[x+1][y+1]="."
if y==2*M-2:
for i in range(x+1,2*N,2):
ANS[i][-2]="."
else:
for i in range(x+3,2*N,2):
ANS[i][-2]="."
break
else:
if y==0:
ANS[x+1][y+1]="."
ANS[x+3][-2]="."
x+=4
if x!=2*N-1:
y=2*M-2
else:
y=1
for ans in ANS:
print("".join(ans))
|
ConDefects/ConDefects/Code/abc358_f/Python/54701655
|
condefects-python_data_364
|
def create_end_wall(hall):
return "+" * (2 * M - 1) + hall + "+"
def create_road(walls):
if isinstance(walls, int):
walls = [walls]
walls = set(map(lambda x: M - x - 2, walls))
ret = ["+o"]
for x in range(M - 1):
if x in walls:
ret.append("|")
else:
ret.append(".")
ret.append("o")
ret.append("+")
return "".join(ret)
def create_wall(roads):
if isinstance(roads, int):
roads = [roads]
roads = set(map(lambda x: M - x - 1, roads))
ret = ["+"]
for x in range(M):
if x in roads:
ret.append(".")
else:
ret.append("-")
ret.append("+")
return "".join(ret)
N, M, K = map(int, input().split())
if N % 2 != K % 2 or N * M < K or K < N:
print("No")
exit()
if N * M > K + 2:
K += 2
print("Yes")
remain = K - N
answer = [create_end_wall("S")]
if N % 2 == 0 or (N * M - M + 1) >= K:
remain //= 2
div, mod = 0, 0
if M - 1 > 0:
div, mod = remain // (M - 1), remain % (M - 1)
for _ in range(div):
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
answer.append(create_road(-1))
answer.append(create_wall(0))
if mod:
answer.append(create_road(mod))
answer.append(create_wall(mod))
answer.append(create_road(mod))
answer.append(create_wall(0))
while len(answer) < N * 2 + 1:
answer.append(create_road(0))
answer.append(create_wall(0))
answer[-1] = create_end_wall("G")
else:
for i in range(N // 2 - 1):
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
answer.append(create_road(-1))
answer.append(create_wall(0))
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
remain = K - (N - 2) * M - M
top = True
top_walls = []
halls = []
bottom_walls = []
idx = M - 2
for _ in range(remain):
if top:
top_walls.append(idx)
else:
bottom_walls.append(idx)
halls.append(idx + 1)
idx -= 1
top = not top
answer.append(create_road(top_walls))
answer.append(create_wall(halls))
answer.append(create_road(bottom_walls))
answer.append(create_end_wall("G"))
for ans in answer:
print(ans)
def create_end_wall(hall):
return "+" * (2 * M - 1) + hall + "+"
def create_road(walls):
if isinstance(walls, int):
walls = [walls]
walls = set(map(lambda x: M - x - 2, walls))
ret = ["+o"]
for x in range(M - 1):
if x in walls:
ret.append("|")
else:
ret.append(".")
ret.append("o")
ret.append("+")
return "".join(ret)
def create_wall(roads):
if isinstance(roads, int):
roads = [roads]
roads = set(map(lambda x: M - x - 1, roads))
ret = ["+"]
for x in range(M):
if x in roads:
ret.append(".")
else:
ret.append("-")
ret.append("+")
return "".join(ret)
N, M, K = map(int, input().split())
if N % 2 != K % 2 or N * M < K or K < N:
print("No")
exit()
print("Yes")
remain = K - N
answer = [create_end_wall("S")]
if N % 2 == 0 or (N * M - M + 1) >= K:
remain //= 2
div, mod = 0, 0
if M - 1 > 0:
div, mod = remain // (M - 1), remain % (M - 1)
for _ in range(div):
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
answer.append(create_road(-1))
answer.append(create_wall(0))
if mod:
answer.append(create_road(mod))
answer.append(create_wall(mod))
answer.append(create_road(mod))
answer.append(create_wall(0))
while len(answer) < N * 2 + 1:
answer.append(create_road(0))
answer.append(create_wall(0))
answer[-1] = create_end_wall("G")
else:
for i in range(N // 2 - 1):
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
answer.append(create_road(-1))
answer.append(create_wall(0))
answer.append(create_road(-1))
answer.append(create_wall(M - 1))
remain = K - (N - 2) * M - M
top = True
top_walls = []
halls = []
bottom_walls = []
idx = M - 2
for _ in range(remain):
if top:
top_walls.append(idx)
else:
bottom_walls.append(idx)
halls.append(idx + 1)
idx -= 1
top = not top
answer.append(create_road(top_walls))
answer.append(create_wall(halls))
answer.append(create_road(bottom_walls))
answer.append(create_end_wall("G"))
for ans in answer:
print(ans)
|
ConDefects/ConDefects/Code/abc358_f/Python/54691582
|
condefects-python_data_365
|
n = int(input())
a = sorted(list(map(int, input().split())))
avg = sum(a) // n
extra = sum(a) % n
ans = 0
avg_list = [avg if i<extra else avg+1 for i in range(n)]
for i in range(n):
ans += abs(a[i] - avg_list[i])
print(ans // 2)
n = int(input())
a = sorted(list(map(int, input().split())))
avg = sum(a) // n
extra = sum(a) % n
ans = 0
avg_list = [avg if i<n-extra else avg+1 for i in range(n)]
for i in range(n):
ans += abs(a[i] - avg_list[i])
print(ans // 2)
|
ConDefects/ConDefects/Code/abc313_c/Python/45773299
|
condefects-python_data_366
|
MOD = 998244353
N = int(input())
ans = pow(1, N, MOD)
for i in range(N+2, N*2+1):
ans *= i
ans %= MOD
print(ans)
MOD = 998244353
N = int(input())
ans = pow(2, N, MOD)
for i in range(N+2, N*2+1):
ans *= i
ans %= MOD
print(ans)
|
ConDefects/ConDefects/Code/arc145_c/Python/40098177
|
condefects-python_data_367
|
import sys
#input = sys.stdin.readline
#input = sys.stdin.buffer.readline #文字列はダメ
#sys.setrecursionlimit(1000000)
#import math
#import bisect
#import itertools
#import random
#from heapq import heapify, heappop, heappush
#from collections import defaultdict
#from collections import deque
#import copy #DeepCopy: hoge = [_[:] for _ in hogehoge]
#from functools import lru_cache
#@lru_cache(maxsize=None)
#MOD = pow(10,9) + 7
MOD = 998244353
#dx = [1,0,-1,0]
#dy = [0,1,0,-1]
#dx8 = [1,1,0,-1,-1,-1,0,1]
#dy8 = [0,1,1,1,0,-1,-1,-1]
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
ret = fac[n] * finv[r] % p
ret = ret * finv[n-r] % p
return ret
def cmb_inv(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
ret = fac[n-r] * fac[r] % p
ret = ret * finv[n] % p
return ret
def perm(n,r,p):
if (r < 0) or (n < r):
return 0
return fac[n]*finv[n-r]%p
n = 5*pow(10,5) + 100
#MODは自分で入れよう！
fac = [-1]*(n+1); fac[0] = 1; fac[1] = 1 #階乗
finv = [-1]*(n+1); finv[0] = 1; finv[1] = 1 #階乗の逆元
inv = [-1]*(n+1); inv[0] = 0; inv[1] = 1 #逆元
for i in range(2,n+1):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def main():
N = int(input())
if N == 1:
print(1);exit()
ans = 1
for i in range(1,N+1):
ans *= 2*i
ans %= MOD
# print(ans)
x = N-2
f = 0
for i in range(x+1):
val = N-i
num = cmb(x+i,i,MOD) - cmb(x+i,i-1,MOD)
# print(val,num)
temp = val * num%MOD
f += temp
f %= MOD
ans = (ans*f)%MOD
print(ans)
if __name__ == '__main__':
main()
import sys
#input = sys.stdin.readline
#input = sys.stdin.buffer.readline #文字列はダメ
#sys.setrecursionlimit(1000000)
#import math
#import bisect
#import itertools
#import random
#from heapq import heapify, heappop, heappush
#from collections import defaultdict
#from collections import deque
#import copy #DeepCopy: hoge = [_[:] for _ in hogehoge]
#from functools import lru_cache
#@lru_cache(maxsize=None)
#MOD = pow(10,9) + 7
MOD = 998244353
#dx = [1,0,-1,0]
#dy = [0,1,0,-1]
#dx8 = [1,1,0,-1,-1,-1,0,1]
#dy8 = [0,1,1,1,0,-1,-1,-1]
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
ret = fac[n] * finv[r] % p
ret = ret * finv[n-r] % p
return ret
def cmb_inv(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
ret = fac[n-r] * fac[r] % p
ret = ret * finv[n] % p
return ret
def perm(n,r,p):
if (r < 0) or (n < r):
return 0
return fac[n]*finv[n-r]%p
n = 5*pow(10,5) + 100
#MODは自分で入れよう！
fac = [-1]*(n+1); fac[0] = 1; fac[1] = 1 #階乗
finv = [-1]*(n+1); finv[0] = 1; finv[1] = 1 #階乗の逆元
inv = [-1]*(n+1); inv[0] = 0; inv[1] = 1 #逆元
for i in range(2,n+1):
fac[i] = fac[i-1]*i%MOD
inv[i] = MOD - inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def main():
N = int(input())
if N == 1:
print(2);exit()
ans = 1
for i in range(1,N+1):
ans *= 2*i
ans %= MOD
# print(ans)
x = N-2
f = 0
for i in range(x+1):
val = N-i
num = cmb(x+i,i,MOD) - cmb(x+i,i-1,MOD)
# print(val,num)
temp = val * num%MOD
f += temp
f %= MOD
ans = (ans*f)%MOD
print(ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc145_c/Python/34717448
|
condefects-python_data_368
|
h,w = list(map(int,input().split(' ')))
b = [[0 for j in range(h)] for i in range(w)]
for i in range(h):
tmp = list(map(int,input().split(' ')))
for j in range(w):
b[j][h-1-i] = tmp[j]
for b_ in b:
print(*b_)
h,w = list(map(int,input().split(' ')))
b = [[0 for j in range(h)] for i in range(w)]
for i in range(h):
tmp = list(map(int,input().split(' ')))
for j in range(w):
b[j][i] = tmp[j]
for b_ in b:
print(*b_)
|
ConDefects/ConDefects/Code/abc237_b/Python/52801286
|
condefects-python_data_369
|
from collections import defaultdict
N, M = map(int, input().split())
A = list(map(int, input().split()))
idx = defaultdict(list)
for i in range(N - 1, -1, -1):
idx[A[i]].append(i)
used = set()
ans = []
for a in A:
if a in used:
continue
while ans and ans[-1] > a and idx[ans[-1]]:
used.discard(ans.pop())
ans.append(a)
used.add(a)
idx[a].pop()
print(*ans)
from collections import defaultdict
N, M = map(int, input().split())
A = list(map(int, input().split()))
idx = defaultdict(list)
for i in range(N - 1, -1, -1):
idx[A[i]].append(i)
used = set()
ans = []
for a in A:
idx[a].pop()
if a in used:
continue
while ans and ans[-1] > a and idx[ans[-1]]:
used.discard(ans.pop())
ans.append(a)
used.add(a)
print(*ans)
|
ConDefects/ConDefects/Code/abc299_g/Python/52236570
|
condefects-python_data_370
|
#!/usr/bin/env python3
import sys
import heapq
def solve(N: int, M: int, A: "list[int]"):
last_index = [0 for _ in range(M+1)]
for i in range(N):
last_index[A[i]] = i
partitions = []
for i in range(1, M+1):
partitions.append(last_index[i])
partitions.sort(reverse=True)
l = -1
is_used = [False]*(M+1)
is_called = [False]*N
ans = []
que: list = []
while partitions:
partition = partitions.pop()
minimum_index = -1
for i in range(l+1, partition+1):
heapq.heappush(que, A[i]*N+i)
is_called[i] = True
if is_used[A[partition]]:
continue
while que:
minimum = heapq.heappop(que)
v, index = minimum // N, minimum % N
if (minimum_index < index) and (not is_used[v]):
minimum_index = index
is_used[v] = True
ans.append(v)
if v == A[partition]:
break
l = partition
for i in range(1, M+1):
assert is_used[i]
for i in range(N):
assert is_called[i]
print(*ans)
# Generated by 2.12.0 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, M, A)
if __name__ == '__main__':
main()
#!/usr/bin/env python3
import sys
import heapq
def solve(N: int, M: int, A: "list[int]"):
last_index = [0 for _ in range(M+1)]
for i in range(N):
last_index[A[i]] = i
partitions = []
for i in range(1, M+1):
partitions.append(last_index[i])
partitions.sort(reverse=True)
l = -1
is_used = [False]*(M+1)
is_called = [False]*N
ans = []
que: list = []
minimum_index = -1
while partitions:
partition = partitions.pop()
for i in range(l+1, partition+1):
heapq.heappush(que, A[i]*N+i)
is_called[i] = True
if is_used[A[partition]]:
continue
while que:
minimum = heapq.heappop(que)
v, index = minimum // N, minimum % N
if (minimum_index < index) and (not is_used[v]):
minimum_index = index
is_used[v] = True
ans.append(v)
if v == A[partition]:
break
l = partition
for i in range(1, M+1):
assert is_used[i]
for i in range(N):
assert is_called[i]
print(*ans)
# Generated by 2.12.0 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, M, A)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc299_g/Python/43242154
|
condefects-python_data_371
|
k = int(input())
if k > 60:
k = k-60
if k < 10:
print("22:0"+str(k))
else:
print("22:"+ str(k))
else:
if k < 10:
print("21:0"+str(k))
else:
print("21:"+ str(k))
k = int(input())
if k >= 60:
k = k-60
if k < 10:
print("22:0"+str(k))
else:
print("22:"+ str(k))
else:
if k < 10:
print("21:0"+str(k))
else:
print("21:"+ str(k))
|
ConDefects/ConDefects/Code/abc258_a/Python/46135145
|
condefects-python_data_372
|
# https://atcoder.jp/contests/abc258/tasks/abc258_a
K = int(input())
if K > 69:
print(f"22:{K - 60}")
elif K > 59:
print(f"22:0{K - 60}")
else:
print(f"21:{K}")
# https://atcoder.jp/contests/abc258/tasks/abc258_a
K = int(input())
if K > 69:
print(f"22:{K - 60}")
elif K > 59:
print(f"22:0{K - 60}")
elif K < 10:
print(f"21:0{K}")
else:
print(f"21:{K}")
|
ConDefects/ConDefects/Code/abc258_a/Python/44904869
|
condefects-python_data_373
|
k = int(input())
print(f"{21 + k // 60}:{k % 60}")
k = int(input())
print(f"{21 + k // 60:02}:{k % 60:02}")
|
ConDefects/ConDefects/Code/abc258_a/Python/45012247
|
condefects-python_data_374
|
N, X, Y, Z = map(int, input().split())
if (X<Y and Y<Z) or (X>Y and Y>Z):
print("Yes")
else:
print("No")
N, X, Y, Z = map(int, input().split())
if (X<Z and Z<Y) or (X>Z and Z>Y):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc352_a/Python/55109662
|
condefects-python_data_375
|
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n, x, y, z = LL()
print("Yes" if x < z < y else "No")
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n, x, y, z = LL()
print("Yes" if x < z < y or y < z < x else "No")
|
ConDefects/ConDefects/Code/abc352_a/Python/54917636
|
condefects-python_data_376
|
N,X,Y,Z = map(int,input().split())
if X <= Z and Z <= Y:
print("Yes")
else:
print("No")
N,X,Y,Z = map(int,input().split())
if (X <= Z and Z <= Y) or (Y <= Z and Z <= X):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc352_a/Python/55005308
|
condefects-python_data_377
|
n, x, y, z = map(int, input().split())
if x<z<y or y<z<x:
print("YES")
else:
print("No")
n, x, y, z = map(int, input().split())
if x<z<y or y<z<x:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc352_a/Python/54737577
|
condefects-python_data_378
|
N, X, Y, Z = input().split()
start = min(X, Y)
end = max(X, Y)
result = "No"
if start <= Z and end >= Z:
result = "Yes"
print(result)
N, X, Y, Z = map(int, input().split())
start = min(X, Y)
end = max(X, Y)
result = "No"
if start <= Z and end >= Z:
result = "Yes"
print(result)
|
ConDefects/ConDefects/Code/abc352_a/Python/54864046
|
condefects-python_data_379
|
N = int(input())
key = N
point = 0
l = []
while key > 0:
s = key % 10
key = key // 10
point += 1
l.append(s)
if point <= 3:
print(N)
elif point == 4:
l[0] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 5:
l[0] = 0
l[1] = 1
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 6:
l[0] = 0
l[1] = 0
l[2] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 7:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 8:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
l[4] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 9:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
l[4] = 0
l[5] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
N = int(input())
key = N
point = 0
l = []
while key > 0:
s = key % 10
key = key // 10
point += 1
l.append(s)
if point <= 3:
print(N)
elif point == 4:
l[0] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 5:
l[0] = 0
l[1] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 6:
l[0] = 0
l[1] = 0
l[2] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 7:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 8:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
l[4] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
elif point == 9:
l[0] = 0
l[1] = 0
l[2] = 0
l[3] = 0
l[4] = 0
l[5] = 0
for i in range(point-1, -1, -1):
print(l[i],end='')
|
ConDefects/ConDefects/Code/abc304_b/Python/45808253
|
condefects-python_data_380
|
N = int(input())
def range(n):
if(n < 10**3):
return 0
elif(10**3 <= n < 10**4):
return 1
elif(10**4 <= n < 10**5):
return 2
elif(10**5 <= n < 10**6):
return 3
elif(10**6 <= n < 10**7):
return 4
elif(10**7 <= n < 10**8):
return 5
elif(10**8 <= n < 10**9):
return 6
print(round(N, -range(N)))
N = int(input())
def range(n):
if(n < 10**3):
return 0
elif(10**3 <= n < 10**4):
return 1
elif(10**4 <= n < 10**5):
return 2
elif(10**5 <= n < 10**6):
return 3
elif(10**6 <= n < 10**7):
return 4
elif(10**7 <= n < 10**8):
return 5
elif(10**8 <= n < 10**9):
return 6
print(N // 10**range(N) * 10**range(N) )
|
ConDefects/ConDefects/Code/abc304_b/Python/46153900
|
condefects-python_data_381
|
N = int(input())
if N <= 10 ** 3 - 1:
print(N)
elif 10 ** 3 <= N <= 10 ** 4 - 1:
print(N // 10 * 10)
elif 10 ** 4 <= N <= 10 ** 5 - 1:
print(N // 100 * 100)
elif 10 ** 5 <= N <= 10 ** 6 - 1:
print(N // 1000 * 1000)
elif 10 ** 6 <= N <= 10 ** 7 - 1:
print(N // 10000 * 10000)
elif 10 ** 7 <= N <= 10 ** 8 - 1:
print((N // 100000) * 100000)
else:
None
N = int(input())
if N <= 10 ** 3 - 1:
print(N)
elif 10 ** 3 <= N <= 10 ** 4 - 1:
print(N // 10 * 10)
elif 10 ** 4 <= N <= 10 ** 5 - 1:
print(N // 100 * 100)
elif 10 ** 5 <= N <= 10 ** 6 - 1:
print(N // 1000 * 1000)
elif 10 ** 6 <= N <= 10 ** 7 - 1:
print(N // 10000 * 10000)
elif 10 ** 7 <= N <= 10 ** 8 - 1:
print((N // 100000) * 100000)
elif 10 ** 8 <= N <= 10 ** 9 - 1:
print((N // 1000000) * 1000000)
else:
None
|
ConDefects/ConDefects/Code/abc304_b/Python/46194774
|
condefects-python_data_382
|
n = int(input())
for i in range(6):
if n <= 10**(3 + i) - 1:
print((n // (10**i)) * 10**i)
break
n = int(input())
for i in range(7):
if n <= 10**(3 + i) - 1:
print((n // (10**i)) * 10**i)
break
|
ConDefects/ConDefects/Code/abc304_b/Python/45306152
|
condefects-python_data_383
|
n = int(input())
if n <= 10**3-1:
print(n)
elif n <= 10**4-1:
print(n - n%10)
elif n <= 10**5-1:
print(n - n%100)
elif n <= 10**6-1:
print(n - n%1000)
elif n <= 10**7-1:
print(n - n%10000)
elif n <= 10**8-1:
print(n - n%100000)
n = int(input())
if n <= 10**3-1:
print(n)
elif n <= 10**4-1:
print(n - n%10)
elif n <= 10**5-1:
print(n - n%100)
elif n <= 10**6-1:
print(n - n%1000)
elif n <= 10**7-1:
print(n - n%10000)
elif n <= 10**8-1:
print(n - n%100000)
elif n <= 10**9-1:
print(n - n%1000000)
|
ConDefects/ConDefects/Code/abc304_b/Python/45336297
|
condefects-python_data_384
|
import sys
# sys.setrecursionlimit(100000)
input=lambda:sys.stdin.readline().strip()
# write=lambda x:sys.stdout.write(str(x)+'\n')
# from decimal import Decimal
# from random import randint
# from copy import deepcopy
from collections import deque,Counter
# from heapq import heapify,heappush,heappop
# from bisect import bisect_left,bisect,insort
from math import inf,sqrt,gcd,lcm,pow,ceil,floor,log,log2,log10,pi,sin,cos,tan,asin,acos,atan
# from functools import cmp_to_key
# from itertools import permutations,combinations
def solve():
n=int(input())
if n<1e3:
return n
elif n<1e4:
return n//10*10
elif n<1e5:
return n//100*100
elif n<1e6:
return n//1000*1000
elif n<1e7:
return n//10000*10000
elif n<1e8:
return n//100000*100000
elif n<1e9:
return n//100000*100000
# t=int(input())
# for _ in range(t):
# print(solve())
print(solve())
# solve()
import sys
# sys.setrecursionlimit(100000)
input=lambda:sys.stdin.readline().strip()
# write=lambda x:sys.stdout.write(str(x)+'\n')
# from decimal import Decimal
# from random import randint
# from copy import deepcopy
from collections import deque,Counter
# from heapq import heapify,heappush,heappop
# from bisect import bisect_left,bisect,insort
from math import inf,sqrt,gcd,lcm,pow,ceil,floor,log,log2,log10,pi,sin,cos,tan,asin,acos,atan
# from functools import cmp_to_key
# from itertools import permutations,combinations
def solve():
n=int(input())
if n<1e3:
return n
elif n<1e4:
return n//10*10
elif n<1e5:
return n//100*100
elif n<1e6:
return n//1000*1000
elif n<1e7:
return n//10000*10000
elif n<1e8:
return n//100000*100000
elif n<1e9:
return n//1000000*1000000
# t=int(input())
# for _ in range(t):
# print(solve())
print(solve())
# solve()
|
ConDefects/ConDefects/Code/abc304_b/Python/45577481
|
condefects-python_data_385
|
N = int(input())
S = input()
ans = []
pre = '0'
bottom = ['A', 'B']
for i in range(N-1, -1, -1):
if pre == S[i]:
continue
for j in range(i+1):
ans.append(bottom[int(pre)])
pre = S[i]
print(len(ans))
print(*ans)
N = int(input())
S = input()
ans = []
pre = '0'
bottom = ['A', 'B']
for i in range(N-1, -1, -1):
if pre == S[i]:
continue
for j in range(i+1):
ans.append(bottom[int(pre)])
pre = S[i]
print(len(ans))
print(''.join(ans))
|
ConDefects/ConDefects/Code/arc177_b/Python/53566689
|
condefects-python_data_386
|
N = int(input())
S = input()
ans = ''
for i in range(N-1, -1, -1):
s = S[i]
if s == '1':
print(i, 'A'*(i+1)+'B'*i)
ans += 'A'*(i+1)+'B'*i
print(len(ans))
print(ans)
N = int(input())
S = input()
ans = ''
for i in range(N-1, -1, -1):
s = S[i]
if s == '1':
#print(i, 'A'*(i+1)+'B'*i)
ans += 'A'*(i+1)+'B'*i
print(len(ans))
print(ans)
|
ConDefects/ConDefects/Code/arc177_b/Python/53558819
|
condefects-python_data_387
|
N = int(input())
S = input()
cur = 0
ans = ''
for i in range(N):
if int(S[N-i-1]) != (cur // 2**i) % 2:
X = (1 << N) - (1 << i)
if S[i] == '1':
ans += 'A' * (N-i)
cur = cur ^ X
else:
ans += 'B' * (N-i)
cur = cur ^ X
print(len(ans))
print(ans)
N = int(input())
S = input()
cur = 0
ans = ''
for i in range(N):
if int(S[N-i-1]) != (cur // 2**i) % 2:
X = (1 << N) - (1 << i)
if S[N-i-1] == '1':
ans += 'A' * (N-i)
cur = cur ^ X
else:
ans += 'B' * (N-i)
cur = cur ^ X
print(len(ans))
print(ans)
|
ConDefects/ConDefects/Code/arc177_b/Python/54054467
|
condefects-python_data_388
|
def hantei(N,A):
for n1 in range(N):
for n2 in range(N):
if ((A[n1][n2] == "-" and A[n2][n1] == "-")
or (A[n1][n2] == "W" and A[n2][n1] == "L")
or (A[n1][n2] == "L" and A[n2][n1] == "W")
or (A[n1][n2] == "D" and A[n2][n1] == "D")):
continue
else:
return "incorrect"
return "correnct"
N = int(input())
A = []
for _ in range(N):
A.append(list(str(input())))
print(hantei(N,A))
def hantei(N,A):
for n1 in range(N):
for n2 in range(N):
if ((A[n1][n2] == "-" and A[n2][n1] == "-")
or (A[n1][n2] == "W" and A[n2][n1] == "L")
or (A[n1][n2] == "L" and A[n2][n1] == "W")
or (A[n1][n2] == "D" and A[n2][n1] == "D")):
continue
else:
return "incorrect"
return "correct"
N = int(input())
A = []
for _ in range(N):
A.append(list(str(input())))
print(hantei(N,A))
|
ConDefects/ConDefects/Code/abc261_b/Python/45054015
|
condefects-python_data_389
|
N = int(input())
A = [list(input()) for _ in range(N)]
for i in range(N):
for j in range(N):
if A[i][j] == 'W' and A[j][i] =='W' or A[i][j] == 'L' and A[j][i] =='L':
print('incorrect')
exit()
print('correct')
N = int(input())
A = [list(input()) for _ in range(N)]
for i in range(N):
for j in range(N):
if A[i][j] == 'W' and A[j][i] =='W' or A[i][j] == 'L' and A[j][i] =='L' or A[i][j] == 'D' and A[j][i] !='D' or A[i][j] != 'D' and A[j][i] =='D':
print('incorrect')
exit()
print('correct')
|
ConDefects/ConDefects/Code/abc261_b/Python/45282531
|
condefects-python_data_390
|
n = int(input())
a = [list(input()) for _ in range(n)]
b = []
for i in range(n):
tmp = []
for j in range(n):
tmp.append(a[j][i])
b.append(tmp)
ans = "correct"
for i in range(n):
for j in range(n):
if i == j:
continue
if a[i][j] == b[i][j] == 'D':
continue
if a[i][j] == b[i][j]:
ans = "incorrect"
break
print(ans)
n = int(input())
a = [list(input()) for _ in range(n)]
b = []
for i in range(n):
tmp = []
for j in range(n):
tmp.append(a[j][i])
b.append(tmp)
ans = "correct"
for i in range(n):
for j in range(n):
if i == j:
continue
if a[i][j] == b[i][j] == 'D':
continue
if a[i][j] == b[i][j] or a[i][j] == 'D' or b[i][j] == 'D':
ans = "incorrect"
break
print(ans)
|
ConDefects/ConDefects/Code/abc261_b/Python/45997045
|
condefects-python_data_391
|
N = int(input())
A = [list(input()) for _ in range(N)]
for i in range(N):
for j in range(N):
if i != j and A[i][j] == 'W' and A[j][i] == 'L':
continue
elif i != j and A[i][j] == 'D' and A[j][i] == 'D':
continue
elif i == j:
continue
else:
print('incorrect')
exit()
print('correct')
N = int(input())
A = [list(input()) for _ in range(N)]
for i in range(N):
for j in range(N):
if i != j and A[i][j] == 'W' and A[j][i] == 'L':
continue
elif i != j and A[i][j] == 'L' and A[j][i] == 'W':
continue
elif i != j and A[i][j] == 'D' and A[j][i] == 'D':
continue
elif i == j:
continue
else:
print('incorrect')
exit()
print('correct')
|
ConDefects/ConDefects/Code/abc261_b/Python/45074177
|
condefects-python_data_392
|
N = int(input())
A = [list(input()) for _ in range(N)]
count = 0
for i in range(N):
for k in range(N):
if (i == k) and (A[i][k] == '-') :
count += 1
if (i != k) and (A[i][k] == 'W') and (A[k][i] == 'L'):
count += 1
if (i != k) and (A[k][i] == 'W') and (A[i][k] == 'L'):
count += 1
if count == N**2:
print("correct")
else:
print("incorrect")
N = int(input())
A = [list(input()) for _ in range(N)]
count = 0
for i in range(N):
for k in range(N):
if (i == k) and (A[i][k] == '-') :
count += 1
if (i != k) and (A[i][k] == 'W') and (A[k][i] == 'L'):
count += 1
if (i != k) and (A[k][i] == 'W') and (A[i][k] == 'L'):
count += 1
if (i != k) and (A[i][k] == 'D') and (A[k][i] == 'D'):
count += 1
if count == N**2:
print("correct")
else:
print("incorrect")
|
ConDefects/ConDefects/Code/abc261_b/Python/45115214
|
condefects-python_data_393
|
n = int(input())
kama = [list(input()) for i in range(n)]
for i in range(n):
for ipp in range(n):
if kama[i][ipp] == "W":
if kama[ipp][i] != "L":
print("incorrect")
exit()
elif kama[i][ipp] == "D":
if kama[ipp][i] != "D":
print("incorrect")
exit()
elif kama[i][ipp] == "L":
if kama[ipp][i] == "W":
print("incorrect")
exit()
print("correct")
n = int(input())
kama = [list(input()) for i in range(n)]
for i in range(n):
for ipp in range(n):
if kama[i][ipp] == "W":
if kama[ipp][i] != "L":
print("incorrect")
exit()
elif kama[i][ipp] == "D":
if kama[ipp][i] != "D":
print("incorrect")
exit()
elif kama[i][ipp] == "L":
if kama[ipp][i] != "W":
print("incorrect")
exit()
print("correct")
|
ConDefects/ConDefects/Code/abc261_b/Python/46179770
|
condefects-python_data_394
|
n=int(input())
p=list(map(int,input().split()))
ans=p[0] if p.count(max(p))==1 and p[0]==max(p) else max(p)+1-p[0]
print(ans)
n=int(input())
p=list(map(int,input().split()))
ans=0 if p.count(max(p))==1 and p[0]==max(p) else max(p)+1-p[0]
print(ans)
|
ConDefects/ConDefects/Code/abc313_a/Python/45698032
|
condefects-python_data_395
|
import sys
N, *P = map(int, sys.stdin.buffer.read().split())
if N > 1:
print(max(0, max(P[1:])-P[0]+1))
else:
print(P[0])
import sys
N, *P = map(int, sys.stdin.buffer.read().split())
if N > 1:
print(max(0, max(P[1:])-P[0]+1))
else:
print(0)
|
ConDefects/ConDefects/Code/abc313_a/Python/45811912
|
condefects-python_data_396
|
N = int(input())
P = list(map(int,input().split()))
m = 0
for i in range(1,N):
m = max(m, P[i])
print(0,m+1-P[0])
N = int(input())
P = list(map(int,input().split()))
m = 0
for i in range(1,N):
m = max(m, P[i])
print(max(0,m+1-P[0]))
|
ConDefects/ConDefects/Code/abc313_a/Python/45785774
|
condefects-python_data_397
|
N = int(input())
X = 0
Y = 0
for i in range(N):
x, y = map(int,input().split())
X += x
Y += y
if X > Y:
print("Takahasi")
elif X == Y:
print("Draw")
else:
print("Aoki")
N = int(input())
X = 0
Y = 0
for i in range(N):
x, y = map(int,input().split())
X += x
Y += y
if X > Y:
print("Takahashi")
elif X == Y:
print("Draw")
else:
print("Aoki")
|
ConDefects/ConDefects/Code/abc337_a/Python/54540906
|
condefects-python_data_398
|
n = int(input())
x = 0
y = 0
for i in range(n):
a, b= map(int,input().split())
x += a
y += b
if x > y: print("Takahashi")
elif x < y: print("Aoki")
else: print("Drow")
n = int(input())
x = 0
y = 0
for i in range(n):
a, b= map(int,input().split())
x += a
y += b
if x > y: print("Takahashi")
elif x < y: print("Aoki")
else: print("Draw")
|
ConDefects/ConDefects/Code/abc337_a/Python/54867325
|
condefects-python_data_399
|
T = 0
A = 0
N = int(input())
for i in range(N):
a, t = map(int, input().split())
T += t
A += a
if T == A:
print('Draw')
elif T > A:
print('Takahashi')
else:
print('Aoki')
T = 0
A = 0
N = int(input())
for i in range(N):
a, t = map(int, input().split())
T += t
A += a
if T == A:
print('Draw')
elif T < A:
print('Takahashi')
else:
print('Aoki')
|
ConDefects/ConDefects/Code/abc337_a/Python/54731532
|
condefects-python_data_400
|
N = int(input())
scoreX = 0
scoreY = 0
for i in range(N):
X, Y = map(int, input().split())
scoreX += X
scoreY += Y
if scoreX > scoreY:
print('Takahashi')
elif scoreX < scoreY:
print('Aoki')
else:
print('draw')
N = int(input())
scoreX = 0
scoreY = 0
for i in range(N):
X, Y = map(int, input().split())
scoreX += X
scoreY += Y
if scoreX > scoreY:
print('Takahashi')
elif scoreX < scoreY:
print('Aoki')
else:
print('Draw')
|
ConDefects/ConDefects/Code/abc337_a/Python/54518158
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.