id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_1801
|
import sys
input = sys.stdin.readline
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC250 E 1421 - Prefix Equality
N = ip()
A = lmp()
B = lmp()
aset = set()
bset = set()
xorset = set()
# xorset: A, B どちらかだけに含まれる要素の集合
bp = 0
same = [False] * (N+1)
same[0] = True
for a in A:
# if a in aset:continue
aset.add(a)
if a in xorset:
xorset.remove(a)
else:
xorset.add(a)
while bp < N and B[bp] in bset:
bp += 1
if bp == N:
break
b = B[bp]
bset.add(b)
if b in xorset:
xorset.remove(b)
else:
xorset.add(b)
same[len(aset)] = (len(xorset) == 0)
# print(aset, bset, xorset, same)
cntA = [0] * (N+1)
cntB = [0] * (N+1)
# cntA[i], cntB[i]: i番目までに含まれる要素数
aset = set()
bset = set()
for i in range(N):
aset.add(A[i])
cntA[i+1] = len(aset)
bset.add(B[i])
cntB[i+1] = len(bset)
# print(aset, bset, cntA, cntB)
Q = ip()
for _ in range(Q):
x, y = mp()
if cntA[x] == cntB[y] and same[cntA[x]]:
print("Yes")
else:
print("No")
import sys
input = sys.stdin.readline
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC250 E 1421 - Prefix Equality
N = ip()
A = lmp()
B = lmp()
aset = set()
bset = set()
xorset = set()
# xorset: A, B どちらかだけに含まれる要素の集合
bp = 0
same = [False] * (N+1)
same[0] = True
for a in A:
if a in aset:continue
aset.add(a)
if a in xorset:
xorset.remove(a)
else:
xorset.add(a)
while bp < N and B[bp] in bset:
bp += 1
if bp == N:
break
b = B[bp]
bset.add(b)
if b in xorset:
xorset.remove(b)
else:
xorset.add(b)
same[len(aset)] = (len(xorset) == 0)
# print(aset, bset, xorset, same)
cntA = [0] * (N+1)
cntB = [0] * (N+1)
# cntA[i], cntB[i]: i番目までに含まれる要素数
aset = set()
bset = set()
for i in range(N):
aset.add(A[i])
cntA[i+1] = len(aset)
bset.add(B[i])
cntB[i+1] = len(bset)
# print(aset, bset, cntA, cntB)
Q = ip()
for _ in range(Q):
x, y = mp()
if cntA[x] == cntB[y] and same[cntA[x]]:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc250_e/Python/44674065
|
condefects-python_data_1802
|
from collections import defaultdict
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=[[0,-1] for _ in range(n)]
nowa=set()
nowb=set()
notcheck=set()
d=defaultdict(int)
cnt=0
for i in range(n):
if a[i] in notcheck:
notcheck.remove(a[i])
if notcheck:
ans[i][0]=ans[i-1][0]
if a[i] in nowa:
ans[i]=ans[i-1]
continue
if a[i] in nowb:
ans[i][0]=max(ans[i-1][0],d[a[i]])
if not notcheck:
ans[i][1]=cnt-1
nowa.add(a[i])
continue
nowa.add(a[i])
bool=False
while cnt<n:
if b[cnt] not in nowa:
notcheck.add(b[cnt])
if b[cnt] in nowb:
cnt+=1
continue
else:
d[b[cnt]]=cnt
nowb.add(b[cnt])
if b[cnt]==a[i]:
bool=True
ans[i][0]=cnt
cnt+=1
while cnt<n:
if b[cnt]!=a[i]:
break
cnt+=1
if not notcheck:
ans[i][1]=cnt-1
if bool:
break
cnt+=1
if not bool:
break
q=int(input())
for i in range(q):
x,y=map(int,input().split())
x-=1
y-=1
if ans[x][0]<=y<=ans[x][1]:
print('Yes')
else:
print('No')
from collections import defaultdict
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans=[[0,-1] for _ in range(n)]
nowa=set()
nowb=set()
notcheck=set()
d=defaultdict(int)
cnt=0
for i in range(n):
if a[i] in notcheck:
notcheck.remove(a[i])
if notcheck:
ans[i][0]=ans[i-1][0]
if a[i] in nowa:
ans[i]=ans[i-1]
continue
if a[i] in nowb:
ans[i][0]=max(ans[i-1][0],d[a[i]])
if not notcheck:
ans[i][1]=cnt-1
nowa.add(a[i])
continue
nowa.add(a[i])
bool=False
while cnt<n:
if b[cnt] not in nowa:
notcheck.add(b[cnt])
if b[cnt] in nowb:
cnt+=1
continue
else:
d[b[cnt]]=cnt
nowb.add(b[cnt])
if b[cnt]==a[i]:
bool=True
ans[i][0]=cnt
cnt+=1
while cnt<n:
if b[cnt] not in nowb:
break
cnt+=1
if not notcheck:
ans[i][1]=cnt-1
if bool:
break
cnt+=1
if not bool:
break
q=int(input())
for i in range(q):
x,y=map(int,input().split())
x-=1
y-=1
if ans[x][0]<=y<=ans[x][1]:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc250_e/Python/46017900
|
condefects-python_data_1803
|
def func():
pattern1 = ["H","D","C","S"]
pattern2 = ["A","2","3","4","5","6","7","8","9","T","J","Q","K"]
pat_set = set()
# 入力を取得
N = int(input())
for n in range(N):
s = input()
if (not(s[0] in pattern1)) or (not(s[1] in pattern2)) or (not(s in pat_set)):
print("No")
return
pat_set.add(s)
print("Yes")
if __name__ == '__main__':
func()
def func():
pattern1 = ["H","D","C","S"]
pattern2 = ["A","2","3","4","5","6","7","8","9","T","J","Q","K"]
pat_set = set()
# 入力を取得
N = int(input())
for n in range(N):
s = input()
if (not(s[0] in pattern1)) or (not(s[1] in pattern2)) or (s in pat_set):
print("No")
return
pat_set.add(s)
print("Yes")
if __name__ == '__main__':
func()
|
ConDefects/ConDefects/Code/abc277_b/Python/45992139
|
condefects-python_data_1804
|
n=int(input())
a=[]
b=['H', 'D', 'C', 'S']
first = set(b)
second = set(['A', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'])
tmp = set()
answer = "Yes"
for i in range(n):
c=input()
if (c[0] not in first or c[1] not in second or c in tmp):
answer = "No"
tmp.add(c)
print(answer)
n=int(input())
a=[]
b=['H', 'D', 'C', 'S']
first = set(b)
second = set(['A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K'])
tmp = set()
answer = "Yes"
for i in range(n):
c=input()
if (c[0] not in first or c[1] not in second or c in tmp):
answer = "No"
tmp.add(c)
print(answer)
|
ConDefects/ConDefects/Code/abc277_b/Python/45577199
|
condefects-python_data_1805
|
n = int(input())
one = ["H", "D", "C", "S"]
two = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"]
spawned = []
for i in range(n):
s = input()
if not s[0] in one or not s[1] in two or not s in spawned:
print("No")
exit(0)
else:
spawned.append(s)
print("Yes")
n = int(input())
one = ["H", "D", "C", "S"]
two = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"]
spawned = []
for i in range(n):
s = input()
if not s[0] in one or not s[1] in two or s in spawned:
print("No")
exit(0)
else:
spawned.append(s)
print("Yes")
|
ConDefects/ConDefects/Code/abc277_b/Python/46214171
|
condefects-python_data_1806
|
import sys
ipt = sys.stdin.readline
N,Q = map(int,ipt().split())
A = list(map(int,ipt().split()))
query = []
for i in range(Q):
q = list(map(int,ipt().split()))+[i]
query.append(q)
query.sort(key=lambda x:x[1])
ans = [None]*Q
B = [0]*60
S = [0]*60
D = []
def GEM(X,idx,L=None):
"""
Gaussian Elimination Method
B: basis space
X: # to reduce
L: dim of the basis space (len(B) if not mentioned)
"""
if L is None:
L = len(B)
M = -1
T = 0
for i in range(L-1,-1,-1):
if X&(1<<i):
if B[i]:
X ^= B[i]
T ^= S[i]
elif M == -1:
M = i
if M == -1:
#従属
mi = 10**7
for i in range(L):
if T&(1<<i):
mi = min(mi,D[i])
out = D.index(mi)
D[out] = idx
for i in range(L):
if S[i]&(1<<out):
S[i] ^= T
S[i] |= 1<<out
else:
#独立
B[M] = X
S[M] = T+(1<<len(D))
D.append(idx)
for i in range(L):
if i == M:
continue
if B[i]&(1<<M):
B[i] ^= X
S[i] ^= T
return X
def GEM2(X,l,a,L=None):
"""
Gaussian Elimination Method
B: basis space
X: # to reduce
L: dim of the basis space (len(B) if not mentioned)
"""
if L is None:
L = len(B)
M = -1
T = 0
for i in range(L-1,-1,-1):
if X&(1<<i):
if B[i]:
X ^= B[i]
T ^= S[i]
elif M == -1:
M = i
if M == -1:
#従属
mi = 10**7
for i in range(L):
if T&(1<<i):
mi = min(mi,D[i])
if mi >= l:
ans[a] = "Yes"
else:
ans[a] = "No"
else:
ans[a] = "No"
last = -1
for l,r,x,a in query:
l,r = l-1,r-1
while last < r:
last += 1
GEM(A[last],last)
GEM2(x,l,a)
for a in ans:
print(a)
import sys
ipt = sys.stdin.readline
N,Q = map(int,ipt().split())
A = list(map(int,ipt().split()))
query = []
for i in range(Q):
q = list(map(int,ipt().split()))+[i]
query.append(q)
query.sort(key=lambda x:x[1])
ans = [None]*Q
B = [0]*60
S = [0]*60
D = []
def GEM(X,idx,L=None):
"""
Gaussian Elimination Method
B: basis space
X: # to reduce
L: dim of the basis space (len(B) if not mentioned)
"""
if L is None:
L = len(B)
M = -1
T = 0
for i in range(L-1,-1,-1):
if X&(1<<i):
if B[i]:
X ^= B[i]
T ^= S[i]
elif M == -1:
M = i
if M == -1:
#従属
mi = 10**7
for i in range(L):
if T&(1<<i):
mi = min(mi,D[i])
out = D.index(mi)
D[out] = idx
for i in range(L):
if S[i]&(1<<out):
S[i] ^= T
S[i] |= 1<<out
else:
#独立
B[M] = X
S[M] = T+(1<<len(D))
D.append(idx)
for i in range(L):
if i == M:
continue
if B[i]&(1<<M):
B[i] ^= X
S[i] ^= S[M]
return X
def GEM2(X,l,a,L=None):
"""
Gaussian Elimination Method
B: basis space
X: # to reduce
L: dim of the basis space (len(B) if not mentioned)
"""
if L is None:
L = len(B)
M = -1
T = 0
for i in range(L-1,-1,-1):
if X&(1<<i):
if B[i]:
X ^= B[i]
T ^= S[i]
elif M == -1:
M = i
if M == -1:
#従属
mi = 10**7
for i in range(L):
if T&(1<<i):
mi = min(mi,D[i])
if mi >= l:
ans[a] = "Yes"
else:
ans[a] = "No"
else:
ans[a] = "No"
last = -1
for l,r,x,a in query:
l,r = l-1,r-1
while last < r:
last += 1
GEM(A[last],last)
GEM2(x,l,a)
for a in ans:
print(a)
|
ConDefects/ConDefects/Code/abc223_h/Python/26668974
|
condefects-python_data_1807
|
from collections import defaultdict
class UnionFind:
def __init__(self,N,label=None,f=None,weighted=False,rollback=False):
self.N=N
self.parents=[None]*self.N
self.size=[1]*self.N
self.roots={i for i in range(self.N)}
self.label=label
if self.label!=None:
self.label=[x for x in label]
self.f=f
self.weighted=weighted
if self.weighted:
self.weight=[0]*self.N
self.rollback=rollback
if self.rollback:
self.operate_list=[]
self.operate_set=[]
def Find(self,x):
stack=[]
while self.parents[x]!=None:
stack.append(x)
x=self.parents[x]
if not self.rollback:
if self.weighted:
w=0
for y in stack[::-1]:
self.parents[y]=x
w+=self.weight[y]
self.weight[y]=w
else:
for y in stack[::-1]:
self.parents[y]=x
return x
def Union(self,x,y,w=None):
root_x=self.Find(x)
root_y=self.Find(y)
if self.rollback:
self.operate_list.append([])
self.operate_set.append([])
if root_x==root_y:
if self.weighted:
if self.weight[y]-self.weight[x]==w:
return True
else:
return False
else:
if self.size[root_x]<self.size[root_y]:
x,y=y,x
root_x,root_y=root_y,root_x
if self.weighted:
w=-w
if self.rollback:
self.operate_list[-1].append((self.parents,root_y,self.parents[root_y]))
self.operate_list[-1].append((self.size,root_x,self.size[root_x]))
self.operate_set[-1].append(root_y)
if self.label!=None:
self.operate_list[-1]((self.label,root_x,self.label[root_x]))
if self.weighted:
self.operate_list[-1].append((self.weight,root_y,self.weight[root_y]))
self.parents[root_y]=root_x
self.size[root_x]+=self.size[root_y]
self.roots.remove(root_y)
if self.label!=None:
self.label[root_x]=self.f(self.label[root_x],self.label[root_y])
if self.weighted:
self.weight[root_y]=w+self.weight[x]-self.weight[y]
def Size(self,x):
return self.size[self.Find(x)]
def Same(self,x,y):
return self.Find(x)==self.Find(y)
def Label(self,x):
return self.label[self.Find(x)]
def Weight(self,x,y):
root_x=self.Find(x)
root_y=self.Find(y)
if root_x!=root_y:
return None
return self.weight[y]-self.weight[x]
def Roots(self):
return list(self.roots)
def Linked_Components_Count(self):
return len(self.roots)
def Linked_Components(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return linked_components
def Rollback(self):
assert self.rollback
if self.operate_list:
for lst,x,v in self.operate_list.pop():
lst[x]=v
for x in self.operate_set.pop():
self.roots.add(x)
return True
else:
return False
def __str__(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return "\n".join(f"{r}: {linked_components[r]}" for r in sorted(list(linked_components.keys())))
N,M=map(int,input().split())
A=list(map(int,input().split()))
edges=[]
UF=UnionFind(N)
for m in range(M):
u,v=map(int,input().split())
u-=1;v-=1
if A[u]==A[v]:
UF.Union(u,v)
else:
if A[u]>A[v]:
u,v=v,u
edges.append((u,v))
idx=[None]*N
lc=UF.Linked_Components()
le=len(lc)
AA=[]
for i,lst in enumerate(lc.values()):
for x in lst:
idx[x]=i
AA.append(A[lst[0]])
graph=[[] for i in range(le)]
for u,v in edges:
graph[idx[u]].append(idx[v])
inf=1<<30
dp=[-inf]*le
dp[idx[0]]=1
for i in sorted([i for i in range(le)],key=lambda i:AA[i]):
for j in graph[i]:
dp[j]=max(dp[j],dp[i]+1)
ans=dp[idx[N-1]]
if ans==-inf:
ans=0
print(ans)
from collections import defaultdict
class UnionFind:
def __init__(self,N,label=None,f=None,weighted=False,rollback=False):
self.N=N
self.parents=[None]*self.N
self.size=[1]*self.N
self.roots={i for i in range(self.N)}
self.label=label
if self.label!=None:
self.label=[x for x in label]
self.f=f
self.weighted=weighted
if self.weighted:
self.weight=[0]*self.N
self.rollback=rollback
if self.rollback:
self.operate_list=[]
self.operate_set=[]
def Find(self,x):
stack=[]
while self.parents[x]!=None:
stack.append(x)
x=self.parents[x]
if not self.rollback:
if self.weighted:
w=0
for y in stack[::-1]:
self.parents[y]=x
w+=self.weight[y]
self.weight[y]=w
else:
for y in stack[::-1]:
self.parents[y]=x
return x
def Union(self,x,y,w=None):
root_x=self.Find(x)
root_y=self.Find(y)
if self.rollback:
self.operate_list.append([])
self.operate_set.append([])
if root_x==root_y:
if self.weighted:
if self.weight[y]-self.weight[x]==w:
return True
else:
return False
else:
if self.size[root_x]<self.size[root_y]:
x,y=y,x
root_x,root_y=root_y,root_x
if self.weighted:
w=-w
if self.rollback:
self.operate_list[-1].append((self.parents,root_y,self.parents[root_y]))
self.operate_list[-1].append((self.size,root_x,self.size[root_x]))
self.operate_set[-1].append(root_y)
if self.label!=None:
self.operate_list[-1]((self.label,root_x,self.label[root_x]))
if self.weighted:
self.operate_list[-1].append((self.weight,root_y,self.weight[root_y]))
self.parents[root_y]=root_x
self.size[root_x]+=self.size[root_y]
self.roots.remove(root_y)
if self.label!=None:
self.label[root_x]=self.f(self.label[root_x],self.label[root_y])
if self.weighted:
self.weight[root_y]=w+self.weight[x]-self.weight[y]
def Size(self,x):
return self.size[self.Find(x)]
def Same(self,x,y):
return self.Find(x)==self.Find(y)
def Label(self,x):
return self.label[self.Find(x)]
def Weight(self,x,y):
root_x=self.Find(x)
root_y=self.Find(y)
if root_x!=root_y:
return None
return self.weight[y]-self.weight[x]
def Roots(self):
return list(self.roots)
def Linked_Components_Count(self):
return len(self.roots)
def Linked_Components(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return linked_components
def Rollback(self):
assert self.rollback
if self.operate_list:
for lst,x,v in self.operate_list.pop():
lst[x]=v
for x in self.operate_set.pop():
self.roots.add(x)
return True
else:
return False
def __str__(self):
linked_components=defaultdict(list)
for x in range(self.N):
linked_components[self.Find(x)].append(x)
return "\n".join(f"{r}: {linked_components[r]}" for r in sorted(list(linked_components.keys())))
N,M=map(int,input().split())
A=list(map(int,input().split()))
edges=[]
UF=UnionFind(N)
for m in range(M):
u,v=map(int,input().split())
u-=1;v-=1
if A[u]==A[v]:
UF.Union(u,v)
else:
if A[u]>A[v]:
u,v=v,u
edges.append((u,v))
idx=[None]*N
lc=UF.Linked_Components()
le=len(lc)
AA=[]
for i,lst in enumerate(lc.values()):
for x in lst:
idx[x]=i
AA.append(A[lst[0]])
graph=[[] for i in range(le)]
for u,v in edges:
graph[idx[u]].append(idx[v])
inf=1<<30
dp=[-inf]*le
dp[idx[0]]=1
for i in sorted([i for i in range(le)],key=lambda i:AA[i]):
for j in graph[i]:
dp[j]=max(dp[j],dp[i]+1)
ans=dp[idx[N-1]]
if ans<0:
ans=0
print(ans)
|
ConDefects/ConDefects/Code/abc335_e/Python/55029036
|
condefects-python_data_1808
|
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
from atcoder.segtree import SegTree
from atcoder.lazysegtree import LazySegTree
from atcoder.dsu import DSU
from atcoder.scc import SCCGraph
from itertools import permutations, combinations
from heapq import heappop, heappush
import math, sys
_int = lambda x: int(x)-1
MOD = 998244353
INF = 1<<62
Yes, No = "Yes", "No"
N, M = map(int, input().split())
A = list(map(int, input().split()))
S = sorted(set(A))
UV = []
D = DSU(N)
for _ in range(M):
u, v = map(_int, input().split())
if A[u] == A[v]:
D.merge(u, v)
else:
if A[u] > A[v]: u, v = v, u
UV.append((u, v))
G = SCCGraph(N)
E = defaultdict(list)
for u, v in UV:
G.add_edge(D.leader(u), D.leader(v))
E[u].append(v)
memo = [0]*N
memo[D.leader(0)] = 1
for g in G.scc():
for i in g:
if memo[i] == 0: continue
for j in E[i]:
memo[j] = max(memo[j], memo[i]+1)
print(memo[D.leader(N-1)])
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
from atcoder.segtree import SegTree
from atcoder.lazysegtree import LazySegTree
from atcoder.dsu import DSU
from atcoder.scc import SCCGraph
from itertools import permutations, combinations
from heapq import heappop, heappush
import math, sys
_int = lambda x: int(x)-1
MOD = 998244353
INF = 1<<62
Yes, No = "Yes", "No"
N, M = map(int, input().split())
A = list(map(int, input().split()))
S = sorted(set(A))
UV = []
D = DSU(N)
for _ in range(M):
u, v = map(_int, input().split())
if A[u] == A[v]:
D.merge(u, v)
else:
if A[u] > A[v]: u, v = v, u
UV.append((u, v))
G = SCCGraph(N)
E = defaultdict(list)
for u, v in UV:
G.add_edge(D.leader(u), D.leader(v))
E[D.leader(u)].append(D.leader(v))
memo = [0]*N
memo[D.leader(0)] = 1
for g in G.scc():
for i in g:
if memo[i] == 0: continue
for j in E[i]:
memo[j] = max(memo[j], memo[i]+1)
print(memo[D.leader(N-1)])
|
ConDefects/ConDefects/Code/abc335_e/Python/54715880
|
condefects-python_data_1809
|
def chmax(A, idx, val):
if A[idx] < val: A[idx] = val
from atcoder.dsu import DSU
INF = float("INF")
N, M = map(int, input().split())
A = list(map(int, input().split()))
G = [[] for v in range(N)]
uf = DSU(N)
for _ in range(M):
a, b = map(lambda x: int(x) - 1, input().split())
G[a].append(b)
G[b].append(a)
if A[a] == A[b]:
uf.merge(a, b)
def solve(N, M, A, G, uf):
def contract(G, uf: DSU):
N = len(G)
nG = [[] for v in range(N)]
for v in range(N):
for a in G[v]:
nG[uf.leader(v)].append(uf.leader(a))
return nG
G = contract(G, uf)
dp = [-(INF)]*N
dp[0] = 1
for v in sorted(range(N), key=lambda i: A[i]):
for a in G[v]:
if A[v] < A[a]:
chmax(dp, a, dp[v] + 1)
ans = dp[uf.leader(N-1)]
return ans
ans = solve(N, M, A, G, uf)
if ans == -INF:
print(0)
else:
print(ans)
def chmax(A, idx, val):
if A[idx] < val: A[idx] = val
from atcoder.dsu import DSU
INF = float("INF")
N, M = map(int, input().split())
A = list(map(int, input().split()))
G = [[] for v in range(N)]
uf = DSU(N)
for _ in range(M):
a, b = map(lambda x: int(x) - 1, input().split())
G[a].append(b)
G[b].append(a)
if A[a] == A[b]:
uf.merge(a, b)
def solve(N, M, A, G, uf):
def contract(G, uf: DSU):
N = len(G)
nG = [[] for v in range(N)]
for v in range(N):
for a in G[v]:
nG[uf.leader(v)].append(uf.leader(a))
return nG
G = contract(G, uf)
dp = [-(INF)]*N
dp[uf.leader(0)] = 1
for v in sorted(range(N), key=lambda i: A[i]):
for a in G[v]:
if A[v] < A[a]:
chmax(dp, a, dp[v] + 1)
ans = dp[uf.leader(N-1)]
return ans
ans = solve(N, M, A, G, uf)
if ans == -INF:
print(0)
else:
print(ans)
|
ConDefects/ConDefects/Code/abc335_e/Python/54978942
|
condefects-python_data_1810
|
n_strings = int(input())
data = []
for i in range(n_strings):
info = input().split()
data.append((info[0], int(info[1])))
max_strings = set()
max_score = 0
max_index = 0
for i in range(n_strings):
string, score = data[i]
if score > max_score and string not in max_strings:
max_score = score
max_strings.add(string)
max_index = i
print(max_index + 1)
n_strings = int(input())
data = []
for i in range(n_strings):
info = input().split()
data.append((info[0], int(info[1])))
max_strings = set()
max_score = 0
max_index = 0
for i in range(n_strings):
string, score = data[i]
if score > max_score and string not in max_strings:
max_score = score
max_index = i
max_strings.add(string)
print(max_index + 1)
|
ConDefects/ConDefects/Code/abc251_c/Python/44644261
|
condefects-python_data_1811
|
n, k = map(int, input().split())
s = [input() for _ in range(n)]
s.sort()
for i in range(k):
print(s[i])
n, k = map(int, input().split())
s = [input() for _ in range(k)]
s.sort()
for i in range(k):
print(s[i])
|
ConDefects/ConDefects/Code/abc288_b/Python/44592257
|
condefects-python_data_1812
|
a,b=map(int,input().split())
c=[]
for i in range(a):
c.append(str(input()))
c.sort()
c=c[0:b]
for i in c:
print(i)
a,b=map(int,input().split())
c=[]
for i in range(a):
c.append(str(input()))
c=c[0:b]
c.sort()
for i in c:
print(i)
|
ConDefects/ConDefects/Code/abc288_b/Python/45965822
|
condefects-python_data_1813
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
d = {}
for a in A:
if a not in d:
d[a] = 0
d[a] += 1
n = 0
for a in d:
n = max(n, d[a])
M = []
for a in d:
if n == d[a]:
M.append(a)
M.sort()
M.reverse()
m = len(M)
ans = M[m - 1] - M[0] + (N - n) * K
for j in range(m - 1):
cand = M[j + 1] - M[j] + (N - n - 1) * K
ans = max(ans, cand)
print(ans)
N, K = map(int, input().split())
A = list(map(int, input().split()))
d = {}
for a in A:
if a not in d:
d[a] = 0
d[a] += 1
n = 0
for a in d:
n = max(n, d[a])
M = []
for a in d:
if n == d[a]:
M.append(a)
M.sort()
M.reverse()
m = len(M)
ans = M[m - 1] - M[0] + (N - n) * K
for j in range(m - 1):
cand = M[j] - M[j + 1] + (N - n - 1) * K
ans = max(ans, cand)
print(ans)
|
ConDefects/ConDefects/Code/agc065_a/Python/49045953
|
condefects-python_data_1814
|
x, y, z = map(int, input().split())
if x*y < 0:
print(abs(x))
else:
if abs(y) > abs(x):
print(abs(x))
else:
if x*z <0:
print(abs(x)+2*abs(z))
else:
if abs(z) < abs(x):
print(abs(x))
else:
print(-1)
x, y, z = map(int, input().split())
if x*y < 0:
print(abs(x))
else:
if abs(y) > abs(x):
print(abs(x))
else:
if x*z <0:
print(abs(x)+2*abs(z))
else:
if abs(z) < abs(y):
print(abs(x))
else:
print(-1)
|
ConDefects/ConDefects/Code/abc270_b/Python/46011134
|
condefects-python_data_1815
|
x, y, z = map(int, input().split())
if y < 0 < x or y > 0 > x:
print(abs(x))
elif 0 < y < x or 0 > y > x:
if 0 < y < z or 0 > y > z:
print(-1)
elif 0 < z < x or 0 > z > x:
print(abs(x))
else:
print(abs(x) + abs(z) * 2)
x, y, z = map(int, input().split())
if y < 0 < x or y > 0 > x:
print(abs(x))
elif 0 < x < y or 0 > x > y:
print(abs(x))
elif 0 < y < x or 0 > y > x:
if 0 < y < z or 0 > y > z:
print(-1)
elif 0 < z < x or 0 > z > x:
print(abs(x))
else:
print(abs(x) + abs(z) * 2)
|
ConDefects/ConDefects/Code/abc270_b/Python/45342389
|
condefects-python_data_1816
|
INT = lambda : int(input())
MI = lambda : map(int, input().split())
MI_DEC = lambda : map(lambda x : int(x)-1, input().split())
LI = lambda : list(map(int, input().split()))
LI_DEC = lambda : list(map(lambda x : int(x)-1, input().split()))
INF = float('inf')
X, Y, Z = MI()
if X * Y > 0:
if abs(X) < abs(Y):
print(abs(X))
exit(0)
elif Z * Y < 0:
print(abs(X) + 2 * abs(Z))
exit(0)
elif Y < Z:
print(-1)
exit(0)
else:
print(abs(X))
else:
print(abs(X))
INT = lambda : int(input())
MI = lambda : map(int, input().split())
MI_DEC = lambda : map(lambda x : int(x)-1, input().split())
LI = lambda : list(map(int, input().split()))
LI_DEC = lambda : list(map(lambda x : int(x)-1, input().split()))
INF = float('inf')
X, Y, Z = MI()
if X * Y > 0:
if abs(X) < abs(Y):
print(abs(X))
exit(0)
elif Z * Y < 0:
print(abs(X) + 2 * abs(Z))
exit(0)
elif abs(Y) < abs(Z):
print(-1)
exit(0)
else:
print(abs(X))
else:
print(abs(X))
|
ConDefects/ConDefects/Code/abc270_b/Python/46011140
|
condefects-python_data_1817
|
#!/usr/bin/env python3
x, y, z = [int(x) for x in input().split()]
if (0 < x - y < x and x > 0) or (x < x - y < 0 and x < 0):
if 0 < y - z < y:
print(abs(x))
elif (y - z < 0 and y > 0) or (y - z > 0 and y < 0):
print(-1)
else:
print(abs(z) * 2 + abs(x))
else:
print(abs(x))
#!/usr/bin/env python3
x, y, z = [int(x) for x in input().split()]
if (0 < x - y < x and x > 0) or (x < x - y < 0 and x < 0):
if (0 < y - z < y and y > 0) or (y < y - z < 0 and y < 0):
print(abs(x))
elif (y - z < 0 and y > 0) or (y - z > 0 and y < 0):
print(-1)
else:
print(abs(z) * 2 + abs(x))
else:
print(abs(x))
|
ConDefects/ConDefects/Code/abc270_b/Python/45519272
|
condefects-python_data_1818
|
n=int(input())
b=input().split()
a=[int(i) for i in b]
ans=a[0]
sum_=0
for i in a:
sum_+=i
ans=min(ans,sum_)
print(sum(a)-ans)
n=int(input())
b=input().split()
a=[int(i) for i in b]
ans=0
sum_=0
for i in a:
sum_+=i
ans=min(ans,sum_)
print(sum(a)-ans)
|
ConDefects/ConDefects/Code/abc339_c/Python/54709074
|
condefects-python_data_1819
|
n = int(input())
A = list(map(int, input().split()))
B = [0]*n
B[0] = A[0]
mi = 0
for i in range(1,n):
B[i] = B[i-1] + A[i]
if B[i] < B[mi]:
mi = i
# print(B, mi)
ans = sum(A[mi+1:])
print(ans)
n = int(input())
A = list(map(int, input().split()))
B = [0]*n
B[0] = A[0]
mi = 0
for i in range(1,n):
B[i] = B[i-1] + A[i]
if B[i] < B[mi]:
mi = i
# print(B, mi)
ans = sum(A[mi+1:])
if 0 < B[mi]:
ans += B[mi]
print(ans)
|
ConDefects/ConDefects/Code/abc339_c/Python/54653451
|
condefects-python_data_1820
|
n = int(input())
A = list(map(int, input().split()))
x = 0
s = 0
for i in A:
s += i
if s < 0:
x = max(x, -s)
s=0
print(sum(A) + x)
n = int(input())
A = list(map(int, input().split()))
x = 0
s = 0
for i in A:
s += i
if s < 0:
x += (-s)
s=0
print(sum(A) + x)
|
ConDefects/ConDefects/Code/abc339_c/Python/54915341
|
condefects-python_data_1821
|
n = int(input())
alist = list(map(int, input().split()))
acc = 0
imin = 0
amin = 0
for i in range(n):
acc += alist[i]
if acc <= amin:
amin = acc
imin = i
print(sum(alist[imin+1:]))
n = int(input())
alist = list(map(int, input().split()))
acc = 0
imin = -1
amin = 0
for i in range(n):
acc += alist[i]
if acc <= amin:
amin = acc
imin = i
print(sum(alist[imin+1:]))
|
ConDefects/ConDefects/Code/abc339_c/Python/54222445
|
condefects-python_data_1822
|
n = int(input())
a_s = list(map(int, input().split()))
num = 0
passengers = []
current_passenger = 0
for i in range(len(a_s)):
current_passenger = current_passenger + a_s[i]
passengers.append(current_passenger)
if min(passengers) >= 0:
print(max(passengers))
else:
print(passengers[-1] + abs(min(passengers)))
n = int(input())
a_s = list(map(int, input().split()))
num = 0
passengers = []
current_passenger = 0
for i in range(len(a_s)):
current_passenger = current_passenger + a_s[i]
passengers.append(current_passenger)
if min(passengers) >= 0:
print(passengers[-1])
else:
print(passengers[-1] + abs(min(passengers)))
|
ConDefects/ConDefects/Code/abc339_c/Python/54873036
|
condefects-python_data_1823
|
# Perfect Bus
def calc(N, A):
start = 0
total = 0
for i in A:
total += i
if -start > total:
start = -total
print("total: " + str(total))
print("start: " + str(start))
return start + total
def main():
N = int(input())
A = [int(i) for i in input().split()]
print(calc(N, A))
if __name__=="__main__":
main()
# Perfect Bus
def calc(N, A):
start = 0
total = 0
for i in A:
total += i
if -start > total:
start = -total
return start + total
def main():
N = int(input())
A = [int(i) for i in input().split()]
print(calc(N, A))
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/abc339_c/Python/54482593
|
condefects-python_data_1824
|
N = int(input())
A = list(map(int, input().split()))
total = 0
min_diff = float('inf')
for i in range(N):
total += A[i]
min_diff = min(min_diff, total)
print(total + abs(min_diff))
N = int(input())
A = list(map(int, input().split()))
total = 0
min_diff = 0
for i in range(N):
total += A[i]
min_diff = min(min_diff, total)
print(total + abs(min_diff))
|
ConDefects/ConDefects/Code/abc339_c/Python/54545063
|
condefects-python_data_1825
|
## https://atcoder.jp/contests/abc250/tasks/abc250_g
MAX_INT = 10 ** 18
class LazySegmentTree:
"""
非再帰版遅延セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
取得のところの都合で取得演算子は可換になっている必要がある。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(MAX_INT, MAX_INT) for _ in range(2 * self.size)]
self.lazy_array = [0 for _ in range(2 * self.size)]
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def _propagates(self, *ids):
for i in reversed(ids):
self._propagate(i)
def _propagate(self, i):
v = self.lazy_array[i]
if v == 0:
return
if i < self.size:
self.lazy_array[2 * i] += v
self.lazy_array[2 * i + 1] += v
self.array[2 * i] = (self.array[2 * i][0] + v, self.array[2 * i][1])
self.array[2 * i + 1] = (self.array[2 * i + 1][0] + v, self.array[2 * i + 1][1])
self.lazy_array[i] = 0
def _get_target_index(self, l, r):
L = l + self.size; R = r + self.size
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while 0 < L and L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L > 0:
yield L
L >>= 1
def add(self, l, r, x):
# 2. 区間[l, r)のdata, lazyの値を更新
L = self.size + l; R = self.size + r
*ids, = self._get_target_index(l, r)
self._propagates(*ids)
while L < R:
if R & 1:
R -= 1
self.lazy_array[R] += x
self.array[R] = (self.array[R][0] + x, self.array[R][1])
if L & 1:
self.lazy_array[L] += x
self.array[L] = (self.array[L][0] + x, self.array[R][1])
L += 1
L >>= 1; R >>= 1
# 3. 伝搬させた区間について、ボトムアップにdataの値を伝搬する
for i in ids:
if i < self.size:
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
def get_max(self, l, r):
# 1. トップダウンにlazyの値を伝搬
self._propagates(*self._get_target_index(l, r))
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (MAX_INT, MAX_INT)
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
class SegmentTree:
"""
非再帰版セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(MAX_INT, -1)] * (2 * self.size)
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def set(self, x, a):
index = self.size + x
self.array[index] = (a, x)
while index > 1:
index //= 2
self.array[index] = min(self.array[2 * index], self.array[2 * index + 1])
def get_max(self, l, r):
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (MAX_INT, -1)
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
def main():
N = int(input())
P = list(map(int, input().split()))
# 株の保持数を管理するセグメント木
lazy_seg_tree = LazySegmentTree([0] * N)
# 価格を管理するセグメント木
seg_tree = SegmentTree(P)
p_array = [(i, p) for i, p in enumerate(P)]
p_array.sort(key=lambda x: x[1], reverse=True)
answer = 0
for i, p in p_array:
v, max_range = lazy_seg_tree.get_max(i, N)
if v < 0:
max_range = N - 1
s, j = seg_tree.get_max(0, max_range + 1)
if s < p:
seg_tree.set(j, MAX_INT)
seg_tree.set(i, MAX_INT)
answer += p - s
if i < j:
lazy_seg_tree.add(i, j, -1)
else:
lazy_seg_tree.add(j, i, +1)
print(answer)
if __name__ == "__main__":
main()
## https://atcoder.jp/contests/abc250/tasks/abc250_g
MAX_INT = 10 ** 18
class LazySegmentTree:
"""
非再帰版遅延セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
取得のところの都合で取得演算子は可換になっている必要がある。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(MAX_INT, MAX_INT) for _ in range(2 * self.size)]
self.lazy_array = [0 for _ in range(2 * self.size)]
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def _propagates(self, *ids):
for i in reversed(ids):
self._propagate(i)
def _propagate(self, i):
v = self.lazy_array[i]
if v == 0:
return
if i < self.size:
self.lazy_array[2 * i] += v
self.lazy_array[2 * i + 1] += v
self.array[2 * i] = (self.array[2 * i][0] + v, self.array[2 * i][1])
self.array[2 * i + 1] = (self.array[2 * i + 1][0] + v, self.array[2 * i + 1][1])
self.lazy_array[i] = 0
def _get_target_index(self, l, r):
L = l + self.size; R = r + self.size
lm = (L // (L & -L)) >> 1
rm = (R // (R & -R)) >> 1
while 0 < L and L < R:
if R <= rm:
yield R
if L <= lm:
yield L
L >>= 1; R >>= 1
while L > 0:
yield L
L >>= 1
def add(self, l, r, x):
# 2. 区間[l, r)のdata, lazyの値を更新
L = self.size + l; R = self.size + r
*ids, = self._get_target_index(l, r)
self._propagates(*ids)
while L < R:
if R & 1:
R -= 1
self.lazy_array[R] += x
self.array[R] = (self.array[R][0] + x, self.array[R][1])
if L & 1:
self.lazy_array[L] += x
self.array[L] = (self.array[L][0] + x, self.array[L][1])
L += 1
L >>= 1; R >>= 1
# 3. 伝搬させた区間について、ボトムアップにdataの値を伝搬する
for i in ids:
if i < self.size:
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
def get_max(self, l, r):
# 1. トップダウンにlazyの値を伝搬
self._propagates(*self._get_target_index(l, r))
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (MAX_INT, MAX_INT)
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
class SegmentTree:
"""
非再帰版セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(MAX_INT, -1)] * (2 * self.size)
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def set(self, x, a):
index = self.size + x
self.array[index] = (a, x)
while index > 1:
index //= 2
self.array[index] = min(self.array[2 * index], self.array[2 * index + 1])
def get_max(self, l, r):
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (MAX_INT, -1)
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
def main():
N = int(input())
P = list(map(int, input().split()))
# 株の保持数を管理するセグメント木
lazy_seg_tree = LazySegmentTree([0] * N)
# 価格を管理するセグメント木
seg_tree = SegmentTree(P)
p_array = [(i, p) for i, p in enumerate(P)]
p_array.sort(key=lambda x: x[1], reverse=True)
answer = 0
for i, p in p_array:
v, max_range = lazy_seg_tree.get_max(i, N)
if v < 0:
max_range = N - 1
s, j = seg_tree.get_max(0, max_range + 1)
if s < p:
seg_tree.set(j, MAX_INT)
seg_tree.set(i, MAX_INT)
answer += p - s
if i < j:
lazy_seg_tree.add(i, j, -1)
else:
lazy_seg_tree.add(j, i, +1)
print(answer)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc250_g/Python/51402169
|
condefects-python_data_1826
|
from heapq import heappush,heappop
n = int(input())
P = list(map(int,input().split()))
ans = 0
cand_heapq = []
selled_heapq = []
for p in P:
s1 = -1
s2 = -1
if cand_heapq and cand_heapq[0] < p:
s1 = p-cand_heapq[0]
elif selled_heapq and selled_heapq[0] < p:
s2 = p-selled_heapq[0]
if s1 == s2 == -1:
heappush(cand_heapq,p)
continue
if s1 >= s2:
ans += p-heappop(cand_heapq)
heappush(selled_heapq,p)
else:
s = heappop(selled_heapq)
ans += p-s
heappush(cand_heapq,s)
heappush(selled_heapq,p)
print(ans)
from heapq import heappush,heappop
n = int(input())
P = list(map(int,input().split()))
ans = 0
cand_heapq = []
selled_heapq = []
for p in P:
s1 = -1
s2 = -1
if cand_heapq and cand_heapq[0] < p:
s1 = p-cand_heapq[0]
if selled_heapq and selled_heapq[0] < p:
s2 = p-selled_heapq[0]
if s1 == s2 == -1:
heappush(cand_heapq,p)
continue
if s1 >= s2:
ans += p-heappop(cand_heapq)
heappush(selled_heapq,p)
else:
s = heappop(selled_heapq)
ans += p-s
heappush(cand_heapq,s)
heappush(selled_heapq,p)
print(ans)
|
ConDefects/ConDefects/Code/abc250_g/Python/31608048
|
condefects-python_data_1827
|
from heapq import *
n = int(input())
p = list(map(int, input().split()))
ans = 0
q = []
for v in p:
if q and p[0] < v:
ans += v - heappop(q)
heappush(q, v)
heappush(q, v)
print(ans)
from heapq import *
n = int(input())
p = list(map(int, input().split()))
ans = 0
q = []
for v in p:
if q and q[0] < v:
ans += v - heappop(q)
heappush(q, v)
heappush(q, v)
print(ans)
|
ConDefects/ConDefects/Code/abc250_g/Python/36759156
|
condefects-python_data_1828
|
s = input()
r = s[::-1]
if s.find('B') % 2 == r.find('B') % 2:
if s.find('R') < s.find('K') < 8 - s.find('R') + 1:
print('Yes')
exit()
print('No')
s = input()
r = s[::-1]
if s.find('B') % 2 == r.find('B') % 2:
if s.find('R') < s.find('K') < 8 - r.find('R') + 1:
print('Yes')
exit()
print('No')
|
ConDefects/ConDefects/Code/abc297_b/Python/46013217
|
condefects-python_data_1829
|
def main():
s = input()
slist = list(s)
if not "K" in s.split("R")[1]:
print("No")
return
firstB = s.index("B")
secondB = s.rindex("B")
if firstB+secondB % 2 == 0:
print("No")
return
print("Yes")
if __name__ == "__main__":
main()
def main():
s = input()
slist = list(s)
if not "K" in s.split("R")[1]:
print("No")
return
firstB = s.index("B")
secondB = s.rindex("B")
if (secondB-firstB) % 2 == 0:
print("No")
return
print("Yes")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc297_b/Python/45489946
|
condefects-python_data_1830
|
S = input()
K = S.find('K')
B1 = S.find('B')
B2 = S.rfind('B')
R1 = S.find('R')
R2 = S.rfind('R')
if B1+B2 % 2 != 0 and R1 < K < R2:
print('Yes')
else:
print('No')
S = input()
K = S.find('K')
B1 = S.find('B')
B2 = S.rfind('B')
R1 = S.find('R')
R2 = S.rfind('R')
if ((B1+B2) % 2) != 0 and (R1 < K < R2):
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc297_b/Python/45577916
|
condefects-python_data_1831
|
n,m,k,s,t,x = map(int, input().split())
uvl = [list(map(int, input().split())) for _ in range(m)]
mod = 998244353
from collections import defaultdict
gd = defaultdict(set)
for u,v in uvl:
gd[u-1].add(v-1)
gd[v-1].add(u-1)
dp = [[[0] * 2 for i in range(n)] for j in range(k+1)]
dp[0][s-1][0] = 1
for i in range(1,k+1):
for u, vs in gd.items():
for v in vs:
if v == x-1:
dp[i][v][0] += dp[i-1][u][1]%mod
dp[i][v][1] += dp[i-1][u][0]%mod
else:
dp[i][v][0] += dp[i-1][u][0]%mod
dp[i][v][1] += dp[i-1][u][1]%mod
print(dp[k][t-1][0])
n,m,k,s,t,x = map(int, input().split())
uvl = [list(map(int, input().split())) for _ in range(m)]
mod = 998244353
from collections import defaultdict
gd = defaultdict(set)
for u,v in uvl:
gd[u-1].add(v-1)
gd[v-1].add(u-1)
dp = [[[0] * 2 for i in range(n)] for j in range(k+1)]
dp[0][s-1][0] = 1
for i in range(1,k+1):
for u, vs in gd.items():
for v in vs:
if v == x-1:
dp[i][v][0] += dp[i-1][u][1]%mod
dp[i][v][1] += dp[i-1][u][0]%mod
else:
dp[i][v][0] += dp[i-1][u][0]%mod
dp[i][v][1] += dp[i-1][u][1]%mod
print(dp[k][t-1][0]%mod)
|
ConDefects/ConDefects/Code/abc244_e/Python/45970204
|
condefects-python_data_1832
|
class Input_kyopro:
def II(self): return int(input())
def MI(self): return map( int,input().split())
def MS(self): return map(str,input().split())
def LMI(self): return list(self.MI())
def LMS(self): return list(self.MS())
def LLI(self,N): return [self.LMI() for _ in range(N)]
def LLS(self,N): return [self.LMS() for _ in range(N)]
def LS(self,N): return [input() for _ in range(N)]
def LSL(self,N): return [list(input()) for _ in range(N)]
def LI(self,N): return [self.II() for _ in range(N)]
I=Input_kyopro()
#入力
from collections import deque
H,W,T=I.MI()
a=I.LSL(H)
dx=[1,0,-1,0]
dy=[0,1,0,-1]
start=[0,0]
g=[0,0]
ls=[]
for i in range(H):
for j in range(W):
if a[i][j]=='S':
s=[i,j]
if a[i][j]=='G':
g=[i,j]
if a[i][j]=='o':
ls.append([i,j])
cnt=len(ls)
d=[[[0]*W for _ in range(H)] for _ in range(cnt)]
def dist(i,j):
res=[[float('inf')]*W for _ in range(H)]
res[i][j]=0
q=deque()
q.append([i,j])
while q:
i,j=q.popleft()
for k in range(4):
if 0<=i+dx[k]<H and 0<=j+dy[k]<W:
if res[i+dx[k]][j+dy[k]]!=float('inf') or a[i+dx[k]][j+dy[k]]=='#':
continue
res[i+dx[k]][j+dy[k]]=res[i][j]+1
q.append([i+dx[k],j+dy[k]])
return res
for i in range(cnt):
d[i]=dist(ls[i][0],ls[i][1])
dp=[[float('inf')]*(cnt) for _ in range(1<<cnt)]
for i in range(cnt):
dp[1<<i][i]=d[i][start[0]][start[1]]
for s in range(1,1<<cnt):
for last in range(cnt):
if dp[s][last]==float('inf'):
continue
for nx in range(cnt):
if s>>nx&1:
continue
dp[s|1<<nx][nx]=min(dp[s|1<<nx][nx],dp[s][last]+d[last][ls[nx][0]][ls[nx][1]])
ans=-1
if dist(start[0],start[1])[g[0]][g[1]]<=T:
ans=0
for s in range(1,1<<cnt):
for last in range(cnt):
if dp[s][last]+d[last][g[0]][g[1]]<=T:
now=0
for i in range(cnt):
if s>>i&1:
now+=1
ans=max(ans,now)
print(ans)
class Input_kyopro:
def II(self): return int(input())
def MI(self): return map( int,input().split())
def MS(self): return map(str,input().split())
def LMI(self): return list(self.MI())
def LMS(self): return list(self.MS())
def LLI(self,N): return [self.LMI() for _ in range(N)]
def LLS(self,N): return [self.LMS() for _ in range(N)]
def LS(self,N): return [input() for _ in range(N)]
def LSL(self,N): return [list(input()) for _ in range(N)]
def LI(self,N): return [self.II() for _ in range(N)]
I=Input_kyopro()
#入力
from collections import deque
H,W,T=I.MI()
a=I.LSL(H)
dx=[1,0,-1,0]
dy=[0,1,0,-1]
start=[0,0]
g=[0,0]
ls=[]
for i in range(H):
for j in range(W):
if a[i][j]=='S':
start=[i,j]
if a[i][j]=='G':
g=[i,j]
if a[i][j]=='o':
ls.append([i,j])
cnt=len(ls)
d=[[[0]*W for _ in range(H)] for _ in range(cnt)]
def dist(i,j):
res=[[float('inf')]*W for _ in range(H)]
res[i][j]=0
q=deque()
q.append([i,j])
while q:
i,j=q.popleft()
for k in range(4):
if 0<=i+dx[k]<H and 0<=j+dy[k]<W:
if res[i+dx[k]][j+dy[k]]!=float('inf') or a[i+dx[k]][j+dy[k]]=='#':
continue
res[i+dx[k]][j+dy[k]]=res[i][j]+1
q.append([i+dx[k],j+dy[k]])
return res
for i in range(cnt):
d[i]=dist(ls[i][0],ls[i][1])
dp=[[float('inf')]*(cnt) for _ in range(1<<cnt)]
for i in range(cnt):
dp[1<<i][i]=d[i][start[0]][start[1]]
for s in range(1,1<<cnt):
for last in range(cnt):
if dp[s][last]==float('inf'):
continue
for nx in range(cnt):
if s>>nx&1:
continue
dp[s|1<<nx][nx]=min(dp[s|1<<nx][nx],dp[s][last]+d[last][ls[nx][0]][ls[nx][1]])
ans=-1
if dist(start[0],start[1])[g[0]][g[1]]<=T:
ans=0
for s in range(1,1<<cnt):
for last in range(cnt):
if dp[s][last]+d[last][g[0]][g[1]]<=T:
now=0
for i in range(cnt):
if s>>i&1:
now+=1
ans=max(ans,now)
print(ans)
|
ConDefects/ConDefects/Code/abc301_e/Python/45949713
|
condefects-python_data_1833
|
s = list(input())
t = list(input())
ans = []
idx = 0
for i in range(len(s)):
for j in range(idx, len(t)):
print(i,j)
if s[i] == t[j]:
print("A")
ans.append(j+1)
idx = j+1
break
print(*ans)
s = list(input())
t = list(input())
ans = []
idx = 0
for i in range(len(s)):
for j in range(idx, len(t)):
if s[i] == t[j]:
ans.append(j+1)
idx = j+1
break
print(*ans)
|
ConDefects/ConDefects/Code/abc352_b/Python/54958483
|
condefects-python_data_1834
|
S = str(input())
T = str(input())
a = 0
b = []
c = []
for i in range(len(T)):
if S[a] == T[i]:
b.append(i+1)
a+=1
else:
pass
c.append(b)
print(c[0])
S = str(input())
T = str(input())
a = 0
b = []
c = []
for i in range(len(T)):
if S[a] == T[i]:
b.append(i+1)
a+=1
else:
pass
c.append(b)
print(*c[0])
|
ConDefects/ConDefects/Code/abc352_b/Python/55135076
|
condefects-python_data_1835
|
s = input()
s2 = input()
x = 0
l = []
while len(l) != len(s):
for i in range(len(s)):
for j in range(x, len(s2)):
if s[i] == s2[j]:
l.append(j + 1)
x = j
break
print(*l)
s = input()
s2 = input()
x = 0
l = []
while len(l) != len(s):
for i in range(len(s)):
for j in range(x, len(s2)):
if s[i] == s2[j]:
l.append(j + 1)
x = j + 1
break
print(*l)
|
ConDefects/ConDefects/Code/abc352_b/Python/55031255
|
condefects-python_data_1836
|
S = input()
if len(set(S)) == 1:
print(-1)
elif len(set(S)) == 3:
print(list(S)[0])
elif len(set(S)) == 2:
S = list(S)
s = S.count(S[0])
if s == 1:
print(S[0])
else:
print(S[1])
S = input()
if len(set(S)) == 1:
print(-1)
elif len(set(S)) == 3:
print(list(S)[0])
elif len(set(S)) == 2:
S = list(S)
s = S.count(S[0])
if s == 1:
print(S[0])
elif S[0] == S[1]:
print(S[2])
else:
print(S[1])
|
ConDefects/ConDefects/Code/abc260_a/Python/45791402
|
condefects-python_data_1837
|
S = input()
for i in range(2):
if S.count(S[i]) == 1:
exit(print(S[i]))
print(-1)
S = input()
for i in range(3):
if S.count(S[i]) == 1:
exit(print(S[i]))
print(-1)
|
ConDefects/ConDefects/Code/abc260_a/Python/45479937
|
condefects-python_data_1838
|
N, M, K = list(map(int, input().split()))
C = []
A = []
X = []
for _ in range(M):
buf = input().split()
C.append(int(buf[0]))
A.append(list(map(int, buf[1:-1])))
X.append(buf[-1])
ans = 0
for bit in range(1, 1<<N):
flg = True
for i in range(M):
cnt = 0
for j in range(C[i]):
if (bit >> (A[i][j] - 1)) & 0b1:
cnt += 1
if cnt >= K and X[i] == "o": continue
if cnt < K and X[i] == "x": continue
break
else:
ans += 1
print(ans)
N, M, K = list(map(int, input().split()))
C = []
A = []
X = []
for _ in range(M):
buf = input().split()
C.append(int(buf[0]))
A.append(list(map(int, buf[1:-1])))
X.append(buf[-1])
ans = 0
for bit in range(1<<N):
flg = True
for i in range(M):
cnt = 0
for j in range(C[i]):
if (bit >> (A[i][j] - 1)) & 0b1:
cnt += 1
if cnt >= K and X[i] == "o": continue
if cnt < K and X[i] == "x": continue
break
else:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc356_c/Python/55144138
|
condefects-python_data_1839
|
def main():
n, m, k = map(int, input().split())
Tests = []
for _ in range(m):
_, *A, r = input().split()
A = list(map(int, A))
Tests.append((A, r))
ans = 0
for i in range(2**n):
ok = True
if i.bit_count() < k:
continue
for test in Tests:
A, r = test
trueKey = 0
for a in A:
trueKey += (i >> (a - 1)) & 1
if r == "o":
ok &= k <= trueKey
else:
ok &= trueKey < k
if ok:
ans += 1
print(ans)
if __name__ == "__main__":
main()
def main():
n, m, k = map(int, input().split())
Tests = []
for _ in range(m):
_, *A, r = input().split()
A = list(map(int, A))
Tests.append((A, r))
ans = 0
for i in range(2**n):
ok = True
for test in Tests:
A, r = test
trueKey = 0
for a in A:
trueKey += (i >> (a - 1)) & 1
if r == "o":
ok &= k <= trueKey
else:
ok &= trueKey < k
if ok:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc356_c/Python/54920982
|
condefects-python_data_1840
|
N,M,K = map(int,input().split())
C_List = []
A_list_list = []
R_list = []
for _ in range(M):
tmp = list(input().split())
C_List.append(int(tmp[0]))
R_list.append(tmp[-1])
tmp_a = tmp[1:-1]
tmp_a = list(map(int,tmp_a))
A_list_list.append(tmp_a)
ret = 0
for i in range(2**N + 1):
for A_list,r in zip(A_list_list,R_list):
tmp = 0
for a in A_list:
a = a-1
if(i & 2**a):
tmp = tmp + 1
if(((tmp >= K) and (r == "o"))
or ((tmp < K) and (r == "x"))):
pass
else:
break
else:
ret = ret + 1
print(ret)
N,M,K = map(int,input().split())
C_List = []
A_list_list = []
R_list = []
for _ in range(M):
tmp = list(input().split())
C_List.append(int(tmp[0]))
R_list.append(tmp[-1])
tmp_a = tmp[1:-1]
tmp_a = list(map(int,tmp_a))
A_list_list.append(tmp_a)
ret = 0
for i in range(2**N):
for A_list,r in zip(A_list_list,R_list):
tmp = 0
for a in A_list:
a = a-1
if(i & 2**a):
tmp = tmp + 1
if(((tmp >= K) and (r == "o"))
or ((tmp < K) and (r == "x"))):
pass
else:
break
else:
ret = ret + 1
print(ret)
|
ConDefects/ConDefects/Code/abc356_c/Python/54900882
|
condefects-python_data_1841
|
n,m,k=map(int,input().split())
C=[0 for _ in range(m)]
A=[[0 for _ in range(n)] for _ in range(m)]
R=[False for _ in range(m)]
for i in range(m):
X=list(map(str, input().split()))
C[i]=int(X[0])
r=X[-1]
if r=="o":
R[i]=True
xx=[int(X[j]) for j in range(1,C[i]+1)]
for j in range(n):
if j+1 in xx:
A[i][j]=1
s=0
for i in range(1,2**n):
key=[0 for _ in range(n)]
bi=bin(i)[2:]
for j in range(len(bi)):
key[j]=int(bi[-j-1])
judge=True
for ii in range(m):
keysum=sum([A[ii][j]*key[j] for j in range(n)])
if (keysum>=k)!=R[ii]:
judge=False
break
if judge:
s+=1
print(s)
n,m,k=map(int,input().split())
C=[0 for _ in range(m)]
A=[[0 for _ in range(n)] for _ in range(m)]
R=[False for _ in range(m)]
for i in range(m):
X=list(map(str, input().split()))
C[i]=int(X[0])
r=X[-1]
if r=="o":
R[i]=True
xx=[int(X[j]) for j in range(1,C[i]+1)]
for j in range(n):
if j+1 in xx:
A[i][j]=1
s=0
for i in range(2**n):
key=[0 for _ in range(n)]
bi=bin(i)[2:]
for j in range(len(bi)):
key[j]=int(bi[-j-1])
judge=True
for ii in range(m):
keysum=sum([A[ii][j]*key[j] for j in range(n)])
if (keysum>=k)!=R[ii]:
judge=False
break
if judge:
s+=1
print(s)
|
ConDefects/ConDefects/Code/abc356_c/Python/54940782
|
condefects-python_data_1842
|
import sys
# sys.setrecursionlimit(200005)
# sys.set_int_max_str_digits(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = -1-(-1 << 63)
md = 10**9+7
# md = 998244353
from math import gcd
# 各強連結成分をリストにしてトポロジカル順に返す
def SCC(to, ot):
n = len(to)
# トポロジカルソート
fin = [-1]*n
topo = []
for u in range(n):
if fin[u] != -1: continue
stack = [u]
while stack:
u = stack[-1]
if fin[u] == -1:
fin[u] = 0
for v in to[u]:
if fin[v] != -1: continue
stack.append(v)
else:
stack.pop()
if fin[u] == 0:
fin[u] = 1
topo.append(u)
# 逆辺でdfs
res = []
while topo:
u = topo.pop()
if fin[u] != 1: continue
fin[u] = 2
cur = [u]
i = 0
while i < len(cur):
u = cur[i]
for v in ot[u]:
if fin[v] == 2: continue
fin[v] = 2
cur.append(v)
i += 1
res.append(cur)
return res
def solve():
def dfs(root=0):
st = [root]
while st:
u = st.pop()
for v in to[u]:
if dead[v]: continue
if depth[v] == -1:
depth[v] = depth[u]+1
st.append(v)
else:
back.append((u, v))
n, m = LI()
to = [[] for _ in range(n)]
ot = [[] for _ in range(n)]
for _ in range(m):
u, v = LI1()
to[u].append(v)
ot[v].append(u)
gg = SCC(to, ot)
dead = [1]*n
for g in gg:
if 0 in g:
for u in g: dead[u] = 0
break
depth = [-1]*n
depth[0] = 0
back = []
dfs()
g = 0
for u, v in back:
g = gcd(g, abs(depth[u]+1-depth[v]))
if g==0:
print("No")
exit()
while g%5 == 0: g //= 5
print("Yes" if g == g & -g else "No")
for _ in range(II()): solve()
import sys
# sys.setrecursionlimit(200005)
# sys.set_int_max_str_digits(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = -1-(-1 << 63)
md = 10**9+7
# md = 998244353
from math import gcd
# 各強連結成分をリストにしてトポロジカル順に返す
def SCC(to, ot):
n = len(to)
# トポロジカルソート
fin = [-1]*n
topo = []
for u in range(n):
if fin[u] != -1: continue
stack = [u]
while stack:
u = stack[-1]
if fin[u] == -1:
fin[u] = 0
for v in to[u]:
if fin[v] != -1: continue
stack.append(v)
else:
stack.pop()
if fin[u] == 0:
fin[u] = 1
topo.append(u)
# 逆辺でdfs
res = []
while topo:
u = topo.pop()
if fin[u] != 1: continue
fin[u] = 2
cur = [u]
i = 0
while i < len(cur):
u = cur[i]
for v in ot[u]:
if fin[v] == 2: continue
fin[v] = 2
cur.append(v)
i += 1
res.append(cur)
return res
def solve():
def dfs(root=0):
st = [root]
while st:
u = st.pop()
for v in to[u]:
if dead[v]: continue
if depth[v] == -1:
depth[v] = depth[u]+1
st.append(v)
else:
back.append((u, v))
n, m = LI()
to = [[] for _ in range(n)]
ot = [[] for _ in range(n)]
for _ in range(m):
u, v = LI1()
to[u].append(v)
ot[v].append(u)
gg = SCC(to, ot)
dead = [1]*n
for g in gg:
if 0 in g:
for u in g: dead[u] = 0
break
depth = [-1]*n
depth[0] = 0
back = []
dfs()
g = 0
for u, v in back:
g = gcd(g, abs(depth[u]+1-depth[v]))
if g==0:
print("No")
return
while g%5 == 0: g //= 5
print("Yes" if g == g & -g else "No")
for _ in range(II()): solve()
|
ConDefects/ConDefects/Code/abc306_g/Python/45483518
|
condefects-python_data_1843
|
N=int(input())
A=list(map(int,input().split()))
cnt=[0]*4
for Ai in A:
cnt[Ai-1]+=1
mat=[[0]*4 for _ in range(4)]
now=0
for Ai in A:
if cnt[now]==0: now+=1
mat[now][Ai-1]+=1
cnt[now]-=1
ans=0
for i in range(4):
mat[i][i]=0
for j in range(i):
m=min(mat[i][j],mat[j][i])
ans+=m
mat[i][j]-=m ; mat[j][i]-=m
li=[(0,1,2),(1,2,3),(2,3,0),(3,0,1),(0,3,2),(1,0,3),(2,1,0),(3,2,1)]
while True:
m=-1 ; idx=-1
for t,(i,j,k) in enumerate(li):
if min(mat[i][j],mat[j][k],mat[k][i])>m:
m=min(mat[i][j],mat[j][k],mat[k][i]) ; idx=t
if not m: break
ans+=2
i,j,k=li[idx]
mat[i][j],mat[j][k],mat[k][i]=mat[i][j]-1,mat[j][k]-1,mat[k][i]-1
S=0
for i in range(4):
for j in range(4):
S+=mat[i][j]
ans+=3*S//4
print(ans)
N=int(input())
A=list(map(int,input().split()))
cnt=[0]*4
for Ai in A:
cnt[Ai-1]+=1
mat=[[0]*4 for _ in range(4)]
now=0
for Ai in A:
while cnt[now]==0: now+=1
mat[now][Ai-1]+=1
cnt[now]-=1
ans=0
for i in range(4):
mat[i][i]=0
for j in range(i):
m=min(mat[i][j],mat[j][i])
ans+=m
mat[i][j]-=m ; mat[j][i]-=m
li=[(0,1,2),(1,2,3),(2,3,0),(3,0,1),(0,3,2),(1,0,3),(2,1,0),(3,2,1)]
while True:
m=-1 ; idx=-1
for t,(i,j,k) in enumerate(li):
if min(mat[i][j],mat[j][k],mat[k][i])>m:
m=min(mat[i][j],mat[j][k],mat[k][i]) ; idx=t
if not m: break
ans+=2
i,j,k=li[idx]
mat[i][j],mat[j][k],mat[k][i]=mat[i][j]-1,mat[j][k]-1,mat[k][i]-1
S=0
for i in range(4):
for j in range(4):
S+=mat[i][j]
ans+=3*S//4
print(ans)
|
ConDefects/ConDefects/Code/abc302_g/Python/41709058
|
condefects-python_data_1844
|
from itertools import *
N=int(input())
A=list(map(int, input().split()))
A=[a-1 for a in A]
B=list(sorted(A))
L=4
C=[0]*(L**2)
for a,b in zip(A,B):
if a!=b:
C[a*L+b]+=1
res=0
for p in permutations(range(4),2):
x,y=p
cnt=min(C[x*L+y],C[y*L+x])
C[x*L+y]-=cnt
C[y*L+x]-=cnt
res+=cnt
for p in combinations(range(4),3):
x,y,z=p
cnt=min(C[x*L+y],C[y*L+z],C[z*L+x])
C[x*L+y]-=cnt
C[y*L+z]-=cnt
C[z*L+x]-=cnt
res+=cnt*2
res+=(sum(C)*3)//4
print(res)
from itertools import *
N=int(input())
A=list(map(int, input().split()))
A=[a-1 for a in A]
B=list(sorted(A))
L=4
C=[0]*(L**2)
for a,b in zip(A,B):
if a!=b:
C[a*L+b]+=1
res=0
for p in permutations(range(4),2):
x,y=p
cnt=min(C[x*L+y],C[y*L+x])
C[x*L+y]-=cnt
C[y*L+x]-=cnt
res+=cnt
for p in permutations(range(4),3):
x,y,z=p
cnt=min(C[x*L+y],C[y*L+z],C[z*L+x])
C[x*L+y]-=cnt
C[y*L+z]-=cnt
C[z*L+x]-=cnt
res+=cnt*2
res+=(sum(C)*3)//4
print(res)
|
ConDefects/ConDefects/Code/abc302_g/Python/41887698
|
condefects-python_data_1845
|
import sys
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
import bisect,string,math,time,functools,random,fractions
from bisect import*
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
import itertools
rep=range;R=range
def I():return int(input())
def LI():return [int(i) for i in input().split()]
def SLI():return sorted([int(i) for i in input().split()])
def LI_():return [int(i)-1 for i in input().split()]
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def NLI(n):return [[int(i) for i in input().split()] for i in range(n)]
def NLI_(n):return [[int(i)-1 for i in input().split()] for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RLI(n=8,a=1,b=10):return [random.randint(a,b)for i in range(n)]
def RI(a=1,b=10):return random.randint(a,b)
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:a,b=inp;c=1
else:a,b,c=inp
if index==1:a-=1;b-=1
aa=a,c,;bb=b,c,;g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def RE(E):
rt=[[]for i in range(len(E))]
for i in range(len(E)):
for nb,d in E[i]:
rt[nb]+=(i,d),
return rt
def RLE(it):
rt=[]
for i in it:
if rt and rt[-1][0]==i:rt[-1][1]+=1
else:rt+=[i,1],
return rt
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in R(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
rt=[0]
for i in ls:rt+=[rt[-1]+i]
return rt
def bit_combination(n,base=2):
rt=[]
for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('UDRL',FourNb));HexNb=[(-1,0),(-1,-1),(0,1),(0,-1),(1,1),(1,0)]
alp=[chr(ord('a')+i)for i in range(26)]
#sys.setrecursionlimit(10**7)
def gcj(t,*a):
print('Case #{}:'.format(t+1),*a)
def INP():
N=80
n=random.randint(1,N)
x=random.randint(1,N)
n,d=RLI(2,1,10)
k=RI(1,n)
return n,d,k
def Rtest(T):
case,err=0,0
for i in range(T):
inp=INP()
#show(inp)
a1=naive(*inp)
a2=solve(*inp)
if a1!=a2:
print(inp)
n,d,k=inp
#a,b=bin(n)[2:],bin(x)[2:]
show(n,d,k)
print('naive',a1)
print('solve',a2)
err+=1
case+=1
print('Tested',case,'case with',err,'errors')
def graph():
g=[[]for i in range(n)]
for i in range(m):
u,v=LI()
g[u]+=v,
g[v]+=u,
mo=998244353
#mo=10**9+7
show_flg=False
show_flg=True
ans=0
n=I()
a=LI_()
n=8
a=RLI(n,0,3)
b=sorted(a)
d=defaultdict(int)
for i in range(n):
if a[i]==b[i]:
continue
d[(a[i],b[i])]+=1
p=[]
for i in range(4):
for j in range(i+1,4):
p+=(i,j,j,i),
q=[]
for i in range(4):
for j in range(4):
if i==j:
continue
for k in range(4):
for l in range(4):
if k==l:
continue
if k!=j and i!=l:
continue
if (i,j)==(k,l):
continue
if (i,j)==(l,k):
continue
q+=(i,j,k,l),
for _ in range(n):
f=False
for i,j,k,l in p:
x,y=d[(i,j)],d[(k,l)]
if x==0 or y==0:
continue
f=True
d[(i,j)]-=1
d[(k,l)]-=1
ans+=1
break
if f:
continue
for i,j,k,l in q:
x,y=d[(i,j)],d[(k,l)]
if x==0 or y==0:
continue
f=True
d[(i,j)]-=1
d[(k,l)]-=1
if i==l:
d[(k,j)]+=1
elif k==j:
d[(i,l)]+=1
ans+=1
break
print(ans)
import sys
read=sys.stdin.buffer.read;readline=sys.stdin.buffer.readline;input=lambda:sys.stdin.readline().rstrip()
import bisect,string,math,time,functools,random,fractions
from bisect import*
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
import itertools
rep=range;R=range
def I():return int(input())
def LI():return [int(i) for i in input().split()]
def SLI():return sorted([int(i) for i in input().split()])
def LI_():return [int(i)-1 for i in input().split()]
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def NLI(n):return [[int(i) for i in input().split()] for i in range(n)]
def NLI_(n):return [[int(i)-1 for i in input().split()] for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def RLI(n=8,a=1,b=10):return [random.randint(a,b)for i in range(n)]
def RI(a=1,b=10):return random.randint(a,b)
def GI(V,E,ls=None,Directed=False,index=1):
org_inp=[];g=[[] for i in range(V)]
FromStdin=True if ls==None else False
for i in range(E):
if FromStdin:
inp=LI()
org_inp.append(inp)
else:
inp=ls[i]
if len(inp)==2:a,b=inp;c=1
else:a,b,c=inp
if index==1:a-=1;b-=1
aa=a,c,;bb=b,c,;g[a].append(bb)
if not Directed:g[b].append(aa)
return g,org_inp
def RE(E):
rt=[[]for i in range(len(E))]
for i in range(len(E)):
for nb,d in E[i]:
rt[nb]+=(i,d),
return rt
def RLE(it):
rt=[]
for i in it:
if rt and rt[-1][0]==i:rt[-1][1]+=1
else:rt+=[i,1],
return rt
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0},boundary=1) # sample usage
mp=[boundary]*(w+2);found={}
for i in R(h):
s=input()
for char in search:
if char in s:
found[char]=((i+1)*(w+2)+s.index(char)+1)
mp_def[char]=mp_def[replacement_of_found]
mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
mp+=[boundary]*(w+2)
return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def accum(ls):
rt=[0]
for i in ls:rt+=[rt[-1]+i]
return rt
def bit_combination(n,base=2):
rt=[]
for tb in R(base**n):s=[tb//(base**bt)%base for bt in R(n)];rt+=[s]
return rt
def gcd(x,y):
if y==0:return x
if x%y==0:return y
while x%y!=0:x,y=y,x%y
return y
def YN(x):print(['NO','YES'][x])
def Yn(x):print(['No','Yes'][x])
def show(*inp,end='\n'):
if show_flg:print(*inp,end=end)
inf=float('inf')
FourNb=[(-1,0),(1,0),(0,1),(0,-1)];EightNb=[(-1,0),(1,0),(0,1),(0,-1),(1,1),(-1,-1),(1,-1),(-1,1)];compas=dict(zip('WENS',FourNb));cursol=dict(zip('UDRL',FourNb));HexNb=[(-1,0),(-1,-1),(0,1),(0,-1),(1,1),(1,0)]
alp=[chr(ord('a')+i)for i in range(26)]
#sys.setrecursionlimit(10**7)
def gcj(t,*a):
print('Case #{}:'.format(t+1),*a)
def INP():
N=80
n=random.randint(1,N)
x=random.randint(1,N)
n,d=RLI(2,1,10)
k=RI(1,n)
return n,d,k
def Rtest(T):
case,err=0,0
for i in range(T):
inp=INP()
#show(inp)
a1=naive(*inp)
a2=solve(*inp)
if a1!=a2:
print(inp)
n,d,k=inp
#a,b=bin(n)[2:],bin(x)[2:]
show(n,d,k)
print('naive',a1)
print('solve',a2)
err+=1
case+=1
print('Tested',case,'case with',err,'errors')
def graph():
g=[[]for i in range(n)]
for i in range(m):
u,v=LI()
g[u]+=v,
g[v]+=u,
mo=998244353
#mo=10**9+7
show_flg=False
show_flg=True
ans=0
n=I()
a=LI_()
b=sorted(a)
d=defaultdict(int)
for i in range(n):
if a[i]==b[i]:
continue
d[(a[i],b[i])]+=1
p=[]
for i in range(4):
for j in range(i+1,4):
p+=(i,j,j,i),
q=[]
for i in range(4):
for j in range(4):
if i==j:
continue
for k in range(4):
for l in range(4):
if k==l:
continue
if k!=j and i!=l:
continue
if (i,j)==(k,l):
continue
if (i,j)==(l,k):
continue
q+=(i,j,k,l),
for _ in range(n):
f=False
for i,j,k,l in p:
x,y=d[(i,j)],d[(k,l)]
if x==0 or y==0:
continue
f=True
d[(i,j)]-=1
d[(k,l)]-=1
ans+=1
break
if f:
continue
for i,j,k,l in q:
x,y=d[(i,j)],d[(k,l)]
if x==0 or y==0:
continue
f=True
d[(i,j)]-=1
d[(k,l)]-=1
if i==l:
d[(k,j)]+=1
elif k==j:
d[(i,l)]+=1
ans+=1
break
print(ans)
|
ConDefects/ConDefects/Code/abc302_g/Python/41876580
|
condefects-python_data_1846
|
N = int(input())
S = str(1)
if N == 1:
print(S)
for i in range(2, N+1):
S = S +" "+ str(i) + " " + S
print(S)
N = int(input())
S = str(1)
if N == 1:
exit(print(S))
for i in range(2, N+1):
S = S +" "+ str(i) + " " + S
print(S)
|
ConDefects/ConDefects/Code/abc247_c/Python/45240043
|
condefects-python_data_1847
|
li = []
def write(n):
if n == 1:
return [1]
else:
return write(n-1) + [n] + write(n-1)
n = int(input())
write(n)
li = []
def write(n):
if n == 1:
return [1]
else:
return write(n-1) + [n] + write(n-1)
n = int(input())
print(*write(n))
|
ConDefects/ConDefects/Code/abc247_c/Python/45710087
|
condefects-python_data_1848
|
import sympy
for n in[*open(0)][1:]:a,b=sympy.factorint(n:=int(n));print(*[b,a][::-1**(n%b**2>0)])
import sympy
for n in[*open(0)][1:]:a,b=sympy.factorint(n:=int(n));print(*[b,a][::1-(n%b**2>0)*2])
|
ConDefects/ConDefects/Code/abc284_d/Python/45300656
|
condefects-python_data_1849
|
h,w,a,b = map(int,input().split())
def f(h,w,a,b):
if a > b:
return [(y,x) for x,y in f(w,h,b,a)]
if h == 1:
return [(0,y) for y in range(w)]
if h == 2 and (a,b) == (1,1):
return [(0,0),(1,0)]+[(x,y+1) for x,y in f(2,w-1,1,0)]
return [(x,0) for x in range(h)]+[(h-1-x,y+1) for x,y in f(h,w-1,h-1-a,b-1)]
for x,y in f(h,w,a-1,b-1):
print(x+1,y+1)
h,w,a,b = map(int,input().split())
def f(h,w,a,b):
if (a,h) > (b,w):
return [(y,x) for x,y in f(w,h,b,a)]
if h == 1:
return [(0,y) for y in range(w)]
if h == 2 and (a,b) == (1,1):
return [(0,0),(1,0)]+[(x,y+1) for x,y in f(2,w-1,1,0)]
return [(x,0) for x in range(h)]+[(h-1-x,y+1) for x,y in f(h,w-1,h-1-a,b-1)]
for x,y in f(h,w,a-1,b-1):
print(x+1,y+1)
|
ConDefects/ConDefects/Code/abc232_h/Python/28052217
|
condefects-python_data_1850
|
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = 18446744073709551615
# inf = 4294967295
md = 10**9+7
# md = 998244353
def two(i0, j0, s, t):
i, j = i0, j0
di = dj = 1
if i > s: di = -1
if j > t: dj = -1
l, r = i, j
if l > r: l, r = r, l
res = []
while l <= j <= r:
res.append((i, j))
if i == i0:
i += di
else:
i -= di
j += dj
return res
def move(i0, j0, s, t):
i, j = i0, j0
l, r = min(j0, t), max(j0, t)
di = dj = 1
if i > s: di = -1
if j > t: dj = -1
res = []
if i & 1 != s & 1:
res += two(i, j, s, t)
if abs(i-s) == 1: return res
i += di*2
j = t
while l <= j <= r:
res.append((i, j))
j -= dj
i, j = i+di, j0
while 1:
res.append((i, j))
if (i, j) == (s, t): break
if l <= j+dj <= r:
j += dj
else:
i += di
dj = -dj
return res
h, w, a, b = LI()
if a == h and b == w:
ans = move(1, 1, a, b)
elif a == 1 and b == w:
ans = move(1, 1, h, w-1)+move(h, w, 1, w)
elif a == h and b == 1:
ans = move(1, 1, h-1, w)+move(h, w, h, 1)
elif a == 1:
ans = move(1, 1, h, b-1)+move(h, b, h, w)+move(h-1, w, a, b)
elif a == h:
ans = move(1, 1, h, b-1)+move(a-1, b, 1, b)+move(1, b+1, h-1, w)+move(h, w, a, b)
elif b == 1:
ans = move(1, 1, a-1, w)+move(a, w, h, w)+move(h, w-1, a, b)
elif b == w:
ans = move(1, 1, a-1, w)+move(a, w-1, a, 1)+move(a+1, 1, h, w-1)+move(h, w, a, b)
else:
ans = move(1, 1, a-1, w)+move(a, w, h, b+1)+move(h, b, a+1, 1)+move(a, 1, a, b)
for i, j in ans: print(i, j)
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = 18446744073709551615
# inf = 4294967295
md = 10**9+7
# md = 998244353
def two(i0, j0, s, t):
i, j = i0, j0
di = dj = 1
if i > s: di = -1
if j > t: dj = -1
l, r = j0, t
if l > r: l, r = r, l
res = []
while l <= j <= r:
res.append((i, j))
if i == i0:
i += di
else:
i -= di
j += dj
return res
def move(i0, j0, s, t):
i, j = i0, j0
l, r = min(j0, t), max(j0, t)
di = dj = 1
if i > s: di = -1
if j > t: dj = -1
res = []
if i & 1 != s & 1:
res += two(i, j, s, t)
if abs(i-s) == 1: return res
i += di*2
j = t
while l <= j <= r:
res.append((i, j))
j -= dj
i, j = i+di, j0
while 1:
res.append((i, j))
if (i, j) == (s, t): break
if l <= j+dj <= r:
j += dj
else:
i += di
dj = -dj
return res
h, w, a, b = LI()
if a == h and b == w:
ans = move(1, 1, a, b)
elif a == 1 and b == w:
ans = move(1, 1, h, w-1)+move(h, w, 1, w)
elif a == h and b == 1:
ans = move(1, 1, h-1, w)+move(h, w, h, 1)
elif a == 1:
ans = move(1, 1, h, b-1)+move(h, b, h, w)+move(h-1, w, a, b)
elif a == h:
ans = move(1, 1, h, b-1)+move(a-1, b, 1, b)+move(1, b+1, h-1, w)+move(h, w, a, b)
elif b == 1:
ans = move(1, 1, a-1, w)+move(a, w, h, w)+move(h, w-1, a, b)
elif b == w:
ans = move(1, 1, a-1, w)+move(a, w-1, a, 1)+move(a+1, 1, h, w-1)+move(h, w, a, b)
else:
ans = move(1, 1, a-1, w)+move(a, w, h, b+1)+move(h, b, a+1, 1)+move(a, 1, a, b)
for i, j in ans: print(i, j)
|
ConDefects/ConDefects/Code/abc232_h/Python/28235852
|
condefects-python_data_1851
|
a=[*map(int, input().split())]
a[a[a[0]]]
a=[*map(int, input().split())]
print(a[a[a[0]]])
|
ConDefects/ConDefects/Code/abc241_a/Python/46045206
|
condefects-python_data_1852
|
from bisect import bisect_left
tri = [(i * i - i) // 2 for i in range(2000)]
N = int(input())
vals = []
for i in range(7):
u = bisect_left(tri, N + 1) - 1
print(N, u, tri[u])
vals.extend([i] * u)
N -= tri[u]
assert N == 0
assert vals[0] == 0
curr = vals.pop(0)
out = []
mult = 1
for v in vals:
#curr *= 10
u = 7 - ((mult * (curr - v)) % 7)
out.append(u)
mult *= 5
mult %= 7
curr = v
print(''.join(map(str,out[::-1])))
from bisect import bisect_left
tri = [(i * i - i) // 2 for i in range(2000)]
N = int(input())
vals = []
for i in range(7):
u = bisect_left(tri, N + 1) - 1
#print(N, u, tri[u])
vals.extend([i] * u)
N -= tri[u]
assert N == 0
assert vals[0] == 0
curr = vals.pop(0)
out = []
mult = 1
for v in vals:
#curr *= 10
u = 7 - ((mult * (curr - v)) % 7)
out.append(u)
mult *= 5
mult %= 7
curr = v
print(''.join(map(str,out[::-1])))
|
ConDefects/ConDefects/Code/arc129_c/Python/43964198
|
condefects-python_data_1853
|
N = int(input())
ans = []
now = 0
count = 0
while N>0:
for i in range(2000):
if (i+1)*(i+2)//2 > N:
N -= i*(i+1)//2
break
ans.append("7"*i)
now += i
delim = pow(10,5*now,7)
if delim==0:
delim = 7
now += 1
ans.append(str(delim))
count += 1
if count==8:
a
print("".join(ans)[:-1])
N = int(input())
ans = []
now = 0
count = 0
while N>0:
for i in range(2000):
if (i+1)*(i+2)//2 > N:
N -= i*(i+1)//2
break
ans.append("7"*i)
now += i
delim = pow(10,5*now,7)
if delim==0:
delim = 7
now += 1
ans.append(str(delim))
count += 1
if count==8:
a
print("".join(ans)[:-1][::-1])
|
ConDefects/ConDefects/Code/arc129_c/Python/35701293
|
condefects-python_data_1854
|
def solve(n, vs):
ans = []
l = 0
while (l+1)*(l+2)//2 <= n:
l += 1
ans.append('7'*l)
n -= l*(l+1)//2
if n:
for i in range(l):
for j in range(len(vs)):
vs[j] = (vs[j]*10+7)%7
nxt = 1
while nxt < 10:
b = ((nxt%7)!=0)
for v in vs:
if (v*10+nxt)%7 == 0:
b = False
if b:
break
nxt += 1
ans.append(str(nxt))
for j in range(len(vs)):
vs[j] = (vs[j]*10+7)%7
vs.append(nxt)
ans += solve(n, vs)
return ans
n = int(input())
vs = []
ans = solve(n, vs)
ans = ''.join(ans)
print(ans)
def solve(n, vs):
ans = []
l = 0
while (l+1)*(l+2)//2 <= n:
l += 1
ans.append('7'*l)
n -= l*(l+1)//2
if n:
for i in range(l):
for j in range(len(vs)):
vs[j] = (vs[j]*10+7)%7
nxt = 1
while nxt < 10:
b = ((nxt%7)!=0)
for v in vs:
if (v*10+nxt)%7 == 0:
b = False
if b:
break
nxt += 1
ans.append(str(nxt))
for j in range(len(vs)):
vs[j] = (vs[j]*10+nxt)%7
vs.append(nxt)
ans += solve(n, vs)
return ans
n = int(input())
vs = []
ans = solve(n, vs)
ans = ''.join(ans)
print(ans)
|
ConDefects/ConDefects/Code/arc129_c/Python/34289751
|
condefects-python_data_1855
|
from collections import deque
li=[i*(i+1)//2 for i in range(1,2000)]
N=int(input())
ans=[]
now=N
for j in range(1998,-1,-1):
for k in range(now//li[j]):
ans.append(j+1)
now%=li[j]
fin_ans=deque()
for ai in ans:
for _ in range(ai):
fin_ans.appendleft("7")
fin_ans.appendleft(str((3*len(fin_ans)-3)%7))
print("".join(fin_ans))
from collections import deque
li=[i*(i+1)//2 for i in range(1,2000)]
N=int(input())
ans=[]
now=N
for j in range(1998,-1,-1):
for k in range(now//li[j]):
ans.append(j+1)
now%=li[j]
fin_ans=deque()
for ai in ans:
for _ in range(ai):
fin_ans.appendleft("7")
fin_ans.appendleft(str(pow(3,len(fin_ans)*5,7)))
print("".join(fin_ans))
|
ConDefects/ConDefects/Code/arc129_c/Python/39744798
|
condefects-python_data_1856
|
import time
ts = time.perf_counter_ns()
import sys
dsum = 0
def search_p(n):
global dsum
for p in range(3,400000,2):
if p*p>n:
dsum += p//2 - 1
return 0
elif n%p<1:
dsum += p//2
return p
sys.stdin.readline()
for s in sys.stdin.readlines():
n = int(s)
p = search_p(n)
if p:
while n%p<1:
n//=p
print('Yes' if p and n>1 else 'No')
sys.stdout.flush()
te = ts + dsum * 1000
while time.perf_counter_ns() < te:
pass
import time
ts = time.perf_counter_ns()
import sys
dsum = 0
def search_p(n):
global dsum
for p in range(3,400000,2):
if p*p>n:
dsum += p//2 - 1
return 0
elif n%p<1:
dsum += p//2
return p
sys.stdin.readline()
for s in sys.stdin.readlines():
n = int(s)
p = 2 if n%2<1 else search_p(n)
if p:
while n%p<1:
n//=p
print('Yes' if p and n>1 else 'No')
sys.stdout.flush()
te = ts + dsum * 1000
while time.perf_counter_ns() < te:
pass
|
ConDefects/ConDefects/Code/arc165_a/Python/45736644
|
condefects-python_data_1857
|
a=list(map(int,input().split()))
ans=[]
for i in range(12):
i+=1
s=a.count(i)
if s==0:
continue
ans.append(s)
if (len(ans)==2)and((ans[0]==3 and ans[1]==2)or(ans[0]==2 and ans[1]==3)):
print("Yes")
else:
print("No")
a=list(map(int,input().split()))
ans=[]
for i in range(13):
i+=1
s=a.count(i)
if s==0:
continue
ans.append(s)
if (len(ans)==2)and((ans[0]==3 and ans[1]==2)or(ans[0]==2 and ans[1]==3)):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc263_a/Python/44922329
|
condefects-python_data_1858
|
def main():
cards = list(map(int, input().split()))
assert len(cards) == 5
cards.sort()
if cards[0] == cards[1] and cards[0] == cards[2] and cards[0] != cards[3] and cards[3] == cards[4]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
def main():
cards = list(map(int, input().split()))
assert len(cards) == 5
cards.sort()
if cards[0] == cards[1] and cards[0] == cards[2] and cards[0] != cards[3] and cards[3] == cards[4]:
print("Yes")
elif cards[0] == cards[1] and cards[0] != cards[2] and cards[2] == cards[3] and cards[3] == cards[4]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc263_a/Python/44884204
|
condefects-python_data_1859
|
a=list(map(int,input().split()))
a.sort()
if ((a[0]==a[1] and a[1]==a[2]) and (a[3]==a[4])) or ((a[0]==a[1] and a[1]==a[2]) or (a[3]==a[4])):
print("Yes")
else:
print("No")
a=list(map(int,input().split()))
a.sort()
if ((a[0]==a[1] and a[1]==a[2]) and (a[3]==a[4])) or ((a[0]==a[1]) and (a[2]==a[3] and a[3]==a[4])):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc263_a/Python/45528012
|
condefects-python_data_1860
|
x=list(map(int,input().split()))
if len(set(x))==2:
print("Yes")
else:
print("No")
x=list(map(int,input().split()))
if len(set(x))==2 and x.count(list(set(x))[0])>=2:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc263_a/Python/45002191
|
condefects-python_data_1861
|
K = sorted(list(map(int, input().split())))
if len(set(K)) == 2 and K[2] != K[3]:
print('Yes')
else:
print('No')
K = sorted(list(map(int, input().split())))
if len(set(K)) == 2 and (K[2] != K[3] or K[1] != K[2]):
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc263_a/Python/45986379
|
condefects-python_data_1862
|
from collections import defaultdict
count = defaultdict(int)
A=list(map(int, input().split()))
for i in range(len(A)):
count[A[i]] += 1
a = count.values()
a = list(a)
if 2 < len(count.values()):
print("No")
elif a[0] == 3 or a[1] == 3:
print("YES")
else:
print("No")
from collections import defaultdict
count = defaultdict(int)
A=list(map(int, input().split()))
for i in range(len(A)):
count[A[i]] += 1
a = count.values()
a = list(a)
if 2 < len(count.values()):
print("No")
elif a[0] == 3 or a[1] == 3:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc263_a/Python/45972944
|
condefects-python_data_1863
|
n=int(input())
s=input()
s=list(s)
cnt=0
for i in range(n):
if s[i]=='"':
cnt+=1
if s[i]==",":
if cnt%2==1:
s[i]="."
ans=""
for i in range(n):
ans+=s[i]
print(ans)
n=int(input())
s=input()
s=list(s)
cnt=0
for i in range(n):
if s[i]=='"':
cnt+=1
if s[i]==",":
if cnt%2==0:
s[i]="."
ans=""
for i in range(n):
ans+=s[i]
print(ans)
|
ConDefects/ConDefects/Code/abc282_c/Python/44818334
|
condefects-python_data_1864
|
# coding: utf-8
#import
import random
import os
import operator
from operator import add,sub,mul,xor,or_,and_
import time
import sys
import re
import string
import math
from fractions import Fraction
import inspect
from math import sqrt,ceil,floor,gcd,log,log2
import collections
from collections import defaultdict,deque,Counter
from fractions import Fraction
import bisect
from bisect import bisect_left,bisect_right
import itertools
from itertools import accumulate,permutations
import functools
from functools import cmp_to_key
from copy import deepcopy,copy
import heapq
from heapq import heappush,heappop,heapify
from functools import lru_cache,reduce
readline=sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
inf=int(10**18)
#データ構造
class Edge:
def __init__(self,x,y,cost=1):
self.x=x
self.y=y
self.cost=cost
class UnionFind:
def __init__(self,n):
self.n=n
self.size_=n
self.P=[-1 for i in range(n)]#根ノードの場合:ノード数×-1。それ以外：親ノードのindex
def root(self,x):
if self.P[x]>=0:
self.P[x]=self.root(self.P[x])
return self.P[x]
else:
return x
def same(self,x,y):
return self.root(x)==self.root(y)
def union(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:return
if -self.P[x]<-self.P[y]:x,y=y,x
self.P[x]+=self.P[y]
self.P[y]=x
self.size_-=1
def unionSize(self,x):
return -self.P[self.root(x)]#P[根ノード]=同じ集合のノード数×-1
def roots(self):
ret=set()
for i in range(self.n):
ret.add(self.root(i))
return list(ret)
def getMembersByRoot(self):
ret=defaultdict(list)
for u in range(self.n):
root=self.root(u)
ret[root].append(u)
return ret
def size(self):
return self.size_
def __str__(self):
ret=[]
for i in range(self.n):
ret.append((i,self.root(i)))
ret=str(ret)
return ret
class BinaryTrie:
def __init__(self,depth):
self.root=[None,None,0] #0-child 1-child count
self.bit_start=1<<(depth-1)
def insert(self,x):
node=self.root
b=self.bit_start
while b:
i=bool(x&b)
if node[i]==None:
node[i]=[None,None,1]
else:
node[i][2]+=1
node=node[i]
b>>=1
def pop_min(self,xor_mask=0):
node=self.root
b=self.bit_start
ret=0
node[2]-=1
while b:
i=bool(b&xor_mask)
ret<<=1
if node[i]==None:
i^=1
ret+=1
node=node[i]
b >>= 1
if node[i][2] > 1:
node[i][2] -= 1
node = node[i]
else:
tmp = node[i]
node[i] = None
node = tmp
return ret
def get_min(self,xor_mask=0):
node=self.root
b=self.bit_start
ret=0
while b:
i=bool(b&xor_mask)
ret<<=1
if node[i]==None:
i^=1
ret+=1
node=node[i]
b>>=1
return ret
def get_kth_min(self,k):
b = self.bit_start
node = self.root
ret = 0
while b:
ret = ret << 1
b >>= 1
if node[0] is None:
node = node[1]
ret += 1
elif node[1] is None:
node = node[0]
elif k <= node[0][2]:
node = node[0]
else:
k -= node[0][2]
node = node[1]
ret += 1
return ret
def erase(self, x):
b = self.bit_start
node = self.root
node[2] -= 1
while b:
i = bool(x & b)
if node[i][2] > 1:
node[i][2] -= 1
node = node[i]
else:
tmp = node[i]
node[i] = None
node = tmp
b >>= 1
def lower_bound(self, bound=0):
ret = self.get_kth_min(self.less_x(bound)+1)
if ret > bound:return ret
def upper_bound(self, bound=0):
ret = self.get_kth_min(self.less_x(bound+1)+1)
if ret < bound:return ret
def less_x(self, x):
if x < 0:return 0
b = self.bit_start
node = self.root
ret = 0
while b:
i = bool(x & b)
if node[i] is None:
if i == 1:
ret += node[0][2]
return ret
else:
if i == 1:
if node[0] is not None:
ret += node[0][2]
node = node[i]
b >>= 1
return ret
def is_exist(self, x):
b = self.bit_start
node = self.root
while b:
i = bool(x & b)
if node[i] is None:
return False
node = node[i]
b >>= 1
return True
class SegTree:#[l,r) query(i),query(i,i+1)がO(1)
def __init__(self, n, ide_ele, func):
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.func = func
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
"""初期値に配列を渡す実装の場合
for i in range(self.bottomStartPos - 1, 0, -1):
self.tree[i] = self.func(self.tree[2 * i], self.tree[2 * i + 1])
"""
def update(self, k, x):
k += self.bottomStartPos
self.tree[k] = x
while k > 1:
self.tree[k//2] = self.func(self.tree[k], self.tree[k ^ 1])
k//=2
def query(self, L,R=None):
if R==None or L+1==R:return self.tree[self.bottomStartPos+L]
L=max(0,L)
R=min(self.n,R)
#非再帰
res = self.ide_ele
L += self.bottomStartPos
R += self.bottomStartPos
while L < R:
if L & 1:
res = self.func(res, self.tree[L])
L += 1
if R & 1:
res = self.func(res, self.tree[R - 1])
L//=2
R//=2
return res
def __str__(self):
return str(self.tree[self.bottomStartPos:])
class Heap:#heapqと違い要素の削除ができる
def __init__(self,List=[],selfInvFunc=lambda x:x):
self.h=[]
self.d=defaultdict(int)
self.len=0
self.selfInvFunc=selfInvFunc #自己逆関数
for l in List:self.add(l)
def __len__(self):
return self.len
def __str__(self):
return str(sorted(self.getValues()))
def add(self,val):
val=self.selfInvFunc(val)
heapq.heappush(self.h,val)
self.d[val]+=1
self.len+=1
def __cleanup(self):
top=self.h[0]
while self.d[top]==0:
heappop(self.h)
top=self.h[0]
def pop(self):
self.__cleanup()
top=heappop(self.h)
self.remove(self.selfInvFunc(top))
return self.selfInvFunc(top)
def remove(self,val):
val=self.selfInvFunc(val)
if val not in self.d or self.d[val]==0:
raise ValueError(f"{self.selfInvFunc(val)} is not in Heap")
else:
self.d[val]-=1
self.len-=1
def exists(self,val):
val=self.selfInvFunc(val)
return val in self.d and self.d[val]!=0
def top(self):
self.__cleanup()
val=self.h[0]
return self.selfInvFunc(val)
def getValues(self):
return [self.selfInvFunc(val) for val,cnt in self.d.items() for _ in range(cnt)]
class LazyRMQ:#[l,r)
def __init__(self, n, ide_ele, maximum=True):#Falseならminimum
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.func = lambda x,y:max(x,y) if maximum else lambda x,y:min(x,y)
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]=self.lazy[k]
self.lazy[k*2+1]=self.lazy[k]
self.tree[k]=self.lazy[k]
self.lazy[k]=self.ide_ele
def update(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.update(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x
self.eval(k)
elif L<r and l<R:#
self.update(L,R,x,k*2,l,(l+r)//2)
self.update(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.func(self.tree[k*2],self.tree[k*2+1])
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return self.func(leftVal,rightVal)
class LazyRangeUpdateQuery:#[l,r)
def __init__(self, n, ide_ele):#
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]=self.lazy[k]//2
self.lazy[k*2+1]=self.lazy[k]//2
self.tree[k]=self.lazy[k]
self.lazy[k]=self.ide_ele
def update(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.update(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x*(r-l)
self.eval(k)
elif L<r and l<R:
self.update(L,R,x,k*2,l,(l+r)//2)
self.update(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.tree[k*2]+self.tree[k*2+1]
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return leftVal+rightVal
class LazyRangeAddQuery:#[l,r)
def __init__(self, n, ide_ele):#
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]+=self.lazy[k]//2
self.lazy[k*2+1]+=self.lazy[k]//2
self.tree[k]+=self.lazy[k]
self.lazy[k]=self.ide_ele
def add(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.add(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x*(r-l)
self.eval(k)
elif L<r and l<R:
self.add(L,R,x,k*2,l,(l+r)//2)
self.add(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.tree[k*2]+self.tree[k*2+1]
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return leftVal+rightVal
class SkipList:#順序付き集合(重複可)
def __init__(self,A=[],maxHeight=30):
self.length=len(A)
self.maxHeight=maxHeight #十分な数 0-indexed
self.cnt=defaultdict(int)
#ノードは配列の方が高速
self.valIndex=0
self.nextIndex=1
self.sentinel=[None,[None]*(self.maxHeight+1)]
for a in A:
self.add(a)
def __str__(self):
elems=[k for k,v in self.cnt.items() for _ in range(v)]
return str(elems)
def __len__(self):
return self.length
def __getMaxLTE(self,x):
now=self.sentinel
for h in range(self.maxHeight,-1,-1):
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<=x:
now=now[self.nextIndex][h]
return now
def exists(self,x):
node=self.__getMaxLTE(x)
return node[self.valIndex]==x
def minGTE(self,x):#x以上の最小値
node=self.__getMaxLTE(x)
if node[self.valIndex]==x:
return x
else:
if node[self.nextIndex][0]==None:
return None
else:
return node[self.nextIndex][0][self.valIndex]
def minGT(self,x):#xを超える最小値
node=self.__getMaxLTE(x)
if node[self.nextIndex][0]==None:
return None
else:
return node[self.nextIndex][0][self.valIndex]
def maxLTE(self,x):#x以下の最大値
node=self.__getMaxLTE(x)
return node[self.valIndex]
def __pickHeight(self):#0-indexed
h=0
while random.randint(0,1)==0:
h+=1
return h
def add(self,x):
self.cnt[x]+=1
if self.exists(x):
return
self.length+=1
newNodeHeight=self.__pickHeight()
newNode=[x,[None]*(newNodeHeight+1)]
now=self.sentinel
for h in range(self.maxHeight,-1,-1):#newNodeHeightから始めると最初のwhile文の時間がかかる
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<x:
now=now[self.nextIndex][h]
#リンクの更新
if h<=newNodeHeight:
maxLessThanXNode=now
newNode[self.nextIndex][h]=maxLessThanXNode[self.nextIndex][h]
maxLessThanXNode[self.nextIndex][h]=newNode
def discard(self,x):
if not self.exists(x):
return
self.cnt[x]-=1
if self.cnt[x]!=0:
return
del self.cnt[x]
self.length-=1
now=self.sentinel
for h in range(self.maxHeight,-1,-1):
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<x:
now=now[self.nextIndex][h]
maxLessThanXNode=now
#リンクの更新(xが存在する高さなら)
if maxLessThanXNode[self.nextIndex][h]!=None and maxLessThanXNode[self.nextIndex][h][self.valIndex]==x:
removeNode=maxLessThanXNode[self.nextIndex][h]
maxLessThanXNode[self.nextIndex][h]=removeNode[self.nextIndex][h]
class BIT:
def __init__(self,N):
self.N=N
self.values=[0]*(N+1)#1-indexed
def add(self,i,x):
i+=1 #1-indexed
while i<=self.N:
self.values[i]+=x
i+=i&(-i)
def query(self,i):#[0,i]
i+=1 #1-indexed
ret=0
while i!=0:
ret+=self.values[i]
i-=i&(-i)
return ret
#文字列
alphabet=string.ascii_lowercase
ALPHABET=string.ascii_uppercase
alphaToIdx={c:i if c<"A" else i-26 for i,c in enumerate(alphabet+ALPHABET)}
def join(A,s=""):
return s.join(list(map(str,A)))
def sortStr(s):
return "".join(sorted(s))
#数学系
mod=998244353
mod2=1000000007
def invsign(num):
return -num
def gcd(*args):
return reduce(math.gcd,args)
def lcm(*args):
return reduce(lambda a,b:a*b//math.gcd(a,b),args)
def getPrimes(n,returnNums=False):#O(n log log n)
if n==0:return []
ret=[True]*(n+1)
ret[0]=False
ret[1]=False
for a in range(2,n+1):
if ret[a]:
for b in range(a*2,n+1,a):
ret[b]=False
if returnNums:
ret=[i for i,flag in enumerate(ret) if flag]
return ret
def isPrime(n):#O(√n)
if(n<=1):return False
i=2
while i*i<=n:
if(n%i==0):return False
i+=1
return True
def factorize(n):#O(√n)
b = 2
ret=defaultdict(int)
while b * b <= n:
while n % b == 0:
n //= b
ret[b]+=1
b+=1
if n > 1:ret[n]+=1
return ret
class EratosthenesFactorization:#O(n log log n)
def __init__(self,N):
self.primeFactor=[None]*(N+1)
for i in range(2,N+1):
if self.primeFactor[i]==None:
self.primeFactor[i]=i
for j in range(i*2,N+1,i):
self.primeFactor[j]=i
def factorize(self,N):#O(logN)
now=N
primes=[]
while now!=1:
primes.append(self.primeFactor[now])
now=now//self.primeFactor[now]
return Counter(primes)
def getPowList(base,maxExponent,mod):
ret=[1]*(maxExponent+1)
for i in range(1,maxExponent+1):
ret[i]=ret[i-1]*base%mod
return ret
def getFactorials(n,mod):
ret=[1]*(n+1)
for a in range(2,len(ret)):
ret[a]=ret[a-1]*a
if mod!=None:
ret[a]%=mod
return ret
def getFactorialModInvs(n,mod):
return [pow(factorial,mod-2,mod) for factorial in getFactorials(n,mod)]
def comb_(n,r,factorials,mod=None,factorialModInvs=None):#O(1)
if n-r<0:return 0
if mod==None:
return factorials[n]//(factorials[n-r]*factorials[r])
else:
if factorialModInvs:
return (factorials[n]*factorialModInvs[n-r]%mod)*factorialModInvs[r]%mod
else:
return (factorials[n]*pow(factorials[n-r],mod-2,mod)%mod)*pow(factorials[r],mod-2,mod)%mod
class Comb:
def __init__(self,n,mod,factorials=None,factorialModInvs=None):
self.n=n
self.mod=mod
if factorials:
self.factorials=factorials
else:
self.factorials=getFactorials(n,mod)
if factorialModInvs:
self.factorialModInvs=factorialModInvs
else:
self.factorialModInvs=getFactorialModInvs(n,mod)
def comb(self,n,r):
if n-r<0:return 0
return (self.factorials[n]*self.factorialModInvs[n-r]%self.mod)*self.factorialModInvs[r]%self.mod
def comb2(n,mod=None):
if n-2<0:return 0
if mod==None:
return (n*(n-1))//2
else:
return (n*(n-1)%mod)*pow(2,mod-2,mod)
def baseConversion(numbers,base,nextbase):
N=len(numbers)
if nextbase==10:
sum_=0
for i,number in enumerate(numbers):
p=(N-i-1)
sum_+=number*base**p
ret=list(map(int,list(str(sum_))))
elif base==10:
number=int(join(numbers))
ret=deque()
while 0<number:
ret.appendleft(number%nextbase)
number//=nextbase
if len(ret)==0:ret.append(0)
ret=list(ret)
else:
ret=baseConversion(numbers,base,10)
ret=baseConversion(ret,10,nextbase)
return ret
def getDigitSum(numAsStr):
A=list(map(int,list(str(numAsStr))))
return sum(A)
def getDivisors(number):#O(√n log √n)
ret=[]
i=1
while i**2<=number:
if number%i==0:
ret.append(i)
ret.append(number//i)
if i==number//i:ret.pop()
i+=1
ret.sort()
return ret
def iceil(a,b,mul=False):
return int(((a+(b-1))//b)*(b if mul else 1))
def ifloor(a,b,mul=False):
return int((a//b)*(b if mul else 1))
def mex(S):#集合で受け取る
ret=0
while ret in S:
ret+=1
return ret
def isqrt(num):#pypyではisqrtは使えない
return int(math.sqrt(num))
def sumTousa(l,r,d,mod=None):
if mod==None:
N=((r-l)//d+1)
return N*(l+r)//2
else:
N=((r-l)*pow(d,mod-2,mod)+1)
return (N*(l+r)*pow(2,mod-2,mod))%mod
def sign(num):
if num>=0:
return 1
elif num<0:
return -1
else:
return 0
def inc(x):
return x+1
def dec(x):
return x-1
def minmax(A):
m,M=A[0],A[0]
for a in A:
m=min(m,a)
M=max(M,a)
return m,M
def getDigits(num):
if num==0:return 1
ret=0
while num>0:
num//=10
ret+=1
return ret
def phi(num):#O(log N)
P=factorize(num).keys()
return (num//(reduce(mul,P)))*reduce(mul,[p-1 for p in P])
def modinv(num,mod,isprime=True):
if isprime:
return pow(num,mod-2,mod)
else:
if gcd(num,mod)==1:
return pow(num,phi(mod)-1,mod)
else:
return None
def nearlyEqual(a,b,delta):
return abs(a-b)<=delta
def getSetTeams(numOfMems,MinNumOfTeams,MaxNumOfTeams):
ret=[]
teams=[]
def f(i):
if i==numOfMems:
if MinNumOfTeams<=len(teams)<=MaxNumOfTeams:
ret.append([team[:] for team in teams])
else:
for team in teams:
team.append(i)
f(i+1)
team.pop()
if len(teams)<MaxNumOfTeams:
teams.append([i])
f(i+1)
teams.pop()
f(0)
return ret
def getMedian(A,isSortedList=False):
sortedList=A[:]
N=len(A)
if isSortedList==False:
sortedList.sort()
return (sortedList[N//2]+sortedList[N-N//2-1])/2
#二分探索
def intBS(left,right,func):
while right-left>1:
mid=(left+right)//2
if func(mid):
left=mid
else:
right=mid
return left,right
def floatBS(left,right,func,delta):
while right-left>delta:
mid=(left+right)/2
if func(mid):
left=mid
else:
right=mid
return left,right
def bisectLeft(A,x,left=0,right=None,func=lambda x:x):
left=left-1 #含まない
if right==None:right=len(A)#含む
return intBS(left,right,lambda i:A[i]<x)[1]
def bisectRight(A,x,left=0,right=None,func=lambda x:x):
left=left-1 #含まない
if right==None:right=len(A)#含む
return intBS(left,right,lambda i:A[i]<=x)[1]
def rvBisectLeft(A,x):
return intBS(-1,len(A),lambda i:x<A[i])[1]
def rvBisectRight(A,x):
return intBS(-1,len(A),lambda i:x<=A[i])[1]
def binarySearch(A,x):
i=bisect.bisect_left(A,x)
if i==len(A):
ret=-1
else:
if A[i]==x:
ret=i
else:
ret=-1
return ret
#ビット演算
def getCombs(bits,length):
if bits==0:return [0]
ret=[]
num=2**bits-1
while num<(1<<length):
ret.append(num)
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
return ret
def getPopCountList(length):
list_length=2**length
popcount=[0]*list_length
for i in range(1,list_length):
popcount[i]=i%2+popcount[i//2]
return popcount
def getBinSubs(num):
ret=[]
T=num
while True:
ret.append(T)
if T==0:break
T=(T-1)&num
return ret
def getbit(num,i):
return (num>>i)&1
def cntbits(num):
ret=0
while num:
ret+=num&1
num>>=1
return ret
def getSetBitPos(num):
return [i for i in range(num.bit_length()) if getbit(num,i)]
def getUnSetBitPos(num,N):
return [i for i in range(N) if getbit(num,i)==0]
#座標
rd=[[0,1],[1,0]]
crossmove=[[0,-1],[0,1],[1,0],[-1,0]]
xmove=[[-1,-1],[1,1],[-1,1],[1,-1]]
arround=crossmove+xmove
def getDist(x1,y1,x2,y2,sq=False):
ret=(x1-x2)**2+(y1-y2)**2
if not sq:ret**=0.5
return ret
def getManhattanDist(x1,y1,x2,y2):
return abs(x1-x2)+abs(y1-y2)
def lrudToYXMat(d):
if d.upper()=="L":return [0,-1]
elif d.upper()=="R":return [0,1]
elif d.upper()=="U":return [-1,0]
elif d.upper()=="D":return [1,0]
def lrudToYXCoor(d):
if d.upper()=="L":return [0,-1]
elif d.upper()=="R":return [0,1]
elif d.upper()=="U":return [1,0]
elif d.upper()=="D":return [-1,0]
def within(y,x,H,W):
return 0<=y<H and 0<=x<W
def rot45(y,x):#√2の倍率は無視
return x+y,x-y
def rot90(y,x):
return x,-y
def rot180(y,x):
return -y,-x
def rot270(y,x):
return -x,y
def newPoints(y,x,H,W,move):
ret=[]
for dy,dx in move:
newy=y+dy
newx=x+dx
if within(newy,newx,H,W):
ret.append([newy,newx])
return ret
#行列
def getIdMat(width):
ret=[[0]*width for i in range(width)]
for i in range(width):
ret[i][i]=1
return ret
def transpose(mat):
if mat==[]:return []
ret=[[None for j in range(len(mat))] for i in range(len(mat[0]))]
for i in range(len(mat)):
for j in range(len(mat[0])):
ret[j][i]=mat[i][j]
return ret
def dot(A,B):
B_=copyMat(B)
if type(B[0])!=list:
B_=transpose([B_])
if len(A[0])!=len(B_):raise ValueError
H=len(A)
W=len(B_[0])
ret=[[0 for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
for k in range(len(B_)):
ret[i][j]+=A[i][k]*B_[k][j]
return ret
def getMatrixPowDict(A,max_,mod=None):
D={}
D[1]=A
now=2
while now<=max_:
D[now]=dot(D[now//2],D[now//2])
if mod!=None:
for j in range(len(D[now])):
D[now]=list(map(lambda x:x%mod,D[now]))
now*=2
return D
def matrixPow(A,i,mod=None,matrixPowDict=None):
if matrixPowDict==None:matrixPowDict=getMatrixPowDict(A,i)
B=bin(i)[2:][::-1]
I=[[1 if k==j else 0 for k in range(len(A))] for j in range(len(A))]
ret=I
for j,v in enumerate(B):
if v=="1":
ret=dot(ret,matrixPowDict[2**j])
if mod!=None:
for j in range(len(ret)):
ret[j]=list(map(lambda x:x%mod,ret[j]))
return ret
def modHakidashi(A,mod,isExtended=False):#return rank
rows=len(A)
cols=len(A[0])
rank=0
for col in range(cols):
#行を入れ替える
if isExtended and col==cols-1:break
pivot=None
for row in range(rank,rows):
if A[row][col]!=0:
pivot=row
break
if pivot==None:continue
A[rank],A[pivot]=A[pivot],A[rank]
#ピボットの値を1にする
A[rank]=list(map(lambda x:x*pow(A[rank][col],mod-2,mod),A[rank]))
#ピボットのある列の値をすべて0にする
for row in range(rows):
if row==rank:continue
constantFactor=A[row][col]
for col2 in range(cols):
A[row][col2]-=(A[rank][col2]*constantFactor)%mod
A[row][col2]%=mod
rank+=1
return rank
def hakidashi(A,eps,isExtended=False):#未検証
rows=len(A)
cols=len(A[0])
rank=0
for col in range(cols):
#行を入れ替える
if isExtended and col==cols-1:break
pivot=None
maxAbs=-inf
for row in range(rank,rows):
if abs(A[row][col])>eps and abs(A[row][col])>maxAbs:#計算誤差を小さくするため絶対値が大きいものを優先する
pivot=row
maxAbs=abs(A[row][col])
break
if pivot==None:continue
A[rank],A[pivot]=A[pivot],A[rank]
#ピボットの値を1にする
A[rank]=list(map(lambda x:x/A[rank][col],A[rank]))
#ピボットのある列の値をすべて0にする
for row in range(rows):
if row==rank and abs(A[row][col])>eps:continue
constantFactor=A[row][col]
for col2 in range(cols):
A[row][col2]-=A[rank][col2]*constantFactor
rank+=1
return rank
#一次元配列
class wideRangeCumSum:
def __init__(self):
self.deltaList=defaultdict(int)
self.cumsum={}
self.keys_=[]
def keys(self):
return self.keys_
def add(self,i,x):
self.deltaList[i]+=x
def updateCumSum(self):
self.keys_=sorted(self.deltaList.keys())
for i,curKey in enumerate(self.keys_):
self.cumsum[curKey]=self.deltaList[curKey]
if 0<i:
prevKey=self.keys_[i-1]
self.cumsum[curKey]+=self.cumsum[prevKey]
def get(self,i):
if i in self.cumsum:#O(1)
return self.cumsum[i]
else:#O(log len(cumsumKeys))
j=bisect_right(self.keys_,i)-1
if j==-1:
return 0
else:
return self.cumsum[self.keys_[j]]
def getAllRanges(self,includingEnd=False):
ret=[]
for i in range(len(self.keys_)-1):
left=self.keys_[i]
right=self.keys_[i+1]
ret.append([left,right])
if includingEnd:
ret.append([self.keys[-1],None])
return ret
def zaatsu(A):#座標圧縮
B=list(set(A))
B.sort()
ret=[]
for a in A:
ret.append(bisect.bisect_left(B,a))
return ret
def getCumSum(A):
N=len(A)
ret=[0]*(N+1)
for i in range(1,N+1):
ret[i]=ret[i-1]+A[i-1]
return ret
def imos(deltaList):
ret=deltaList[:]
for i in range(1,len(deltaList)):
ret[i]=ret[i-1]+deltaList[i]
return ret
def nextPermutation(A):
N=len(A)
for i in range(N-1-1,-1,-1):
if A[i]<A[i+1]:
for j in range(N-1,-1,-1):
if A[i]<A[j]:
A[i],A[j]=A[j],A[i]
A[i+1:]=A[i+1:][::-1]
return True
return None
def listmap(A,func):
return list(map(func,A))
def getValsWithIdx(A):
return [[val,i] for i,val in enumerate(A)]
def getPos(A,isInjective=False):
if isInjective:
ret=defaultdict(int)
for i,a in enumerate(A):
ret[a]=i
else:
ret=defaultdict(list)
for i,a in enumerate(A):
ret[a].append(i)
return ret
def cntIf(A,func):
ret=0
for a in A:
if func(a):
ret+=1
return ret
def cntUnique(A):
return len(Counter(A))
def linkedsort(*args,key=None,reverse=False):
args=list(args)
mat=list(zip(*args))
if key==None:
mat.sort(reverse=reverse)
else:
mat.sort(key=key,reverse=reverse)
mat=list(zip(*mat))
for i in range(len(args)):
args[i][:]=mat[i]
def findIf(A,func):
for i,a in enumerate(A):
if func(a):
return i
return -1
def rfindIf(A,func):
for i in range(len(A)-1,-1,-1):
if func(A[i]):
return i
return -1
def isSub(a,A):
now=0
N=len(A)
for i in range(len(a)):
while now<N:
if a[i]==A[now]:
now+=1
break
else:
now+=1
else:
return False
return True
def rfind(A,val):
for i in range(len(A)-1,-1,-1):
if A[i]==val:
return i
return -1
def cntInv(A):#O(N log N)
ret=0
A=zaatsu(A)
bit=BIT(len(A))
for i in range(len(A)):
ret+=i-bit.query(A[i])
bit.add(A[i],1)
return ret
def cntInv2v(A):#O(N)
if A==[]:return 0
maxval=max(A)
cnt=0
ret=0
for a in A:
if a==maxval:
cnt+=1
else:
ret+=cnt
return ret
def RLE(A):
ret=[]
prev=None
for a in A:
if prev==a:
ret[-1][1]+=1
else:
ret.append([a,1])
prev=a
return ret
def LIS(A):#最長増加部分列 O(N log N)
dp=[inf]*len(A) #dp[i]=部分列の長さが(i+1)の時の最終要素の最小値
for a in A:
dp[bisect.bisect_left(dp,a)]=a
return bisect.bisect_left(dp,inf-1)
def replace(A,curVal,newVal):
return [newVal if a==curVal else a for a in A]
def getLoopIdx(*args):
ret=[]
code=""
for i,arg in enumerate(args):
code+=f"{' '*i}for {alphabet[i]} in {arg}:\n"
code+=f"{' '*len(args)}ret.append(({','.join(alphabet[:len(args)])}))"
exec(code)
return ret
def zalgo(A):#O(N)
N=len(A)
ret=[0]*N
ret[0]=N
i=1
j=0
while i<N:
while i+j<N and A[j]==A[i+j]:
j+=1
ret[i]=j
if j==0:
i+=1
else:
k=1
while i+k<N and k+ret[k]<j:
ret[i+k]=ret[k]
k+=1
i+=k
j-=k
return ret
def getTrueIdx(A):
return [i for i,a in enumerate(A) if a]
def getUnique(A):
return list(Counter(A).keys())
def rvsort(A):
return A.sort(reverse=True)
#多次元配列
def copyMat(A):
N=len(A)
dim=1
cur=A
while len(cur)>0 and type(cur[0]) in (tuple,list):
dim+=1
cur=cur[0]
if dim==1:
return A[:]
else:
ret=[None]*N
for i in range(N):
ret[i]=copy(A[i])
return ret
def sqlist(H,W,initVal=None):
return [[initVal]*W for i in range(H)]
def cblist(H,W,Z,initVal=None):
return [[[initVal]*Z for j in range(W)] for i in range(H)]
def getCol(A,col):
return [A[i][col] for i in range(len(A))]
def getRangeSumCumSumMat(cumSum,y1,x1,y2,x2):#1-indexed 閉区間
ret=cumSum[y2][x2]
ret-=cumSum[y2][x1-1]
ret-=cumSum[y1-1][x2]
ret+=cumSum[y1-1][x1-1]
return ret
def getCumSumMat(mat):
H,W=len(mat),len(mat[0])
ret=sqlist(H+1,W+1,0)
for i in range(1,H+1):
for j in range(1,W+1):
ret[i][j]+=ret[i][j-1]+mat[i-1][j-1]
for j in range(1,W+1):
for i in range(1,H+1):
ret[i][j]+=ret[i-1][j]
return ret
class CumSumByValue:#メモリO(N) 1-indexed
def __init__(self,A):
self.cumsum=defaultdict(None)
for a in set(A):
self.cumsum[a]=wideRangeCumSum()
for i,a in enumerate(A):
self.cumsum[a].add(i+1,1)
for a in set(A):
self.cumsum[a].updateCumSum()
def get(self,key,i):
if key in self.cumsum:
return self.cumsum[key].get(i)
else:
return 0
def imosMat(deltaList):
H,W=len(deltaList),len(deltaList[0])
ret=copyMat(deltaList)
for i in range(H):
for j in range(1,W):
ret[i][j]+=ret[i][j-1]
for j in range(W):
for i in range(1,H):
ret[i][j]+=ret[i-1][j]
return ret
def yxToX(y,x,H,W):
return y*W+x
def yxzToX(y,x,z,H,W,D):
return y*(W*D)+x*D+z
def cntMat(mat,val):
cnt=0
for i in range(len(mat)):
for j in range(len(mat[i])):
if mat[i][j]==val:
cnt+=1
return cnt
def mapping(A,func):
N=len(A)
dim=1
cur=A
while len(cur)>0 and type(cur[0]) in (tuple,list):
dim+=1
cur=cur[0]
if dim==1:
return list(map(func,A))
else:
ret=[None]*N
for i in range(N):
ret[i]=mapping(A[i],func)
return ret
def rot90Mat(mat):
H=len(mat[0])
W=len(mat)
ret=sqlist(H,W)
for i in range(H):
for j in range(W):
ret[i][j]=mat[j][H-1-i]
return ret
def addWall(A,chr="#"):
H=len(A)
W=len(A[0])
type_=type(A[0])
if type_==str:
for i in range(H):
A[i]+=chr
A.append(chr*(W+1))
else:
for i in range(H):
A[i].append(chr)
A.append([chr]*(W+1))
def findMat(mat,val):
for i in range(len(mat)):
for j in range(len(mat[i])):
if mat[i][j]==val:return (i,j)
return None
def flatten(mat):
return list(itertools.chain.from_iterable(mat))
def listToMat(A,H,W):
N=len(A)
ret=sqlist(H,W)
for i in range(H):
for j in range(W):
ret[i][j]=A[i*W+j]
return ret
def sliceMat(mat,top,bottom,left,right):#閉区間
ret=[]
for i in range(top,bottom+1):
if 0<=i<len(mat):
ret.append(mat[i][left:right+1])
if ret[-1]==[]:ret.pop()
return ret
def listToTuple(A):
ret=[]
for item in A:
if isinstance(item, list):
ret.append(tuple(listToTuple(item)))
elif isinstance(item, tuple):
ret.append(listToTuple(item))
else:
ret.append(item)
ret=tuple(ret)
return ret
#グラフ
class Doubling:#パスグラフ用 O(log dist * N)
def __init__(self,pathGraph,maxDist):
self.bitLength=len(bin(maxDist)[2:])
self.N=len(pathGraph)
self.D=sqlist(self.bitLength,self.N,list)
for i in range(self.bitLength):
if i==0:
self.D[0]=pathGraph[:]
else:
for j in range(self.N):
self.D[i][j]=self.D[i-1][self.D[i-1][j]]
def getVal(self,start,dist):
ret=start
distBitLength=len(bin(dist)[2:])
for i in range(distBitLength):
if ((dist>>i)&1)==1:
ret=self.D[i][ret]
return ret
class CyclicPath:#入力はパス(パスグラフではない) O(N)
def __init__(self,path):
visited=defaultdict(bool)
cycleStartVal=None
cycleEndIndex=None
for i,u in enumerate(path):
if visited[u]:
cycleStartVal=u
cycleEndIndex=i
break
visited[u]=True
cycleStartIndex=path.index(cycleStartVal)
self.acyclicPath=path[:cycleStartIndex]
self.cyclicPath=path[cycleStartIndex:cycleEndIndex]
def getVal(self,index):#O(1)
if index<=len(self.acyclicPath)-1:
return self.acyclicPath[index]
else:
index-=len(self.acyclicPath)
index%=len(self.cyclicPath)
return self.cyclicPath[index]
def getPath(self):
return self.acyclicPath,self.cyclicPath
class FordFulkerson:
def __init__(self,edges,V,s,t):
self.V=V
self.used=[False]*V
self.G=[[] for a in range(V)]
self.s=s
self.t=t
for edge in edges:
self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.cost,"rev":len(self.G[edge.y])})
self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
def dfs(self,v,t,f=inf):
if v==t:return f
self.used[v]=True
for a in range(len(self.G[v])):
x=self.G[v][a]["x"]
y=self.G[v][a]["y"]
cap=self.G[v][a]["cap"]
rev=self.G[y][self.G[x][a]["rev"]]
if self.used[y] or cap==0:continue
f2=self.dfs(y,t,min(f,cap))
if f2>0:
self.G[v][a]["cap"]-=f2
rev["cap"]+=f2
return f2
return 0
def maxflow(self):
flow=0
while True:
self.used=[False]*self.V
zouka=self.dfs(self.s,self.t)
if zouka==0:break
flow+=zouka
return flow
def edgesToUG(edges,N):
G=[[] for i in range(N)]
for edge in edges:
u,v=edge
G[u].append(v)
G[v].append(u)
return G
def edgesToDG(edges,N):#未検証
G=[[] for i in range(N)]
for edge in edges:
u,v=edge
G[u].append(v)
return G
def UGToEdges(G):
N=len(G)
edges=[]
for i in range(N):
for j in G[i]:
if i<j:
edges.append((i,j))
return edges
def DGToEdges(G):#未検証
N=len(G)
edges=[]
for i in range(N):
for j in G[i]:
edges.append((i,j))
return edges
def dijkstra(edges,N,start):#O(V+E*logV)
G=[[] for a in range(N)]
for edge in edges:
G[edge.x].append([edge.cost,edge.y])
mincost=[inf]*N
Q=[[0,start]]
while len(Q)>0:
curCost,cur=heappop(Q)
if mincost[cur]!=inf:continue
mincost[cur]=curCost
for edgeCost,nxt in G[cur]:
newCost=curCost+edgeCost
if mincost[nxt]==inf:#高速化のため
heappush(Q,[newCost,nxt])
return mincost
def dictDijkstra(edges,start):
mincost=defaultdict(lambda x:inf)
visited=defaultdict(bool)
G=defaultdict(list)
for edge in edges:
G[edge.x].append([edge.cost,edge.y])
Q=[]
heappush(Q,[0,start])
while len(Q)>0:
nowcost,nowx=heappop(Q)
if visited[nowx]:continue
visited[nowx]=True
mincost[nowx]=nowcost
for cost,y in G[nowx]:
if visited[y]:continue #高速化
newcost=nowcost+cost
heappush(Q,[newcost,y])
return mincost
def dictBFS01(edges,start):
G=defaultdict(list)
for edge in edges:
G[edge.x].append((edge.y,edge.cost))
mincost=defaultdict(lambda:inf)
Q=deque([[start,0]])
while Q:
cur,cost=Q.popleft()
if mincost[cur]!=inf:continue
mincost[cur]=cost
for nxt,edgeCost in G[cur]:
if edgeCost==1:
Q.append([nxt,cost+edgeCost])
else:
Q.appendleft([nxt,cost+edgeCost])
return mincost
def shortestBFS(adjList,start):
N=len(adjList)
mincost=[inf]*N
mincost[start]=0
Q=deque([start])
while Q:
now=Q.popleft()
for tugi in adjList[now]:
if mincost[tugi]==inf:
mincost[tugi]=mincost[now]+1
Q.append(tugi)
return mincost
def dictShortedBFS(adjList,start):
mincost=defaultdict(lambda:inf)
mincost[start]=0
Q=deque([start])
while Q:
now=Q.popleft()
for tugi in adjList[now]:
if mincost[tugi]==inf:
mincost[tugi]=mincost[now]+1
Q.append(tugi)
return mincost
def warshallFloyd(adjMat):#O(N**3)
V=len(adjMat)
mincost=[[inf for j in range(V)] for i in range(V)]
for i in range(V):
for j in range(V):
mincost[i][j]=adjMat[i][j]
for i in range(V):mincost[i][i]=0 #この行をコメントすると同じ頂点を一回以上辺を通ってたどり着く場合の最短距離が分かる
for k in range(V):
for s in range(V):
for t in range(V):
if mincost[s][k]==inf or mincost[k][t]==inf:continue
mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
return mincost
def bellemanFord(edges,N,start):
mincost=[inf]*N
mincost[start]=0
for _ in range(N):
for edge in edges:
if mincost[edge.x]==inf:continue
mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.cost)
return mincost
def getConnectedNodes(adjList,start):
S=[start]
connectedNodes=set([start])
while len(S)>0:
cur=S.pop()
for nxt in adjList[cur]:
if nxt not in connectedNodes:
connectedNodes.add(nxt)
S.append(nxt)
return connectedNodes
def topologicalSort(adjList):#閉路がある場合Noneを返す
path=[]
#入次数
indeg=[0]*len(adjList)
for u in range(len(adjList)):
for v in adjList[u]:
indeg[v]+=1
isolatedNodes=[]
#初めから入次数が0の頂点をスタックに入れる
for u in range(len(adjList)):
if indeg[u]==0:
isolatedNodes.append(u)
while isolatedNodes:
u=isolatedNodes.pop()
path.append(u)
for v in adjList[u]:
indeg[v]-=1
if indeg[v]==0:
isolatedNodes.append(v)
return path if len(path)==len(adjList) else None
def SSC(edges,N):#強連結成分分解 O(VlogV+E)
#DFS一回目
G=[[] for i in range(N)]
for edge in edges:
G[edge.x].append(edge.y)
nokori=set(list(range(N)))
visited=defaultdict(bool)
kaerigake=[]
while nokori:
start=nokori.pop()
S=[(start,True)]#(start,行き道か)
while S:
now,isIki=S.pop()
if visited[(now,isIki)]:continue
visited[(now,isIki)]=True
nokori.discard(now)
if isIki:
S.append((now,False))
for tugi in G[now]:
if visited[(tugi,True)]:
pass
else:
S.append((tugi,True))
else:
kaerigake.append(now)
numbers=[None]*N
for i,v in enumerate(kaerigake):
numbers[v]=i
#DFS二回目
G=[[] for i in range(N)]
for edge in edges:
G[edge.y].append(edge.x)
maxQ=[(numbers[i],i) for i in range(N)]
maxQ.sort(reverse=True)
visited=[False]*N
ret=[]
for tmp,start in maxQ:
if visited[start]:continue#既に訪れていたら
visited[start]=True
S=[start]
ret.append([])
while S:
now=S.pop()
ret[-1].append(now)
for tugi in G[now]:
if not visited[tugi]:
visited[tugi]=True
S.append(tugi)
return ret #上流の強連結成分から
def isConnected(adjList):
S=[0]
V=[False]*len(adjList)
V[0]=True
while S:
now=S.pop()
for tugi in adjList[now]:
if not V[tugi]:
V[tugi]=True
S.append(tugi)
return all(V)
def isNibuGraph(adjList):
V=len(adjList)
colors=[None]*V
for s in range(V):
if colors[s]==None:
S=[s]
colors[s]=0
while S:
cur=S.pop()
for nxt in adjList[cur]:
if colors[nxt]==None:
colors[nxt]=1-colors[cur]
S.append(nxt)
elif colors[nxt]==colors[cur]:
return False
else:
pass
return True
def paintNibuGraph(adjList):
N=len(adjList)
colors=[None]*N
for start in range(N):
if colors[start]==None:
S=[start]
colors[start]=0
while S:
cur=S.pop()
for nxt in adjList[cur]:
if colors[nxt]==None:
colors[nxt]=1-colors[cur]
S.append(nxt)
elif colors[nxt]==colors[cur]:
return None
else:
pass
return colors
def diam(adjMat):#グラフの直径を求める
mincost=warshallFloyd(adjMat)
ret=-inf
for i in range(len(adjMat)):
for j in range(len(adjMat)):
ret=max(ret,mincost[i][j])
return ret
def reverseDegree(adjList):
N=len(adjList)
ret=[[] for i in range(N)]
for i in range(N):
for next_ in adjList[i]:
ret[next_].append(i)
return ret
def gridToGraph(A,move,obstacle="#"):
H=len(A)
W=len(A[0])
G=defaultdict(list)
for y in range(H):
for x in range(W):
for d in move:
nextY=y+d[0]
nextX=x+d[1]
if within(nextY,nextX,H,W) and A[nextY][nextX]!=obstacle:
G[(y,x)].append((nextY,nextX))
return G
def TSP(adjMat,start=None):#O(N**2 * 2**N)
#dp[bin_][i]=bin_のbitが立っている箇所を通る&最後に頂点iに到達する場合の最小値
N=len(adjMat)
dp=sqlist(2**N,N,inf)
dp[0][start]=0
for curbin in range(2**N-1):
for cur in range(N):
for nxt in range(N):
if getbit(curbin,nxt)==0:
nxtbin=curbin|(1<<nxt)
if dp[curbin][cur]!=inf:
dp[nxtbin][nxt]=min(dp[nxtbin][nxt],dp[curbin][cur]+adjMat[cur][nxt])
return dp
def getConnectedComponents(edges,N,updateVertexNumbers=True):
U=UnionFind(N)
for edge in edges:
u=edge.x
v=edge.y
U.union(u,v)
ret={}
for edge in edges:
u=edge.x
v=edge.y
root=U.root(u)
if root not in ret:
ret[root]={"N":U.unionSize(root),"edges":[]}
ret[root]["M"]+=1
ret[root]["edges"].append(Edge(u,v,edge.cost))
for u in range(N):
if U.unionSize(u)==1:
ret[u]={"N":1,"edges":[]}
if updateVertexNumbers:
for root in U.roots():
vertexNums=set()
for edge in ret[root]["edges"]:
vertexNums.add(edge.x)
vertexNums.add(edge.y)
vertexNums=sorted(vertexNums)
pos=getPos(vertexNums,isInjective=True)
for i in range(len(ret[root]["edges"])):
ret[root]["edges"][i].x=pos[ret[root]["edges"][i].x]
ret[root]["edges"][i].y=pos[ret[root]["edges"][i].y]
ret=list(ret.values())
return ret
def getPostOrder(adjList,start):
ret=[]
S=[(start,True)]
departed=[False]*len(adjList)
while S:
cur,iki=S.pop()
if iki:
departed[cur]=True
S.append((cur,False))
for nxt in adjList[cur]:
if departed[nxt]:continue
S.append((nxt,True))
else:
ret.apend(cur)
return ret
#グラフ(木)
def edgesToTree(N,edges,root):
parents=[None]*N
children=[[] for i in range(N)]
G=edgesToUG(edges,N)
S=[root]
V=[False]*N
V[root]=True
while S:
cur=S.pop()
for nxt in G[cur]:
if not V[nxt]:
V[nxt]=True
S.append(nxt)
children[cur].append(nxt)
parents[nxt]=cur
return parents,children
def treeToUG(parents,children):
N=len(parents)
ret=[[] for i in range(N)]
for i in range(N):
if parents[i]!=None:
ret[i].append(parents[i])
ret[i]+=children[i]
return ret
def getLeafs(parents,children):
ret=[]
N=len(parents)
for i in range(N):
deg=0
if parents[i]!=None:deg+=1
deg+=len(children[i])
if deg==1:
ret.append(i)
return ret
def getTreeDepths(parents,children):
root=parents.index(None)
N=len(parents)
S=[root]
ret=[None]*N
ret[root]=0
while S:
cur=S.pop()
for child in children[cur]:
S.append(child)
ret[child]=ret[cur]+1
return ret
def doubleSweep(edges,N):#木の直径を求める
G=[[] for i in range(N)]
for e in edges:
G[e.x].append((e.y,e.cost))
start=0
maxmincost=None
for _ in range(2):
S=[start]
mincost=[inf]*N
mincost[start]=0
while S:
now=S.pop()
nowcost=mincost[now]
for e in G[now]:
if mincost[e[0]]==inf:
mincost[e[0]]=nowcost+e[1]
S.append(e[0])
maxmincost=max(mincost)
start=mincost.index(maxmincost)
return maxmincost
def kruskal(N,Edges):#最小全域木 O(M logN)
U=UnionFind(N)
Edges.sort(key=lambda x:x.cost)
treeEdges=[]
for i in range(len(Edges)):
edge=Edges[i]
x=edge.x
y=edge.y
cost=edge.cost
if not U.same(x,y):
treeEdges.append(Edge(x,y,cost))
U.union(x,y)
return treeEdges
def extractSimpleUGCycle(G):#O(N log N)
N=len(G)
deg=[len(G[u]) for u in range(N)]
ret=copyMat(G)
Q=[u for u in range(N) if deg[u]==1]
for u in range(N):
ret[u]=set(ret[u])
while Q:
u=Q.pop()
v=ret[u].pop()
ret[v].remove(u)
deg[v]-=1
if deg[v]==1:
Q.append(v)
for u in range(N):
ret[u]=list(ret[u])
return ret
#他
class MinMaxWithIndex:
def __init__(self,values=[],indices=[]):
self.minVal=None
self.minIndex=None
self.maxVal=None
self.maxIndex=None
for i in range(len(values)):
self.update(values[i],indices[indices[i]])
def update(self,val,index):
if self.minVal==None or self.minVal>val:
self.minVal=val
self.minIndex=index
if self.maxVal==None or self.maxVal<val:
self.maxVal=val
self.maxIndex=index
def min(self):
return self.minVal,self.minIndex
def max(self):
return self.maxVal,self.maxIndex
def getMaxIndex(A):
max_=-inf
idx=None
for i,a in enumerate(A):
if max_<a:
max_=a
idx=i
return idx
def getMinIndex(A):
min_=-inf
idx=None
for i,a in enumerate(A):
if a<min_:
min_=a
idx=i
return idx
#入力
def inputs(row=None,func=None):
ret=None
if row==None:
ret=input().split()
else:
ret=[input() for _ in range(row)]
if func!=None:ret=mapping(ret,func)
return ret
def inputmat(row,func=None,transpose=False):
if transpose:
ret=None
col=None
for i in range(row):
A=inputs()
if i==0:
col=len(A)
ret=[[None]*row for _ in range(col)]
for j in range(col):
ret[j][i]=A[j]
else:
ret=[inputs() for _ in range(row)]
if func!=None:ret=mapping(ret,func)
return ret
def inputint():
return int(input())
def inputints(row=None,func=None):
ret=inputs(row,int)
if func!=None:ret=mapping(ret,func)
return ret
def inputintmat(row,func=None,transpose=False):
ret=inputmat(row,int,transpose)
if func!=None:ret=mapping(ret,func)
return ret
def inputUG(N,M):
G=[[] for i in range(N)]
for i in range(M):
u,v=inputints()
u-=1
v-=1
G[u].append(v)
G[v].append(u)
return G
def inputDG(N,M):
G=[[] for i in range(N)]
for i in range(M):
u,v=inputints()
u-=1
v-=1
G[u].append(v)
return G
def inputUEdges(M):
Edges=[]
for i in range(M):
a,b=inputints()
a-=1
b-=1
Edges.append(Edge(a,b,1))
Edges.append(Edge(b,a,1))
return Edges
def inputDEdges(M):
Edges=[]
for i in range(M):
a,b=inputints()
a-=1
b-=1
Edges.append(Edge(a,b,1))
return Edges
def inputTree(N,root):
parents=[None]*N
children=[[] for i in range(N)]
M=N-1
G=inputUG(N,M)
S=[root]
V=[False]*N
V[root]=True
while S:
now=S.pop()
for next_ in G[now]:
if not V[next_]:
V[next_]=True
S.append(next_)
children[now].append(next_)
parents[next_]=now
return parents,children
def fillNone(mat,width):
N=len(mat)
ret=copyMat(mat)
for i in range(N):
for _ in range(width-len(ret[i])):
ret[i].append(None)
return ret
#出力
def yn(flag,trueOutput="Yes",falseOutput="No"):
print(trueOutput if flag else falseOutput)
def YN(flag):
print("YES" if flag else "NO")
def no(*args):
print(f"{inspect.currentframe().f_back.f_lineno}: {' '.join(list(map(str,args)))}")
def printmat(A,sep=" ",fill=0):
if sep==" " and fill==0:
for a in A:
print(*a)
else:
for a in A:
print(sep.join(list(map(lambda x:str(x).center(fill),a))))
###############################################################################
N,M=inputints()
G=inputUG(N,M)
Q=inputint()
XK=inputintmat(Q)
dp=sqlist(4,N)
for cnt in range(4):
for u in range(N):
dp[cnt][u]={cnt+1}
if cnt>0:
for nxt in G[u]:
dp[cnt][u]|=dp[cnt-1][nxt]
for x,k in XK:
x-=1
print(sum(dp[k][x]))
# coding: utf-8
#import
import random
import os
import operator
from operator import add,sub,mul,xor,or_,and_
import time
import sys
import re
import string
import math
from fractions import Fraction
import inspect
from math import sqrt,ceil,floor,gcd,log,log2
import collections
from collections import defaultdict,deque,Counter
from fractions import Fraction
import bisect
from bisect import bisect_left,bisect_right
import itertools
from itertools import accumulate,permutations
import functools
from functools import cmp_to_key
from copy import deepcopy,copy
import heapq
from heapq import heappush,heappop,heapify
from functools import lru_cache,reduce
readline=sys.stdin.buffer.readline
sys.setrecursionlimit(10**8)
inf=int(10**18)
#データ構造
class Edge:
def __init__(self,x,y,cost=1):
self.x=x
self.y=y
self.cost=cost
class UnionFind:
def __init__(self,n):
self.n=n
self.size_=n
self.P=[-1 for i in range(n)]#根ノードの場合:ノード数×-1。それ以外：親ノードのindex
def root(self,x):
if self.P[x]>=0:
self.P[x]=self.root(self.P[x])
return self.P[x]
else:
return x
def same(self,x,y):
return self.root(x)==self.root(y)
def union(self,x,y):
x=self.root(x)
y=self.root(y)
if x==y:return
if -self.P[x]<-self.P[y]:x,y=y,x
self.P[x]+=self.P[y]
self.P[y]=x
self.size_-=1
def unionSize(self,x):
return -self.P[self.root(x)]#P[根ノード]=同じ集合のノード数×-1
def roots(self):
ret=set()
for i in range(self.n):
ret.add(self.root(i))
return list(ret)
def getMembersByRoot(self):
ret=defaultdict(list)
for u in range(self.n):
root=self.root(u)
ret[root].append(u)
return ret
def size(self):
return self.size_
def __str__(self):
ret=[]
for i in range(self.n):
ret.append((i,self.root(i)))
ret=str(ret)
return ret
class BinaryTrie:
def __init__(self,depth):
self.root=[None,None,0] #0-child 1-child count
self.bit_start=1<<(depth-1)
def insert(self,x):
node=self.root
b=self.bit_start
while b:
i=bool(x&b)
if node[i]==None:
node[i]=[None,None,1]
else:
node[i][2]+=1
node=node[i]
b>>=1
def pop_min(self,xor_mask=0):
node=self.root
b=self.bit_start
ret=0
node[2]-=1
while b:
i=bool(b&xor_mask)
ret<<=1
if node[i]==None:
i^=1
ret+=1
node=node[i]
b >>= 1
if node[i][2] > 1:
node[i][2] -= 1
node = node[i]
else:
tmp = node[i]
node[i] = None
node = tmp
return ret
def get_min(self,xor_mask=0):
node=self.root
b=self.bit_start
ret=0
while b:
i=bool(b&xor_mask)
ret<<=1
if node[i]==None:
i^=1
ret+=1
node=node[i]
b>>=1
return ret
def get_kth_min(self,k):
b = self.bit_start
node = self.root
ret = 0
while b:
ret = ret << 1
b >>= 1
if node[0] is None:
node = node[1]
ret += 1
elif node[1] is None:
node = node[0]
elif k <= node[0][2]:
node = node[0]
else:
k -= node[0][2]
node = node[1]
ret += 1
return ret
def erase(self, x):
b = self.bit_start
node = self.root
node[2] -= 1
while b:
i = bool(x & b)
if node[i][2] > 1:
node[i][2] -= 1
node = node[i]
else:
tmp = node[i]
node[i] = None
node = tmp
b >>= 1
def lower_bound(self, bound=0):
ret = self.get_kth_min(self.less_x(bound)+1)
if ret > bound:return ret
def upper_bound(self, bound=0):
ret = self.get_kth_min(self.less_x(bound+1)+1)
if ret < bound:return ret
def less_x(self, x):
if x < 0:return 0
b = self.bit_start
node = self.root
ret = 0
while b:
i = bool(x & b)
if node[i] is None:
if i == 1:
ret += node[0][2]
return ret
else:
if i == 1:
if node[0] is not None:
ret += node[0][2]
node = node[i]
b >>= 1
return ret
def is_exist(self, x):
b = self.bit_start
node = self.root
while b:
i = bool(x & b)
if node[i] is None:
return False
node = node[i]
b >>= 1
return True
class SegTree:#[l,r) query(i),query(i,i+1)がO(1)
def __init__(self, n, ide_ele, func):
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.func = func
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
"""初期値に配列を渡す実装の場合
for i in range(self.bottomStartPos - 1, 0, -1):
self.tree[i] = self.func(self.tree[2 * i], self.tree[2 * i + 1])
"""
def update(self, k, x):
k += self.bottomStartPos
self.tree[k] = x
while k > 1:
self.tree[k//2] = self.func(self.tree[k], self.tree[k ^ 1])
k//=2
def query(self, L,R=None):
if R==None or L+1==R:return self.tree[self.bottomStartPos+L]
L=max(0,L)
R=min(self.n,R)
#非再帰
res = self.ide_ele
L += self.bottomStartPos
R += self.bottomStartPos
while L < R:
if L & 1:
res = self.func(res, self.tree[L])
L += 1
if R & 1:
res = self.func(res, self.tree[R - 1])
L//=2
R//=2
return res
def __str__(self):
return str(self.tree[self.bottomStartPos:])
class Heap:#heapqと違い要素の削除ができる
def __init__(self,List=[],selfInvFunc=lambda x:x):
self.h=[]
self.d=defaultdict(int)
self.len=0
self.selfInvFunc=selfInvFunc #自己逆関数
for l in List:self.add(l)
def __len__(self):
return self.len
def __str__(self):
return str(sorted(self.getValues()))
def add(self,val):
val=self.selfInvFunc(val)
heapq.heappush(self.h,val)
self.d[val]+=1
self.len+=1
def __cleanup(self):
top=self.h[0]
while self.d[top]==0:
heappop(self.h)
top=self.h[0]
def pop(self):
self.__cleanup()
top=heappop(self.h)
self.remove(self.selfInvFunc(top))
return self.selfInvFunc(top)
def remove(self,val):
val=self.selfInvFunc(val)
if val not in self.d or self.d[val]==0:
raise ValueError(f"{self.selfInvFunc(val)} is not in Heap")
else:
self.d[val]-=1
self.len-=1
def exists(self,val):
val=self.selfInvFunc(val)
return val in self.d and self.d[val]!=0
def top(self):
self.__cleanup()
val=self.h[0]
return self.selfInvFunc(val)
def getValues(self):
return [self.selfInvFunc(val) for val,cnt in self.d.items() for _ in range(cnt)]
class LazyRMQ:#[l,r)
def __init__(self, n, ide_ele, maximum=True):#Falseならminimum
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.func = lambda x,y:max(x,y) if maximum else lambda x,y:min(x,y)
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]=self.lazy[k]
self.lazy[k*2+1]=self.lazy[k]
self.tree[k]=self.lazy[k]
self.lazy[k]=self.ide_ele
def update(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.update(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x
self.eval(k)
elif L<r and l<R:#
self.update(L,R,x,k*2,l,(l+r)//2)
self.update(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.func(self.tree[k*2],self.tree[k*2+1])
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return self.func(leftVal,rightVal)
class LazyRangeUpdateQuery:#[l,r)
def __init__(self, n, ide_ele):#
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]=self.lazy[k]//2
self.lazy[k*2+1]=self.lazy[k]//2
self.tree[k]=self.lazy[k]
self.lazy[k]=self.ide_ele
def update(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.update(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x*(r-l)
self.eval(k)
elif L<r and l<R:
self.update(L,R,x,k*2,l,(l+r)//2)
self.update(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.tree[k*2]+self.tree[k*2+1]
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return leftVal+rightVal
class LazyRangeAddQuery:#[l,r)
def __init__(self, n, ide_ele):#
#要素数 簡単のため2の冪乗にする
self.n=1
while self.n<n:self.n*=2
self.ide_ele = ide_ele
self.bottomStartPos = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.bottomStartPos #1-indexd
self.lazy = [ide_ele] * 2 * self.bottomStartPos #1-indexd
def eval(self,k):
if self.lazy[k]==self.ide_ele:return
if k<self.bottomStartPos:#葉ではないか
self.lazy[k*2]+=self.lazy[k]//2
self.lazy[k*2+1]+=self.lazy[k]//2
self.tree[k]+=self.lazy[k]
self.lazy[k]=self.ide_ele
def add(self,L,R,x,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
if k==None:return self.add(L,R,x,1,0,self.n)
self.eval(k)
if L<=l and r<=R:#範囲内
self.lazy[k]=x*(r-l)
self.eval(k)
elif L<r and l<R:
self.add(L,R,x,k*2,l,(l+r)//2)
self.add(L,R,x,k*2+1,(l+r)//2,r)
self.tree[k]=self.tree[k*2]+self.tree[k*2+1]
else:#範囲外
pass
def query(self, L,R,k=None,l=None,r=None):
L=max(0,L)
R=min(self.n,R)
#再帰
if k==None:return self.query(L,R,1,0,self.n)
self.eval(k)
if r<=L or R<=l:#範囲外
return self.ide_ele
elif L<=l and r<=R:#範囲内
return self.tree[k]
else:
leftVal=self.query(L,R,k*2,l,(l+r)//2)
rightVal=self.query(L,R,k*2+1,(l+r)//2,r)
return leftVal+rightVal
class SkipList:#順序付き集合(重複可)
def __init__(self,A=[],maxHeight=30):
self.length=len(A)
self.maxHeight=maxHeight #十分な数 0-indexed
self.cnt=defaultdict(int)
#ノードは配列の方が高速
self.valIndex=0
self.nextIndex=1
self.sentinel=[None,[None]*(self.maxHeight+1)]
for a in A:
self.add(a)
def __str__(self):
elems=[k for k,v in self.cnt.items() for _ in range(v)]
return str(elems)
def __len__(self):
return self.length
def __getMaxLTE(self,x):
now=self.sentinel
for h in range(self.maxHeight,-1,-1):
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<=x:
now=now[self.nextIndex][h]
return now
def exists(self,x):
node=self.__getMaxLTE(x)
return node[self.valIndex]==x
def minGTE(self,x):#x以上の最小値
node=self.__getMaxLTE(x)
if node[self.valIndex]==x:
return x
else:
if node[self.nextIndex][0]==None:
return None
else:
return node[self.nextIndex][0][self.valIndex]
def minGT(self,x):#xを超える最小値
node=self.__getMaxLTE(x)
if node[self.nextIndex][0]==None:
return None
else:
return node[self.nextIndex][0][self.valIndex]
def maxLTE(self,x):#x以下の最大値
node=self.__getMaxLTE(x)
return node[self.valIndex]
def __pickHeight(self):#0-indexed
h=0
while random.randint(0,1)==0:
h+=1
return h
def add(self,x):
self.cnt[x]+=1
if self.exists(x):
return
self.length+=1
newNodeHeight=self.__pickHeight()
newNode=[x,[None]*(newNodeHeight+1)]
now=self.sentinel
for h in range(self.maxHeight,-1,-1):#newNodeHeightから始めると最初のwhile文の時間がかかる
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<x:
now=now[self.nextIndex][h]
#リンクの更新
if h<=newNodeHeight:
maxLessThanXNode=now
newNode[self.nextIndex][h]=maxLessThanXNode[self.nextIndex][h]
maxLessThanXNode[self.nextIndex][h]=newNode
def discard(self,x):
if not self.exists(x):
return
self.cnt[x]-=1
if self.cnt[x]!=0:
return
del self.cnt[x]
self.length-=1
now=self.sentinel
for h in range(self.maxHeight,-1,-1):
while now[self.nextIndex][h]!=None and now[self.nextIndex][h][self.valIndex]<x:
now=now[self.nextIndex][h]
maxLessThanXNode=now
#リンクの更新(xが存在する高さなら)
if maxLessThanXNode[self.nextIndex][h]!=None and maxLessThanXNode[self.nextIndex][h][self.valIndex]==x:
removeNode=maxLessThanXNode[self.nextIndex][h]
maxLessThanXNode[self.nextIndex][h]=removeNode[self.nextIndex][h]
class BIT:
def __init__(self,N):
self.N=N
self.values=[0]*(N+1)#1-indexed
def add(self,i,x):
i+=1 #1-indexed
while i<=self.N:
self.values[i]+=x
i+=i&(-i)
def query(self,i):#[0,i]
i+=1 #1-indexed
ret=0
while i!=0:
ret+=self.values[i]
i-=i&(-i)
return ret
#文字列
alphabet=string.ascii_lowercase
ALPHABET=string.ascii_uppercase
alphaToIdx={c:i if c<"A" else i-26 for i,c in enumerate(alphabet+ALPHABET)}
def join(A,s=""):
return s.join(list(map(str,A)))
def sortStr(s):
return "".join(sorted(s))
#数学系
mod=998244353
mod2=1000000007
def invsign(num):
return -num
def gcd(*args):
return reduce(math.gcd,args)
def lcm(*args):
return reduce(lambda a,b:a*b//math.gcd(a,b),args)
def getPrimes(n,returnNums=False):#O(n log log n)
if n==0:return []
ret=[True]*(n+1)
ret[0]=False
ret[1]=False
for a in range(2,n+1):
if ret[a]:
for b in range(a*2,n+1,a):
ret[b]=False
if returnNums:
ret=[i for i,flag in enumerate(ret) if flag]
return ret
def isPrime(n):#O(√n)
if(n<=1):return False
i=2
while i*i<=n:
if(n%i==0):return False
i+=1
return True
def factorize(n):#O(√n)
b = 2
ret=defaultdict(int)
while b * b <= n:
while n % b == 0:
n //= b
ret[b]+=1
b+=1
if n > 1:ret[n]+=1
return ret
class EratosthenesFactorization:#O(n log log n)
def __init__(self,N):
self.primeFactor=[None]*(N+1)
for i in range(2,N+1):
if self.primeFactor[i]==None:
self.primeFactor[i]=i
for j in range(i*2,N+1,i):
self.primeFactor[j]=i
def factorize(self,N):#O(logN)
now=N
primes=[]
while now!=1:
primes.append(self.primeFactor[now])
now=now//self.primeFactor[now]
return Counter(primes)
def getPowList(base,maxExponent,mod):
ret=[1]*(maxExponent+1)
for i in range(1,maxExponent+1):
ret[i]=ret[i-1]*base%mod
return ret
def getFactorials(n,mod):
ret=[1]*(n+1)
for a in range(2,len(ret)):
ret[a]=ret[a-1]*a
if mod!=None:
ret[a]%=mod
return ret
def getFactorialModInvs(n,mod):
return [pow(factorial,mod-2,mod) for factorial in getFactorials(n,mod)]
def comb_(n,r,factorials,mod=None,factorialModInvs=None):#O(1)
if n-r<0:return 0
if mod==None:
return factorials[n]//(factorials[n-r]*factorials[r])
else:
if factorialModInvs:
return (factorials[n]*factorialModInvs[n-r]%mod)*factorialModInvs[r]%mod
else:
return (factorials[n]*pow(factorials[n-r],mod-2,mod)%mod)*pow(factorials[r],mod-2,mod)%mod
class Comb:
def __init__(self,n,mod,factorials=None,factorialModInvs=None):
self.n=n
self.mod=mod
if factorials:
self.factorials=factorials
else:
self.factorials=getFactorials(n,mod)
if factorialModInvs:
self.factorialModInvs=factorialModInvs
else:
self.factorialModInvs=getFactorialModInvs(n,mod)
def comb(self,n,r):
if n-r<0:return 0
return (self.factorials[n]*self.factorialModInvs[n-r]%self.mod)*self.factorialModInvs[r]%self.mod
def comb2(n,mod=None):
if n-2<0:return 0
if mod==None:
return (n*(n-1))//2
else:
return (n*(n-1)%mod)*pow(2,mod-2,mod)
def baseConversion(numbers,base,nextbase):
N=len(numbers)
if nextbase==10:
sum_=0
for i,number in enumerate(numbers):
p=(N-i-1)
sum_+=number*base**p
ret=list(map(int,list(str(sum_))))
elif base==10:
number=int(join(numbers))
ret=deque()
while 0<number:
ret.appendleft(number%nextbase)
number//=nextbase
if len(ret)==0:ret.append(0)
ret=list(ret)
else:
ret=baseConversion(numbers,base,10)
ret=baseConversion(ret,10,nextbase)
return ret
def getDigitSum(numAsStr):
A=list(map(int,list(str(numAsStr))))
return sum(A)
def getDivisors(number):#O(√n log √n)
ret=[]
i=1
while i**2<=number:
if number%i==0:
ret.append(i)
ret.append(number//i)
if i==number//i:ret.pop()
i+=1
ret.sort()
return ret
def iceil(a,b,mul=False):
return int(((a+(b-1))//b)*(b if mul else 1))
def ifloor(a,b,mul=False):
return int((a//b)*(b if mul else 1))
def mex(S):#集合で受け取る
ret=0
while ret in S:
ret+=1
return ret
def isqrt(num):#pypyではisqrtは使えない
return int(math.sqrt(num))
def sumTousa(l,r,d,mod=None):
if mod==None:
N=((r-l)//d+1)
return N*(l+r)//2
else:
N=((r-l)*pow(d,mod-2,mod)+1)
return (N*(l+r)*pow(2,mod-2,mod))%mod
def sign(num):
if num>=0:
return 1
elif num<0:
return -1
else:
return 0
def inc(x):
return x+1
def dec(x):
return x-1
def minmax(A):
m,M=A[0],A[0]
for a in A:
m=min(m,a)
M=max(M,a)
return m,M
def getDigits(num):
if num==0:return 1
ret=0
while num>0:
num//=10
ret+=1
return ret
def phi(num):#O(log N)
P=factorize(num).keys()
return (num//(reduce(mul,P)))*reduce(mul,[p-1 for p in P])
def modinv(num,mod,isprime=True):
if isprime:
return pow(num,mod-2,mod)
else:
if gcd(num,mod)==1:
return pow(num,phi(mod)-1,mod)
else:
return None
def nearlyEqual(a,b,delta):
return abs(a-b)<=delta
def getSetTeams(numOfMems,MinNumOfTeams,MaxNumOfTeams):
ret=[]
teams=[]
def f(i):
if i==numOfMems:
if MinNumOfTeams<=len(teams)<=MaxNumOfTeams:
ret.append([team[:] for team in teams])
else:
for team in teams:
team.append(i)
f(i+1)
team.pop()
if len(teams)<MaxNumOfTeams:
teams.append([i])
f(i+1)
teams.pop()
f(0)
return ret
def getMedian(A,isSortedList=False):
sortedList=A[:]
N=len(A)
if isSortedList==False:
sortedList.sort()
return (sortedList[N//2]+sortedList[N-N//2-1])/2
#二分探索
def intBS(left,right,func):
while right-left>1:
mid=(left+right)//2
if func(mid):
left=mid
else:
right=mid
return left,right
def floatBS(left,right,func,delta):
while right-left>delta:
mid=(left+right)/2
if func(mid):
left=mid
else:
right=mid
return left,right
def bisectLeft(A,x,left=0,right=None,func=lambda x:x):
left=left-1 #含まない
if right==None:right=len(A)#含む
return intBS(left,right,lambda i:A[i]<x)[1]
def bisectRight(A,x,left=0,right=None,func=lambda x:x):
left=left-1 #含まない
if right==None:right=len(A)#含む
return intBS(left,right,lambda i:A[i]<=x)[1]
def rvBisectLeft(A,x):
return intBS(-1,len(A),lambda i:x<A[i])[1]
def rvBisectRight(A,x):
return intBS(-1,len(A),lambda i:x<=A[i])[1]
def binarySearch(A,x):
i=bisect.bisect_left(A,x)
if i==len(A):
ret=-1
else:
if A[i]==x:
ret=i
else:
ret=-1
return ret
#ビット演算
def getCombs(bits,length):
if bits==0:return [0]
ret=[]
num=2**bits-1
while num<(1<<length):
ret.append(num)
x=num&(-num)
y=num+x
z=num&(~y)
z//=x
z=z>>1
num=(y|z)
return ret
def getPopCountList(length):
list_length=2**length
popcount=[0]*list_length
for i in range(1,list_length):
popcount[i]=i%2+popcount[i//2]
return popcount
def getBinSubs(num):
ret=[]
T=num
while True:
ret.append(T)
if T==0:break
T=(T-1)&num
return ret
def getbit(num,i):
return (num>>i)&1
def cntbits(num):
ret=0
while num:
ret+=num&1
num>>=1
return ret
def getSetBitPos(num):
return [i for i in range(num.bit_length()) if getbit(num,i)]
def getUnSetBitPos(num,N):
return [i for i in range(N) if getbit(num,i)==0]
#座標
rd=[[0,1],[1,0]]
crossmove=[[0,-1],[0,1],[1,0],[-1,0]]
xmove=[[-1,-1],[1,1],[-1,1],[1,-1]]
arround=crossmove+xmove
def getDist(x1,y1,x2,y2,sq=False):
ret=(x1-x2)**2+(y1-y2)**2
if not sq:ret**=0.5
return ret
def getManhattanDist(x1,y1,x2,y2):
return abs(x1-x2)+abs(y1-y2)
def lrudToYXMat(d):
if d.upper()=="L":return [0,-1]
elif d.upper()=="R":return [0,1]
elif d.upper()=="U":return [-1,0]
elif d.upper()=="D":return [1,0]
def lrudToYXCoor(d):
if d.upper()=="L":return [0,-1]
elif d.upper()=="R":return [0,1]
elif d.upper()=="U":return [1,0]
elif d.upper()=="D":return [-1,0]
def within(y,x,H,W):
return 0<=y<H and 0<=x<W
def rot45(y,x):#√2の倍率は無視
return x+y,x-y
def rot90(y,x):
return x,-y
def rot180(y,x):
return -y,-x
def rot270(y,x):
return -x,y
def newPoints(y,x,H,W,move):
ret=[]
for dy,dx in move:
newy=y+dy
newx=x+dx
if within(newy,newx,H,W):
ret.append([newy,newx])
return ret
#行列
def getIdMat(width):
ret=[[0]*width for i in range(width)]
for i in range(width):
ret[i][i]=1
return ret
def transpose(mat):
if mat==[]:return []
ret=[[None for j in range(len(mat))] for i in range(len(mat[0]))]
for i in range(len(mat)):
for j in range(len(mat[0])):
ret[j][i]=mat[i][j]
return ret
def dot(A,B):
B_=copyMat(B)
if type(B[0])!=list:
B_=transpose([B_])
if len(A[0])!=len(B_):raise ValueError
H=len(A)
W=len(B_[0])
ret=[[0 for j in range(W)] for i in range(H)]
for i in range(H):
for j in range(W):
for k in range(len(B_)):
ret[i][j]+=A[i][k]*B_[k][j]
return ret
def getMatrixPowDict(A,max_,mod=None):
D={}
D[1]=A
now=2
while now<=max_:
D[now]=dot(D[now//2],D[now//2])
if mod!=None:
for j in range(len(D[now])):
D[now]=list(map(lambda x:x%mod,D[now]))
now*=2
return D
def matrixPow(A,i,mod=None,matrixPowDict=None):
if matrixPowDict==None:matrixPowDict=getMatrixPowDict(A,i)
B=bin(i)[2:][::-1]
I=[[1 if k==j else 0 for k in range(len(A))] for j in range(len(A))]
ret=I
for j,v in enumerate(B):
if v=="1":
ret=dot(ret,matrixPowDict[2**j])
if mod!=None:
for j in range(len(ret)):
ret[j]=list(map(lambda x:x%mod,ret[j]))
return ret
def modHakidashi(A,mod,isExtended=False):#return rank
rows=len(A)
cols=len(A[0])
rank=0
for col in range(cols):
#行を入れ替える
if isExtended and col==cols-1:break
pivot=None
for row in range(rank,rows):
if A[row][col]!=0:
pivot=row
break
if pivot==None:continue
A[rank],A[pivot]=A[pivot],A[rank]
#ピボットの値を1にする
A[rank]=list(map(lambda x:x*pow(A[rank][col],mod-2,mod),A[rank]))
#ピボットのある列の値をすべて0にする
for row in range(rows):
if row==rank:continue
constantFactor=A[row][col]
for col2 in range(cols):
A[row][col2]-=(A[rank][col2]*constantFactor)%mod
A[row][col2]%=mod
rank+=1
return rank
def hakidashi(A,eps,isExtended=False):#未検証
rows=len(A)
cols=len(A[0])
rank=0
for col in range(cols):
#行を入れ替える
if isExtended and col==cols-1:break
pivot=None
maxAbs=-inf
for row in range(rank,rows):
if abs(A[row][col])>eps and abs(A[row][col])>maxAbs:#計算誤差を小さくするため絶対値が大きいものを優先する
pivot=row
maxAbs=abs(A[row][col])
break
if pivot==None:continue
A[rank],A[pivot]=A[pivot],A[rank]
#ピボットの値を1にする
A[rank]=list(map(lambda x:x/A[rank][col],A[rank]))
#ピボットのある列の値をすべて0にする
for row in range(rows):
if row==rank and abs(A[row][col])>eps:continue
constantFactor=A[row][col]
for col2 in range(cols):
A[row][col2]-=A[rank][col2]*constantFactor
rank+=1
return rank
#一次元配列
class wideRangeCumSum:
def __init__(self):
self.deltaList=defaultdict(int)
self.cumsum={}
self.keys_=[]
def keys(self):
return self.keys_
def add(self,i,x):
self.deltaList[i]+=x
def updateCumSum(self):
self.keys_=sorted(self.deltaList.keys())
for i,curKey in enumerate(self.keys_):
self.cumsum[curKey]=self.deltaList[curKey]
if 0<i:
prevKey=self.keys_[i-1]
self.cumsum[curKey]+=self.cumsum[prevKey]
def get(self,i):
if i in self.cumsum:#O(1)
return self.cumsum[i]
else:#O(log len(cumsumKeys))
j=bisect_right(self.keys_,i)-1
if j==-1:
return 0
else:
return self.cumsum[self.keys_[j]]
def getAllRanges(self,includingEnd=False):
ret=[]
for i in range(len(self.keys_)-1):
left=self.keys_[i]
right=self.keys_[i+1]
ret.append([left,right])
if includingEnd:
ret.append([self.keys[-1],None])
return ret
def zaatsu(A):#座標圧縮
B=list(set(A))
B.sort()
ret=[]
for a in A:
ret.append(bisect.bisect_left(B,a))
return ret
def getCumSum(A):
N=len(A)
ret=[0]*(N+1)
for i in range(1,N+1):
ret[i]=ret[i-1]+A[i-1]
return ret
def imos(deltaList):
ret=deltaList[:]
for i in range(1,len(deltaList)):
ret[i]=ret[i-1]+deltaList[i]
return ret
def nextPermutation(A):
N=len(A)
for i in range(N-1-1,-1,-1):
if A[i]<A[i+1]:
for j in range(N-1,-1,-1):
if A[i]<A[j]:
A[i],A[j]=A[j],A[i]
A[i+1:]=A[i+1:][::-1]
return True
return None
def listmap(A,func):
return list(map(func,A))
def getValsWithIdx(A):
return [[val,i] for i,val in enumerate(A)]
def getPos(A,isInjective=False):
if isInjective:
ret=defaultdict(int)
for i,a in enumerate(A):
ret[a]=i
else:
ret=defaultdict(list)
for i,a in enumerate(A):
ret[a].append(i)
return ret
def cntIf(A,func):
ret=0
for a in A:
if func(a):
ret+=1
return ret
def cntUnique(A):
return len(Counter(A))
def linkedsort(*args,key=None,reverse=False):
args=list(args)
mat=list(zip(*args))
if key==None:
mat.sort(reverse=reverse)
else:
mat.sort(key=key,reverse=reverse)
mat=list(zip(*mat))
for i in range(len(args)):
args[i][:]=mat[i]
def findIf(A,func):
for i,a in enumerate(A):
if func(a):
return i
return -1
def rfindIf(A,func):
for i in range(len(A)-1,-1,-1):
if func(A[i]):
return i
return -1
def isSub(a,A):
now=0
N=len(A)
for i in range(len(a)):
while now<N:
if a[i]==A[now]:
now+=1
break
else:
now+=1
else:
return False
return True
def rfind(A,val):
for i in range(len(A)-1,-1,-1):
if A[i]==val:
return i
return -1
def cntInv(A):#O(N log N)
ret=0
A=zaatsu(A)
bit=BIT(len(A))
for i in range(len(A)):
ret+=i-bit.query(A[i])
bit.add(A[i],1)
return ret
def cntInv2v(A):#O(N)
if A==[]:return 0
maxval=max(A)
cnt=0
ret=0
for a in A:
if a==maxval:
cnt+=1
else:
ret+=cnt
return ret
def RLE(A):
ret=[]
prev=None
for a in A:
if prev==a:
ret[-1][1]+=1
else:
ret.append([a,1])
prev=a
return ret
def LIS(A):#最長増加部分列 O(N log N)
dp=[inf]*len(A) #dp[i]=部分列の長さが(i+1)の時の最終要素の最小値
for a in A:
dp[bisect.bisect_left(dp,a)]=a
return bisect.bisect_left(dp,inf-1)
def replace(A,curVal,newVal):
return [newVal if a==curVal else a for a in A]
def getLoopIdx(*args):
ret=[]
code=""
for i,arg in enumerate(args):
code+=f"{' '*i}for {alphabet[i]} in {arg}:\n"
code+=f"{' '*len(args)}ret.append(({','.join(alphabet[:len(args)])}))"
exec(code)
return ret
def zalgo(A):#O(N)
N=len(A)
ret=[0]*N
ret[0]=N
i=1
j=0
while i<N:
while i+j<N and A[j]==A[i+j]:
j+=1
ret[i]=j
if j==0:
i+=1
else:
k=1
while i+k<N and k+ret[k]<j:
ret[i+k]=ret[k]
k+=1
i+=k
j-=k
return ret
def getTrueIdx(A):
return [i for i,a in enumerate(A) if a]
def getUnique(A):
return list(Counter(A).keys())
def rvsort(A):
return A.sort(reverse=True)
#多次元配列
def copyMat(A):
N=len(A)
dim=1
cur=A
while len(cur)>0 and type(cur[0]) in (tuple,list):
dim+=1
cur=cur[0]
if dim==1:
return A[:]
else:
ret=[None]*N
for i in range(N):
ret[i]=copy(A[i])
return ret
def sqlist(H,W,initVal=None):
return [[initVal]*W for i in range(H)]
def cblist(H,W,Z,initVal=None):
return [[[initVal]*Z for j in range(W)] for i in range(H)]
def getCol(A,col):
return [A[i][col] for i in range(len(A))]
def getRangeSumCumSumMat(cumSum,y1,x1,y2,x2):#1-indexed 閉区間
ret=cumSum[y2][x2]
ret-=cumSum[y2][x1-1]
ret-=cumSum[y1-1][x2]
ret+=cumSum[y1-1][x1-1]
return ret
def getCumSumMat(mat):
H,W=len(mat),len(mat[0])
ret=sqlist(H+1,W+1,0)
for i in range(1,H+1):
for j in range(1,W+1):
ret[i][j]+=ret[i][j-1]+mat[i-1][j-1]
for j in range(1,W+1):
for i in range(1,H+1):
ret[i][j]+=ret[i-1][j]
return ret
class CumSumByValue:#メモリO(N) 1-indexed
def __init__(self,A):
self.cumsum=defaultdict(None)
for a in set(A):
self.cumsum[a]=wideRangeCumSum()
for i,a in enumerate(A):
self.cumsum[a].add(i+1,1)
for a in set(A):
self.cumsum[a].updateCumSum()
def get(self,key,i):
if key in self.cumsum:
return self.cumsum[key].get(i)
else:
return 0
def imosMat(deltaList):
H,W=len(deltaList),len(deltaList[0])
ret=copyMat(deltaList)
for i in range(H):
for j in range(1,W):
ret[i][j]+=ret[i][j-1]
for j in range(W):
for i in range(1,H):
ret[i][j]+=ret[i-1][j]
return ret
def yxToX(y,x,H,W):
return y*W+x
def yxzToX(y,x,z,H,W,D):
return y*(W*D)+x*D+z
def cntMat(mat,val):
cnt=0
for i in range(len(mat)):
for j in range(len(mat[i])):
if mat[i][j]==val:
cnt+=1
return cnt
def mapping(A,func):
N=len(A)
dim=1
cur=A
while len(cur)>0 and type(cur[0]) in (tuple,list):
dim+=1
cur=cur[0]
if dim==1:
return list(map(func,A))
else:
ret=[None]*N
for i in range(N):
ret[i]=mapping(A[i],func)
return ret
def rot90Mat(mat):
H=len(mat[0])
W=len(mat)
ret=sqlist(H,W)
for i in range(H):
for j in range(W):
ret[i][j]=mat[j][H-1-i]
return ret
def addWall(A,chr="#"):
H=len(A)
W=len(A[0])
type_=type(A[0])
if type_==str:
for i in range(H):
A[i]+=chr
A.append(chr*(W+1))
else:
for i in range(H):
A[i].append(chr)
A.append([chr]*(W+1))
def findMat(mat,val):
for i in range(len(mat)):
for j in range(len(mat[i])):
if mat[i][j]==val:return (i,j)
return None
def flatten(mat):
return list(itertools.chain.from_iterable(mat))
def listToMat(A,H,W):
N=len(A)
ret=sqlist(H,W)
for i in range(H):
for j in range(W):
ret[i][j]=A[i*W+j]
return ret
def sliceMat(mat,top,bottom,left,right):#閉区間
ret=[]
for i in range(top,bottom+1):
if 0<=i<len(mat):
ret.append(mat[i][left:right+1])
if ret[-1]==[]:ret.pop()
return ret
def listToTuple(A):
ret=[]
for item in A:
if isinstance(item, list):
ret.append(tuple(listToTuple(item)))
elif isinstance(item, tuple):
ret.append(listToTuple(item))
else:
ret.append(item)
ret=tuple(ret)
return ret
#グラフ
class Doubling:#パスグラフ用 O(log dist * N)
def __init__(self,pathGraph,maxDist):
self.bitLength=len(bin(maxDist)[2:])
self.N=len(pathGraph)
self.D=sqlist(self.bitLength,self.N,list)
for i in range(self.bitLength):
if i==0:
self.D[0]=pathGraph[:]
else:
for j in range(self.N):
self.D[i][j]=self.D[i-1][self.D[i-1][j]]
def getVal(self,start,dist):
ret=start
distBitLength=len(bin(dist)[2:])
for i in range(distBitLength):
if ((dist>>i)&1)==1:
ret=self.D[i][ret]
return ret
class CyclicPath:#入力はパス(パスグラフではない) O(N)
def __init__(self,path):
visited=defaultdict(bool)
cycleStartVal=None
cycleEndIndex=None
for i,u in enumerate(path):
if visited[u]:
cycleStartVal=u
cycleEndIndex=i
break
visited[u]=True
cycleStartIndex=path.index(cycleStartVal)
self.acyclicPath=path[:cycleStartIndex]
self.cyclicPath=path[cycleStartIndex:cycleEndIndex]
def getVal(self,index):#O(1)
if index<=len(self.acyclicPath)-1:
return self.acyclicPath[index]
else:
index-=len(self.acyclicPath)
index%=len(self.cyclicPath)
return self.cyclicPath[index]
def getPath(self):
return self.acyclicPath,self.cyclicPath
class FordFulkerson:
def __init__(self,edges,V,s,t):
self.V=V
self.used=[False]*V
self.G=[[] for a in range(V)]
self.s=s
self.t=t
for edge in edges:
self.G[edge.x].append({"x":edge.x,"y":edge.y,"cap":edge.cost,"rev":len(self.G[edge.y])})
self.G[edge.y].append({"x":edge.y,"y":edge.x,"cap":0,"rev":len(self.G[edge.x])-1})
def dfs(self,v,t,f=inf):
if v==t:return f
self.used[v]=True
for a in range(len(self.G[v])):
x=self.G[v][a]["x"]
y=self.G[v][a]["y"]
cap=self.G[v][a]["cap"]
rev=self.G[y][self.G[x][a]["rev"]]
if self.used[y] or cap==0:continue
f2=self.dfs(y,t,min(f,cap))
if f2>0:
self.G[v][a]["cap"]-=f2
rev["cap"]+=f2
return f2
return 0
def maxflow(self):
flow=0
while True:
self.used=[False]*self.V
zouka=self.dfs(self.s,self.t)
if zouka==0:break
flow+=zouka
return flow
def edgesToUG(edges,N):
G=[[] for i in range(N)]
for edge in edges:
u,v=edge
G[u].append(v)
G[v].append(u)
return G
def edgesToDG(edges,N):#未検証
G=[[] for i in range(N)]
for edge in edges:
u,v=edge
G[u].append(v)
return G
def UGToEdges(G):
N=len(G)
edges=[]
for i in range(N):
for j in G[i]:
if i<j:
edges.append((i,j))
return edges
def DGToEdges(G):#未検証
N=len(G)
edges=[]
for i in range(N):
for j in G[i]:
edges.append((i,j))
return edges
def dijkstra(edges,N,start):#O(V+E*logV)
G=[[] for a in range(N)]
for edge in edges:
G[edge.x].append([edge.cost,edge.y])
mincost=[inf]*N
Q=[[0,start]]
while len(Q)>0:
curCost,cur=heappop(Q)
if mincost[cur]!=inf:continue
mincost[cur]=curCost
for edgeCost,nxt in G[cur]:
newCost=curCost+edgeCost
if mincost[nxt]==inf:#高速化のため
heappush(Q,[newCost,nxt])
return mincost
def dictDijkstra(edges,start):
mincost=defaultdict(lambda x:inf)
visited=defaultdict(bool)
G=defaultdict(list)
for edge in edges:
G[edge.x].append([edge.cost,edge.y])
Q=[]
heappush(Q,[0,start])
while len(Q)>0:
nowcost,nowx=heappop(Q)
if visited[nowx]:continue
visited[nowx]=True
mincost[nowx]=nowcost
for cost,y in G[nowx]:
if visited[y]:continue #高速化
newcost=nowcost+cost
heappush(Q,[newcost,y])
return mincost
def dictBFS01(edges,start):
G=defaultdict(list)
for edge in edges:
G[edge.x].append((edge.y,edge.cost))
mincost=defaultdict(lambda:inf)
Q=deque([[start,0]])
while Q:
cur,cost=Q.popleft()
if mincost[cur]!=inf:continue
mincost[cur]=cost
for nxt,edgeCost in G[cur]:
if edgeCost==1:
Q.append([nxt,cost+edgeCost])
else:
Q.appendleft([nxt,cost+edgeCost])
return mincost
def shortestBFS(adjList,start):
N=len(adjList)
mincost=[inf]*N
mincost[start]=0
Q=deque([start])
while Q:
now=Q.popleft()
for tugi in adjList[now]:
if mincost[tugi]==inf:
mincost[tugi]=mincost[now]+1
Q.append(tugi)
return mincost
def dictShortedBFS(adjList,start):
mincost=defaultdict(lambda:inf)
mincost[start]=0
Q=deque([start])
while Q:
now=Q.popleft()
for tugi in adjList[now]:
if mincost[tugi]==inf:
mincost[tugi]=mincost[now]+1
Q.append(tugi)
return mincost
def warshallFloyd(adjMat):#O(N**3)
V=len(adjMat)
mincost=[[inf for j in range(V)] for i in range(V)]
for i in range(V):
for j in range(V):
mincost[i][j]=adjMat[i][j]
for i in range(V):mincost[i][i]=0 #この行をコメントすると同じ頂点を一回以上辺を通ってたどり着く場合の最短距離が分かる
for k in range(V):
for s in range(V):
for t in range(V):
if mincost[s][k]==inf or mincost[k][t]==inf:continue
mincost[s][t]=min(mincost[s][t],mincost[s][k]+mincost[k][t])
return mincost
def bellemanFord(edges,N,start):
mincost=[inf]*N
mincost[start]=0
for _ in range(N):
for edge in edges:
if mincost[edge.x]==inf:continue
mincost[edge.y]=min(mincost[edge.y],mincost[edge.x]+edge.cost)
return mincost
def getConnectedNodes(adjList,start):
S=[start]
connectedNodes=set([start])
while len(S)>0:
cur=S.pop()
for nxt in adjList[cur]:
if nxt not in connectedNodes:
connectedNodes.add(nxt)
S.append(nxt)
return connectedNodes
def topologicalSort(adjList):#閉路がある場合Noneを返す
path=[]
#入次数
indeg=[0]*len(adjList)
for u in range(len(adjList)):
for v in adjList[u]:
indeg[v]+=1
isolatedNodes=[]
#初めから入次数が0の頂点をスタックに入れる
for u in range(len(adjList)):
if indeg[u]==0:
isolatedNodes.append(u)
while isolatedNodes:
u=isolatedNodes.pop()
path.append(u)
for v in adjList[u]:
indeg[v]-=1
if indeg[v]==0:
isolatedNodes.append(v)
return path if len(path)==len(adjList) else None
def SSC(edges,N):#強連結成分分解 O(VlogV+E)
#DFS一回目
G=[[] for i in range(N)]
for edge in edges:
G[edge.x].append(edge.y)
nokori=set(list(range(N)))
visited=defaultdict(bool)
kaerigake=[]
while nokori:
start=nokori.pop()
S=[(start,True)]#(start,行き道か)
while S:
now,isIki=S.pop()
if visited[(now,isIki)]:continue
visited[(now,isIki)]=True
nokori.discard(now)
if isIki:
S.append((now,False))
for tugi in G[now]:
if visited[(tugi,True)]:
pass
else:
S.append((tugi,True))
else:
kaerigake.append(now)
numbers=[None]*N
for i,v in enumerate(kaerigake):
numbers[v]=i
#DFS二回目
G=[[] for i in range(N)]
for edge in edges:
G[edge.y].append(edge.x)
maxQ=[(numbers[i],i) for i in range(N)]
maxQ.sort(reverse=True)
visited=[False]*N
ret=[]
for tmp,start in maxQ:
if visited[start]:continue#既に訪れていたら
visited[start]=True
S=[start]
ret.append([])
while S:
now=S.pop()
ret[-1].append(now)
for tugi in G[now]:
if not visited[tugi]:
visited[tugi]=True
S.append(tugi)
return ret #上流の強連結成分から
def isConnected(adjList):
S=[0]
V=[False]*len(adjList)
V[0]=True
while S:
now=S.pop()
for tugi in adjList[now]:
if not V[tugi]:
V[tugi]=True
S.append(tugi)
return all(V)
def isNibuGraph(adjList):
V=len(adjList)
colors=[None]*V
for s in range(V):
if colors[s]==None:
S=[s]
colors[s]=0
while S:
cur=S.pop()
for nxt in adjList[cur]:
if colors[nxt]==None:
colors[nxt]=1-colors[cur]
S.append(nxt)
elif colors[nxt]==colors[cur]:
return False
else:
pass
return True
def paintNibuGraph(adjList):
N=len(adjList)
colors=[None]*N
for start in range(N):
if colors[start]==None:
S=[start]
colors[start]=0
while S:
cur=S.pop()
for nxt in adjList[cur]:
if colors[nxt]==None:
colors[nxt]=1-colors[cur]
S.append(nxt)
elif colors[nxt]==colors[cur]:
return None
else:
pass
return colors
def diam(adjMat):#グラフの直径を求める
mincost=warshallFloyd(adjMat)
ret=-inf
for i in range(len(adjMat)):
for j in range(len(adjMat)):
ret=max(ret,mincost[i][j])
return ret
def reverseDegree(adjList):
N=len(adjList)
ret=[[] for i in range(N)]
for i in range(N):
for next_ in adjList[i]:
ret[next_].append(i)
return ret
def gridToGraph(A,move,obstacle="#"):
H=len(A)
W=len(A[0])
G=defaultdict(list)
for y in range(H):
for x in range(W):
for d in move:
nextY=y+d[0]
nextX=x+d[1]
if within(nextY,nextX,H,W) and A[nextY][nextX]!=obstacle:
G[(y,x)].append((nextY,nextX))
return G
def TSP(adjMat,start=None):#O(N**2 * 2**N)
#dp[bin_][i]=bin_のbitが立っている箇所を通る&最後に頂点iに到達する場合の最小値
N=len(adjMat)
dp=sqlist(2**N,N,inf)
dp[0][start]=0
for curbin in range(2**N-1):
for cur in range(N):
for nxt in range(N):
if getbit(curbin,nxt)==0:
nxtbin=curbin|(1<<nxt)
if dp[curbin][cur]!=inf:
dp[nxtbin][nxt]=min(dp[nxtbin][nxt],dp[curbin][cur]+adjMat[cur][nxt])
return dp
def getConnectedComponents(edges,N,updateVertexNumbers=True):
U=UnionFind(N)
for edge in edges:
u=edge.x
v=edge.y
U.union(u,v)
ret={}
for edge in edges:
u=edge.x
v=edge.y
root=U.root(u)
if root not in ret:
ret[root]={"N":U.unionSize(root),"edges":[]}
ret[root]["M"]+=1
ret[root]["edges"].append(Edge(u,v,edge.cost))
for u in range(N):
if U.unionSize(u)==1:
ret[u]={"N":1,"edges":[]}
if updateVertexNumbers:
for root in U.roots():
vertexNums=set()
for edge in ret[root]["edges"]:
vertexNums.add(edge.x)
vertexNums.add(edge.y)
vertexNums=sorted(vertexNums)
pos=getPos(vertexNums,isInjective=True)
for i in range(len(ret[root]["edges"])):
ret[root]["edges"][i].x=pos[ret[root]["edges"][i].x]
ret[root]["edges"][i].y=pos[ret[root]["edges"][i].y]
ret=list(ret.values())
return ret
def getPostOrder(adjList,start):
ret=[]
S=[(start,True)]
departed=[False]*len(adjList)
while S:
cur,iki=S.pop()
if iki:
departed[cur]=True
S.append((cur,False))
for nxt in adjList[cur]:
if departed[nxt]:continue
S.append((nxt,True))
else:
ret.apend(cur)
return ret
#グラフ(木)
def edgesToTree(N,edges,root):
parents=[None]*N
children=[[] for i in range(N)]
G=edgesToUG(edges,N)
S=[root]
V=[False]*N
V[root]=True
while S:
cur=S.pop()
for nxt in G[cur]:
if not V[nxt]:
V[nxt]=True
S.append(nxt)
children[cur].append(nxt)
parents[nxt]=cur
return parents,children
def treeToUG(parents,children):
N=len(parents)
ret=[[] for i in range(N)]
for i in range(N):
if parents[i]!=None:
ret[i].append(parents[i])
ret[i]+=children[i]
return ret
def getLeafs(parents,children):
ret=[]
N=len(parents)
for i in range(N):
deg=0
if parents[i]!=None:deg+=1
deg+=len(children[i])
if deg==1:
ret.append(i)
return ret
def getTreeDepths(parents,children):
root=parents.index(None)
N=len(parents)
S=[root]
ret=[None]*N
ret[root]=0
while S:
cur=S.pop()
for child in children[cur]:
S.append(child)
ret[child]=ret[cur]+1
return ret
def doubleSweep(edges,N):#木の直径を求める
G=[[] for i in range(N)]
for e in edges:
G[e.x].append((e.y,e.cost))
start=0
maxmincost=None
for _ in range(2):
S=[start]
mincost=[inf]*N
mincost[start]=0
while S:
now=S.pop()
nowcost=mincost[now]
for e in G[now]:
if mincost[e[0]]==inf:
mincost[e[0]]=nowcost+e[1]
S.append(e[0])
maxmincost=max(mincost)
start=mincost.index(maxmincost)
return maxmincost
def kruskal(N,Edges):#最小全域木 O(M logN)
U=UnionFind(N)
Edges.sort(key=lambda x:x.cost)
treeEdges=[]
for i in range(len(Edges)):
edge=Edges[i]
x=edge.x
y=edge.y
cost=edge.cost
if not U.same(x,y):
treeEdges.append(Edge(x,y,cost))
U.union(x,y)
return treeEdges
def extractSimpleUGCycle(G):#O(N log N)
N=len(G)
deg=[len(G[u]) for u in range(N)]
ret=copyMat(G)
Q=[u for u in range(N) if deg[u]==1]
for u in range(N):
ret[u]=set(ret[u])
while Q:
u=Q.pop()
v=ret[u].pop()
ret[v].remove(u)
deg[v]-=1
if deg[v]==1:
Q.append(v)
for u in range(N):
ret[u]=list(ret[u])
return ret
#他
class MinMaxWithIndex:
def __init__(self,values=[],indices=[]):
self.minVal=None
self.minIndex=None
self.maxVal=None
self.maxIndex=None
for i in range(len(values)):
self.update(values[i],indices[indices[i]])
def update(self,val,index):
if self.minVal==None or self.minVal>val:
self.minVal=val
self.minIndex=index
if self.maxVal==None or self.maxVal<val:
self.maxVal=val
self.maxIndex=index
def min(self):
return self.minVal,self.minIndex
def max(self):
return self.maxVal,self.maxIndex
def getMaxIndex(A):
max_=-inf
idx=None
for i,a in enumerate(A):
if max_<a:
max_=a
idx=i
return idx
def getMinIndex(A):
min_=-inf
idx=None
for i,a in enumerate(A):
if a<min_:
min_=a
idx=i
return idx
#入力
def inputs(row=None,func=None):
ret=None
if row==None:
ret=input().split()
else:
ret=[input() for _ in range(row)]
if func!=None:ret=mapping(ret,func)
return ret
def inputmat(row,func=None,transpose=False):
if transpose:
ret=None
col=None
for i in range(row):
A=inputs()
if i==0:
col=len(A)
ret=[[None]*row for _ in range(col)]
for j in range(col):
ret[j][i]=A[j]
else:
ret=[inputs() for _ in range(row)]
if func!=None:ret=mapping(ret,func)
return ret
def inputint():
return int(input())
def inputints(row=None,func=None):
ret=inputs(row,int)
if func!=None:ret=mapping(ret,func)
return ret
def inputintmat(row,func=None,transpose=False):
ret=inputmat(row,int,transpose)
if func!=None:ret=mapping(ret,func)
return ret
def inputUG(N,M):
G=[[] for i in range(N)]
for i in range(M):
u,v=inputints()
u-=1
v-=1
G[u].append(v)
G[v].append(u)
return G
def inputDG(N,M):
G=[[] for i in range(N)]
for i in range(M):
u,v=inputints()
u-=1
v-=1
G[u].append(v)
return G
def inputUEdges(M):
Edges=[]
for i in range(M):
a,b=inputints()
a-=1
b-=1
Edges.append(Edge(a,b,1))
Edges.append(Edge(b,a,1))
return Edges
def inputDEdges(M):
Edges=[]
for i in range(M):
a,b=inputints()
a-=1
b-=1
Edges.append(Edge(a,b,1))
return Edges
def inputTree(N,root):
parents=[None]*N
children=[[] for i in range(N)]
M=N-1
G=inputUG(N,M)
S=[root]
V=[False]*N
V[root]=True
while S:
now=S.pop()
for next_ in G[now]:
if not V[next_]:
V[next_]=True
S.append(next_)
children[now].append(next_)
parents[next_]=now
return parents,children
def fillNone(mat,width):
N=len(mat)
ret=copyMat(mat)
for i in range(N):
for _ in range(width-len(ret[i])):
ret[i].append(None)
return ret
#出力
def yn(flag,trueOutput="Yes",falseOutput="No"):
print(trueOutput if flag else falseOutput)
def YN(flag):
print("YES" if flag else "NO")
def no(*args):
print(f"{inspect.currentframe().f_back.f_lineno}: {' '.join(list(map(str,args)))}")
def printmat(A,sep=" ",fill=0):
if sep==" " and fill==0:
for a in A:
print(*a)
else:
for a in A:
print(sep.join(list(map(lambda x:str(x).center(fill),a))))
###############################################################################
N,M=inputints()
G=inputUG(N,M)
Q=inputint()
XK=inputintmat(Q)
dp=sqlist(4,N)
for cnt in range(4):
for u in range(N):
dp[cnt][u]={u+1}
if cnt>0:
for nxt in G[u]:
dp[cnt][u]|=dp[cnt-1][nxt]
for x,k in XK:
x-=1
print(sum(dp[k][x]))
|
ConDefects/ConDefects/Code/abc254_e/Python/44452913
|
condefects-python_data_1865
|
# BFS
import collections
N, M = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
Q = int(input())
XK = [list(map(int, input().split())) for _ in range(Q)]
graph = collections.defaultdict(list)
for i in range(0, M):
a = AB[i][0]
b = AB[i][1]
graph[a].append(b)
graph[b].append(a)
for i in range(Q):
x = XK[i][0]
k = XK[i][1]
queue = []
if k != 0: queue.append(x)
dist = collections.defaultdict(lambda: -1)
dist[x] = 0
while queue:
q = queue.pop()
if dist[q] >= k: continue
for v in graph[q]:
if dist[v] != -1: continue
dist[v] = dist[q] + 1
queue.append(v)
print(sum(dist.keys()))
# BFS
import collections
N, M = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(M)]
Q = int(input())
XK = [list(map(int, input().split())) for _ in range(Q)]
graph = collections.defaultdict(list)
for i in range(0, M):
a = AB[i][0]
b = AB[i][1]
graph[a].append(b)
graph[b].append(a)
for i in range(Q):
x = XK[i][0]
k = XK[i][1]
queue = []
if k != 0: queue.append(x)
dist = collections.defaultdict(lambda: -1)
dist[x] = 0
while queue:
q = queue.pop(0)
if dist[q] >= k: continue
for v in graph[q]:
if dist[v] != -1: continue
dist[v] = dist[q] + 1
queue.append(v)
print(sum(dist.keys()))
|
ConDefects/ConDefects/Code/abc254_e/Python/44691275
|
condefects-python_data_1866
|
def solve(n, m, a, b):
# 0-indexへ変換
a = [_-1 for _ in a]
b = [_-1 for _ in b]
# 対角要素とのズレがどれぐらいのパターンを使っているか
S = set() # m個のパターンが必要
for i, j in zip(a, b):
S.add((i+j) % n)
i = 0
while len(S) < m:
S.add(i)
i += 1
# パターンごとにn個のマスを埋められる(i+j = d mod nとなる(i,j)のペア)
ans = []
for d in S:
for i in range(n):
# ズレが異なるパターン同士は重なり合うことはないので、解として追記していく
j = (n - 1 - i + d) % n
ans.append((i+1, j+1))
return ans
n, m = map(int, input().split())
a, b = zip(*[map(int, input().split()) for i in range(m)])
ans = solve(n, m, a, b)
print(len(ans))
for i, j in ans:
print(i, j)
def solve(n, m, a, b):
# 0-indexへ変換
a = [_-1 for _ in a]
b = [_-1 for _ in b]
# 対角要素とのズレがどれぐらいのパターンを使っているか
S = set() # m個のパターンが必要
for i, j in zip(a, b):
S.add((i+j) % n)
i = 0
while len(S) < m:
S.add(i)
i += 1
# パターンごとにn個のマスを埋められる(i+j = d mod nとなる(i,j)のペア)
ans = []
for d in S:
for i in range(n):
# ズレが異なるパターン同士は重なり合うことはないので、解として追記していく
j = (d - i) % n
ans.append((i+1, j+1))
return ans
n, m = map(int, input().split())
a, b = zip(*[map(int, input().split()) for i in range(m)])
ans = solve(n, m, a, b)
print(len(ans))
for i, j in ans:
print(i, j)
|
ConDefects/ConDefects/Code/arc176_a/Python/55031190
|
condefects-python_data_1867
|
N,M = map(int,input().split())
S = set()
for _ in range(M):
A,B = map(int,input().split())
S.add((A+B)%N)
for i in range(M+1):
if len(S)==M: break
S.add(i)
print(N*M)
for v in S:
for a in range(N):
print(a+1,(v-a)%N+1)
N,M = map(int,input().split())
S = set()
for _ in range(M):
A,B = map(int,input().split())
S.add((A+B)%N)
for i in range(M+1):
if len(S)==M: break
S.add(i)
print(N*M)
for v in S:
for a in range(N):
print(a+1,(v-2-a)%N+1)
|
ConDefects/ConDefects/Code/arc176_a/Python/53542158
|
condefects-python_data_1868
|
N, M = map(int,input().split())
print(N*M)
L = [0]*N
count = 0
for _ in range(M):
a, b = map(int,input().split())
d = (a-b)%N
if L[d]==1:
continue
for _ in range(N):
print(a,b)
a += 1
b += 1
if a==N+1:
a=1
if b==N+1:
b=1
L[d]=1
count += 1
for i in range(M):
if count==M:
break
if L[i]==0:
a, b = i,0
for _ in range(N):
print(a,b)
a += 1
b += 1
if a==N+1:
a=1
if b==N+1:
b=1
L[i]=1
count += 1
N, M = map(int,input().split())
print(N*M)
L = [0]*N
count = 0
for _ in range(M):
a, b = map(int,input().split())
d = (a-b)%N
if L[d]==1:
continue
for _ in range(N):
print(a,b)
a += 1
b += 1
if a==N+1:
a=1
if b==N+1:
b=1
L[d]=1
count += 1
for i in range(M):
if count==M:
break
if L[i]==0:
a, b = i+1,1
for _ in range(N):
print(a,b)
a += 1
b += 1
if a==N+1:
a=1
if b==N+1:
b=1
L[i]=1
count += 1
|
ConDefects/ConDefects/Code/arc176_a/Python/53668393
|
condefects-python_data_1869
|
N, M = map(int, input().split())
S = set()
for _ in range(M):
a, b = map(int, input().split())
a -= 1; b -= 1
S.add((a+b)%N)
T = len(S) - M
for i in range(N):
if T == 0: break
if not i in S:
T -= 1
S.add(i)
ret = []
for i in S:
for j in range(N):
ret.append((j, (i - j) % N))
print(len(ret))
for u, v in ret:
print(u+1, v+1)
N, M = map(int, input().split())
S = set()
for _ in range(M):
a, b = map(int, input().split())
a -= 1; b -= 1
S.add((a+b)%N)
T = M - len(S)
for i in range(N):
if T == 0: break
if not i in S:
T -= 1
S.add(i)
ret = []
for i in S:
for j in range(N):
ret.append((j, (i - j) % N))
print(len(ret))
for u, v in ret:
print(u+1, v+1)
|
ConDefects/ConDefects/Code/arc176_a/Python/53516629
|
condefects-python_data_1870
|
def solve(n, m, a, b):
# 対角要素との列の位置ズレが異なるm種を用意
S = set([(i+j)%n for i, j in zip(a, b)])
for i in range(n):
if len(S) == m:
break
S.add(i)
# ズレごとのマスを埋めていく
ans = []
for d in S:
for i in range(n):
j = (d - i) % n
ans.append((i+1, j+1))
return ans
n, m = map(int, input().split())
a, b = zip(*[map(int, input().split()) for i in range(m)])
ans = solve(n, m, a, b)
print(len(ans))
for i, j in ans:
print(i, j)
def solve(n, m, a, b):
a = [_-1 for _ in a]
b = [_-1 for _ in b]
# 対角要素との列の位置ズレが異なるm種を用意
S = set([(i+j)%n for i, j in zip(a, b)])
for i in range(n):
if len(S) == m:
break
S.add(i)
# ズレごとのマスを埋めていく
ans = []
for d in S:
for i in range(n):
j = (d - i) % n
ans.append((i+1, j+1))
return ans
n, m = map(int, input().split())
a, b = zip(*[map(int, input().split()) for i in range(m)])
ans = solve(n, m, a, b)
print(len(ans))
for i, j in ans:
print(i, j)
|
ConDefects/ConDefects/Code/arc176_a/Python/55106959
|
condefects-python_data_1871
|
A=int(input())
B=int(input())
print(str(A)+str(B*10//2))
A=int(input())
B=int(input())
print(str(A)+"0"+str(B*10//2))
|
ConDefects/ConDefects/Code/arc131_a/Python/45453669
|
condefects-python_data_1872
|
a=input()
b=str(int(input())*5)
print('1'+a+b)
a=input()
b=str(int(input())*5)
print(a+'0'+b)
|
ConDefects/ConDefects/Code/arc131_a/Python/43033195
|
condefects-python_data_1873
|
a = int(input())
b = int(input())
print(str(a)+str(b*5))
a = int(input())
b = int(input())
print(str(a)+"0"+str(b*5))
|
ConDefects/ConDefects/Code/arc131_a/Python/44093333
|
condefects-python_data_1874
|
a = input()
b = input()
ans = a
if int(b)%2==1:
ans += str(int(b+"0")//2)
else:
ans += str(int(b)//2)
print(ans)
a = input()
b = input()
ans = a+"0"
if int(b)%2==1:
ans += str(int(b+"0")//2)
else:
ans += str(int(b)//2)
print(ans)
|
ConDefects/ConDefects/Code/arc131_a/Python/42234750
|
condefects-python_data_1875
|
a=input()
b=input()
print (a+str(int(b)*5))
a=input()
b=input()
print (str(int(b)*5)+a)
|
ConDefects/ConDefects/Code/arc131_a/Python/45086721
|
condefects-python_data_1876
|
A = int(input())
B = int(input())
if B%2==1:
B *= 10
C = B//2
# A = list(str(A))
# print(A)
D = len(str(C))
print(A*(10**D)+C)
A = int(input())
B = int(input())
if B%2==1:
B *= 10
C = B//2
# A = list(str(A))
# print(A)
D = len(str(C))+1
print(A*(10**D)+C)
|
ConDefects/ConDefects/Code/arc131_a/Python/42235783
|
condefects-python_data_1877
|
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def doubling(n,mod):
a,res,c,c1 = 1,0,1,0
while n > 0:
if n&1:
res = (a*pow(10,c1,mod)+res)%mod
c1 += c
a = (a+a*pow(10,c,mod))%mod
n >>= 1
c *= 2
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n // i)
i += 1
return lower_divisors + upper_divisors[::-1]
def calc(K:int)->int:
if K == 1 or K == 2:return 1
if K % 2 == 0:
K //= 2
if math.gcd(K,10) != 1:return -1
for i in divisors(euler_phi(K)):
if pow(10,i,K) == 1:
j = 1
while True:
if doubling(i*j,K) == 0:return i
j += 1
def main():
T = ii()
ans = []
for i in range(T):
K = ii()
ans.append(calc(K))
print(*ans,sep="\n")
if __name__=="__main__":
main()
import sys
import copy
from collections import deque,defaultdict
import math
import heapq
from itertools import accumulate
import itertools
from functools import reduce
#import pypyjit
#pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(10**8)
mod = 10**9 + 7
INF = math.inf
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
from functools import lru_cache #@lru_cache(maxsize=None)
def doubling(n,mod):
a,res,c,c1 = 1,0,1,0
while n > 0:
if n&1:
res = (a*pow(10,c1,mod)+res)%mod
c1 += c
a = (a+a*pow(10,c,mod))%mod
n >>= 1
c *= 2
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def divisors(n):
lower_divisors, upper_divisors = [], []
i = 1
while i * i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n // i)
i += 1
return lower_divisors + upper_divisors[::-1]
def calc(K:int)->int:
if K == 1 or K == 2:return 1
if K % 2 == 0:
K //= 2
if math.gcd(K,10) != 1:return -1
for i in divisors(euler_phi(K)):
if pow(10,i,K) == 1:
j = 1
while True:
if doubling(i*j,K) == 0:return i*j
j += 1
def main():
T = ii()
ans = []
for i in range(T):
K = ii()
ans.append(calc(K))
print(*ans,sep="\n")
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/abc222_g/Python/45118973
|
condefects-python_data_1878
|
def factor(x):
d=[]
e=[]
for i in range(1,x+1):
if i*i>x:
break
if i*i==x:
d.append(i)
break
if x%i==0:
d.append(i)
e.append(x//i)
return d+e[::-1]
def make_prime(N): #O(NloglogN)
Plist=[]
L=[0]*(N+1)
for i in range(2,N+1):
if L[i]==0:
Plist.append(i)
for j in range(i,N+1,i):
L[j]=1
return Plist
Plist=make_prime(10000)
from collections import *
def prime(N): #O(sqrt(N))
P=defaultdict(int)
for i in Plist:
if i*i>N:
break
if N%i==0:
j=0
while N%i==0:
N//=i
j+=1
P[i]=j
i+=1
if N!=1:
P[N]=1
return P
T=int(input())
for _ in range(T):
K=int(input())
if K%4==0 or K%5==0:
print(-1)
continue
pk=prime(K)
pk[3]+=2
l=9*K
for p in pk:
l=l*(p-1)//p
for i in factor(l):
if pow(10,i,9*K)==1:
print(i)
break
def factor(x):
d=[]
e=[]
for i in range(1,x+1):
if i*i>x:
break
if i*i==x:
d.append(i)
break
if x%i==0:
d.append(i)
e.append(x//i)
return d+e[::-1]
def make_prime(N): #O(NloglogN)
Plist=[]
L=[0]*(N+1)
for i in range(2,N+1):
if L[i]==0:
Plist.append(i)
for j in range(i,N+1,i):
L[j]=1
return Plist
Plist=make_prime(10000)
from collections import *
def prime(N): #O(sqrt(N))
P=defaultdict(int)
for i in Plist:
if i*i>N:
break
if N%i==0:
j=0
while N%i==0:
N//=i
j+=1
P[i]=j
i+=1
if N!=1:
P[N]=1
return P
T=int(input())
for _ in range(T):
K=int(input())
if K%4==0 or K%5==0:
print(-1)
continue
if K%2==0:
K//=2
pk=prime(K)
pk[3]+=2
l=9*K
for p in pk:
l=l*(p-1)//p
for i in factor(l):
if pow(10,i,9*K)==1:
print(i)
break
|
ConDefects/ConDefects/Code/abc222_g/Python/50712644
|
condefects-python_data_1879
|
from math import sqrt
def gcd2(a, b):
x, y, lx, ly = 0, 1, 1, 0
while b != 0:
q = a // b
a, b = b, a % b
x, y, lx, ly = lx - q * x, ly - q * y, x, y
return (lx, ly)
def inv(n, p):
return gcd2(n, p)[0] % p
def solve(k):
if k <= 2:
return 1
if not (k & 1):
k //= 2
if not (k % 2 and k % 5):
return -1
sq = int(sqrt(k))
s = 1
tbl = {}
for i in range(sq + 2):
if s not in tbl:
tbl[s] = i
s = s * 10 % k
psinv = inv(pow(10, sq, k), k)
m = inv(10, k)
for i in range(sq + 2):
if m in tbl:
return sq * i + tbl[m] + 1
m = m * psinv % k
return -1
t = int(input())
for i in range(t):
k = int(input())
print(solve(k))
from math import sqrt
def gcd2(a, b):
x, y, lx, ly = 0, 1, 1, 0
while b != 0:
q = a // b
a, b = b, a % b
x, y, lx, ly = lx - q * x, ly - q * y, x, y
return (lx, ly)
def inv(n, p):
return gcd2(n, p)[0] % p
def solve(k):
if k <= 2:
return 1
if not (k & 1):
k //= 2
if not (k % 2 and k % 5):
return -1
if not (k % 3):
k *= 9
sq = int(sqrt(k))
s = 1
tbl = {}
for i in range(sq + 2):
if s not in tbl:
tbl[s] = i
s = s * 10 % k
psinv = inv(pow(10, sq, k), k)
m = inv(10, k)
for i in range(sq + 2):
if m in tbl:
return sq * i + tbl[m] + 1
m = m * psinv % k
return -1
t = int(input())
for i in range(t):
k = int(input())
print(solve(k))
|
ConDefects/ConDefects/Code/abc222_g/Python/45276473
|
condefects-python_data_1880
|
def resolve():
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
k = int(input())
if k == 1:
print(1)
continue
m = 9 * k if k % 2 else 9 * k // 2
try:
ans = bsgs(10, pow(10, -1, m), m)
print(ans + 2 if ans >= 0 else -1)
except:
print(-1)
def bsgs(a, b, m, is_prime=False):
# a^x = b (mod m) たる最小のx
def inv(a, m):
x, y = 1, 0
while m != 0:
x, y = y, x - (a // m) * y
a, m = m, a % m
return x
if m == 1:
return 0
if a == 0:
if b <= 1:
return b ^ 1
return -1
# gcd(a,m) == 1 にする
import math
c = 0
while True:
if m == 1:
return c
g = math.gcd(a, m)
if g == 1:
break
if b % g:
return -1
b //= g
m //= g
if is_prime:
b *= pow(a // g, m - 2, m)
else:
b *= inv(a // g, m)
b %= m
c += 1
# baby step
r = int(m**0.5) + 1
baby = {}
x = a
for i in range(r):
baby[x] = i
if x == b:
return i + c
x *= a
x %= m
x *= inv(a, m)
x %= m
# giant step x:a^r
if is_prime:
inv_ar = pow(x, m - 2, m)
else:
inv_ar = inv(x, m)
for j in range(1, r + 1):
b *= inv_ar
b %= m
if b in baby:
return j * r + baby[b] + c
return -1
if __name__ == "__main__":
resolve()
def resolve():
import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
k = int(input())
if k == 1 or k == 2:
print(1)
continue
m = 9 * k if k % 2 else 9 * k // 2
try:
ans = bsgs(10, pow(10, -1, m), m)
print(ans + 2 if ans >= 0 else -1)
except:
print(-1)
def bsgs(a, b, m, is_prime=False):
# a^x = b (mod m) たる最小のx
def inv(a, m):
x, y = 1, 0
while m != 0:
x, y = y, x - (a // m) * y
a, m = m, a % m
return x
if m == 1:
return 0
if a == 0:
if b <= 1:
return b ^ 1
return -1
# gcd(a,m) == 1 にする
import math
c = 0
while True:
if m == 1:
return c
g = math.gcd(a, m)
if g == 1:
break
if b % g:
return -1
b //= g
m //= g
if is_prime:
b *= pow(a // g, m - 2, m)
else:
b *= inv(a // g, m)
b %= m
c += 1
# baby step
r = int(m**0.5) + 1
baby = {}
x = a
for i in range(r):
baby[x] = i
if x == b:
return i + c
x *= a
x %= m
x *= inv(a, m)
x %= m
# giant step x:a^r
if is_prime:
inv_ar = pow(x, m - 2, m)
else:
inv_ar = inv(x, m)
for j in range(1, r + 1):
b *= inv_ar
b %= m
if b in baby:
return j * r + baby[b] + c
return -1
if __name__ == "__main__":
resolve()
|
ConDefects/ConDefects/Code/abc222_g/Python/49217735
|
condefects-python_data_1881
|
T = int(input())
for _ in range(T):
N,K = map(int,input().split())
P = [0,0]+list(map(int,input().split()))
A = [0]+list(map(int,input().split()))
G = {i:[] for i in range(1,N+1)}
for i in range(2,N+1):
G[P[i]].append(i)
lack = {i:[True,0,set()] for i in range(1,N+1)}
B = set(range(K))
def dfs(x):
if A[x]==K:
lack[x][0] = False
if len(G[x])==0:
if A[x]>=0:
lack[x][2] = B-set([A[x]])
else:
lack[x][1] += 1
lack[x][2] = B
else:
lack[x][2] = B
for y in G[x]:
dfs(y)
lack[x][0] = lack[x][0] and lack[y][0]
lack[x][1] += lack[y][1]
lack[x][2] = lack[x][2]&lack[y][2]
if A[x]==-1:
lack[x][1] += 1
dfs(1)
flag = "Bob"
for i in range(1,N+1):
if not lack[i][0]:continue
if (len(lack[i][2])==0 and lack[i][1]<=1) or (len(lack[i][2])==1 and lack[i][1]==1):
flag = "Alice"
break
print(flag)
T = int(input())
for _ in range(T):
N,K = map(int,input().split())
P = [0,0]+list(map(int,input().split()))
A = [0]+list(map(int,input().split()))
G = {i:[] for i in range(1,N+1)}
for i in range(2,N+1):
G[P[i]].append(i)
lack = {i:[True,0,set()] for i in range(1,N+1)}
B = set(range(K))
def dfs(x):
if A[x]==K:
lack[x][0] = False
if len(G[x])==0:
if A[x]>=0:
lack[x][2] = B-set([A[x]])
else:
lack[x][1] += 1
lack[x][2] = B
else:
lack[x][2] = B
for y in G[x]:
dfs(y)
lack[x][0] = lack[x][0] and lack[y][0]
lack[x][1] += lack[y][1]
lack[x][2] = lack[x][2]&lack[y][2]
if A[x]==-1:
lack[x][1] += 1
else:
lack[x][2] = lack[x][2]-set([A[x]])
dfs(1)
flag = "Bob"
for i in range(1,N+1):
if not lack[i][0]:continue
if (len(lack[i][2])==0 and lack[i][1]<=1) or (len(lack[i][2])==1 and lack[i][1]==1):
flag = "Alice"
break
print(flag)
|
ConDefects/ConDefects/Code/arc162_c/Python/45998728
|
condefects-python_data_1882
|
import math
import heapq
import itertools
import bisect
import random
import time
from collections import deque
import sys
from cmath import exp,pi
from functools import cmp_to_key
input=sys.stdin.readline
def check(line):
line.sort()
p=0
cnt=0
for i in line:
if p==i:
p+=1
if p==k:
return 0
if p<k:
p+=1
for i in line:
if p==i:
p+=1
if p==k:
return 1
return -1
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
graph=[[] for _ in range(n+1)]
p=list(map(int,input().split()))
for i in range(n-1):
graph[p[i]].append(i+2)
ans='Bob'
arr=list(map(int,input().split()))
for i in range(1,n+1):
line=[]
queue=deque([i])
cnt=0
while queue:
a=queue.popleft()
if arr[a-1]==-1:
cnt+=1
line.append(arr[a-1])
for j in graph[a]:
queue.append(j)
x=check(line)
if (x==0 and cnt==0) or (x==1 and cnt==1):
ans='Alice'
print(ans)
import math
import heapq
import itertools
import bisect
import random
import time
from collections import deque
import sys
from cmath import exp,pi
from functools import cmp_to_key
input=sys.stdin.readline
def check(line):
line.sort()
p=0
cnt=0
for i in line:
if p==i:
p+=1
if p==k:
return 0
if p<k:
p+=1
for i in line:
if p==i:
p+=1
if p==k:
return 1
return -1
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
graph=[[] for _ in range(n+1)]
p=list(map(int,input().split()))
for i in range(n-1):
graph[p[i]].append(i+2)
ans='Bob'
arr=list(map(int,input().split()))
for i in range(1,n+1):
line=[]
queue=deque([i])
cnt=0
while queue:
a=queue.popleft()
if arr[a-1]==-1:
cnt+=1
line.append(arr[a-1])
for j in graph[a]:
queue.append(j)
x=check(line)
if (x==0 and cnt<=1) or (x==1 and cnt==1):
ans='Alice'
print(ans)
|
ConDefects/ConDefects/Code/arc162_c/Python/43399874
|
condefects-python_data_1883
|
from collections import deque
T = int(input())
for _ in range(T):
N,K = map(int, input().split())
P = [int(p) for p in input().split()]
A = [int(a) for a in input().split()]
E = [[] for _ in range(N)]
for i in range(N-1):
E[P[i]-1].append(i+1)
ans = "Bob"
for i in range(N):
cnt = 0
memo = [0]*(K+1)
q = deque([i])
if -1 < A[i] <= K:
memo[A[i]] = 1
elif A[i] == -1:
cnt += 1
while q:
u = q.pop()
for v in E[u]:
if -1 < A[v] <= K:
memo[A[v]] += 1
elif A[v] == -1:
cnt += 1
q.append(v)
if memo[K] == 1:
continue
if cnt < 2 and sum(memo) == K:
ans = "Alice"
elif cnt == 1 and sum(memo) == K-1:
ans = "Alice"
print(ans)
from collections import deque
T = int(input())
for _ in range(T):
N,K = map(int, input().split())
P = [int(p) for p in input().split()]
A = [int(a) for a in input().split()]
E = [[] for _ in range(N)]
for i in range(N-1):
E[P[i]-1].append(i+1)
ans = "Bob"
for i in range(N):
cnt = 0
memo = [0]*(K+1)
q = deque([i])
if -1 < A[i] <= K:
memo[A[i]] = 1
elif A[i] == -1:
cnt += 1
while q:
u = q.pop()
for v in E[u]:
if -1 < A[v] <= K:
memo[A[v]] = 1
elif A[v] == -1:
cnt += 1
q.append(v)
if memo[K] == 1:
continue
if cnt < 2 and sum(memo) == K:
ans = "Alice"
elif cnt == 1 and sum(memo) == K-1:
ans = "Alice"
print(ans)
|
ConDefects/ConDefects/Code/arc162_c/Python/43410315
|
condefects-python_data_1884
|
from itertools import permutations as perm
from itertools import combinations, product, combinations_with_replacement, groupby, accumulate
from fractions import Fraction
from collections import *
from sys import stdin
from bisect import *
from heapq import *
#import numpy as np
# from math import *
g = lambda : stdin.readline().strip()
#[gl[0], dl[1], ...]
gl = lambda : g().split()
#gl -> int
gil = lambda : [int(var) for var in gl()]
#[n] = gil("A") -> n = A
#[n,m] = gil("A B") -> n = A, M = B
#n=gil("A B C D ...") -> n = [A, B, C, D, ...]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
#[n]= gbs("A") -> n = A
arr = lambda l:" ".join(str(n) for n in l)
#arr([1,2,3,...]) -> "1 2 3 ..." 配列で答えをprintする時に使う
mod = int(1e9)+7
inf = 2**30
[T]=gil()
def query():
[N,K]=gil()
Tree = [[] for i in range(N+1)]
P = gil()
A = gil()
for i,p in enumerate(P,1):
p -= 1
Tree[p].append(i)
Tree[i].append(p)
P=[-1]+P
for i in range(N):
num = 0
s = set()
q = [i]
while q:
now = q.pop()
if A[now] == -1:
num += 1
else:
s.add(A[now])
for nex in Tree[now]:
if nex == P[now]-1:
continue
q.append(nex)
mex = -1
need = [0]*(K+1)
for j in range(K+1):
if j in s:
need[j]=1
if need[K] or num > 1:
continue #"Bob"かもしれない
count = 0
for j in range(K):
if need[j] == 0:
count += 1
if count == 0:
return "Alice"
if count == 1 and num == 1:
return "Alice"
return "Bob"
def main():
for _ in range(T):
print(query())
if __name__ == '__main__':
main()
from itertools import permutations as perm
from itertools import combinations, product, combinations_with_replacement, groupby, accumulate
from fractions import Fraction
from collections import *
from sys import stdin
from bisect import *
from heapq import *
#import numpy as np
# from math import *
g = lambda : stdin.readline().strip()
#[gl[0], dl[1], ...]
gl = lambda : g().split()
#gl -> int
gil = lambda : [int(var) for var in gl()]
#[n] = gil("A") -> n = A
#[n,m] = gil("A B") -> n = A, M = B
#n=gil("A B C D ...") -> n = [A, B, C, D, ...]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
#[n]= gbs("A") -> n = A
arr = lambda l:" ".join(str(n) for n in l)
#arr([1,2,3,...]) -> "1 2 3 ..." 配列で答えをprintする時に使う
mod = int(1e9)+7
inf = 2**30
[T]=gil()
def query():
[N,K]=gil()
Tree = [[] for i in range(N+1)]
P = gil()
A = gil()
for i,p in enumerate(P,1):
p -= 1
Tree[p].append(i)
Tree[i].append(p)
P=[-1]+P
for i in range(N):
num = 0
s = set()
q = [i]
while q:
now = q.pop()
if A[now] == -1:
num += 1
else:
s.add(A[now])
for nex in Tree[now]:
if nex == P[now]-1:
continue
q.append(nex)
mex = -1
need = [0]*(K+1)
for j in range(K+1):
if j in s:
need[j]=1
if need[K] or num > 1:
continue #"Bob"かもしれない
count = 0
for j in range(K):
if need[j] == 0:
count += 1
if count == 0:
return "Alice"
if count == 1 and num == 1:
return "Alice"
return "Bob"
def main():
for _ in range(T):
print(query())
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc162_c/Python/43234436
|
condefects-python_data_1885
|
import sys
sys.setrecursionlimit(1000000000)
t=int(input())
s=[[]for i in range(2002)]
a=[]
def mdfs(x,y,z):
p=[0for i in range(y+2)]
for i in s[x]:
(f,d)=mdfs(i,y,z)
if f:
return (1,p)
p[0]+=d[0]
if p[0]>1:
return(0,p)
for j in range(1,y+2):
p[j]|=d[j]
if a[x]==-1:
p[0]+=1
elif a[x]<=y:
p[a[x]+1]=1
cnt=0
for j in range(1,y+1):
if p[j]==0:
cnt+=1
if cnt==0 and p[y+1]==0 and p[0]<=1:
return (1,p)
elif cnt==1 and p[0]==1 and p[y+1]==0:
return (1,p)
else:
return(0,p)
for i in range(t):
n,k=map(int,input().split())
for j in range(n):
s[j]=[]
p=list(map(int,input().split()))
for j in range(n-1):
s[p[j]-1].append(j+1)
a=list(map(int,input().split()))
f,t=mdfs(0,k,n)
if f:
print("Alice")
else:
print("Bob")
import sys
sys.setrecursionlimit(1000000000)
t=int(input())
s=[[]for i in range(2002)]
a=[]
def mdfs(x,y,z):
p=[0for i in range(y+2)]
for i in s[x]:
(f,d)=mdfs(i,y,z)
if f:
return (1,p)
p[0]+=d[0]
for j in range(1,y+2):
p[j]|=d[j]
if a[x]==-1:
p[0]+=1
elif a[x]<=y:
p[a[x]+1]=1
cnt=0
for j in range(1,y+1):
if p[j]==0:
cnt+=1
if cnt==0 and p[y+1]==0 and p[0]<=1:
return (1,p)
elif cnt==1 and p[0]==1 and p[y+1]==0:
return (1,p)
else:
return(0,p)
for i in range(t):
n,k=map(int,input().split())
for j in range(n):
s[j]=[]
p=list(map(int,input().split()))
for j in range(n-1):
s[p[j]-1].append(j+1)
a=list(map(int,input().split()))
f,t=mdfs(0,k,n)
if f:
print("Alice")
else:
print("Bob")
|
ConDefects/ConDefects/Code/arc162_c/Python/45291562
|
condefects-python_data_1886
|
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
p = [ -1 ] + list(map(lambda x: int(x) - 1, input().split()))
a = list(map(int, input().split()))
for i in range(n):
if a[i] == -1:
a[i] = n + 1
dp = [ [ 0 ] * (n + 2) for i in range(n) ]
for i in range(n):
dp[i][a[i]] += 1
answer = False
for i in range(n - 1, -1, -1):
for j in range(n + 2):
dp[p[i]][j] += dp[i][j]
if dp[i][n + 1] <= 1:
cnt = 0
for j in range(k):
if dp[i][j] == 0:
cnt += 1
if dp[i][k] == 0 and cnt <= 1:
answer = True
print('Alice' if answer else 'Bob')
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
p = [ -1 ] + list(map(lambda x: int(x) - 1, input().split()))
a = list(map(int, input().split()))
for i in range(n):
if a[i] == -1:
a[i] = n + 1
dp = [ [ 0 ] * (n + 2) for i in range(n) ]
for i in range(n):
dp[i][a[i]] += 1
answer = False
for i in range(n - 1, -1, -1):
for j in range(n + 2):
dp[p[i]][j] += dp[i][j]
if dp[i][n + 1] <= 1:
cnt = 0
for j in range(k):
if dp[i][j] == 0:
cnt += 1
if dp[i][k] == 0 and cnt <= 1 and cnt <= dp[i][n + 1]:
answer = True
print('Alice' if answer else 'Bob')
|
ConDefects/ConDefects/Code/arc162_c/Python/45663637
|
condefects-python_data_1887
|
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
def check_mex(LIST):
t = []
for i in range(n+1):
if LIST[i] == 0:t.append(i)
if len(t) == 2:break
return t
def merge(mae,now):
A = have[mae]
B = have[now]
C = [0]*(n+1)
for i in range(n+1):
C[i] = A[i] + B[i]
return C
def dfs(now,mae):
if a[now] != -1:
have[now][a[now]] += 1
for i in edge[now]:
if i == mae:continue
dfs(i,now)
if a[now] == -1:
mitei[now] += 1
mitei[mae] += mitei[now]
have[mae] = merge(mae,now)
mex = check_mex(have[mae])
if mitei[now] == 0 and check_mex(have[now])[0] == k:
flag[0] = 1
if mitei[now] == 1 and (mex[0] == k or mex[1] == k):
flag[0] = 1
t = int(input())
for _ in range(t):
n,k = mp()
p = lm1(lmp())
a = lmp()
flag = [0]
edge = [[] for i in range(n)]
for i in range(n-1):
edge[i+1].append(p[i])
edge[p[i]].append(i+1)
aset = set(a)
mitei = [0]*(n+1)
have = [[0]*(n+1) for _ in range(n+1)]
dfs(0,-1)
mitei.pop()
if flag[0]:print("Alice")
else:
print("Bob")
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
def check_mex(LIST):
t = []
for i in range(n+1):
if LIST[i] == 0:t.append(i)
if len(t) == 2:break
return t
def merge(mae,now):
A = have[mae]
B = have[now]
C = [0]*(n+1)
for i in range(n+1):
C[i] = A[i] + B[i]
return C
def dfs(now,mae):
if a[now] != -1:
have[now][a[now]] += 1
for i in edge[now]:
if i == mae:continue
dfs(i,now)
if a[now] == -1:
mitei[now] += 1
mitei[mae] += mitei[now]
have[mae] = merge(mae,now)
mex = check_mex(have[now])
if mitei[now] == 0 and check_mex(have[now])[0] == k:
flag[0] = 1
if mitei[now] == 1 and (mex[0] == k or mex[1] == k):
flag[0] = 1
t = int(input())
for _ in range(t):
n,k = mp()
p = lm1(lmp())
a = lmp()
flag = [0]
edge = [[] for i in range(n)]
for i in range(n-1):
edge[i+1].append(p[i])
edge[p[i]].append(i+1)
aset = set(a)
mitei = [0]*(n+1)
have = [[0]*(n+1) for _ in range(n+1)]
dfs(0,-1)
mitei.pop()
if flag[0]:print("Alice")
else:
print("Bob")
|
ConDefects/ConDefects/Code/arc162_c/Python/44163778
|
condefects-python_data_1888
|
class SegTree:
def __init__(self, init_list, func=lambda x,y: x+y, ide_ele=0):
self.n = len(init_list)
self.length = 1<<(self.n-1).bit_length()
self.node_list = [ide_ele]*(2*self.length)
self.func = func
self.ide_ele = ide_ele
for i in range(self.n):
self.node_list[i+self.length] = init_list[i]
for i in range(self.length-1, 0, -1):
self.node_list[i] = self.func(self.node_list[2*i], self.node_list[2*i+1])
def add(self, index, x):
if not 0 <= index < self.n: raise Exception("segtree index out of range")
index += self.length
self.node_list[index] = self.func(self.node_list[index], x)
while index > 1:
self.node_list[index>>1] = self.func(self.node_list[index], self.node_list[index^1])
index >>= 1
def update(self, index, x):
if not 0 <= index < self.n: raise Exception("segtree index out of range")
index += self.length
self.node_list[index] = x
while index > 1:
self.node_list[index>>1] = self.func(self.node_list[index], self.node_list[index^1])
index >>= 1
def query(self, l, r):
if not (0 <= l <= self.n and 0 <= r <= self.n): raise Exception("segtree index out of range")
ans = self.ide_ele
l += self.length
r += self.length
while l < r:
if l & 1:
ans = self.func(ans, self.node_list[l])
l += 1
if r & 1:
ans = self.func(ans, self.node_list[r-1])
l >>= 1
r >>= 1
return ans
def __getitem__(self, index):
if type(index) != int: raise Exception("segtree indices must be integers")
if not 0 <= index < self.n: raise Exception("segtree index out of range")
return self.node_list[index+self.length]
def __setitem__(self, index, value):
if type(index) != int: raise Exception("segtree indices must be integers")
if not 0 <= index < self.n: raise Exception("segtree index out of range")
self.update(index, value)
def __str__(self):
return str(self.node_list[self.length:self.length+self.n])
def solve():
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
a_list = list(map(int, input().split()))
tree = [set() for _ in range(n)]
for i in range(n-1):
p = p_list[i]
tree[i+1].add(p-1)
tree[p-1].add(i+1)
todo = [0]
ecount_list = [-2]*n
num_list = [set() for _ in range(n)]
while todo:
t = todo[-1]
if ecount_list[t] == -2:
for i in tree[t]:
if ecount_list[i] == -2:
todo.append(i)
ecount_list[t] = -1
elif ecount_list[t] == -1:
if a_list[t] == -1:
count = 1
else:
count = 0
if a_list[t] <= k: num_list[t].add(a_list[t])
for i in tree[t]:
if ecount_list[i] > 0:
count += ecount_list[i]
num_list[t] |= num_list[i]
ecount_list[t] = count
todo.pop()
count = 0
#print(ecount_list)
#print(num_list)
for i in range(n):
if ecount_list[i] == 0 and len(num_list[i]) == k and k not in num_list[i]:
print("Alice")
break
elif ecount_list[i] == 1 and len(num_list[i]) == k-1 and k not in num_list[i]:
print("Alice")
break
else:
print("Bob")
t = int(input())
for _ in range(t):
solve()
class SegTree:
def __init__(self, init_list, func=lambda x,y: x+y, ide_ele=0):
self.n = len(init_list)
self.length = 1<<(self.n-1).bit_length()
self.node_list = [ide_ele]*(2*self.length)
self.func = func
self.ide_ele = ide_ele
for i in range(self.n):
self.node_list[i+self.length] = init_list[i]
for i in range(self.length-1, 0, -1):
self.node_list[i] = self.func(self.node_list[2*i], self.node_list[2*i+1])
def add(self, index, x):
if not 0 <= index < self.n: raise Exception("segtree index out of range")
index += self.length
self.node_list[index] = self.func(self.node_list[index], x)
while index > 1:
self.node_list[index>>1] = self.func(self.node_list[index], self.node_list[index^1])
index >>= 1
def update(self, index, x):
if not 0 <= index < self.n: raise Exception("segtree index out of range")
index += self.length
self.node_list[index] = x
while index > 1:
self.node_list[index>>1] = self.func(self.node_list[index], self.node_list[index^1])
index >>= 1
def query(self, l, r):
if not (0 <= l <= self.n and 0 <= r <= self.n): raise Exception("segtree index out of range")
ans = self.ide_ele
l += self.length
r += self.length
while l < r:
if l & 1:
ans = self.func(ans, self.node_list[l])
l += 1
if r & 1:
ans = self.func(ans, self.node_list[r-1])
l >>= 1
r >>= 1
return ans
def __getitem__(self, index):
if type(index) != int: raise Exception("segtree indices must be integers")
if not 0 <= index < self.n: raise Exception("segtree index out of range")
return self.node_list[index+self.length]
def __setitem__(self, index, value):
if type(index) != int: raise Exception("segtree indices must be integers")
if not 0 <= index < self.n: raise Exception("segtree index out of range")
self.update(index, value)
def __str__(self):
return str(self.node_list[self.length:self.length+self.n])
def solve():
n, k = map(int, input().split())
p_list = list(map(int, input().split()))
a_list = list(map(int, input().split()))
tree = [set() for _ in range(n)]
for i in range(n-1):
p = p_list[i]
tree[i+1].add(p-1)
tree[p-1].add(i+1)
todo = [0]
ecount_list = [-2]*n
num_list = [set() for _ in range(n)]
while todo:
t = todo[-1]
if ecount_list[t] == -2:
for i in tree[t]:
if ecount_list[i] == -2:
todo.append(i)
ecount_list[t] = -1
elif ecount_list[t] == -1:
if a_list[t] == -1:
count = 1
else:
count = 0
if a_list[t] <= k: num_list[t].add(a_list[t])
for i in tree[t]:
if ecount_list[i] > 0:
count += ecount_list[i]
num_list[t] |= num_list[i]
ecount_list[t] = count
todo.pop()
count = 0
#print(ecount_list)
#print(num_list)
for i in range(n):
if ecount_list[i] == 0 and len(num_list[i]) == k and k not in num_list[i]:
print("Alice")
break
elif ecount_list[i] == 1 and k-1 <= len(num_list[i]) <= k and k not in num_list[i]:
print("Alice")
break
else:
print("Bob")
t = int(input())
for _ in range(t):
solve()
|
ConDefects/ConDefects/Code/arc162_c/Python/43723091
|
condefects-python_data_1889
|
import sys
sys.setrecursionlimit(1000000)
t = int(input())
def dfs(x):
for y in edges[x]:
dfs(y)
sizes[x] += sizes[y]
nums[x] += nums[y]
sizes[x] += 1
nums[x].append(A[x])
for _ in range(t):
n, k = map(int, input().split())
P = [-1]+list(map(lambda x: int(x)-1, input().split()))
edges = [[] for _ in range(n)]
for i in range(1, n):
edges[P[i]].append(i)
A = list(map(int, input().split()))
sizes = [0]*n
nums = [[] for _ in range(n)]
dfs(0)
for i in range(n):
x = nums[i].count(-1)
s = set(nums[i])
if k in s:
continue
y = 0
mex = k
for j in range(k):
if j not in s:
y += 1
if mex == k:
mex = j
if (x==1 and y==1) or (mex==k and x==0):
print("Alice")
break
else:
print("Bob")
import sys
sys.setrecursionlimit(1000000)
t = int(input())
def dfs(x):
for y in edges[x]:
dfs(y)
sizes[x] += sizes[y]
nums[x] += nums[y]
sizes[x] += 1
nums[x].append(A[x])
for _ in range(t):
n, k = map(int, input().split())
P = [-1]+list(map(lambda x: int(x)-1, input().split()))
edges = [[] for _ in range(n)]
for i in range(1, n):
edges[P[i]].append(i)
A = list(map(int, input().split()))
sizes = [0]*n
nums = [[] for _ in range(n)]
dfs(0)
for i in range(n):
x = nums[i].count(-1)
s = set(nums[i])
if k in s:
continue
y = 0
mex = k
for j in range(k):
if j not in s:
y += 1
if mex == k:
mex = j
if (x==1 and y==1) or (mex==k and (x==0 or x==1)):
print("Alice")
break
else:
print("Bob")
|
ConDefects/ConDefects/Code/arc162_c/Python/43008956
|
condefects-python_data_1890
|
import sys
sys.setrecursionlimit((1<<19)-1)
def dfs(pos):
global ans
cnt=0
less=set()
for i in tree[pos]:
tocnt,toless=dfs(i)
cnt+=tocnt
less=less|toless
if A[pos]==-1:
cnt+=1
elif A[pos]<=K:
less.add(pos)
if K not in less and len(less)>=K-cnt and cnt<=1:
ans="Alice"
return cnt,less
T=int(input())
for _ in range(T):
N,K=map(int,input().split())
P=list(map(int,input().split()))
A=list(map(int,input().split()))
ans="Bob"
tree=[set() for i in range(N)]
for i in range(N-1):
tree[P[i]-1].add(i+1)
dfs(0)
print(ans)
import sys
sys.setrecursionlimit((1<<19)-1)
def dfs(pos):
global ans
cnt=0
less=set()
for i in tree[pos]:
tocnt,toless=dfs(i)
cnt+=tocnt
less=less|toless
if A[pos]==-1:
cnt+=1
elif A[pos]<=K:
less.add(A[pos])
if K not in less and len(less)>=K-cnt and cnt<=1:
ans="Alice"
return cnt,less
T=int(input())
for _ in range(T):
N,K=map(int,input().split())
P=list(map(int,input().split()))
A=list(map(int,input().split()))
ans="Bob"
tree=[set() for i in range(N)]
for i in range(N-1):
tree[P[i]-1].add(i+1)
dfs(0)
print(ans)
|
ConDefects/ConDefects/Code/arc162_c/Python/45802611
|
condefects-python_data_1891
|
## https://atcoder.jp/contests/abc294/tasks/abc294_g
from collections import deque
class BinaryIndexTree:
"""
フェニック木(BinaryIndexTree)の基本的な機能を実装したクラス
"""
def __init__(self, size):
self.size = size
self.array = [0] * (size + 1)
def add(self, x, a):
index = x
while index <= self.size:
self.array[index] += a
index += index & (-index)
def sum(self, x):
index = x
ans = 0
while index > 0:
ans += self.array[index]
index -= index & (-index)
return ans
def least_upper_bound(self, value):
if self.sum(self.size) < value:
return -1
elif value <= 0:
return 0
m = 1
while m < self.size:
m *= 2
k = 0
k_sum = 0
while m > 0:
k0 = k + m
if k0 < self.size:
if k_sum + self.array[k0] < value:
k_sum += self.array[k0]
k += m
m //= 2
if k < self.size:
return k + 1
else:
return -1
class SegmentTree:
"""
非再帰版セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(float("inf"), float("inf")) for _ in range(2 * self.size)]
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def add(self, x, a):
index = self.size + x
self.array[index] += a
while index > 1:
index //= 2
self.array[index] = min(self.array[2 * index], self.array[2 * index + 1])
def get_min(self, l, r):
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (float("inf"), float("inf"))
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
def main():
N = int(input())
next_nodes = [[] for _ in range(N)]
for i in range(N - 1):
u, v, w = map(int, input().split())
u -= 1
v -= 1
next_nodes[u].append((v, w, i))
next_nodes[v].append((u, w, i))
Q = int(input())
queries = []
for _ in range(Q):
values = tuple(map(int, input().split()))
queries.append(values)
# オイラーツアー
queue = deque()
queue.append((0, 0))
index_array = [-1] * N
index_array[0] = 0
parents = [-2] * N
parents[0] = -1
euler_tour_node = [0]
euler_tour_edge = [0]
edge_index_to_eluer_tour_index = {}
while len(queue) > 0:
v, index = queue.pop()
if index > 0:
euler_tour_node.append(index_array[v])
next_node, w, edge_index = next_nodes[v][index - 1]
euler_tour_edge.append(-w)
edge_index_to_eluer_tour_index[edge_index].append(len(euler_tour_edge) - 1)
while index < len(next_nodes[v]):
next_node, w, edge_index = next_nodes[v][index]
if next_node == parents[v]:
index += 1
continue
parents[next_node] = v
index_array[next_node] = len(euler_tour_node)
euler_tour_node.append(len(euler_tour_node))
euler_tour_edge.append(w)
edge_index_to_eluer_tour_index[edge_index] = []
edge_index_to_eluer_tour_index[edge_index].append(len(euler_tour_edge) - 1)
queue.append((v, index + 1))
queue.append((next_node, 0))
break
# euler_tour_edgeの累積和を取る
bit = BinaryIndexTree(len(euler_tour_edge))
for i in range(len(euler_tour_edge)):
bit.add(i + 1, euler_tour_edge[i])
# セグメント木
seg_tree = SegmentTree(euler_tour_node)
# クエリの対応
for query in queries:
if query[0] == 1:
_, i, w = query
i -= 1
index1, index2 = edge_index_to_eluer_tour_index[i]
old_w = euler_tour_edge[index1]
bit.add(index1 + 1, w - old_w)
euler_tour_edge[index1] = w
old_w = euler_tour_edge[index2]
bit.add(index2 + 1, -w - old_w)
euler_tour_edge[index2] = w
else:
_, u, v = query
u -= 1
v -= 1
ind_u = index_array[u]
ind_v = index_array[v]
if ind_u > ind_v:
u, v = v, u
ind_u, ind_v = ind_v, ind_u
_, j = seg_tree.get_min(ind_u, ind_v + 1)
ans1 = bit.sum(ind_u + 1) - bit.sum(j + 1)
ans2 = bit.sum(ind_v + 1) - bit.sum(j + 1)
print(ans1 + ans2)
if __name__ == "__main__":
main()
## https://atcoder.jp/contests/abc294/tasks/abc294_g
from collections import deque
class BinaryIndexTree:
"""
フェニック木(BinaryIndexTree)の基本的な機能を実装したクラス
"""
def __init__(self, size):
self.size = size
self.array = [0] * (size + 1)
def add(self, x, a):
index = x
while index <= self.size:
self.array[index] += a
index += index & (-index)
def sum(self, x):
index = x
ans = 0
while index > 0:
ans += self.array[index]
index -= index & (-index)
return ans
def least_upper_bound(self, value):
if self.sum(self.size) < value:
return -1
elif value <= 0:
return 0
m = 1
while m < self.size:
m *= 2
k = 0
k_sum = 0
while m > 0:
k0 = k + m
if k0 < self.size:
if k_sum + self.array[k0] < value:
k_sum += self.array[k0]
k += m
m //= 2
if k < self.size:
return k + 1
else:
return -1
class SegmentTree:
"""
非再帰版セグメント木。
更新は「加法」、取得は「最大値」のもの限定。
"""
def __init__(self, init_array):
n = 1
while n < len(init_array):
n *= 2
self.size = n
self.array = [(float("inf"), float("inf")) for _ in range(2 * self.size)]
for i, a in enumerate(init_array):
self.array[self.size + i] = (a, i)
end_index = self.size
start_index = end_index // 2
while start_index >= 1:
for i in range(start_index, end_index):
self.array[i] = min(self.array[2 * i], self.array[2 * i + 1])
end_index = start_index
start_index = end_index // 2
def add(self, x, a):
index = self.size + x
self.array[index] += a
while index > 1:
index //= 2
self.array[index] = min(self.array[2 * index], self.array[2 * index + 1])
def get_min(self, l, r):
L = self.size + l; R = self.size + r
# 2. 区間[l, r)の最大値を求める
s = (float("inf"), float("inf"))
while L < R:
if R & 1:
R -= 1
s = min(s, self.array[R])
if L & 1:
s = min(s, self.array[L])
L += 1
L >>= 1; R >>= 1
return s
def main():
N = int(input())
next_nodes = [[] for _ in range(N)]
for i in range(N - 1):
u, v, w = map(int, input().split())
u -= 1
v -= 1
next_nodes[u].append((v, w, i))
next_nodes[v].append((u, w, i))
Q = int(input())
queries = []
for _ in range(Q):
values = tuple(map(int, input().split()))
queries.append(values)
# オイラーツアー
queue = deque()
queue.append((0, 0))
index_array = [-1] * N
index_array[0] = 0
parents = [-2] * N
parents[0] = -1
euler_tour_node = [0]
euler_tour_edge = [0]
edge_index_to_eluer_tour_index = {}
while len(queue) > 0:
v, index = queue.pop()
if index > 0:
euler_tour_node.append(index_array[v])
next_node, w, edge_index = next_nodes[v][index - 1]
euler_tour_edge.append(-w)
edge_index_to_eluer_tour_index[edge_index].append(len(euler_tour_edge) - 1)
while index < len(next_nodes[v]):
next_node, w, edge_index = next_nodes[v][index]
if next_node == parents[v]:
index += 1
continue
parents[next_node] = v
index_array[next_node] = len(euler_tour_node)
euler_tour_node.append(len(euler_tour_node))
euler_tour_edge.append(w)
edge_index_to_eluer_tour_index[edge_index] = []
edge_index_to_eluer_tour_index[edge_index].append(len(euler_tour_edge) - 1)
queue.append((v, index + 1))
queue.append((next_node, 0))
break
# euler_tour_edgeの累積和を取る
bit = BinaryIndexTree(len(euler_tour_edge))
for i in range(len(euler_tour_edge)):
bit.add(i + 1, euler_tour_edge[i])
# セグメント木
seg_tree = SegmentTree(euler_tour_node)
# クエリの対応
for query in queries:
if query[0] == 1:
_, i, w = query
i -= 1
index1, index2 = edge_index_to_eluer_tour_index[i]
old_w = euler_tour_edge[index1]
bit.add(index1 + 1, w - old_w)
euler_tour_edge[index1] = w
old_w = euler_tour_edge[index2]
bit.add(index2 + 1, -w - old_w)
euler_tour_edge[index2] = -w
else:
_, u, v = query
u -= 1
v -= 1
ind_u = index_array[u]
ind_v = index_array[v]
if ind_u > ind_v:
u, v = v, u
ind_u, ind_v = ind_v, ind_u
_, j = seg_tree.get_min(ind_u, ind_v + 1)
ans1 = bit.sum(ind_u + 1) - bit.sum(j + 1)
ans2 = bit.sum(ind_v + 1) - bit.sum(j + 1)
print(ans1 + ans2)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc294_g/Python/53664226
|
condefects-python_data_1892
|
import sys; sys.setrecursionlimit(10**6); import pypyjit; pypyjit.set_param('max_unroll_recursion=-1')
class DubTree:
def __init__(self,N):
self.N, self.K = N, 1
while (1<<self.K)<N : self.K += 1
self.node,self.wei = [None]*self.N, [None]*self.N
self.edge = [[] for n in range(self.N)]
self.parent = [[None]*N for k in range(self.K)]
self.euler = []
self.eunum = [[] for n in range(N)]
self.tree = []
def append_edge(self,a,b,w=1):
self.edge[a].append((b,w)); self.edge[b].append((a,w))
def dfs(self,s):
stack, self.node[s],self.wei[s] = [s], 0, 0
self.parent[0][s] = None
self._dfs(s)
self.tree = [0]*(len(self.euler)+1)
def _dfs(self,pos):
self.euler.append(pos)
self.eunum[pos].append(len(self.euler))
for p,w in self.edge[pos]:
if self.node[p] is None:
self.node[p], self.wei[p] = self.node[pos]+1, self.wei[pos]+w
self.parent[0][p] = pos
self._dfs(p)
self.euler.append(pos)
self.eunum[pos].append(len(self.euler))
def doubling(self):
for k in range(self.K-1):
for n in range(self.N):
if self.parent[k][n] is None : self.parent[k+1][n] = None
else : self.parent[k+1][n] = self.parent[k][self.parent[k][n]]
def lca(self,a,b):
if self.node[a]<self.node[b] : a,b=b,a
for k in range(self.K-1,-1,-1):
if self.node[a]-self.node[b]>=(1<<k) : a = self.parent[k][a]
if a==b : return a
for k in range(self.K-1,-1,-1):
if self.parent[k][a]!=self.parent[k][b] :
a,b = self.parent[k][a],self.parent[k][b]
return self.parent[0][a]
def dist(self,a,b):
lca = self.lca(a,b)
alen = self.wei[a] + self._sum(self.eunum[a][0]) - self.wei[lca] - self._sum(self.eunum[lca][0])
blen = self.wei[b] + self._sum(self.eunum[b][0]) - self.wei[lca] - self._sum(self.eunum[lca][0])
return alen + blen
def add(self,a,i):
n = self.eunum[a][0]
while n<=len(self.tree)-1:
self.tree[n]+=i
n += n&-n
n = self.eunum[a][-1]
while n<=len(self.tree)-1:
self.tree[n]-=i
n += n&-n
def _sum(self,n):
ans = 0
while n>0:
ans += self.tree[n]
n -= n&-n
return ans
N = int(input())
dt = DubTree(N)
edge = [None for n in range(N-1)]
wei = [0 for n in range(N-1)]
for n in range(N-1):
a,b,w = map(int,input().split())
dt.append_edge(a-1,b-1,w)
edge[n] = (a-1,b-1)
wei[n] = w
dt.dfs(0)
dt.doubling()
for _ in range(int(input())):
q,x,y = map(int,input().split())
if q==1:
a,b = edge[x-1]
if dt.parent[0][b]==a : a,b=b,a
dt.add(a,y-wei[x-1])
wei[x-1]=y
else:
print(dt.dist(x-1,y-1))
import sys; sys.setrecursionlimit(10**6); import pypyjit; pypyjit.set_param('max_unroll_recursion=-1')
class DubTree:
def __init__(self,N):
self.N, self.K = N, 1
while (1<<self.K)<N : self.K += 1
self.node,self.wei = [None]*self.N, [None]*self.N
self.edge = [[] for n in range(self.N)]
self.parent = [[None]*N for k in range(self.K)]
self.euler = []
self.eunum = [[] for n in range(N)]
self.tree = []
def append_edge(self,a,b,w=1):
self.edge[a].append((b,w)); self.edge[b].append((a,w))
def dfs(self,s):
stack, self.node[s],self.wei[s] = [s], 0, 0
self.parent[0][s] = None
self._dfs(s)
self.tree = [0]*(len(self.euler)+1)
def _dfs(self,pos):
self.euler.append(pos)
self.eunum[pos].append(len(self.euler))
for p,w in self.edge[pos]:
if self.node[p] is None:
self.node[p], self.wei[p] = self.node[pos]+1, self.wei[pos]+w
self.parent[0][p] = pos
self._dfs(p)
self.euler.append(pos)
self.eunum[pos].append(len(self.euler))
def doubling(self):
for k in range(self.K-1):
for n in range(self.N):
if self.parent[k][n] is None : self.parent[k+1][n] = None
else : self.parent[k+1][n] = self.parent[k][self.parent[k][n]]
def lca(self,a,b):
if self.node[a]<self.node[b] : a,b=b,a
for k in range(self.K-1,-1,-1):
if self.node[a]-self.node[b]>=(1<<k) : a = self.parent[k][a]
if a==b : return a
for k in range(self.K-1,-1,-1):
if self.parent[k][a]!=self.parent[k][b] :
a,b = self.parent[k][a],self.parent[k][b]
return self.parent[0][a]
def dist(self,a,b):
lca = self.lca(a,b)
alen = self.wei[a] + self._sum(self.eunum[a][0]) - self.wei[lca] - self._sum(self.eunum[lca][0])
blen = self.wei[b] + self._sum(self.eunum[b][0]) - self.wei[lca] - self._sum(self.eunum[lca][0])
return alen + blen
def add(self,a,i):
n = self.eunum[a][0]
while n<=len(self.tree)-1:
self.tree[n]+=i
n += n&-n
n = self.eunum[a][-1]+1
while n<=len(self.tree)-1:
self.tree[n]-=i
n += n&-n
def _sum(self,n):
ans = 0
while n>0:
ans += self.tree[n]
n -= n&-n
return ans
N = int(input())
dt = DubTree(N)
edge = [None for n in range(N-1)]
wei = [0 for n in range(N-1)]
for n in range(N-1):
a,b,w = map(int,input().split())
dt.append_edge(a-1,b-1,w)
edge[n] = (a-1,b-1)
wei[n] = w
dt.dfs(0)
dt.doubling()
for _ in range(int(input())):
q,x,y = map(int,input().split())
if q==1:
a,b = edge[x-1]
if dt.parent[0][b]==a : a,b=b,a
dt.add(a,y-wei[x-1])
wei[x-1]=y
else:
print(dt.dist(x-1,y-1))
|
ConDefects/ConDefects/Code/abc294_g/Python/50893680
|
condefects-python_data_1893
|
from heapq import heappop, heappush
class Set:
def __init__(self):
self.q = []
self.d = []
self.sm = 0
def add(self, x):
heappush(self.q, x)
self.sm += x
def delete(self, x):
heappush(self.d, x)
self.sm -= x
def get_min(self):
while self.d and self.q[0] == self.d[0]:
heappop(self.q)
heappop(self.d)
return self.q[0]
def pop_min(self):
while self.d and self.q[0] == self.d[0]:
heappop(self.q)
heappop(self.d)
res = heappop(self.q)
self.sm -= res
return res
class BottomK:
def __init__(self, n, a, k):
assert k <= n
self.a = a
self.n = n
self.k = k
self.low = Set()
self.high = Set()
a.sort()
for i in range(k):
self.low.add(a[i])
for i in range(k, n):
self.high.add(a[i])
# 0-indexed
def set(self, i, x):
ai = self.a[i]
self.a[i] = x
if self.k == self.n:
self.low.delete(-ai)
self.low.add(-x)
return
if not self.k:
self.high.delete(ai)
self.high.add(x)
return
if ai < self.high.get_min():
self.low.delete(-ai)
hl = self.high.pop_min()
if x > hl:
self.low.add(-hl)
self.high.add(x)
else:
self.high.add(hl)
self.low.add(-x)
else:
self.high.delete(ai)
lh = self.low.pop_min()
lh *= -1
if x > lh:
self.high.add(x)
self.low.add(-lh)
else:
self.high.add(lh)
self.low.add(-x)
def get(self):
return -self.low.sm
def inc_k(self):
assert self.k < self.n
self.k += 1
hl = self.high.pop_min()
self.low.add(-hl)
def dec_k(self):
assert self.k
self.k -= 1
lh = self.low.pop_min()
self.high.add(-lh)
n, m, h = map(int, input().split())
s = BottomK(m, [0] * m, m)
ans = []
for i in range(n):
a, b = map(int, input().split())
b -= 1
s.set(b, a + s.a[b])
while s.get() > h:
ans.append(i)
s.dec_k()
ans += [n] * (m + 1 - len(ans))
print(*ans)
from heapq import heappop, heappush
class Set:
def __init__(self):
self.q = []
self.d = []
self.sm = 0
def add(self, x):
heappush(self.q, x)
self.sm += x
def delete(self, x):
heappush(self.d, x)
self.sm -= x
def get_min(self):
while self.d and self.q[0] == self.d[0]:
heappop(self.q)
heappop(self.d)
return self.q[0]
def pop_min(self):
while self.d and self.q[0] == self.d[0]:
heappop(self.q)
heappop(self.d)
res = heappop(self.q)
self.sm -= res
return res
class BottomK:
def __init__(self, n, a, k):
assert k <= n
self.a = a
self.n = n
self.k = k
self.low = Set()
self.high = Set()
a.sort()
for i in range(k):
self.low.add(a[i])
for i in range(k, n):
self.high.add(a[i])
# 0-indexed
def set(self, i, x):
ai = self.a[i]
self.a[i] = x
if self.k == self.n:
self.low.delete(-ai)
self.low.add(-x)
return
if not self.k:
self.high.delete(ai)
self.high.add(x)
return
if ai < self.high.get_min():
self.low.delete(-ai)
hl = self.high.pop_min()
if x > hl:
self.low.add(-hl)
self.high.add(x)
else:
self.high.add(hl)
self.low.add(-x)
else:
self.high.delete(ai)
lh = self.low.pop_min()
lh *= -1
if x > lh:
self.high.add(x)
self.low.add(-lh)
else:
self.high.add(lh)
self.low.add(-x)
def get(self):
return -self.low.sm
def inc_k(self):
assert self.k < self.n
self.k += 1
hl = self.high.pop_min()
self.low.add(-hl)
def dec_k(self):
assert self.k
self.k -= 1
lh = self.low.pop_min()
self.high.add(-lh)
n, m, h = map(int, input().split())
s = BottomK(m, [0] * m, m)
ans = []
for i in range(n):
a, b = map(int, input().split())
b -= 1
s.set(b, a + s.a[b])
while s.get() >= h:
ans.append(i)
s.dec_k()
ans += [n] * (m + 1 - len(ans))
print(*ans)
|
ConDefects/ConDefects/Code/abc314_g/Python/45264890
|
condefects-python_data_1894
|
from bisect import *
import sys
input=sys.stdin.readline
#####segfunc#####
def segfunc(x, y):
return x+y #区間クエリでのfuncを設定
#################
#####ide_ele#####
ide_ele =0 #クエリの単位元を設定
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def main():
def mgr_bisect(ng,ok): #ここの部分(mgr_bisect)は改変しない
while (abs(ok-ng)>1):
mid=(ok+ng)//2
if is_ok(mid):
ok=mid
else:
ng=mid
return ok
N,M,H=map(int,input().split())
attacks=[]
compnum=set()
compnum.add(0)
damages=[0]*M
attackinsts=[]
for i in range(N):
a,b=map(int,input().split())
b-=1
damages[b]+=a
compnum.add(damages[b])
attackinsts.append((a,b))
compnum=list(compnum)
compnum.sort()
#print(compnum)
num_to_ind={}
ind_to_num={}
for i,v in enumerate(compnum):
num_to_ind[v]=i
ind_to_num[i]=v
n=len(compnum)
cnts=[0]*n
cnts[0]=M
sums=[0]*n
cursuml=[0]*M
cntseg=SegTree(cnts,segfunc,ide_ele)
sumseg=SegTree(sums,segfunc,ide_ele)
allsum=0
needamulets=[0]*N
for i in range(N):
a,b=attackinsts[i]
cursum=cursuml[b]
allsum-=cursum
nxtsum=cursum+a
allsum+=nxtsum
cursuml[b]+=a
curind=num_to_ind[cursum]
nxtind=num_to_ind[nxtsum]
#print(curind,nxtind)
curcnt=cntseg.query(curind,curind+1)
nxtcnt=cntseg.query(nxtind,nxtind+1)
#print(curcnt,nxtcnt)
cntseg.update(curind,curcnt-1)
cntseg.update(nxtind,nxtcnt+1)
cursums=sumseg.query(curind,curind+1)
nxtsums=sumseg.query(nxtind,nxtind+1)
sumseg.update(curind,cursums-cursum)
sumseg.update(nxtind,nxtsums+nxtsum)
if allsum<H:continue
if allsum==H:
needamulets[i]=1
continue
#生き残るため、除く必要がある最小ダメージ
dif=allsum-H
def is_ok(arg):
return sumseg.query(arg,n)>dif
ind=mgr_bisect(n,-1)
thre_num=ind_to_num[ind]
cusum=sumseg.query(ind,n)
#print([cntseg.query(i,i+1) for i in range(n)])
#print([sumseg.query(i,i+1) for i in range(n)])
needamulets[i]=cntseg.query(ind,n)-((cusum-dif)//thre_num)
#print(needamulets)
ans=[-1]*(M+1)
for i in range(M+1):
ans[i]=bisect(needamulets,i)
print(*ans)
main()
from bisect import *
import sys
input=sys.stdin.readline
#####segfunc#####
def segfunc(x, y):
return x+y #区間クエリでのfuncを設定
#################
#####ide_ele#####
ide_ele =0 #クエリの単位元を設定
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def main():
def mgr_bisect(ng,ok): #ここの部分(mgr_bisect)は改変しない
while (abs(ok-ng)>1):
mid=(ok+ng)//2
if is_ok(mid):
ok=mid
else:
ng=mid
return ok
N,M,H=map(int,input().split())
attacks=[]
compnum=set()
compnum.add(0)
damages=[0]*M
attackinsts=[]
for i in range(N):
a,b=map(int,input().split())
b-=1
damages[b]+=a
compnum.add(damages[b])
attackinsts.append((a,b))
compnum=list(compnum)
compnum.sort()
#print(compnum)
num_to_ind={}
ind_to_num={}
for i,v in enumerate(compnum):
num_to_ind[v]=i
ind_to_num[i]=v
n=len(compnum)
cnts=[0]*n
cnts[0]=M
sums=[0]*n
cursuml=[0]*M
cntseg=SegTree(cnts,segfunc,ide_ele)
sumseg=SegTree(sums,segfunc,ide_ele)
allsum=0
needamulets=[0]*N
for i in range(N):
a,b=attackinsts[i]
cursum=cursuml[b]
allsum-=cursum
nxtsum=cursum+a
allsum+=nxtsum
cursuml[b]+=a
curind=num_to_ind[cursum]
nxtind=num_to_ind[nxtsum]
#print(curind,nxtind)
curcnt=cntseg.query(curind,curind+1)
nxtcnt=cntseg.query(nxtind,nxtind+1)
#print(curcnt,nxtcnt)
cntseg.update(curind,curcnt-1)
cntseg.update(nxtind,nxtcnt+1)
cursums=sumseg.query(curind,curind+1)
nxtsums=sumseg.query(nxtind,nxtind+1)
sumseg.update(curind,cursums-cursum)
sumseg.update(nxtind,nxtsums+nxtsum)
if allsum<H:continue
if allsum==H:
needamulets[i]=1
continue
#生き残るため、除く必要がある最小ダメージ
dif=allsum-H
def is_ok(arg):
return sumseg.query(arg,n)>dif
ind=mgr_bisect(n,-1)
thre_num=ind_to_num[ind]
cusum=sumseg.query(ind,n)
#print([cntseg.query(i,i+1) for i in range(n)])
#print([sumseg.query(i,i+1) for i in range(n)])
needamulets[i]=cntseg.query(ind,n)-((cusum-(dif+1))//thre_num)
#print(needamulets)
ans=[-1]*(M+1)
for i in range(M+1):
ans[i]=bisect(needamulets,i)
print(*ans)
main()
|
ConDefects/ConDefects/Code/abc314_g/Python/47095184
|
condefects-python_data_1895
|
def func(a,b):
return pow(a,3) + pow(a,2) * b + a * pow(b,2) + pow(b,3)
n = int(input())
if n == 0:
print(0)
exit()
ans = float("inf")
a = 0
b = int(pow(n, 1/3)) + 1
x = func(a,b)
while a <= b:
tempx = func(a,b)
if tempx >= n:
b -= 1
x = tempx
else:
if ans > x:
ans = x
a += 1
print(ans)
def func(a,b):
return pow(a,3) + pow(a,2) * b + a * pow(b,2) + pow(b,3)
n = int(input())
if n == 0:
print(0)
exit()
ans = float("inf")
a = 0
b = int(pow(n, 1/3)) + 1
x = func(a,b)
while a <= b:
tempx = func(a,b)
if tempx >= n:
b -= 1
x = tempx
if ans > x:
ans = x
else:
if ans > x:
ans = x
a += 1
print(ans)
|
ConDefects/ConDefects/Code/abc246_d/Python/45450422
|
condefects-python_data_1896
|
N=int(input())
def func(a,b):
return (a+b)*(a**2+b**2)
def bs(a,N):
left_b=a
right_b=10**6+10
center_b=(left_b+right_b)//2
if func(a,left_b)>=N:
return left_b
while right_b-left_b>1:
if func(a,center_b)<=N:
left_b=max(center_b,left_b+1)
center_b=(left_b+right_b)//2
else:
right_b=min(center_b,right_b-1)
center_b=(left_b+right_b)//2
return right_b
a1=2
a2=1
ans=func(0,bs(0,N))
for a in range(0,10**6+1):
#print(a,bs(a,N))
ans=min(ans,func(a,bs(a,N)))
print(ans)
#print(func(2,1))
N=int(input())
def func(a,b):
return (a+b)*(a**2+b**2)
def bs(a,N):
left_b=a
right_b=10**6+10
center_b=(left_b+right_b)//2
if func(a,left_b)>=N:
return left_b
while right_b-left_b>1:
if func(a,center_b)<N:
left_b=max(center_b,left_b+1)
center_b=(left_b+right_b)//2
else:
right_b=min(center_b,right_b-1)
center_b=(left_b+right_b)//2
return right_b
a1=2
a2=1
ans=func(0,bs(0,N))
for a in range(0,10**6+1):
#print(a,bs(a,N))
ans=min(ans,func(a,bs(a,N)))
print(ans)
#print(func(2,1))
|
ConDefects/ConDefects/Code/abc246_d/Python/45753152
|
condefects-python_data_1897
|
def calc(a, b):
return a * a * a + a * a * b + a * b * b + b * b * b
N = int(input())
ans = 10 ** 20
for a in range(10 ** 6):
lb = a
ub = 10 ** 6
while ub - lb > 1:
mid = (ub + lb) // 2
if calc(a, mid) >= N:
ub = mid
else:
lb = mid
ans = min(ans, calc(a, ub))
print(ans)
def calc(a, b):
return a * a * a + a * a * b + a * b * b + b * b * b
N = int(input())
ans = 10 ** 20
for a in range(10 ** 6):
lb = a - 1
ub = 10 ** 6
while ub - lb > 1:
mid = (ub + lb) // 2
if calc(a, mid) >= N:
ub = mid
else:
lb = mid
ans = min(ans, calc(a, ub))
print(ans)
|
ConDefects/ConDefects/Code/abc246_d/Python/45067622
|
condefects-python_data_1898
|
n = int(input())
def f(a, b):
return a **3 + a**2*b + a*b**2 + b**3
def binary_search(a):
left = 1
right = 10 ** 6+1
while left < right:
mid = (left + right) // 2
if f(a, mid) >= n:
right = mid
else:
left = mid + 1
return left
ans = 10**18+1
for a in range(10**6+1):
b = binary_search(a)
v = f(a, b)
if v < ans:
ans = v
print(ans)
n = int(input())
def f(a, b):
return a **3 + a**2*b + a*b**2 + b**3
def binary_search(a):
left = 0
right = 10 ** 6+1
while left < right:
mid = (left + right) // 2
if f(a, mid) >= n:
right = mid
else:
left = mid + 1
return left
ans = 10**18+1
for a in range(10**6+1):
b = binary_search(a)
v = f(a, b)
if v < ans:
ans = v
print(ans)
|
ConDefects/ConDefects/Code/abc246_d/Python/45897602
|
condefects-python_data_1899
|
n = int(input())
def f(a, b):
return a*a*a + a*a*b + a*b*b + b*b*b
ni = 10**6
ans = float('inf')
for a in range(1, ni+1):
l = -1
r = 10**6+1
while r - l > 1:
b = (r+l) // 2
if f(a, b) < n:
l = b
else:
r = b
ans = min(ans, f(a, r))
print(ans)
n = int(input())
def f(a, b):
return a*a*a + a*a*b + a*b*b + b*b*b
ni = 10**6
ans = float('inf')
for a in range(ni+1):
l = -1
r = 10**6+1
while r - l > 1:
b = (r+l) // 2
if f(a, b) < n:
l = b
else:
r = b
ans = min(ans, f(a, r))
print(ans)
|
ConDefects/ConDefects/Code/abc246_d/Python/45039073
|
condefects-python_data_1900
|
N = int(input())
def calc(m, n):
return (m**2+n**2)*(m+n)
cand = set()
for a in range(10**6+1):
l,r = 0, 10**6+10
while r-l>1:
m = (l+r)//2
if calc(a,m)>=N:
r = m
else:
l = m
cand.add(calc(a,r))
print(min(cand))
N = int(input())
def calc(m, n):
return (m**2+n**2)*(m+n)
cand = set()
for a in range(10**6+1):
l,r = -1, 10**6+10
while r-l>1:
m = (l+r)//2
if calc(a,m)>=N:
r = m
else:
l = m
cand.add(calc(a,r))
print(min(cand))
|
ConDefects/ConDefects/Code/abc246_d/Python/45469208
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.