id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_701
|
n = int(input())
a = list(map(int,input().split()))
ikeru = [[] for i in range(n)]
for i in range(n-1):
u, v = map(int,input().split())
u-=1; v-=1
ikeru[u].append(v)
ikeru[v].append(u)
def canreach(x):
#x以上に到達可能か？
#部分木DP
mada = [~0, 0]
tansaku = [0] * n
tansaku[0] = 1
dp = [0] * n
while mada:
i = mada.pop()
if i >= 0:
for j in ikeru[i]:
if tansaku[j] == 0:
tansaku[j] = 1
mada.append(~j)
mada.append(j)
else:
i = ~i
tmp = 0
for j in ikeru[i]:
if tansaku[j] == 2:
tmp += dp[j]
tmp = max(0, tmp-1)
if i >= 1:
if a[i-1] >= x:
tmp += 1
dp[i] = tmp
tansaku[i] = 2
if dp[0] >= 1:
return True
return False
suki = 10**9 + 5
kirai = -1
while suki - kirai > 1:
targ = (suki + kirai) // 2
if canreach(targ):
kirai = targ
else:
suki = targ
print(kirai)
n = int(input())
a = list(map(int,input().split()))
ikeru = [[] for i in range(n)]
for i in range(n-1):
u, v = map(int,input().split())
u-=1; v-=1
ikeru[u].append(v)
ikeru[v].append(u)
def canreach(x):
#x以上に到達可能か？
#部分木DP
mada = [~0, 0]
tansaku = [0] * n
tansaku[0] = 1
dp = [0] * n
while mada:
i = mada.pop()
if i >= 0:
for j in ikeru[i]:
if tansaku[j] == 0:
tansaku[j] = 1
mada.append(~j)
mada.append(j)
else:
i = ~i
tmp = 0
for j in ikeru[i]:
if tansaku[j] == 2:
tmp += dp[j]
tmp = max(0, tmp-1)
if i >= 1:
if a[i-1] >= x:
tmp += 1
dp[i] = tmp
tansaku[i] = 2
if dp[0] >= 1:
return True
return False
suki = 10**9 + 5
kirai = 0
while suki - kirai > 1:
targ = (suki + kirai) // 2
if canreach(targ):
kirai = targ
else:
suki = targ
print(kirai)
|
ConDefects/ConDefects/Code/abc246_g/Python/32131546
|
condefects-python_data_702
|
import sys
import math
import sys
from collections import defaultdict
N = int(input())
S = [0]+list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
g = [[] for _ in range(N)]
for a, b in AB:
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
children = [[] for _ in range(N)]
parents = [None]*N
q = [(0, None)]
dfs_ord = []
while len(q) > 0:
u, p = q.pop()
parents[u] = p
dfs_ord.append(u)
for v in g[u]:
if v != p:
q.append((v, u))
children[u].append(v)
def is_ok(arg):
dp = [None]*N
def dfs(u):
if dp[u] is not None:
return dp[u]
ret = -1
for v in children[u]:
if v == parents[u]:
continue
ret = sum([ret, dfs(v)])
ret = max(0, ret)
ret += S[u]>arg
dp[u] = ret
return dp[u]
for u in dfs_ord[::-1]:
dfs(u)
return dfs(0)==0
def bisect(ng, ok):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(bisect(0, max(S)+1))
import sys
import math
import sys
from collections import defaultdict
N = int(input())
S = [0]+list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N-1)]
g = [[] for _ in range(N)]
for a, b in AB:
a -= 1
b -= 1
g[a].append(b)
g[b].append(a)
children = [[] for _ in range(N)]
parents = [None]*N
q = [(0, None)]
dfs_ord = []
while len(q) > 0:
u, p = q.pop()
parents[u] = p
dfs_ord.append(u)
for v in g[u]:
if v != p:
q.append((v, u))
children[u].append(v)
def is_ok(arg):
dp = [None]*N
def dfs(u):
if dp[u] is not None:
return dp[u]
ret = -1
for v in children[u]:
if v == parents[u]:
continue
ret = sum([ret, dfs(v)])
ret = max(0, ret)
ret += S[u]>arg
dp[u] = ret
return dp[u]
for u in dfs_ord[::-1]:
dfs(u)
return dfs(0)==0
def bisect(ng, ok):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
print(bisect(-1, max(S)+1))
|
ConDefects/ConDefects/Code/abc246_g/Python/31385030
|
condefects-python_data_703
|
N = int(input())
A = [0]+list(map(int,input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = map(int,input().split())
u,v = u-1,v-1
G[u].append(v)
G[v].append(u)
order = []
par = [-1]*N
from collections import deque
dq = deque([0])
while dq:
cur = dq.popleft()
order.append(cur)
for nxt in G[cur]:
if par[cur] == nxt:
continue
par[nxt] = cur
dq.append(nxt)
ok = 10**9
ng = 0
order.reverse()
cnt = [0]*N
while ok-ng>1:
cen = (ok+ng)//2
for cur in order:
s = 0
for nxt in G[cur]:
if par[cur] == nxt:
continue
s += cnt[nxt]
s = max(0,s-1)
if cur == 0:
if s < 1:
ok = cen
else:
ng = cen
else:
cnt[cur] = s + int(A[cur] > cen)
print(ok)
N = int(input())
A = [0]+list(map(int,input().split()))
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = map(int,input().split())
u,v = u-1,v-1
G[u].append(v)
G[v].append(u)
order = []
par = [-1]*N
from collections import deque
dq = deque([0])
while dq:
cur = dq.popleft()
order.append(cur)
for nxt in G[cur]:
if par[cur] == nxt:
continue
par[nxt] = cur
dq.append(nxt)
ok = 10**9
ng = -1
order.reverse()
cnt = [0]*N
while ok-ng>1:
cen = (ok+ng)//2
for cur in order:
s = 0
for nxt in G[cur]:
if par[cur] == nxt:
continue
s += cnt[nxt]
s = max(0,s-1)
if cur == 0:
if s < 1:
ok = cen
else:
ng = cen
else:
cnt[cur] = s + int(A[cur] > cen)
print(ok)
|
ConDefects/ConDefects/Code/abc246_g/Python/41873287
|
condefects-python_data_704
|
N = int(input())
A = list(map(int,input().split()))
A = [-1] + A
G = [[] for i in range(N)]
for _ in range(N-1):
u,v = map(int,input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
dist = [-1 for i in range(N)]
dist[0] = 0
todo = [0]
RG = [[] for i in range(N)]
H = []
while len(todo):
u = todo.pop()
for v in G[u]:
if dist[v] >= 0:
continue
dist[v] = dist[u] + 1
RG[u].append(v)
todo.append(v)
for u in range(N):
H.append((dist[u],u))
H.sort()
l = 0
r = 10**9
while r - l > 1:
X = (l + r)//2
B = [0 for i in range(N)]
for i in range(N):
if A[i] >= X:
B[i] = 1
dp = [0 for i in range(N)]
for h in H:
todo.append(h)
while len(todo):
d,u = todo.pop()
res = -1
for v in RG[u]:
res += dp[v]
res = max(res,0)
dp[u] = res + B[u]
if dp[0] == 0:
r = X
else:
l = X
print(l)
N = int(input())
A = list(map(int,input().split()))
A = [-1] + A
G = [[] for i in range(N)]
for _ in range(N-1):
u,v = map(int,input().split())
u -= 1
v -= 1
G[u].append(v)
G[v].append(u)
dist = [-1 for i in range(N)]
dist[0] = 0
todo = [0]
RG = [[] for i in range(N)]
H = []
while len(todo):
u = todo.pop()
for v in G[u]:
if dist[v] >= 0:
continue
dist[v] = dist[u] + 1
RG[u].append(v)
todo.append(v)
for u in range(N):
H.append((dist[u],u))
H.sort()
l = 0
r = 10**9 + 1
while r - l > 1:
X = (l + r)//2
B = [0 for i in range(N)]
for i in range(N):
if A[i] >= X:
B[i] = 1
dp = [0 for i in range(N)]
for h in H:
todo.append(h)
while len(todo):
d,u = todo.pop()
res = -1
for v in RG[u]:
res += dp[v]
res = max(res,0)
dp[u] = res + B[u]
if dp[0] == 0:
r = X
else:
l = X
print(l)
|
ConDefects/ConDefects/Code/abc246_g/Python/49874325
|
condefects-python_data_705
|
class Tree:
__slots__=("N", "index", "parent", "__mutable",
"root", "children", "depth", "tower", "upper_list", "deg", "des_count", "preorder_number",
"euler_vertex", "euler_edge", "in_time", "out_time")
def __init__(self,N,index=0):
""" N 頂点 (index, index+1, ..., N-1+index) の根付き木を生成する. """
self.N=N
self.index=index
self.parent=[-1]*(N+index)
self.__mutable=True
def vertex_exist(self,x):
""" 頂点 x が存在するかどうかを判定する. """
return self.index<=x<self.index+self.N
def __after_seal_check(self,*vertexes):
""" 木が確定していて, vertexes の頂点が存在するかどうかをチェックする. """
if self.__mutable:
return False
for v in vertexes:
if not self.vertex_exist(v):
return False
return True
def is_mutable(self):
""" 木が確定して [いない] かどうかを返す. """
return self.__mutable
#設定パート
def root_set(self,root):
""" 頂点 x を根に設定する."""
assert self.vertex_exist(root)
assert self.__mutable
self.root=root
def parent_set(self,x,y):
""" 頂点 x の親を y に設定する."""
assert self.vertex_exist(x)
assert self.vertex_exist(y)
assert self.__mutable
self.parent[x]=y
def child_set(self,x,y):
""" 頂点 x の子の一つに y を設定する."""
assert self.vertex_exist(x)
assert self.vertex_exist(y)
assert self.__mutable
self.parent[y]=x
def seal(self):
""" 木の情報を確定させる."""
assert self.__mutable
assert hasattr(self,"root")
a=self.index
b=self.index+self.N
C=[[] for _ in range(b)]
p=self.parent
ve=self.vertex_exist
for i in range(a,b):
if i!=self.root:
assert ve(p[i])
C[p[i]].append(i)
self.__mutable=False
self.children=C
#データを求める.
def depth_search(self,Mode=True):
""" 木の深さを求める. """
assert self.__after_seal_check()
if hasattr(self,"depth"):
if Mode:
return self.depth
else:
return
from collections import deque
C=self.children
D=[-1]*(self.index+self.N)
E=[[] for _ in range(self.N)]
Q=deque([self.root])
D[self.root]=0
E[0]=[self.root]
while Q:
x=Q.popleft()
d=D[x]
for y in C[x]:
D[y]=d+1
E[d+1].append(y)
Q.append(y)
self.depth=D
self.tower=E
if Mode:
return D
def vertex_depth(self,x):
""" 頂点 x の深さを求める."""
assert self.__after_seal_check(x)
if not hasattr(self,"depth"):
self.depth_search(Mode=False)
return self.depth[x]
def __upper_list(self):
assert self.__after_seal_check()
if hasattr(self,"upper_list"):
return
if not hasattr(self,"depth"):
self.depth_search(False)
b=max(self.depth).bit_length()
X=[[-1]*(self.index+self.N) for _ in range(b)]
Y=X[0]
p=self.parent
rg=range(self.index,self.index+self.N)
for x in rg:
if x!=self.root:
Y[x]=p[x]
else:
Y[x]=self.root
for k in range(1,b):
Y=X[k-1]
Z=X[k]
for x in rg:
Z[x]=Y[Y[x]]
self.upper_list=X
def upper(self,x,k,over=True):
""" 頂点 x から見て k 個親の頂点を求める.
over: (頂点 x の深さ)<k のときに True ならば根を返し, False ならばエラーを吐く.
"""
assert self.__after_seal_check(x)
assert 0<=k
if not hasattr(self,"upper_list"):
self.__upper_list()
if self.vertex_depth(x)<k:
if over:
return self.root
else:
raise ValueError
i=0
while k:
if k&1:
x=self.upper_list[i][x]
k>>=1
i+=1
return x
def lowest_common_ancestor(self,x,y):
""" 頂点 x, y の最小共通先祖 (x,yに共通する先祖で最も深いもの) を求める. """
assert self.__after_seal_check(x,y)
dd=self.vertex_depth(y)-self.vertex_depth(x)
if dd<0:
x,y=y,x
dd=-dd
y=self.upper(y,dd)
if x==self.root:
return x
if x==y:
return x
d=self.vertex_depth(x)
b=d.bit_length()
X=self.upper_list
for k in range(b-1,-1,-1):
px=X[k][x];py=X[k][y]
if px!=py:
x=px;y=py
return self.upper(x,1)
def __degree_count(self):
assert self.__after_seal_check()
if hasattr(self,"deg"):
return
self.deg=[0]*(self.index+self.N)
for v in range(self.index,self.index+self.N):
d=len(self.children[v])+1
if d==self.root:
d-=1
self.deg[v]=d
return
def degree(self,v):
""" 頂点 v の次数を求める. """
assert self.__after_seal_check(v)
if not hasattr(self,"deg"):
self.__degree_count()
return self.deg[v]
def diameter(self):
""" 木の直径を求める."""
assert self.__after_seal_check()
from collections import deque
def bfs(start):
X=[-1]*(self.index+self.N)
Q=deque([start])
X[start]=0
pa=self.parent
ch=self.children
while Q:
x=Q.popleft()
if X[pa[x]]==-1:
Q.append(pa[x])
X[pa[x]]=X[x]+1
for y in ch[x]:
if X[y]==-1:
Q.append(y)
X[y]=X[x]+1
y=max(range(self.index,self.index+self.N),key=lambda x:X[x])
return y,X[y]
y,_=bfs(self.root)
z,d=bfs(y)
return d,(y,z)
def path(self,u,v):
""" 頂点 u, v 間のパスを求める. """
assert self.__after_seal_check(u,v)
w=self.lowest_common_ancestor(u,v)
pa=self.parent
X=[u]
while u!=w:
u=pa[u]
X.append(u)
Y=[v]
while v!=w:
v=pa[v]
Y.append(v)
return X+Y[-2::-1]
def is_parent(self, u, v):
""" u は v の親か? """
assert self.__after_seal_check(u,v)
return v!=self.root and u==self.parent[v]
def is_children(self, u, v):
""" u は v の子か? """
assert self.__after_seal_check(u,v)
return self.is_parent(v,u)
def is_brother(self,u,v):
""" 2つの頂点 u, v は兄弟 (親が同じ) か? """
assert self.__after_seal_check(u,v)
if u==self.root or v==self.root:
return False
return self.parent[u]==self.parent[v]
def is_ancestor(self,u,v):
""" 頂点 u は頂点 v の先祖か? """
assert self.__after_seal_check(u,v)
dd=self.vertex_depth(v)-self.vertex_depth(u)
if dd<0:
return False
v=self.upper(v,dd)
return u==v
def is_descendant(self,u,v):
""" 頂点 u は頂点 v の子孫か? """
assert self.__after_seal_check(u,v)
return self.is_ancestor(v,u)
def direction(self, u, v):
""" 頂点 u から頂点 v へ向かうパスが頂点 u の次に通る頂点"""
assert self.__after_seal_check(u,v)
assert u!=v
if self.is_ancestor(u,v):
du=self.vertex_depth(u)
dv=self.vertex_depth(v)
return self.upper(v,dv-(du+1))
else:
return self.parent[u]
def is_leaf(self,v):
""" 頂点 v は葉? """
return not bool(self.children[v])
def distance(self,u,v):
""" 2頂点 u, v 間の距離を求める. """
assert self.__after_seal_check(u,v)
dep=self.vertex_depth
return dep(u)+dep(v)-2*dep(self.lowest_common_ancestor(u,v))
def __descendant_count(self):
assert self.__after_seal_check()
if hasattr(self,"des_count"):
return
if not hasattr(self,"tower"):
self.depth_search(False)
self.des_count=[1]*(self.index+self.N)
pa=self.parent
for T in self.tower[:0:-1]:
for x in T:
self.des_count[pa[x]]+=self.des_count[x]
return
def descendant_count(self, v):
""" 頂点 v の子孫の数を求める. """
assert self.__after_seal_check(v)
self.__descendant_count()
return self.des_count[v]
def subtree_size(self, v):
""" 頂点 v を根とした部分根付き木のサイズを求める. """
return self.descendant_count(v)
def preorder(self,v):
""" 頂点 v の行きがけ順を求める. """
assert self.__after_seal_check(v)
if hasattr(self,"preorder_number"):
self.preorder_number[v]
from collections import deque
Q=deque([self.root])
T=[-1]*(self.N+self.index)
p=1
while Q:
x=Q.popleft()
T[x]=p
p+=1
C=self.children[x]
for y in C:
Q.append(y)
self.preorder_number=T
return T[v]
def dfs_yielder(self, order=None):
""" DFS における頂点の出入りを yield する.
以下のような関数を (仮想的に) 実行する.
def dfs(v):
yield (v,1) #頂点 v に入る
for w in self.children[v]:
dfs(w) #頂点 v を出る.
yield (v,0)
order (1変数関数): for w in self.children[v] の順番を指定する (昇順) (※ 無い場合は任意, 破壊的)
"""
assert self.__after_seal_check()
#最初
yield (self.root,1)
v=self.root
ch=self.children
pa=self.parent
R=[-1]*self.index+[len(ch[x]) for x in range(self.index,self.index+self.N)]
S=[0]*(self.index+self.N)
if order!=None:
for w in range(self.index,self.index+self.N):
ch[w].sort(key=order)
while True:
if R[v]==S[v]: #もし,進めないならば
yield (v,0) #頂点vを出る
if v==self.root:
break
else:
v=pa[v]
else: #進める
w=v
v=ch[v][S[v]]
S[w]+=1
yield (v,1)
def top_down(self):
""" 木の根から yield する. """
assert self.__after_seal_check()
if not hasattr(self,"tower"):
self.depth_search(False)
for E in self.tower:
for v in E:
yield v
def bottom_up(self):
""" 木の葉から yield する. """
assert self.__after_seal_check()
if not hasattr(self,"tower"):
self.depth_search(False)
for E in self.tower[::-1]:
for v in E:
yield v
def tree_dp_from_leaf(self,merge,unit,f,g,Mode=False):
""" 葉から木 DP 行う.
merge,unit,f,g
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: Mの単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
Mode: False → 根の値のみ, True → 全ての値
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は * を merge として
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
assert self.__after_seal_check()
data=[unit]*(self.index+self.N)
ch=self.children
for x in self.bottom_up():
for y in ch[x]:
data[x]=merge(data[x],f(data[y],x,y))
data[x]=g(data[x],x)
if Mode:
return data
else:
return data[self.root]
def tree_dp_from_root(self,f,alpha):
""" 根から木 DP を行う.
[input]
alpha: 初期値
f: X x V x V → X: f(x,v,w): v が親, w が子
[補足]
頂点 v の親が x のとき, 更新式は
dp[v]=f(dp[x],x,v) (x!=root), alpha (x==root)
になる.
"""
assert self.__after_seal_check()
data=[0]*(self.index+self.N)
ch=self.children
data[self.root]=alpha
for x in self.top_down():
for y in ch[x]:
data[y]=f(data[x],x,y)
return data
def rerooting(self,merge,unit,f,g):
""" 全方位木 DP を行う.
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: M の単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
※ tree_dp_from_leaf と同じ形式
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
assert self.__after_seal_check()
upper=[unit]*(self.index+self.N)
lower=[unit]*(self.index+self.N)
ch=self.children
pa=self.parent
#DFSパート
lower=self.tree_dp_from_leaf(merge,unit,f,g,True)
#BFSパート
for v in self.top_down():
cc=ch[v]
#累積マージ
deg=len(cc)
Left=[unit]; x=unit
for c in cc:
x=merge(x,f(lower[c],v,c))
Left.append(x)
Right=[unit]; y=unit
for c in cc[::-1]:
y=merge(y,f(lower[c],v,c))
Right.append(y)
Right=Right[::-1]
for i in range(deg):
c=cc[i]
a=merge(Left[i],Right[i+1])
if v!=self.root:
b=merge(a,f(upper[v],v,pa[v]))
else:
b=a
upper[c]=g(b,v)
A=[unit]*(self.index+self.N)
for v in range(self.index,self.index+self.N):
if v!=self.root:
a=f(upper[v],v,pa[v])
else:
a=unit
for c in ch[v]:
a=merge(a,f(lower[c],v,c))
A[v]=g(a,v)
return A
def euler_tour_vertex(self, order=None):
""" オイラーツアー (vertex) に関する計算を行う.
order: 頂点の順番を指定する (破壊的)
"""
assert self.__after_seal_check()
if hasattr(self,"euler_vertex"):
return
#最初
X=[-1]*(2*self.N-1) #X: Euler Tour (vertex) のリスト
v=self.root
ch=self.children
if order!=None:
for i in range(self.index,self.index+self.N):
ch[i].sort(key=order)
pa=self.parent
R=[-1]*self.index+[len(ch[x]) for x in range(self.index,self.index+self.N)]
S=[0]*(self.index+self.N)
for t in range(2*self.N-1):
X[t]=v
if R[v]==S[v]:
v=pa[v]
else: #進める
w=v
v=ch[v][S[v]]
S[w]+=1
self.euler_vertex=X
self.in_time=[-1]*(self.index+self.N)
self.out_time=[-1]*(self.index+self.N)
for t in range(2*self.N-1):
v=X[t]
if self.in_time[v]==-1:
self.in_time[v]=self.out_time[v]=t
else:
self.out_time[v]=t
def euler_tour_edge(self):
""" オイラーツアー (edge) に関する計算を行う.
(u,v,k): u から v へ向かう (k=+1 のときは葉へ進む向き, k=-1 のときは根へ進む向き)
"""
assert self.__after_seal_check()
if hasattr(self,"euler_edge"):
return
if not hasattr(self, "euler_vertex"):
self.euler_tour_vertex()
self.euler_edge=[0]*(2*(self.N-1))
euler=self.euler_vertex
pa=self.parent
for t in range(2*(self.N-1)):
u=euler[t]; v=euler[t+1]
k=1 if u==pa[v] else -1
self.euler_edge[t]=(u,v,k)
def centroid(self, all=False):
""" 木の重心を求める
all: False → 重心のうちの1頂点. True → 全ての重心.
"""
assert self.__after_seal_check()
M=self.N//2
if not hasattr(self,"des_count"):
self.__descendant_count()
G=[]; ch=self.children; des=self.des_count
for v in range(self.index, self.index+self.N):
if self.N-des[v]>M:
break
flag=1
for x in ch[v]:
if des[x]>M:
flag=0
break
if flag:
if all:
G.append(v)
else:
return v
return G
def generated_subtree(self,S):
""" S を含む最小の部分木の頂点を求める. """
assert self.__after_seal_check(*S)
if not hasattr(self, "in_time"):
self.euler_tour_vertex()
S=sorted(set(S),key=lambda i:self.in_time[i])
K=len(S)
T=set()
for i in range(K-1):
for a in self.path(S[i],S[i+1]):
T.add(a)
return sorted(T)
def generated_subtree_size(self,S):
""" S を含む最小の部分木のサイズを求める. """
assert self.__after_seal_check(*S)
if not hasattr(self, "in_time"):
self.euler_tour_vertex()
S=sorted(set(S),key=lambda i:self.in_time[i])
K=len(S)
X=0
for i in range(K-1):
X+=self.distance(S[i],S[i+1])
return (X+self.distance(S[-1],S[0]))//2
#=================================================
def Making_Tree(N,E,root,index=0):
"""木を作る.
N:頂点数
E: 辺のリスト
root: 根
"""
from collections import deque
F=[[] for _ in range(index+N)]
for u,v in E:
assert index<=u<index+N
assert index<=v<index+N
assert u!=v
F[u].append(v)
F[v].append(u)
X=[-1]*(index+N)
X[root]=root
C=[[] for _ in range(index+N)]
Q=deque([root])
while Q:
x=Q.popleft()
for y in F[x]:
if X[y]==-1:
X[y]=x
Q.append(y)
C[x].append(y)
T=Tree(N,index)
T.root_set(root)
T.parent=X
T.children=C
T.seal()
return T
#==================================================
import sys
input=sys.stdin.readline
N=int(input())
A = [-1]+list(map(int,input().split()))
G=[set() for _ in range(N)]
E=[]
for _ in range(N-1):
u,v=map(int,input().split())
u-=1
v-=1
G[v].add(u)
G[u].add(v)
E.append((u,v))
root=index=0
T=Making_Tree(N,E,root,index)
""" 葉から木 DP 行う.
merge,unit,f,g
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: Mの単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
Mode: False → 根の値のみ, True → 全ての値
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は * を merge として
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
inf=float("inf")
m=0
M=10**9+1
def plus(a,b):
return(a+b)
while m+1<M:
temp = (m+M)//2
#青木君はtempより上を全てつぶせますか
def up(x,v,w):
#print(x,v,w)
if A[w]>temp:
return(x+1)
else:
return(x)
def an(x,v):
#print(x,v)
return(max(x-1,0))
#print(temp,T.tree_dp_from_leaf(plus,0,up,an))
if T.tree_dp_from_leaf(plus,0,up,an) > 0:
m=temp
else:
M=temp
print(M)
class Tree:
__slots__=("N", "index", "parent", "__mutable",
"root", "children", "depth", "tower", "upper_list", "deg", "des_count", "preorder_number",
"euler_vertex", "euler_edge", "in_time", "out_time")
def __init__(self,N,index=0):
""" N 頂点 (index, index+1, ..., N-1+index) の根付き木を生成する. """
self.N=N
self.index=index
self.parent=[-1]*(N+index)
self.__mutable=True
def vertex_exist(self,x):
""" 頂点 x が存在するかどうかを判定する. """
return self.index<=x<self.index+self.N
def __after_seal_check(self,*vertexes):
""" 木が確定していて, vertexes の頂点が存在するかどうかをチェックする. """
if self.__mutable:
return False
for v in vertexes:
if not self.vertex_exist(v):
return False
return True
def is_mutable(self):
""" 木が確定して [いない] かどうかを返す. """
return self.__mutable
#設定パート
def root_set(self,root):
""" 頂点 x を根に設定する."""
assert self.vertex_exist(root)
assert self.__mutable
self.root=root
def parent_set(self,x,y):
""" 頂点 x の親を y に設定する."""
assert self.vertex_exist(x)
assert self.vertex_exist(y)
assert self.__mutable
self.parent[x]=y
def child_set(self,x,y):
""" 頂点 x の子の一つに y を設定する."""
assert self.vertex_exist(x)
assert self.vertex_exist(y)
assert self.__mutable
self.parent[y]=x
def seal(self):
""" 木の情報を確定させる."""
assert self.__mutable
assert hasattr(self,"root")
a=self.index
b=self.index+self.N
C=[[] for _ in range(b)]
p=self.parent
ve=self.vertex_exist
for i in range(a,b):
if i!=self.root:
assert ve(p[i])
C[p[i]].append(i)
self.__mutable=False
self.children=C
#データを求める.
def depth_search(self,Mode=True):
""" 木の深さを求める. """
assert self.__after_seal_check()
if hasattr(self,"depth"):
if Mode:
return self.depth
else:
return
from collections import deque
C=self.children
D=[-1]*(self.index+self.N)
E=[[] for _ in range(self.N)]
Q=deque([self.root])
D[self.root]=0
E[0]=[self.root]
while Q:
x=Q.popleft()
d=D[x]
for y in C[x]:
D[y]=d+1
E[d+1].append(y)
Q.append(y)
self.depth=D
self.tower=E
if Mode:
return D
def vertex_depth(self,x):
""" 頂点 x の深さを求める."""
assert self.__after_seal_check(x)
if not hasattr(self,"depth"):
self.depth_search(Mode=False)
return self.depth[x]
def __upper_list(self):
assert self.__after_seal_check()
if hasattr(self,"upper_list"):
return
if not hasattr(self,"depth"):
self.depth_search(False)
b=max(self.depth).bit_length()
X=[[-1]*(self.index+self.N) for _ in range(b)]
Y=X[0]
p=self.parent
rg=range(self.index,self.index+self.N)
for x in rg:
if x!=self.root:
Y[x]=p[x]
else:
Y[x]=self.root
for k in range(1,b):
Y=X[k-1]
Z=X[k]
for x in rg:
Z[x]=Y[Y[x]]
self.upper_list=X
def upper(self,x,k,over=True):
""" 頂点 x から見て k 個親の頂点を求める.
over: (頂点 x の深さ)<k のときに True ならば根を返し, False ならばエラーを吐く.
"""
assert self.__after_seal_check(x)
assert 0<=k
if not hasattr(self,"upper_list"):
self.__upper_list()
if self.vertex_depth(x)<k:
if over:
return self.root
else:
raise ValueError
i=0
while k:
if k&1:
x=self.upper_list[i][x]
k>>=1
i+=1
return x
def lowest_common_ancestor(self,x,y):
""" 頂点 x, y の最小共通先祖 (x,yに共通する先祖で最も深いもの) を求める. """
assert self.__after_seal_check(x,y)
dd=self.vertex_depth(y)-self.vertex_depth(x)
if dd<0:
x,y=y,x
dd=-dd
y=self.upper(y,dd)
if x==self.root:
return x
if x==y:
return x
d=self.vertex_depth(x)
b=d.bit_length()
X=self.upper_list
for k in range(b-1,-1,-1):
px=X[k][x];py=X[k][y]
if px!=py:
x=px;y=py
return self.upper(x,1)
def __degree_count(self):
assert self.__after_seal_check()
if hasattr(self,"deg"):
return
self.deg=[0]*(self.index+self.N)
for v in range(self.index,self.index+self.N):
d=len(self.children[v])+1
if d==self.root:
d-=1
self.deg[v]=d
return
def degree(self,v):
""" 頂点 v の次数を求める. """
assert self.__after_seal_check(v)
if not hasattr(self,"deg"):
self.__degree_count()
return self.deg[v]
def diameter(self):
""" 木の直径を求める."""
assert self.__after_seal_check()
from collections import deque
def bfs(start):
X=[-1]*(self.index+self.N)
Q=deque([start])
X[start]=0
pa=self.parent
ch=self.children
while Q:
x=Q.popleft()
if X[pa[x]]==-1:
Q.append(pa[x])
X[pa[x]]=X[x]+1
for y in ch[x]:
if X[y]==-1:
Q.append(y)
X[y]=X[x]+1
y=max(range(self.index,self.index+self.N),key=lambda x:X[x])
return y,X[y]
y,_=bfs(self.root)
z,d=bfs(y)
return d,(y,z)
def path(self,u,v):
""" 頂点 u, v 間のパスを求める. """
assert self.__after_seal_check(u,v)
w=self.lowest_common_ancestor(u,v)
pa=self.parent
X=[u]
while u!=w:
u=pa[u]
X.append(u)
Y=[v]
while v!=w:
v=pa[v]
Y.append(v)
return X+Y[-2::-1]
def is_parent(self, u, v):
""" u は v の親か? """
assert self.__after_seal_check(u,v)
return v!=self.root and u==self.parent[v]
def is_children(self, u, v):
""" u は v の子か? """
assert self.__after_seal_check(u,v)
return self.is_parent(v,u)
def is_brother(self,u,v):
""" 2つの頂点 u, v は兄弟 (親が同じ) か? """
assert self.__after_seal_check(u,v)
if u==self.root or v==self.root:
return False
return self.parent[u]==self.parent[v]
def is_ancestor(self,u,v):
""" 頂点 u は頂点 v の先祖か? """
assert self.__after_seal_check(u,v)
dd=self.vertex_depth(v)-self.vertex_depth(u)
if dd<0:
return False
v=self.upper(v,dd)
return u==v
def is_descendant(self,u,v):
""" 頂点 u は頂点 v の子孫か? """
assert self.__after_seal_check(u,v)
return self.is_ancestor(v,u)
def direction(self, u, v):
""" 頂点 u から頂点 v へ向かうパスが頂点 u の次に通る頂点"""
assert self.__after_seal_check(u,v)
assert u!=v
if self.is_ancestor(u,v):
du=self.vertex_depth(u)
dv=self.vertex_depth(v)
return self.upper(v,dv-(du+1))
else:
return self.parent[u]
def is_leaf(self,v):
""" 頂点 v は葉? """
return not bool(self.children[v])
def distance(self,u,v):
""" 2頂点 u, v 間の距離を求める. """
assert self.__after_seal_check(u,v)
dep=self.vertex_depth
return dep(u)+dep(v)-2*dep(self.lowest_common_ancestor(u,v))
def __descendant_count(self):
assert self.__after_seal_check()
if hasattr(self,"des_count"):
return
if not hasattr(self,"tower"):
self.depth_search(False)
self.des_count=[1]*(self.index+self.N)
pa=self.parent
for T in self.tower[:0:-1]:
for x in T:
self.des_count[pa[x]]+=self.des_count[x]
return
def descendant_count(self, v):
""" 頂点 v の子孫の数を求める. """
assert self.__after_seal_check(v)
self.__descendant_count()
return self.des_count[v]
def subtree_size(self, v):
""" 頂点 v を根とした部分根付き木のサイズを求める. """
return self.descendant_count(v)
def preorder(self,v):
""" 頂点 v の行きがけ順を求める. """
assert self.__after_seal_check(v)
if hasattr(self,"preorder_number"):
self.preorder_number[v]
from collections import deque
Q=deque([self.root])
T=[-1]*(self.N+self.index)
p=1
while Q:
x=Q.popleft()
T[x]=p
p+=1
C=self.children[x]
for y in C:
Q.append(y)
self.preorder_number=T
return T[v]
def dfs_yielder(self, order=None):
""" DFS における頂点の出入りを yield する.
以下のような関数を (仮想的に) 実行する.
def dfs(v):
yield (v,1) #頂点 v に入る
for w in self.children[v]:
dfs(w) #頂点 v を出る.
yield (v,0)
order (1変数関数): for w in self.children[v] の順番を指定する (昇順) (※ 無い場合は任意, 破壊的)
"""
assert self.__after_seal_check()
#最初
yield (self.root,1)
v=self.root
ch=self.children
pa=self.parent
R=[-1]*self.index+[len(ch[x]) for x in range(self.index,self.index+self.N)]
S=[0]*(self.index+self.N)
if order!=None:
for w in range(self.index,self.index+self.N):
ch[w].sort(key=order)
while True:
if R[v]==S[v]: #もし,進めないならば
yield (v,0) #頂点vを出る
if v==self.root:
break
else:
v=pa[v]
else: #進める
w=v
v=ch[v][S[v]]
S[w]+=1
yield (v,1)
def top_down(self):
""" 木の根から yield する. """
assert self.__after_seal_check()
if not hasattr(self,"tower"):
self.depth_search(False)
for E in self.tower:
for v in E:
yield v
def bottom_up(self):
""" 木の葉から yield する. """
assert self.__after_seal_check()
if not hasattr(self,"tower"):
self.depth_search(False)
for E in self.tower[::-1]:
for v in E:
yield v
def tree_dp_from_leaf(self,merge,unit,f,g,Mode=False):
""" 葉から木 DP 行う.
merge,unit,f,g
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: Mの単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
Mode: False → 根の値のみ, True → 全ての値
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は * を merge として
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
assert self.__after_seal_check()
data=[unit]*(self.index+self.N)
ch=self.children
for x in self.bottom_up():
for y in ch[x]:
data[x]=merge(data[x],f(data[y],x,y))
data[x]=g(data[x],x)
if Mode:
return data
else:
return data[self.root]
def tree_dp_from_root(self,f,alpha):
""" 根から木 DP を行う.
[input]
alpha: 初期値
f: X x V x V → X: f(x,v,w): v が親, w が子
[補足]
頂点 v の親が x のとき, 更新式は
dp[v]=f(dp[x],x,v) (x!=root), alpha (x==root)
になる.
"""
assert self.__after_seal_check()
data=[0]*(self.index+self.N)
ch=self.children
data[self.root]=alpha
for x in self.top_down():
for y in ch[x]:
data[y]=f(data[x],x,y)
return data
def rerooting(self,merge,unit,f,g):
""" 全方位木 DP を行う.
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: M の単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
※ tree_dp_from_leaf と同じ形式
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
assert self.__after_seal_check()
upper=[unit]*(self.index+self.N)
lower=[unit]*(self.index+self.N)
ch=self.children
pa=self.parent
#DFSパート
lower=self.tree_dp_from_leaf(merge,unit,f,g,True)
#BFSパート
for v in self.top_down():
cc=ch[v]
#累積マージ
deg=len(cc)
Left=[unit]; x=unit
for c in cc:
x=merge(x,f(lower[c],v,c))
Left.append(x)
Right=[unit]; y=unit
for c in cc[::-1]:
y=merge(y,f(lower[c],v,c))
Right.append(y)
Right=Right[::-1]
for i in range(deg):
c=cc[i]
a=merge(Left[i],Right[i+1])
if v!=self.root:
b=merge(a,f(upper[v],v,pa[v]))
else:
b=a
upper[c]=g(b,v)
A=[unit]*(self.index+self.N)
for v in range(self.index,self.index+self.N):
if v!=self.root:
a=f(upper[v],v,pa[v])
else:
a=unit
for c in ch[v]:
a=merge(a,f(lower[c],v,c))
A[v]=g(a,v)
return A
def euler_tour_vertex(self, order=None):
""" オイラーツアー (vertex) に関する計算を行う.
order: 頂点の順番を指定する (破壊的)
"""
assert self.__after_seal_check()
if hasattr(self,"euler_vertex"):
return
#最初
X=[-1]*(2*self.N-1) #X: Euler Tour (vertex) のリスト
v=self.root
ch=self.children
if order!=None:
for i in range(self.index,self.index+self.N):
ch[i].sort(key=order)
pa=self.parent
R=[-1]*self.index+[len(ch[x]) for x in range(self.index,self.index+self.N)]
S=[0]*(self.index+self.N)
for t in range(2*self.N-1):
X[t]=v
if R[v]==S[v]:
v=pa[v]
else: #進める
w=v
v=ch[v][S[v]]
S[w]+=1
self.euler_vertex=X
self.in_time=[-1]*(self.index+self.N)
self.out_time=[-1]*(self.index+self.N)
for t in range(2*self.N-1):
v=X[t]
if self.in_time[v]==-1:
self.in_time[v]=self.out_time[v]=t
else:
self.out_time[v]=t
def euler_tour_edge(self):
""" オイラーツアー (edge) に関する計算を行う.
(u,v,k): u から v へ向かう (k=+1 のときは葉へ進む向き, k=-1 のときは根へ進む向き)
"""
assert self.__after_seal_check()
if hasattr(self,"euler_edge"):
return
if not hasattr(self, "euler_vertex"):
self.euler_tour_vertex()
self.euler_edge=[0]*(2*(self.N-1))
euler=self.euler_vertex
pa=self.parent
for t in range(2*(self.N-1)):
u=euler[t]; v=euler[t+1]
k=1 if u==pa[v] else -1
self.euler_edge[t]=(u,v,k)
def centroid(self, all=False):
""" 木の重心を求める
all: False → 重心のうちの1頂点. True → 全ての重心.
"""
assert self.__after_seal_check()
M=self.N//2
if not hasattr(self,"des_count"):
self.__descendant_count()
G=[]; ch=self.children; des=self.des_count
for v in range(self.index, self.index+self.N):
if self.N-des[v]>M:
break
flag=1
for x in ch[v]:
if des[x]>M:
flag=0
break
if flag:
if all:
G.append(v)
else:
return v
return G
def generated_subtree(self,S):
""" S を含む最小の部分木の頂点を求める. """
assert self.__after_seal_check(*S)
if not hasattr(self, "in_time"):
self.euler_tour_vertex()
S=sorted(set(S),key=lambda i:self.in_time[i])
K=len(S)
T=set()
for i in range(K-1):
for a in self.path(S[i],S[i+1]):
T.add(a)
return sorted(T)
def generated_subtree_size(self,S):
""" S を含む最小の部分木のサイズを求める. """
assert self.__after_seal_check(*S)
if not hasattr(self, "in_time"):
self.euler_tour_vertex()
S=sorted(set(S),key=lambda i:self.in_time[i])
K=len(S)
X=0
for i in range(K-1):
X+=self.distance(S[i],S[i+1])
return (X+self.distance(S[-1],S[0]))//2
#=================================================
def Making_Tree(N,E,root,index=0):
"""木を作る.
N:頂点数
E: 辺のリスト
root: 根
"""
from collections import deque
F=[[] for _ in range(index+N)]
for u,v in E:
assert index<=u<index+N
assert index<=v<index+N
assert u!=v
F[u].append(v)
F[v].append(u)
X=[-1]*(index+N)
X[root]=root
C=[[] for _ in range(index+N)]
Q=deque([root])
while Q:
x=Q.popleft()
for y in F[x]:
if X[y]==-1:
X[y]=x
Q.append(y)
C[x].append(y)
T=Tree(N,index)
T.root_set(root)
T.parent=X
T.children=C
T.seal()
return T
#==================================================
import sys
input=sys.stdin.readline
N=int(input())
A = [-1]+list(map(int,input().split()))
G=[set() for _ in range(N)]
E=[]
for _ in range(N-1):
u,v=map(int,input().split())
u-=1
v-=1
G[v].add(u)
G[u].add(v)
E.append((u,v))
root=index=0
T=Making_Tree(N,E,root,index)
""" 葉から木 DP 行う.
merge,unit,f,g
[input]
merge: 可換モノイドを成す2項演算 M x M -> M
unit: Mの単位元
f: X x V x V → M: f(x,v,w): v が親, w が子
g: M x V → X: g(x,v)
Mode: False → 根の値のみ, True → 全ての値
[補足]
頂点 v の子が x,y,z,...のとき, 更新式は * を merge として
dp[v]=g(f(dp[x],v,x)*f(dp[y],v,y)*f(dp[z],v,z)*..., v)
になる.
"""
inf=float("inf")
m=-1
M=10**9+1
def plus(a,b):
return(a+b)
while m+1<M:
temp = (m+M)//2
#青木君はtempより上を全てつぶせますか
def up(x,v,w):
#print(x,v,w)
if A[w]>temp:
return(x+1)
else:
return(x)
def an(x,v):
#print(x,v)
return(max(x-1,0))
#print(temp,T.tree_dp_from_leaf(plus,0,up,an))
if T.tree_dp_from_leaf(plus,0,up,an) > 0:
m=temp
else:
M=temp
print(M)
|
ConDefects/ConDefects/Code/abc246_g/Python/33722514
|
condefects-python_data_706
|
N = int(input())
S = [input() for _ in range(N)]
dx = [1,0,1,-1]
dy = [0,1,1,1]
for h in range(N):
for w in range(N):
for i in range(4):
cnt = 0
for j in range(6):
nh = h + dy[i]*j
nw = w + dx[i]*j
if not (0 <= nh < N and 0 <= nw < N):
continue
if S[nh][nw] == "#":
cnt += 1
else:
if cnt >= 4:
print('Yes')
exit()
print('No')
N = int(input())
S = [input() for _ in range(N)]
dx = [1,0,1,-1]
dy = [0,1,1,1]
for h in range(N):
for w in range(N):
for i in range(4):
cnt = 0
for j in range(6):
nh = h + dy[i]*j
nw = w + dx[i]*j
if not (0 <= nh < N and 0 <= nw < N):
break
if S[nh][nw] == "#":
cnt += 1
else:
if cnt >= 4:
print('Yes')
exit()
print('No')
|
ConDefects/ConDefects/Code/abc241_c/Python/45443856
|
condefects-python_data_707
|
from heapq import heappop, heappush
N = int(input())
tree = [[] for _ in range(N)]
for _ in range(N-1):
u, v = map(int, input().split())
u -= 1; v -= 1
tree[u].append(v)
tree[v].append(u)
root = 0
parent = [-1] * N
parent[root] = root
num_children = [0] * N
stack = [root]
leaf = set(range(N))
while stack:
node = stack.pop()
for nex in tree[node]:
if parent[nex] != -1:
continue
parent[nex] = node
num_children[node] += 1
stack.append(nex)
leaf.discard(node)
dp1 = [[0, 0] for _ in range(N)] # dp1[node][0/1] := node を使わない/使う
hq = [[] for _ in range(N)]
leaf = list(leaf)
while leaf:
node = leaf.pop()
min_diff = 10**6
have_child = False
for nex in tree[node]:
if nex == parent[node]:
continue
have_child = True
dp1[node][0] += max(dp1[nex])
heappush(hq[node], dp1[nex][1]-dp1[nex][0])
min_diff = min(min_diff, dp1[nex][1]-dp1[nex][0])
if have_child:
dp1[node][1] = dp1[node][0] - min_diff + 1
par = parent[node]
num_children[par] -= 1
if num_children[par] == 0:
leaf.append(par)
dp2 = [[0, 0] for _ in range(N)]
stack = [root]
while stack:
node = stack.pop()
par = parent[node]
for nex in tree[node]:
if nex == par:
continue
stack.append(nex)
if node == par:
continue
dp2[node][1] = dp2[par][0] + dp1[par][0] - max(dp1[node]) + 1
if hq[par][0] == dp1[node][1] - dp1[node][0]:
escape = heappop(hq[par])
if hq[par]:
match = dp2[par][0] + dp1[par][0] - hq[par][0] + 1
else:
match = dp2[par][0]
heappush(hq[par], escape)
else:
match = dp2[par][0] + dp1[par][1] - max(dp1[node])
dp2[node][0] = max(
dp2[node][1] - 1,
dp2[par][1] + dp1[par][0] - max(dp1[node]),
match
)
ans = 0
max_match = max(dp1[root])
for node in range(N):
if dp1[node][0] + dp2[node][0] == max_match:
ans += 1
print(ans)
from heapq import heappop, heappush
N = int(input())
tree = [[] for _ in range(N)]
for _ in range(N-1):
u, v = map(int, input().split())
u -= 1; v -= 1
tree[u].append(v)
tree[v].append(u)
root = 0
parent = [-1] * N
parent[root] = root
num_children = [0] * N
stack = [root]
leaf = set(range(N))
while stack:
node = stack.pop()
for nex in tree[node]:
if parent[nex] != -1:
continue
parent[nex] = node
num_children[node] += 1
stack.append(nex)
leaf.discard(node)
dp1 = [[0, 0] for _ in range(N)] # dp1[node][0/1] := node を使わない/使う
hq = [[] for _ in range(N)]
leaf = list(leaf)
while leaf:
node = leaf.pop()
min_diff = 10**6
have_child = False
for nex in tree[node]:
if nex == parent[node]:
continue
have_child = True
dp1[node][0] += max(dp1[nex])
heappush(hq[node], dp1[nex][1]-dp1[nex][0])
min_diff = min(min_diff, dp1[nex][1]-dp1[nex][0])
if have_child:
dp1[node][1] = dp1[node][0] - min_diff + 1
par = parent[node]
num_children[par] -= 1
if num_children[par] == 0:
leaf.append(par)
dp2 = [[0, 0] for _ in range(N)]
stack = [root]
while stack:
node = stack.pop()
par = parent[node]
for nex in tree[node]:
if nex == par:
continue
stack.append(nex)
if node == par:
continue
dp2[node][1] = dp2[par][0] + dp1[par][0] - max(dp1[node]) + 1
if hq[par][0] == dp1[node][1] - dp1[node][0]:
escape = heappop(hq[par])
if hq[par]:
match = dp2[par][0] + dp1[par][0] - max(dp1[node]) - hq[par][0] + 1
else:
match = dp2[par][0]
heappush(hq[par], escape)
else:
match = dp2[par][0] + dp1[par][1] - max(dp1[node])
dp2[node][0] = max(
dp2[node][1] - 1,
dp2[par][1] + dp1[par][0] - max(dp1[node]),
match
)
ans = 0
max_match = max(dp1[root])
for node in range(N):
if dp1[node][0] + dp2[node][0] == max_match:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc223_g/Python/45319303
|
condefects-python_data_708
|
from typing import NamedTuple, Optional, List, cast
class MFGraph:
class Edge(NamedTuple):
src: int
dst: int
cap: int
flow: int
class _Edge:
def __init__(self, dst: int, cap: int) -> None:
self.dst = dst
self.cap = cap
self.rev: Optional[MFGraph._Edge] = None
def __init__(self, n: int) -> None:
self._n = n
self._g: List[List[MFGraph._Edge]] = [[] for _ in range(n)]
self._edges: List[MFGraph._Edge] = []
def add_edge(self, src: int, dst: int, cap: int) -> int:
assert 0 <= src < self._n
assert 0 <= dst < self._n
assert 0 <= cap
m = len(self._edges)
e = MFGraph._Edge(dst, cap)
re = MFGraph._Edge(src, 0)
e.rev = re
re.rev = e
self._g[src].append(e)
self._g[dst].append(re)
self._edges.append(e)
return m
def get_edge(self, i: int) -> Edge:
assert 0 <= i < len(self._edges)
e = self._edges[i]
re = cast(MFGraph._Edge, e.rev)
return MFGraph.Edge(
re.dst,
e.dst,
e.cap + re.cap,
re.cap
)
def edges(self) -> List[Edge]:
return [self.get_edge(i) for i in range(len(self._edges))]
def change_edge(self, i: int, new_cap: int, new_flow: int) -> None:
assert 0 <= i < len(self._edges)
assert 0 <= new_flow <= new_cap
e = self._edges[i]
e.cap = new_cap - new_flow
assert e.rev is not None
e.rev.cap = new_flow
def flow(self, s: int, t: int, flow_limit: Optional[int] = None) -> int:
assert 0 <= s < self._n
assert 0 <= t < self._n
assert s != t
if flow_limit is None:
flow_limit = cast(int, sum(e.cap for e in self._g[s]))
current_edge = [0] * self._n
level = [0] * self._n
def fill(arr: List[int], value: int) -> None:
for i in range(len(arr)):
arr[i] = value
def bfs() -> bool:
fill(level, self._n)
queue = []
q_front = 0
queue.append(s)
level[s] = 0
while q_front < len(queue):
v = queue[q_front]
q_front += 1
next_level = level[v] + 1
for e in self._g[v]:
if e.cap == 0 or level[e.dst] <= next_level:
continue
level[e.dst] = next_level
if e.dst == t:
return True
queue.append(e.dst)
return False
def dfs(lim: int) -> int:
stack = []
edge_stack: List[MFGraph._Edge] = []
stack.append(t)
while stack:
v = stack[-1]
if v == s:
flow = min(lim, min(e.cap for e in edge_stack))
for e in edge_stack:
e.cap -= flow
assert e.rev is not None
e.rev.cap += flow
return flow
next_level = level[v] - 1
while current_edge[v] < len(self._g[v]):
e = self._g[v][current_edge[v]]
re = cast(MFGraph._Edge, e.rev)
if level[e.dst] != next_level or re.cap == 0:
current_edge[v] += 1
continue
stack.append(e.dst)
edge_stack.append(re)
break
else:
stack.pop()
if edge_stack:
edge_stack.pop()
level[v] = self._n
return 0
flow = 0
while flow < flow_limit:
if not bfs():
break
fill(current_edge, 0)
while flow < flow_limit:
f = dfs(flow_limit - flow)
flow += f
if f == 0:
break
return flow
def min_cut(self, s: int) -> List[bool]:
visited = [False] * self._n
stack = [s]
visited[s] = True
while stack:
v = stack.pop()
for e in self._g[v]:
if e.cap > 0 and not visited[e.dst]:
visited[e.dst] = True
stack.append(e.dst)
return visited
h,w = map(int, input().split())
a=[list(map(int,input().split())) for i in range(h)]
mf = MFGraph(h+w+2)
SRC=h+w
DST=h+w+1
sm = 0
userow=set()
usecol=set()
for i in range(h):
tmp = sum(a[i])
if tmp <= 0:
continue
userow.add(i)
mf.add_edge(i,DST,tmp)
sm+=tmp
for j in range(w):
tmp = 0
for i in range(h):
tmp += a[i][j]
if tmp <= 0:
continue
usecol.add(j)
mf.add_edge(SRC,h+j,tmp)
sm+=tmp
INF=10**18
for i in range(h):
if not i in userow:
continue
for j in range(w):
if not j in usecol:
continue
num = INF if a[i][j]<0 else a[i][j]
mf.add_edge(i,h+j,num)
mf.add_edge(h+j,i,num)
ret = mf.flow(SRC,DST)
print(sm-ret)
from typing import NamedTuple, Optional, List, cast
class MFGraph:
class Edge(NamedTuple):
src: int
dst: int
cap: int
flow: int
class _Edge:
def __init__(self, dst: int, cap: int) -> None:
self.dst = dst
self.cap = cap
self.rev: Optional[MFGraph._Edge] = None
def __init__(self, n: int) -> None:
self._n = n
self._g: List[List[MFGraph._Edge]] = [[] for _ in range(n)]
self._edges: List[MFGraph._Edge] = []
def add_edge(self, src: int, dst: int, cap: int) -> int:
assert 0 <= src < self._n
assert 0 <= dst < self._n
assert 0 <= cap
m = len(self._edges)
e = MFGraph._Edge(dst, cap)
re = MFGraph._Edge(src, 0)
e.rev = re
re.rev = e
self._g[src].append(e)
self._g[dst].append(re)
self._edges.append(e)
return m
def get_edge(self, i: int) -> Edge:
assert 0 <= i < len(self._edges)
e = self._edges[i]
re = cast(MFGraph._Edge, e.rev)
return MFGraph.Edge(
re.dst,
e.dst,
e.cap + re.cap,
re.cap
)
def edges(self) -> List[Edge]:
return [self.get_edge(i) for i in range(len(self._edges))]
def change_edge(self, i: int, new_cap: int, new_flow: int) -> None:
assert 0 <= i < len(self._edges)
assert 0 <= new_flow <= new_cap
e = self._edges[i]
e.cap = new_cap - new_flow
assert e.rev is not None
e.rev.cap = new_flow
def flow(self, s: int, t: int, flow_limit: Optional[int] = None) -> int:
assert 0 <= s < self._n
assert 0 <= t < self._n
assert s != t
if flow_limit is None:
flow_limit = cast(int, sum(e.cap for e in self._g[s]))
current_edge = [0] * self._n
level = [0] * self._n
def fill(arr: List[int], value: int) -> None:
for i in range(len(arr)):
arr[i] = value
def bfs() -> bool:
fill(level, self._n)
queue = []
q_front = 0
queue.append(s)
level[s] = 0
while q_front < len(queue):
v = queue[q_front]
q_front += 1
next_level = level[v] + 1
for e in self._g[v]:
if e.cap == 0 or level[e.dst] <= next_level:
continue
level[e.dst] = next_level
if e.dst == t:
return True
queue.append(e.dst)
return False
def dfs(lim: int) -> int:
stack = []
edge_stack: List[MFGraph._Edge] = []
stack.append(t)
while stack:
v = stack[-1]
if v == s:
flow = min(lim, min(e.cap for e in edge_stack))
for e in edge_stack:
e.cap -= flow
assert e.rev is not None
e.rev.cap += flow
return flow
next_level = level[v] - 1
while current_edge[v] < len(self._g[v]):
e = self._g[v][current_edge[v]]
re = cast(MFGraph._Edge, e.rev)
if level[e.dst] != next_level or re.cap == 0:
current_edge[v] += 1
continue
stack.append(e.dst)
edge_stack.append(re)
break
else:
stack.pop()
if edge_stack:
edge_stack.pop()
level[v] = self._n
return 0
flow = 0
while flow < flow_limit:
if not bfs():
break
fill(current_edge, 0)
while flow < flow_limit:
f = dfs(flow_limit - flow)
flow += f
if f == 0:
break
return flow
def min_cut(self, s: int) -> List[bool]:
visited = [False] * self._n
stack = [s]
visited[s] = True
while stack:
v = stack.pop()
for e in self._g[v]:
if e.cap > 0 and not visited[e.dst]:
visited[e.dst] = True
stack.append(e.dst)
return visited
h,w = map(int, input().split())
a=[list(map(int,input().split())) for i in range(h)]
mf = MFGraph(h+w+2)
SRC=h+w
DST=h+w+1
sm = 0
userow=set()
usecol=set()
for i in range(h):
tmp = sum(a[i])
if tmp <= 0:
continue
userow.add(i)
mf.add_edge(i,DST,tmp)
sm+=tmp
for j in range(w):
tmp = 0
for i in range(h):
tmp += a[i][j]
if tmp <= 0:
continue
usecol.add(j)
mf.add_edge(SRC,h+j,tmp)
sm+=tmp
INF=10**18
for i in range(h):
if not i in userow:
continue
for j in range(w):
if not j in usecol:
continue
num = INF if a[i][j]<0 else a[i][j]
#mf.add_edge(i,h+j,num)
mf.add_edge(h+j,i,num)
ret = mf.flow(SRC,DST)
print(sm-ret)
|
ConDefects/ConDefects/Code/abc259_g/Python/41146837
|
condefects-python_data_709
|
from collections import deque
from math import inf
import sys
import io
import os
# region IO
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')
def read_int_list(): return list(map(int, input().split()))
def read_int_tuple(): return tuple(map(int, input().split()))
def read_int(): return int(input())
# endregion
if 'AW' in os.environ.get('COMPUTERNAME', ''):
test_no = 1
f = open(os.path.dirname(__file__) + f'\\in{test_no}.txt', 'r')
def input(): return f.readline().rstrip("\r\n")
class FordFulkerson:
def __init__(self, edges, source_node, end_node, max_node_num, max_edge_num):
self.edges = edges
self.source_node = source_node
self.end_node = end_node
self.max_edge_num = max_edge_num
self.max_node_num = max_node_num
def getMaxFlow(self):
e = [-1] * (self.max_edge_num*2 + 1)
f = [-1] * (self.max_edge_num*2 + 1)
ne = [-1] * (self.max_edge_num*2 + 1)
h = [-1] * (self.max_node_num + 1)
dis = [-1] * (self.max_node_num + 1)
cur = [-1] * (self.max_node_num + 1)
idx = 0
for a, b, w in self.edges:
e[idx], f[idx], ne[idx], h[a] = b, w, h[a], idx
idx += 1
e[idx], f[idx], ne[idx], h[b] = a, 0, h[b], idx
idx += 1
def bfs() -> bool:
for i in range(self.max_node_num + 1):
dis[i] = -1
que = deque()
que.append(self.source_node)
dis[self.source_node] = 0
cur[self.source_node] = h[self.source_node]
while len(que) > 0:
cur_node = que.popleft()
idx = h[cur_node]
while idx != -1:
next_node = e[idx]
if dis[next_node] == -1 and f[idx] > 0:
dis[next_node] = dis[cur_node] + 1
cur[next_node] = h[next_node]
if next_node == self.end_node:
return True
que.append(next_node)
idx = ne[idx]
return False
def dfs(node, limit) -> int:
if node == self.end_node:
return limit
flow = 0
idx = cur[node]
while idx != -1 and flow < limit:
cur[node] = idx
next_node = e[idx]
if dis[next_node] == dis[node]+1 and f[idx] > 0:
t = dfs(next_node, min(f[idx], limit - flow))
if t == 0:
dis[next_node] = -1
f[idx], f[idx ^ 1], flow = f[idx]-t, f[idx ^ 1]+t, flow+t
idx = ne[idx]
return flow
max_flow = 0
while bfs():
max_flow += dfs(self.source_node, 0x7fffffff)
return max_flow
def solve(m, n, nums):
S, T = m + n, m + n + 1
edges, res = [], 0
row_neg, col_neg = [0] * m, [0] * n
for i in range(m):
for j in range(n):
if nums[i][j] >= 0:
edges.append((i, m + j, nums[i][j]))
res += nums[i][j]
else:
edges.append((m + j, i, inf))
row_neg[i] -= nums[i][j]
col_neg[j] -= nums[i][j]
for i in range(m):
edges.append((S, i, row_neg[i]))
for j in range(n):
edges.append((m + j, T, col_neg[j]))
gf = FordFulkerson(edges, S, T, T, len(edges))
flow = gf.getMaxFlow()
# print(res, flow)
print(res - flow)
for _ in range(1):
m, n = read_int_tuple()
nums = [read_int_list() for _ in range(m)]
print(solve(m, n, nums))
from collections import deque
from math import inf
import sys
import io
import os
# region IO
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.buffer = io.BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')
def read_int_list(): return list(map(int, input().split()))
def read_int_tuple(): return tuple(map(int, input().split()))
def read_int(): return int(input())
# endregion
if 'AW' in os.environ.get('COMPUTERNAME', ''):
test_no = 1
f = open(os.path.dirname(__file__) + f'\\in{test_no}.txt', 'r')
def input(): return f.readline().rstrip("\r\n")
class FordFulkerson:
def __init__(self, edges, source_node, end_node, max_node_num, max_edge_num):
self.edges = edges
self.source_node = source_node
self.end_node = end_node
self.max_edge_num = max_edge_num
self.max_node_num = max_node_num
def getMaxFlow(self):
e = [-1] * (self.max_edge_num*2 + 1)
f = [-1] * (self.max_edge_num*2 + 1)
ne = [-1] * (self.max_edge_num*2 + 1)
h = [-1] * (self.max_node_num + 1)
dis = [-1] * (self.max_node_num + 1)
cur = [-1] * (self.max_node_num + 1)
idx = 0
for a, b, w in self.edges:
e[idx], f[idx], ne[idx], h[a] = b, w, h[a], idx
idx += 1
e[idx], f[idx], ne[idx], h[b] = a, 0, h[b], idx
idx += 1
def bfs() -> bool:
for i in range(self.max_node_num + 1):
dis[i] = -1
que = deque()
que.append(self.source_node)
dis[self.source_node] = 0
cur[self.source_node] = h[self.source_node]
while len(que) > 0:
cur_node = que.popleft()
idx = h[cur_node]
while idx != -1:
next_node = e[idx]
if dis[next_node] == -1 and f[idx] > 0:
dis[next_node] = dis[cur_node] + 1
cur[next_node] = h[next_node]
if next_node == self.end_node:
return True
que.append(next_node)
idx = ne[idx]
return False
def dfs(node, limit) -> int:
if node == self.end_node:
return limit
flow = 0
idx = cur[node]
while idx != -1 and flow < limit:
cur[node] = idx
next_node = e[idx]
if dis[next_node] == dis[node]+1 and f[idx] > 0:
t = dfs(next_node, min(f[idx], limit - flow))
if t == 0:
dis[next_node] = -1
f[idx], f[idx ^ 1], flow = f[idx]-t, f[idx ^ 1]+t, flow+t
idx = ne[idx]
return flow
max_flow = 0
while bfs():
max_flow += dfs(self.source_node, 0x7fffffff)
return max_flow
def solve(m, n, nums):
S, T = m + n, m + n + 1
edges, res = [], 0
row_neg, col_neg = [0] * m, [0] * n
for i in range(m):
for j in range(n):
if nums[i][j] >= 0:
edges.append((i, m + j, nums[i][j]))
res += nums[i][j]
else:
edges.append((m + j, i, inf))
row_neg[i] -= nums[i][j]
col_neg[j] -= nums[i][j]
for i in range(m):
edges.append((S, i, row_neg[i]))
for j in range(n):
edges.append((m + j, T, col_neg[j]))
gf = FordFulkerson(edges, S, T, T, len(edges))
flow = gf.getMaxFlow()
# print(res, flow)
return res - flow
for _ in range(1):
m, n = read_int_tuple()
nums = [read_int_list() for _ in range(m)]
print(solve(m, n, nums))
|
ConDefects/ConDefects/Code/abc259_g/Python/33161543
|
condefects-python_data_710
|
import sys
from collections import deque,defaultdict
import itertools
import heapq
import bisect
import queue
import math
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
li_st = lambda: list(map(str, input().split()))
lli = lambda n: [li() for _ in range(n)]
mod = 998244353
N = ii()
check = set()
for i in range(N):
s = li_st()
s = "".join(s)
check.add(s)
print(len(check))
import sys
from collections import deque,defaultdict
import itertools
import heapq
import bisect
import queue
import math
#sys.setrecursionlimit(10 ** 9)
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
li_st = lambda: list(map(str, input().split()))
lli = lambda n: [li() for _ in range(n)]
mod = 998244353
N = ii()
check = set()
for i in range(N):
s = li_st()
s = " ".join(s)
check.add(s)
print(len(check))
|
ConDefects/ConDefects/Code/abc226_b/Python/45483175
|
condefects-python_data_711
|
n = int(input())
l = set()
for i in range(n):
l.add(input().replace(" ", ""))
print(len(l))
n = int(input())
l = set()
for i in range(n):
l.add(input())
print(len(l))
|
ConDefects/ConDefects/Code/abc226_b/Python/46010276
|
condefects-python_data_712
|
N=int(input())
for i in range(N):
A=list(map(int,input().split()))
ans=[]
for j in range(N):
if A[j]:
ans.append(j+1)
print(ans)
N=int(input())
for i in range(N):
A=list(map(int,input().split()))
ans=[]
for j in range(N):
if A[j]:
ans.append(j+1)
print(*ans)
|
ConDefects/ConDefects/Code/abc343_b/Python/54873239
|
condefects-python_data_713
|
N = int(input())
matrix = []
for _ in range(N):
row = list(map(int, input().strip().split()))
matrix.append(row)
for i in range(N):
ans = []
for j in range(N):
if matrix[i][j] == 1:
ans.append(j)
print(*ans)
N = int(input())
matrix = []
for _ in range(N):
row = list(map(int, input().strip().split()))
matrix.append(row)
for i in range(N):
ans = []
for j in range(N):
if matrix[i][j] == 1:
ans.append(j + 1)
print(*ans)
|
ConDefects/ConDefects/Code/abc343_b/Python/54300616
|
condefects-python_data_714
|
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
ans = []
for i in range(N):
for j in range(N):
if A[i][j] == 1:
ans.append(j+1)
print(*ans)
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
for i in range(N):
ans = []
for j in range(N):
if A[i][j] == 1:
ans.append(j+1)
print(*ans)
|
ConDefects/ConDefects/Code/abc343_b/Python/54540340
|
condefects-python_data_715
|
#!/usr/bin/env python3
import sys
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
def solve(Q: int, A: int, B: int, t: "list[int]", a: "list[int]", b: "list[int]"):
sset: SortedSet = SortedSet()
sset.add(A+B)
sset.add(A-B)
for i in range(Q):
if t[i] == 1:
sset.add(a[i]+b[i])
sset.add(a[i]-b[i])
else:
mid = sset.ge(a[i])
if mid is not None and mid <= b[i]:
ans = 0
else:
l = sset.lt(a[i])
r = sset.gt(b[i])
if l is not None:
ans = a[i]-l
if r is not None:
ans = min(ans, r-b[i])
print(ans)
# Generated by 2.12.0 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
Q = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
t = [int()] * (Q) # type: "List[int]"
a = [int()] * (Q) # type: "List[int]"
b = [int()] * (Q) # type: "List[int]"
for i in range(Q):
t[i] = int(next(tokens))
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(Q, A, B, t, a, b)
if __name__ == '__main__':
main()
#!/usr/bin/env python3
import sys
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size : size * (i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
def solve(Q: int, A: int, B: int, t: "list[int]", a: "list[int]", b: "list[int]"):
sset: SortedSet = SortedSet()
sset.add(A+B)
sset.add(A-B)
INF = 10**18
for i in range(Q):
if t[i] == 1:
sset.add(a[i]+b[i])
sset.add(a[i]-b[i])
else:
mid = sset.ge(a[i])
if mid is not None and mid <= b[i]:
ans = 0
else:
ans = INF
l = sset.lt(a[i])
r = sset.gt(b[i])
if l is not None:
ans = a[i]-l
if r is not None:
ans = min(ans, r-b[i])
print(ans)
# Generated by 2.12.0 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
Q = int(next(tokens)) # type: int
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
t = [int()] * (Q) # type: "List[int]"
a = [int()] * (Q) # type: "List[int]"
b = [int()] * (Q) # type: "List[int]"
for i in range(Q):
t[i] = int(next(tokens))
a[i] = int(next(tokens))
b[i] = int(next(tokens))
solve(Q, A, B, t, a, b)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc155_b/Python/44148523
|
condefects-python_data_716
|
def main():
n = int(input())
s = list(input())
ok = False
for i in range(n):
if s[i] == "o":
ok = True
elif s[i] == "x":
print("No")
break
if ok == True:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
def main():
n = int(input())
s = list(input())
ok = False
for i in range(n):
if s[i] == "o":
ok = True
elif s[i] == "x":
print("No")
return
if ok == True:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc298_a/Python/45277640
|
condefects-python_data_717
|
N = int(input())
S = list(input())
if "○" in S and "x" not in S:
print("Yes")
else:
print("No")
N = int(input())
S = list(input())
if "o" in S and "x" not in S:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc298_a/Python/46129675
|
condefects-python_data_718
|
S = ["and", "not", "that", "the", "you"]
N = int(input())
W = list(input().split())
for w in W:
if w in S:
exit(print("Yes"))
print("NO")
S = ["and", "not", "that", "the", "you"]
N = int(input())
W = list(input().split())
for w in W:
if w in S:
exit(print("Yes"))
print("No")
|
ConDefects/ConDefects/Code/abc295_a/Python/45025721
|
condefects-python_data_719
|
n=int(input())
x=list(input().split())
eng=["and","not","that","the","you"]
for i in range(n):
print(i)
print(x[i])
if x[i] in eng:
print("Yes")
break
elif i==n-1:
print("No")
n=int(input())
x=list(input().split())
eng=["and","not","that","the","you"]
for i in range(n):
if x[i] in eng:
print("Yes")
break
elif i==n-1:
print("No")
|
ConDefects/ConDefects/Code/abc295_a/Python/45272260
|
condefects-python_data_720
|
n=int(input())
L=list(map(str,input().split()))
ans="No"
for i in range(len(L)):
if L[i]=="and" or L[i]=="not" and L[i]=="that" and L[i]=="the" and L[i]=="you":
ans="Yes"
break
print(ans)
n=int(input())
L=list(map(str,input().split()))
ans="No"
for i in range(len(L)):
if L[i]=="and" or L[i]=="not" or L[i]=="that" or L[i]=="the" or L[i]=="you":
ans="Yes"
break
print(ans)
|
ConDefects/ConDefects/Code/abc295_a/Python/46045977
|
condefects-python_data_721
|
n = int(input())
s = list(input())
ary = set(s)
keys = ["and", "not", "that", "the", "you"]
for key in keys:
if key in ary:
print("Yes")
break
else:
print("No")
n = int(input())
s = input().split()
ary = set(s)
keys = ["and", "not", "that", "the", "you"]
for key in keys:
if key in ary:
print("Yes")
break
else:
print("No")
|
ConDefects/ConDefects/Code/abc295_a/Python/45517657
|
condefects-python_data_722
|
N = int(input())
word_list = map(str,input().split())
keywords = ["and", "not", "that", "the", "you"]
found = False
for keyword in keywords:
if keyword in word_list:
found = True
break
if found:
print("Yes")
else:
print("No")
N = int(input())
word_list = list(map(str, input().split()))
keywords = ["and", "not", "that", "the", "you"]
found = False
for keyword in keywords:
if keyword in word_list:
found = True
break
if found:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc295_a/Python/44861660
|
condefects-python_data_723
|
n = int(input())
a = list(input().split())
ans = "No"
for i in a:
if i == "and" or i == "not" or i == "that" or i == "you":
print("Yes")
exit()
print(ans)
n = int(input())
a = list(input().split())
ans = "No"
for i in a:
if i == "and" or i == "not" or i == "that" or i == "you" or i == "the":
print("Yes")
exit()
print(ans)
|
ConDefects/ConDefects/Code/abc295_a/Python/45905401
|
condefects-python_data_724
|
S = input()
for i in range(len(S)):
if 'A' < S[i] < 'Z':
print(i + 1)
S = input()
for i in range(len(S)):
if 'A' <= S[i] <= 'Z':
print(i + 1)
|
ConDefects/ConDefects/Code/abc291_a/Python/45508180
|
condefects-python_data_725
|
print(input().replace("0", "1").replace("1", "0"))
print("".join(map(str, [(i+1)%2 for i in map(int, list(input()))])))
|
ConDefects/ConDefects/Code/abc289_a/Python/45965844
|
condefects-python_data_726
|
A,B,C,X = map(int,input().split())
if X <= A:
print(1.000000000000)
elif X < B:
print(C/(B-A))
else:
print(0.000000000000)
A,B,C,X = map(int,input().split())
if X <= A:
print(1.000000000000)
elif X <= B:
print(C/(B-A))
else:
print(0.000000000000)
|
ConDefects/ConDefects/Code/abc242_a/Python/45438303
|
condefects-python_data_727
|
inp=input().split()
A=inp[0]
A=int(A)
B=inp[1]
B=int(B)
C=inp[2]
C=int(C)
X=inp[3]
X=int(X)
D=B-A
if A>=X:
print(1)
elif B<X:
print(0)
else:
print(D/C)
inp=input().split()
A=inp[0]
A=int(A)
B=inp[1]
B=int(B)
C=inp[2]
C=int(C)
X=inp[3]
X=int(X)
D=B-A
if A>=X:
print(1)
elif B<X:
print(0)
else:
print(C/D)
|
ConDefects/ConDefects/Code/abc242_a/Python/44475619
|
condefects-python_data_728
|
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
def solve():
A, B, C, X = map(int, input().split())
if X >= 1 and X <= A:
res = 1/1
elif X > A and X <= C:
N = B - A
res = C / N
else:
res = 0/1
print(f"{res:.7f}")
solve()
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect_right
from heapq import heapify, heappush, heappop
def solve():
A, B, C, X = map(int, input().split())
if X >= 1 and X <= A:
res = 1/1
elif X > A and X <= B:
N = B - A
res = C / N
else:
res = 0/1
print(f"{res:.7f}")
solve()
|
ConDefects/ConDefects/Code/abc242_a/Python/45767519
|
condefects-python_data_729
|
a,b,c,x=list(map(int,input().split()))
ans=1.0
if x>a+1 and x<=b:
ans=c/(b-a)
elif x>b:
ans=0.0
print('%.10f'%ans)
a,b,c,x=list(map(int,input().split()))
ans=1.0
if x>=a+1 and x<=b:
ans=c/(b-a)
elif x>b:
ans=0.0
print('%.10f'%ans)
|
ConDefects/ConDefects/Code/abc242_a/Python/45709103
|
condefects-python_data_730
|
a, b, c, x = map(int, input().split())
if x <= a:
print(1)
elif a < x <= b:
print(c/(b-a+1))
else:
print(0)
a, b, c, x = map(int, input().split())
if x <= a:
print(1)
elif a < x <= b:
print(c/(b-a))
else:
print(0)
|
ConDefects/ConDefects/Code/abc242_a/Python/45690151
|
condefects-python_data_731
|
#!/usr/bin/env python3
import sys
a, b, c, x = map(int, input().split())
res = 0.0
if x <= a:
res = 100.0
elif x <= b:
res = c / (b - a)
print('%.9f' % (res))
#!/usr/bin/env python3
import sys
a, b, c, x = map(int, input().split())
res = 0.0
if x <= a:
res = 1.0
elif x <= b:
res = c / (b - a)
print('%.9f' % (res))
|
ConDefects/ConDefects/Code/abc242_a/Python/44877017
|
condefects-python_data_732
|
a,b,c,x=map(int,input().split())
if a>=x:
print(1)
elif b>=x>a:
print(c/(b-a+1))
else:
print(0)
a,b,c,x=map(int,input().split())
if a>=x:
print(1)
elif b>=x>a:
print(c/(b-a))
else:
print(0)
|
ConDefects/ConDefects/Code/abc242_a/Python/45214716
|
condefects-python_data_733
|
A, B, C, X = map(int, input().split())
if X < A:
print(1)
elif X > B:
print(0)
else:
answer = C / (B - A)
print(answer)
A, B, C, X = map(int, input().split())
if X <= A:
print(1)
elif X > B:
print(0)
else:
answer = C / (B - A)
print(answer)
|
ConDefects/ConDefects/Code/abc242_a/Python/45439791
|
condefects-python_data_734
|
M,D = map(int,input().split())
y,m,d = map(int,input().split())
if d+1 > D:
d = 1
if m+1 > M:
m = 1
y = y+1
else:
m = m+1
else:
d = d+1
print(f"y m d")
M,D = map(int,input().split())
y,m,d = map(int,input().split())
if d+1 > D:
d = 1
if m+1 > M:
m = 1
y = y+1
else:
m = m+1
else:
d = d+1
print(y,m,d)
|
ConDefects/ConDefects/Code/abc331_a/Python/54744974
|
condefects-python_data_735
|
def resolve():
M, D = map(int, input().split())
y, m, d = map(int, input().split())
sm, sy = 0, 0
if d == D:
d, sm = 1, 1
else:
d+=1
if m+sm == M+1:
m, sy = 1, 1
y += sy
return (y, m, d)
print(*resolve())
def resolve():
M, D = map(int, input().split())
y, m, d = map(int, input().split())
sm, sy = 0, 0
if d == D:
d, sm = 1, 1
else:
d+=1
if m+sm == M+1:
m, sy = 1, 1
else:
m+= sm
y += sy
return (y, m, d)
print(*resolve())
|
ConDefects/ConDefects/Code/abc331_a/Python/54731952
|
condefects-python_data_736
|
M, D = map(int,input().split())
y, m, d = map(int,input().split())
if d==D and m==M:
y += 1
m = 1
d = 1
elif m==M:
m += 1
d = 1
else:
d += 1
print(y,m,d)
M, D = map(int,input().split())
y, m, d = map(int,input().split())
if d==D and m==M:
y += 1
m = 1
d = 1
elif d==D:
m += 1
d = 1
else:
d += 1
print(y,m,d)
|
ConDefects/ConDefects/Code/abc331_a/Python/54773410
|
condefects-python_data_737
|
M,D = map(int,input().split())
y,m,d = map(int,input().split())
if d == D: # 最後の日
d = 1
if m == M:
m = 1
y += 1
else:
d += 1
print(y,m,d)
M,D = map(int,input().split())
y,m,d = map(int,input().split())
if d == D: # 最後の日
d = 1
if m == M:
m = 1
y += 1
else:
m += 1
else:
d += 1
print(y,m,d)
|
ConDefects/ConDefects/Code/abc331_a/Python/54933311
|
condefects-python_data_738
|
import bisect
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
Qinv = {}
for i, q in enumerate(Q):
Qinv[q] = i
S = []
for i, p in enumerate(P):
A = []
for x in range(p, N + 1, p):
j = Qinv[x]
A.append(j)
A.sort()
A.reverse()
S += A
# print(S)
inf = 10 ** 18
dp = [inf] * len(S)
ans = 1
for i, y in enumerate(S):
if i == 0:
dp[0] = y
continue
"dp[m] >= y"
m = bisect.bisect_left(dp, y)
dp[m] = y
ans = max(ans, m)
# print(dp)
print(ans + 1)
import bisect
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
Qinv = {}
for i, q in enumerate(Q):
Qinv[q] = i
S = []
for i, p in enumerate(P):
A = []
for x in range(p, N + 1, p):
j = Qinv[x]
A.append(j)
A.sort()
A.reverse()
S += A
# print(S)
inf = 10 ** 18
dp = [inf] * len(S)
ans = 0
for i, y in enumerate(S):
if i == 0:
dp[0] = y
continue
"dp[m] >= y"
m = bisect.bisect_left(dp, y)
dp[m] = y
ans = max(ans, m)
# print(dp)
print(ans + 1)
|
ConDefects/ConDefects/Code/arc133_b/Python/41864112
|
condefects-python_data_739
|
from bisect import *
n = int(input())
P = [int(x) for x in input().split()]
Q = [int(x) for x in input().split()]
Qpos = [-1]*(n+1)
for i in range(n):
Qpos[Q[i]] = i
LIS = [10**9]*n
for i in range(n):
lst = []
for j in range(P[i],n+1,P[i]):
lst.append(Qpos[j])
lst.sort(reverse=True)
for j in lst:
LIS[bisect_left(LIS,j)] = j
ans = -1
for i in range(n):
if LIS[i]==10**9:
ans = i
break
print(ans)
from bisect import *
n = int(input())
P = [int(x) for x in input().split()]
Q = [int(x) for x in input().split()]
Qpos = [-1]*(n+1)
for i in range(n):
Qpos[Q[i]] = i
LIS = [10**9]*n
for i in range(n):
lst = []
for j in range(P[i],n+1,P[i]):
lst.append(Qpos[j])
lst.sort(reverse=True)
for j in lst:
LIS[bisect_left(LIS,j)] = j
ans = n
for i in range(n):
if LIS[i]==10**9:
ans = i
break
print(ans)
|
ConDefects/ConDefects/Code/arc133_b/Python/34093512
|
condefects-python_data_740
|
import numpy as np
def dp(n,a):
if n==1:
print(a[1]-a[2],a[0]-a[1]+a[2],a[1]-a[0],end=' ')
return [a[1]-a[2], a[1]-a[0],a[0]-a[1]+a[2]]
else:
x = 3**(n-1)
a0 = a[:x]
a1 = a[x:2*x]
a2 = a[2*x:]
print([a1-a2,a0-a1+a2,a1-a0])
return [dp(n-1,a1-a2),dp(n-1,a0-a1+a2),dp(n-1,a1-a0)]
n = int(input())
a = np.array(list(map(int,input().split())))
ans = dp(n,a)
import numpy as np
def dp(n,a):
if n==1:
print(a[1]-a[2],a[0]-a[1]+a[2],a[1]-a[0],end=' ')
return [a[1]-a[2], a[1]-a[0],a[0]-a[1]+a[2]]
else:
x = 3**(n-1)
a0 = a[:x]
a1 = a[x:2*x]
a2 = a[2*x:]
#print([a1-a2,a0-a1+a2,a1-a0])
return [dp(n-1,a1-a2),dp(n-1,a0-a1+a2),dp(n-1,a1-a0)]
n = int(input())
a = np.array(list(map(int,input().split())))
ans = dp(n,a)
|
ConDefects/ConDefects/Code/abc288_g/Python/38755910
|
condefects-python_data_741
|
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10**6)
def main():
N = int(input())
l = []
for i in range(N):
a, b = map(int, input().split())
l.append((-a * 10 ** 100 / (a + b), i + 1))
l.sort()
for i in range(N):
print(l[i][1], end=' ')
print()
if __name__ == '__main__':
main()
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10**6)
def main():
N = int(input())
l = []
for i in range(N):
a, b = map(int, input().split())
l.append((-a * 10 ** 100 // (a + b), i + 1))
l.sort()
for i in range(N):
print(l[i][1], end=' ')
print()
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc308_c/Python/46192638
|
condefects-python_data_742
|
if __name__ == '__main__':
N = int(input())
X = []
for i in range(N):
a, b = map(int, input().split())
X.append((-a*10**100 / (a+b), i))
X.sort()
print(*[i+1 for x, i in X])
if __name__ == '__main__':
N = int(input())
X = []
for i in range(N):
a, b = map(int, input().split())
X.append((-a*10**100 // (a+b), i))
X.sort()
print(*[i+1 for x, i in X])
|
ConDefects/ConDefects/Code/abc308_c/Python/46192113
|
condefects-python_data_743
|
import sys
n = int(input())
ans = []
for i in range(1, n + 1):
a, b = map(int, sys.stdin.readline().strip().split())
sum = a + b
res = a / (sum)
ans.append([res, -i])
ans.sort(reverse = True)
for i in range (0, len(ans)):
print(-ans[i][1], end = " ")
import sys
n = int(input())
ans = []
for i in range(1, n + 1):
a, b = map(int, sys.stdin.readline().strip().split())
sum = a + b
res = a* 10 ** 100 // (sum)
ans.append([res, -i])
ans.sort(reverse = True)
for i in range (0, len(ans)):
print(-ans[i][1], end = " ")
|
ConDefects/ConDefects/Code/abc308_c/Python/45936707
|
condefects-python_data_744
|
N = int(input())
L = []
for i in range(N):
A, B = map(int, input().split())
L.append(((A*10**100)/(A+B), -i))
L.sort(reverse=True)
for i, j in L:
print(-j+1, end=' ')
print()
N = int(input())
L = []
for i in range(N):
A, B = map(int, input().split())
L.append(((A*10**100)//(A+B), -i))
L.sort(reverse=True)
for i, j in L:
print(-j+1, end=' ')
print()
|
ConDefects/ConDefects/Code/abc308_c/Python/45973622
|
condefects-python_data_745
|
n=int(input())
p=[]
for i in range(n):
a,b=map(int,input().split())
p.append(((a*(10**100))/(a+b),i+1))
p.sort(reverse=True)
l=[]
i=0
while i<n:
if i<n-1 and p[i][0]==p[i+1][0]:
same_n=2
same_p=p[i][0]
j=2
while i+j<n and p[i+j][0]==same_p:
same_n+=1
j+=1
if i+j==n:
break
j-=1
while j>=0:
l.append(p[i+j][1])
j-=1
i+=same_n
else:
l.append(p[i][1])
i+=1
print(*l,sep=' ')
n=int(input())
p=[]
for i in range(n):
a,b=map(int,input().split())
p.append(((a*(10**100))//(a+b),i+1))
p.sort(reverse=True)
l=[]
i=0
while i<n:
if i<n-1 and p[i][0]==p[i+1][0]:
same_n=2
same_p=p[i][0]
j=2
while i+j<n and p[i+j][0]==same_p:
same_n+=1
j+=1
if i+j==n:
break
j-=1
while j>=0:
l.append(p[i+j][1])
j-=1
i+=same_n
else:
l.append(p[i][1])
i+=1
print(*l,sep=' ')
|
ConDefects/ConDefects/Code/abc308_c/Python/45926524
|
condefects-python_data_746
|
MOD = 998244353
N, X = map(int, input().split())
dp = [[[0] * (1 << 2 * X - 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
P = [1]
for i in range(N): P.append(P[i] * (i + 1) % MOD)
for i in range(1, N + 1):
for j in range(i):
for bit in range(1 << 2 * X - 1):
# i項目を決める
for k in range(2 * X - 1):
if 1 <= i - X + 1 + k <= N and not bit >> k & 1:
dp[i][j + 1][(bit | 1 << k) >> 1] += dp[i - 1][j][bit]
# i項目を決めない
dp[i][j][bit >> 1] += dp[i - 1][j][bit]
print(sum(sum(dp[N][j]) * P[N - j] * pow(-1, j % 2) for j in range(N + 1)))
MOD = 998244353
N, X = map(int, input().split())
dp = [[[0] * (1 << 2 * X - 1) for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
P = [1]
for i in range(N): P.append(P[i] * (i + 1) % MOD)
for i in range(1, N + 1):
for j in range(i):
for bit in range(1 << 2 * X - 1):
# i項目を決める
for k in range(2 * X - 1):
if 1 <= i - X + 1 + k <= N and not bit >> k & 1:
dp[i][j + 1][(bit | 1 << k) >> 1] += dp[i - 1][j][bit]
# i項目を決めない
dp[i][j][bit >> 1] += dp[i - 1][j][bit]
print(sum(sum(dp[N][j]) * P[N - j] * pow(-1, j % 2) for j in range(N + 1)) % MOD)
|
ConDefects/ConDefects/Code/abc309_g/Python/43412855
|
condefects-python_data_747
|
s = input()
if s <= "ABC349" and s != "ABC316":
print("Yes")
else :
print("No")
s = input()
if "ABC001"<= s <= "ABC349" and s != "ABC316":
print("Yes")
else :
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/55133783
|
condefects-python_data_748
|
S=input()
num=0
if "ABC316"==S:
print("No")
exit()
for x in range(1,350):
x=str(x)
num=('ABC'+x)
if num==S:
print("Yes")
break
else:
print("No")
S=input()
num=0
if "ABC316"==S:
print("No")
exit()
for x in range(1,350):
x=str(x).zfill(3)
num=('ABC'+x)
if num==S:
print("Yes")
break
else:
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54997297
|
condefects-python_data_749
|
print("YNeos"[(k:=int(input()[3:]))==316or k>349::2])
print("YNeos"[(k:=int(input()[3:]))==316or k>349or 1>k::2])
|
ConDefects/ConDefects/Code/abc350_a/Python/54957000
|
condefects-python_data_750
|
s = input()
if len(s)== 6 and int(s[3:]) < 350 and int(s[3:]) != 316 :
print("Yes")
else :
print("No")
s = input()
if int(s[3:]) > 0 and int(s[3:]) < 350 and int(s[3:]) != 316 :
print("Yes")
else :
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54956876
|
condefects-python_data_751
|
S = input()
K = 0
A = ["0", "1", "2", "3", "4"]
if S == "ABC316" or "ABC000":
K = 0
else:
if S[3] == "3":
for a in A:
if S[4] == a:
K = 1
break
else:
for a in A[:3]:
if S[3] == a:
K = 1
break
print("Yes" if K == 1 else "No")
S = input()
K = 0
A = ["0", "1", "2", "3", "4"]
if S == "ABC316" or S == "ABC000":
K = 0
else:
if S[3] == "3":
for a in A:
if S[4] == a:
K = 1
break
else:
for a in A[:3]:
if S[3] == a:
K = 1
break
print("Yes" if K == 1 else "No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54976927
|
condefects-python_data_752
|
s = input()
a = int(s[3:])
if a != 316 and 0 <= a < 350 :
print('Yes')
else :
print('No')
s = input()
a = int(s[3:])
if a != 316 and 0 < a < 350 :
print('Yes')
else :
print('No')
|
ConDefects/ConDefects/Code/abc350_a/Python/55028923
|
condefects-python_data_753
|
s = input()
num = int(s[3:6])
if num > 349:
print("No")
elif num == 316:
print("No")
elif s[0:3] != "ABC":
print("No")
else:
print("Yes")
s = input()
num = int(s[3:6])
if num > 349:
print("No")
elif num == 316:
print("No")
elif num < 1:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc350_a/Python/55141825
|
condefects-python_data_754
|
s = input()
memo = int(s[3])*100+int(s[4])*10+int(s[5])
if memo>=0 and memo<=349 and memo!=316:
print("Yes")
else:
print("No")
s = input()
memo = int(s[3])*100+int(s[4])*10+int(s[5])
if memo>0 and memo<=349 and memo!=316:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54950052
|
condefects-python_data_755
|
s=input()
t=int(s[3:])
if t==316 or t>349:
print("No")
else:
print("Yes")
s=input()
t=int(s[3:])
if t==316 or t>349 or t<=0:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc350_a/Python/54908916
|
condefects-python_data_756
|
c = int(input()[3:])
print("yes" if (c < 350 and c != 0 and c != 316) else "No")
c = int(input()[3:])
print("Yes" if (0 < c < 350 and c != 316) else "No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54959358
|
condefects-python_data_757
|
S = input()
s = S[3:]
n = int(s)
if n > 349:
print("No")
elif n == 316:
print("No")
else:
print("Yes")
S = input()
s = S[3:]
n = int(s)
if n > 349:
print("No")
elif n == 0:
print("No")
elif n == 316:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc350_a/Python/54895381
|
condefects-python_data_758
|
import sys
S = sys.stdin.read().strip()
if int(S[-3:]) <=349 and int(S[-3:]) != 316:
print("Yes")
else:
print("No")
import sys
S = sys.stdin.read().strip()
if 1 <= int(S[-3:]) <=349 and int(S[-3:]) != 316:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/54996500
|
condefects-python_data_759
|
S = input()
s = int(S[3:])
print('Yes' if 350 - s > 0 and s != 316 else 'No')
S = input()
s = int(S[3:])
print('Yes' if 350 > 350 - s > 0 and s != 316 else 'No')
|
ConDefects/ConDefects/Code/abc350_a/Python/55040537
|
condefects-python_data_760
|
S = int(input()[3:6])
if S != 316 and S < 350:
print("Yes")
else:
print("No")
S = int(input()[3:6])
if S != 316 and S!= 0 and S < 350:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/55009759
|
condefects-python_data_761
|
s = input()
s = s.replace("ABC","")
if int(s) ==316:
print("No")
elif 000 <= int(s) <= 349:
print("Yes")
else:
print("No")
s = input()
s = s.replace("ABC","")
if int(s) ==316:
print("No")
elif 1 <= int(s) <= 349:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc350_a/Python/55042592
|
condefects-python_data_762
|
S = input()
if int(S[3:]) == 316 or int(S[3:]) > 349:
print("No")
else:
print("Yes")
S = input()
if int(S[3:]) == 316 or int(S[3:]) > 349 or int(S[3:]) == 0:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc350_a/Python/54971919
|
condefects-python_data_763
|
T = int(input())
LR = [list(input().split()) for _ in range(T)]
def F(l, r):
if len(l) == len(r):
return int(r) - int(l) + 1
elif r[0] == "1":
return int(r) - max(int(r[1:]), int(l), int(r)//10)
else:
return int(r) - 10**(len(r)-1) + 1
for l, r in LR:
print(F(l, r))
T = int(input())
LR = [list(input().split()) for _ in range(T)]
def F(l, r):
if len(l) == len(r):
return int(r) - int(l) + 1
elif r[0] == "1":
return int(r) - max(int(r[1:]), int(l)-1, int(r)//10)
else:
return int(r) - 10**(len(r)-1) + 1
for l, r in LR:
print(F(l, r))
|
ConDefects/ConDefects/Code/agc057_a/Python/36403213
|
condefects-python_data_764
|
from sys import stdin
T = int(input())
for i in range(T):
L,R = [x for x in stdin.readline().rstrip().split()]
x = len(L)
y = len(R)
if(x == y):
print(int(R)-int(L)+1)
elif(R[0]!="1"):
print(int(R)-10**(y-1)+1)
else:
flag = True
j = 0
while j+1 < y:
if(R[j+1]!="0" and R[j+1]!="1"):
print(min(int(R)-int(L)+1,10**(y-1)))
flag = False
break
elif(R[j+1]!="1"):
print(min(int(R)-int(L)+1,int(R)-int(R)//10))
flag = False
break
j += 1
if(flag):
print(print(min(int(R)-int(L)+1,int(R)-int(R)//10)))
from sys import stdin
T = int(input())
for i in range(T):
L,R = [x for x in stdin.readline().rstrip().split()]
x = len(L)
y = len(R)
if(x == y):
print(int(R)-int(L)+1)
elif(R[0]!="1"):
print(int(R)-10**(y-1)+1)
else:
flag = True
j = 0
while j+1 < y:
if(R[j+1]!="0" and R[j+1]!="1"):
print(min(int(R)-int(L)+1,10**(y-1)))
flag = False
break
elif(R[j+1]!="1"):
print(min(int(R)-int(L)+1,int(R)-int(R)//10))
flag = False
break
j += 1
if(flag):
print(min(int(R)-int(L)+1,int(R)-int(R)//10))
|
ConDefects/ConDefects/Code/agc057_a/Python/39108897
|
condefects-python_data_765
|
from collections import defaultdict, deque, Counter
import copy
from itertools import combinations, permutations, product, accumulate, groupby, chain
from heapq import heapify, heappop, heappush
import math
import bisect
from pprint import pprint
from random import randint
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def ceil_div(x, y): return -(-x//y)
#################################################
T = int(input())
for _ in range(T):
l, r = map(int, input().split())
if len(str(r)) == len(str(l)):
print(r+1-l)
else:
l = max(l, 1+10**(len(str(r))-2))
if str(r+1)[0] == "1":
print(r+1-max(int(str(r+1)[1:]), l))
else:
print(r+1-10**(len(str(r))-1))
from collections import defaultdict, deque, Counter
import copy
from itertools import combinations, permutations, product, accumulate, groupby, chain
from heapq import heapify, heappop, heappush
import math
import bisect
from pprint import pprint
from random import randint
import sys
# sys.setrecursionlimit(700000)
input = lambda: sys.stdin.readline().rstrip('\n')
inf = float('inf')
mod1 = 10**9+7
mod2 = 998244353
def ceil_div(x, y): return -(-x//y)
#################################################
T = int(input())
for _ in range(T):
l, r = map(int, input().split())
if len(str(r)) == len(str(l)):
print(r+1-l)
else:
if str(r+1)[0] == "1":
l = max(l, 1+int(str(r)[:-1]))
print(r+1-max(int(str(r+1)[1:]), l))
else:
print(r+1-10**(len(str(r))-1))
|
ConDefects/ConDefects/Code/agc057_a/Python/43754109
|
condefects-python_data_766
|
#ABC057A Antichain of Integer Strings
'''
前哨戦。
いや、なんだこれ、難しすぎるだろ。
下の桁ほど不利っぽいな。L,R=1,100 のとき、A={3}を選んでしまうと3のつく整数全滅だし。
逆に上の桁は貪欲してよかったりする？
どう考えても数字の大きいものから貪欲に決定するかんじ。
R = 32451 として考えると
10000 - 32451 は貪欲に採用できそう。
ああでも19999 を使っているから9999が採用できないか。それはかわいそうだ。
･･･いや、いうて10000 - 19999 を全採用できるほうが嬉しいから、それでいいのか。
R = 12451 のときは？
10000 - 12451 は貪欲に採用できる。とりあえず2451以下は全滅。あと1245以下。
それ以外、すなわち 2452 - 9999 は自由に選べそう？
R = 10451 のときは？
10000 - 10451 は貪欲、あと1000 - 1045 は禁止。それ以上は貪欲可能。
R = 10000 のときは？
このコーナーケース置いてくれるの優しすぎるだろ。
1000 - 1000 が禁止。 1000 - 0000 も禁止。それ以外は貪欲可。
なんかひどい回答になりそう。提出すっか。
'''
for _ in range(int(input())):
L,R=map(int,input().split())
if len(str(L))==len(str(R)): print(R-L+1); continue
X=len(str(R))
R_NG=max(min(10**(X-1)-1,R-10**(X-1)),int(str(R)[:-1]),L-1)
ans=int(str(R)[1:])+1+10**(X-1)-1-R_NG
print(ans)
#ABC057A Antichain of Integer Strings
'''
前哨戦。
いや、なんだこれ、難しすぎるだろ。
下の桁ほど不利っぽいな。L,R=1,100 のとき、A={3}を選んでしまうと3のつく整数全滅だし。
逆に上の桁は貪欲してよかったりする？
どう考えても数字の大きいものから貪欲に決定するかんじ。
R = 32451 として考えると
10000 - 32451 は貪欲に採用できそう。
ああでも19999 を使っているから9999が採用できないか。それはかわいそうだ。
･･･いや、いうて10000 - 19999 を全採用できるほうが嬉しいから、それでいいのか。
R = 12451 のときは？
10000 - 12451 は貪欲に採用できる。とりあえず2451以下は全滅。あと1245以下。
それ以外、すなわち 2452 - 9999 は自由に選べそう？
R = 10451 のときは？
10000 - 10451 は貪欲、あと1000 - 1045 は禁止。それ以上は貪欲可能。
R = 10000 のときは？
このコーナーケース置いてくれるの優しすぎるだろ。
1000 - 1000 が禁止。 1000 - 0000 も禁止。それ以外は貪欲可。
なんかひどい回答になりそう。提出すっか。
'''
for _ in range(int(input())):
L,R=map(int,input().split())
if len(str(L))==len(str(R)): print(R-L+1); continue
X=len(str(R))
R_NG=max(min(10**(X-1)-1,R-10**(X-1)),int(str(R)[:-1]),L-1)
ans=R-10**(X-1)+1+10**(X-1)-1-R_NG
print(ans)
|
ConDefects/ConDefects/Code/agc057_a/Python/41587952
|
condefects-python_data_767
|
T = int(input())
for _ in range(T):
l,r = input().split()
l = int(l)
if r=="1":
print(0)
else:
if r[0]=="1":
a = int(r[:-1])
b = int(r[1:])
r0 = max(a,b)+1
else:
r0 = int("1"+"0"*(len(r)-1))
r = int(r)
if l<=r0:
print(r-r0+1)
else:
print(r-l+1)
T = int(input())
for _ in range(T):
l,r = input().split()
l = int(l)
if r=="1":
print(1)
else:
if r[0]=="1":
a = int(r[:-1])
b = int(r[1:])
r0 = max(a,b)+1
else:
r0 = int("1"+"0"*(len(r)-1))
r = int(r)
if l<=r0:
print(r-r0+1)
else:
print(r-l+1)
|
ConDefects/ConDefects/Code/agc057_a/Python/35335100
|
condefects-python_data_768
|
N = int(input())
A = list(map(int,input().split()))
W = list(map(int,input().split()))
flg = [-1]*(N)
cost = 0
for i in range(N):
if flg[A[i]-1] == -1:
flg[A[i]-1] = W[i]
continue
cost += min(flg[A[i]-1],W[i])
flg[A[i]-1] = min(flg[A[i]-1],W[i])
print(cost)
N = int(input())
A = list(map(int,input().split()))
W = list(map(int,input().split()))
flg = [-1]*(N)
cost = 0
for i in range(N):
if flg[A[i]-1] == -1:
flg[A[i]-1] = W[i]
continue
cost += min(flg[A[i]-1],W[i])
flg[A[i]-1] = max(flg[A[i]-1],W[i])
print(cost)
|
ConDefects/ConDefects/Code/abc360_c/Python/55149622
|
condefects-python_data_769
|
# [l, r)のうち値[x, y]のみを使って作れるLISの長さを返す
def f(l, r, x, y):
if (l, r, x, y) in memory:
return memory[(l, r, x, y)]
if l >= r:
memory[(l, r, x, y)] = 0
return 0
if x > y:
memory[(l, r, x, y)] = 0
return 0
ret = 0
#A[l]を使わない
ret = max(ret, f(l + 1, r, x, y))
if x <= A[l] <= y:
#A[l]をstackに入れた直後に取り出してXに追加
ret = max(ret, 1 + f(l + 1, r, A[l], y))
#A[l]をstackに入れて, A[k]の直後にXに追加
for k in range(l + 1, r):
ret = max(ret, 1 + f(l + 1, k, x, A[l]) + f(k, r, A[l], y))
memory[(l, r, x, y)] = ret
return ret
n = int(input())
A = list(map(int, input().split()))
memory = {}
for i, a in enumerate(A):
memory[(i, i + 1, a, a)] = 1
print(f(0, n, 1, 50))
# [l, r)のうち値[x, y]のみを使って作れるLISの長さを返す
def f(l, r, x, y):
if (l, r, x, y) in memory:
return memory[(l, r, x, y)]
if l >= r:
memory[(l, r, x, y)] = 0
return 0
if x > y:
memory[(l, r, x, y)] = 0
return 0
ret = 0
#A[l]を使わない
ret = max(ret, f(l + 1, r, x, y))
if x <= A[l] <= y:
#A[l]をstackに入れた直後に取り出してXに追加
ret = max(ret, 1 + f(l + 1, r, A[l], y))
#A[l]をstackに入れて, A[k]の直後にXに追加
for k in range(l + 1, r + 1):
ret = max(ret, 1 + f(l + 1, k, x, A[l]) + f(k, r, A[l], y))
memory[(l, r, x, y)] = ret
return ret
n = int(input())
A = list(map(int, input().split()))
memory = {}
for i, a in enumerate(A):
memory[(i, i + 1, a, a)] = 1
print(f(0, n, 1, 50))
|
ConDefects/ConDefects/Code/abc262_g/Python/33776994
|
condefects-python_data_770
|
import sys
input = sys.stdin.readline
N,M=map(int,input().split())
LR=[list(map(int,input().split())) for i in range(M)]
S=[[0]*505 for i in range(505)]
for l,r in LR:
S[l][r]+=1
for i in range(1,505):
for j in range(505):
S[i][j]+=S[i-1][j]
for i in range(505):
for j in range(1,505):
S[i][j]+=S[i][j-1]
def rect(x0,x1,y0,y1):
return S[x1][y1]-S[x0-1][y1]-S[x1][y0-1]+S[x0-1][x0-1]
DP=[[-1]*505 for i in range(505)]
def calc(x,y):
if x>y:
return 0
if DP[x][y]!=-1:
return DP[x][y]
ANS=0
for i in range(x,y+1):
if rect(x,i,i,y)>=1:
ANS=max(ANS,1+calc(x,i-1)+calc(i+1,y))
DP[x][y]=ANS
return ANS
print(calc(1,503))
import sys
input = sys.stdin.readline
N,M=map(int,input().split())
LR=[list(map(int,input().split())) for i in range(M)]
S=[[0]*505 for i in range(505)]
for l,r in LR:
S[l][r]+=1
for i in range(1,505):
for j in range(505):
S[i][j]+=S[i-1][j]
for i in range(505):
for j in range(1,505):
S[i][j]+=S[i][j-1]
def rect(x0,x1,y0,y1):
return S[x1][y1]-S[x0-1][y1]-S[x1][y0-1]+S[x0-1][y0-1]
DP=[[-1]*505 for i in range(505)]
def calc(x,y):
if x>y:
return 0
if DP[x][y]!=-1:
return DP[x][y]
ANS=0
for i in range(x,y+1):
if rect(x,i,i,y)>=1:
ANS=max(ANS,1+calc(x,i-1)+calc(i+1,y))
DP[x][y]=ANS
return ANS
print(calc(1,503))
|
ConDefects/ConDefects/Code/arc168_d/Python/47791112
|
condefects-python_data_771
|
a_s = []
while True:
a = int(input())
if a == 0:
break
a_s.append(a)
for a in reversed(a_s):
print(a)
a_s = []
while True:
a = int(input())
a_s.append(a)
if a == 0:
break
for a in reversed(a_s):
print(a)
|
ConDefects/ConDefects/Code/abc344_b/Python/54708796
|
condefects-python_data_772
|
a = []
while True:
i = int(input())
a.append(i)
if i == 0: break
a.sort()
print(*a,sep='\n')
a = []
while True:
i = int(input())
a.append(i)
if i == 0: break
a.reverse()
print(*a,sep='\n')
|
ConDefects/ConDefects/Code/abc344_b/Python/54684544
|
condefects-python_data_773
|
import sys
array = []
for i in sys.stdin.readlines():
array.append(int(i.rstrip()))
array.sort()
for i in array:
print(i)
import sys
array = []
for i in sys.stdin.readlines():
array.append(int(i.rstrip()))
array.reverse()
for i in array:
print(i)
|
ConDefects/ConDefects/Code/abc344_b/Python/54781147
|
condefects-python_data_774
|
from atcoder.maxflow import MFGraph
INF = 1 << 60
N, M = map(int, input().split())
g = MFGraph(N * 2)
for _ in range(M):
A, B = map(lambda x: int(x)-1, input().split())
g.add_edge(A+N, B, INF) # A_out -> B_in
g.add_edge(B+N, A, INF) # B_out -> A_in
C = list(map(int, input().split()))
for i, c in enumerate(C):
cap = INF if i in [0, N-1] else c
g.add_edge(i, i+N, cap) # i_in -> i_out
ans = g.flow(0, N-1)
mc = g.min_cut(0)
vs = []
for i in range(N):
if mc[i] and not mc[i+1]:
vs.append(i+1)
print(ans)
print(len(vs))
print(*vs)
from atcoder.maxflow import MFGraph
INF = 1 << 60
N, M = map(int, input().split())
g = MFGraph(N * 2)
for _ in range(M):
A, B = map(lambda x: int(x)-1, input().split())
g.add_edge(A+N, B, INF) # A_out -> B_in
g.add_edge(B+N, A, INF) # B_out -> A_in
C = list(map(int, input().split()))
for i, c in enumerate(C):
cap = INF if i in [0, N-1] else c
g.add_edge(i, i+N, cap) # i_in -> i_out
ans = g.flow(0, N-1)
mc = g.min_cut(0)
vs = []
for i in range(N):
if mc[i] and not mc[i+N]:
vs.append(i+1)
print(ans)
print(len(vs))
print(*vs)
|
ConDefects/ConDefects/Code/abc239_g/Python/45950802
|
condefects-python_data_775
|
#ABC290-D
import math
T = int(input())
for _ in range(T):
N, D, K = map(int, input().split())
K -= 1 #0-indexedに直す
x = N//math.gcd(N, D)
#何周期目か
i = K//x
#何番目か
j = K%x
print(((D+i)*j)%N)
#ABC290-D
import math
T = int(input())
for _ in range(T):
N, D, K = map(int, input().split())
K -= 1 #0-indexedに直す
x = N//math.gcd(N, D)
#何周期目か
i = K//x
#何番目か
j = K%x
print(((j*D + i)%N))
|
ConDefects/ConDefects/Code/abc290_d/Python/46020741
|
condefects-python_data_776
|
import math
T=int(input())
for _ in range(T):
N,D,K=map(int,input().split())
gcd=math.gcd(N,D)
if gcd==1:
answer=(D*(K-1))%N
else:
d=D//gcd
n=N//gcd
answer=((((K-1)%n)*d%N)*gcd+(K-1)//n)%n
print(answer)
import math
T=int(input())
for _ in range(T):
N,D,K=map(int,input().split())
gcd=math.gcd(N,D)
if gcd==1:
answer=(D*(K-1))%N
else:
d=D//gcd
n=N//gcd
answer=((((K-1)%n)*d%N)*gcd+(K-1)//n)%N
print(answer)
|
ConDefects/ConDefects/Code/abc290_d/Python/45988606
|
condefects-python_data_777
|
from math import log10
n,m = map(int, input().split())
mketa = int(log10(m))+1
if m % 2 == 0:
numli = [8]
elif m % 5 == 0:
numli = [5]
else:
numli = [9,7]
xli = []
for num in numli:
# resunit = num % m
keta = mketa
tempx = int(str(num) * keta)
res = tempx % m
resunit = (num * pow(10, keta)) % m
while keta <= n:
if res != 0:
keta += 1
resunit = (resunit * 10) % m
res += resunit
res %= m
else:
keta = n // keta * keta
xli.append(int(str(num) * keta))
keta += 1
resunit = (num * pow(10, keta)) % m
res += resunit
if xli:
ans = max(xli)
if ans < m:
print(-1)
else:
print(ans)
else:
print(-1)
from math import log10
n,m = map(int, input().split())
mketa = int(log10(m))+1
if m % 2 == 0:
numli = [8]
elif m % 5 == 0:
numli = [5]
else:
numli = [9,7]
xli = []
for num in numli:
# resunit = num % m
keta = mketa
tempx = int(str(num) * keta)
res = tempx % m
resunit = (num * pow(10, keta-1)) % m
while keta <= n:
if res != 0:
keta += 1
resunit = (resunit * 10) % m
res += resunit
res %= m
else:
keta = n // keta * keta
xli.append(int(str(num) * keta))
keta += 1
resunit = (num * pow(10, keta)) % m
res += resunit
if xli:
ans = max(xli)
if ans < m:
print(-1)
else:
print(ans)
else:
print(-1)
|
ConDefects/ConDefects/Code/arc149_a/Python/42835406
|
condefects-python_data_778
|
def main():
from collections import deque,defaultdict
import itertools
from math import gcd
import sys,heapq,bisect
sys.setrecursionlimit(10**6)
readline=sys.stdin.readline
MOD=998244353
INF=10**15
N,M=list(map(int, readline().split()))
#10^3未満の数->999,998,
l=[0,0]#num,length
c=0
for length in range(1,N+1):
c=(c*10+1)%M
if not c:
l[0]=9
l[1]=length
break
for i in range(2,10):
if not (c*i)%M:
l[0]=i
l[1]=length
if l==[0,0]:
print(-1)
else:
print(str(l[0])*l[1])
if __name__=="__main__":
main()
def main():
from collections import deque,defaultdict
import itertools
from math import gcd
import sys,heapq,bisect
sys.setrecursionlimit(10**6)
readline=sys.stdin.readline
MOD=998244353
INF=10**15
N,M=list(map(int, readline().split()))
#10^3未満の数->999,998,
l=[0,0]#num,length
c=0
for length in range(1,N+1):
c=(c*10+1)%M
if not c:
l[0]=9
l[1]=length
continue
for i in range(2,10):
if not (c*i)%M:
l[0]=i
l[1]=length
if l==[0,0]:
print(-1)
else:
print(str(l[0])*l[1])
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/arc149_a/Python/43012792
|
condefects-python_data_779
|
from collections import Counter
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
INF = 10**9
N, M = map(int, input().split())
ABs = [tuple(map(int, input().split())) for _ in range(N)]
sumA = sum([A for A, B in ABs])
#print('# sumA:', sumA)
diffs = [B-A for A, B in ABs]
cnt = Counter(diffs)
#print('# diffs:', diffs)
#print('# cnt:', cnt)
def f(x):
anss = []
s = 1
while True:
if x-s >= 0:
anss.append(s)
else:
break
x -= s
s *= 2
if x > 0:
anss.append(x)
return anss
dp = [INF] * (M+1)
dp[sumA] = 0
for diff, num in cnt.items():
xs = f(num)
# print('\n##### (diff, num):', (diff, num), '/ xs:', xs)
# print('# dp:', dp)
for x in xs:
d = diff*x
# print('### x:', x, '/ d:', d)
dp2 = dp[:]
for i in range(M+1):
dpNow = dp[i]
if dpNow == INF:
continue
c2 = dpNow+1
i2 = i+d
if c2 < dp2[i2]:
dp2[i2] = c2
dp = dp2
# print('# dp:', dp)
anss = []
for i in range(M+1):
ans = dp[i]
if ans == INF:
anss.append(-1)
else:
anss.append(ans)
print('\n'.join(map(str, anss)))
solve()
from collections import Counter
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**9)
def solve():
INF = 10**9
N, M = map(int, input().split())
ABs = [tuple(map(int, input().split())) for _ in range(N)]
sumA = sum([A for A, B in ABs])
#print('# sumA:', sumA)
diffs = [B-A for A, B in ABs]
cnt = Counter(diffs)
#print('# diffs:', diffs)
#print('# cnt:', cnt)
def f(x):
anss = []
s = 1
while True:
if x-s >= 0:
anss.append(s)
else:
break
x -= s
s *= 2
if x > 0:
anss.append(x)
return anss
dp = [INF] * (M+1)
dp[sumA] = 0
for diff, num in cnt.items():
xs = f(num)
# print('\n##### (diff, num):', (diff, num), '/ xs:', xs)
# print('# dp:', dp)
for x in xs:
d = diff*x
# print('### x:', x, '/ d:', d)
dp2 = dp[:]
for i in range(M+1):
dpNow = dp[i]
if dpNow == INF:
continue
c2 = dpNow+x
i2 = i+d
if c2 < dp2[i2]:
dp2[i2] = c2
dp = dp2
# print('# dp:', dp)
anss = []
for i in range(M+1):
ans = dp[i]
if ans == INF:
anss.append(-1)
else:
anss.append(ans)
print('\n'.join(map(str, anss)))
solve()
|
ConDefects/ConDefects/Code/abc269_g/Python/35978955
|
condefects-python_data_780
|
n,m=map(int,input().split())
s=0
d={}
for i in range(n):
a,b=map(int,input().split())
s+=a
if b-a not in d:
d[b-a]=0
d[b-a]+=1
p=[]
for dd in d:
pp=1
while pp<=d[dd]:
p.append((dd,pp))
d[dd]-=pp
pp*=2
if d[dd]>0:
p.append((dd,d[dd]))
q=[n+1]*(m+1)
q[s]=0
for dd,pp in p:
nq=[n+1]*(m+1)
for i in range(m+1):
if q[i]<n+1:
nq[i]=min(nq[i],q[i])
if 0<=i+dd*pp<=m and dd>0:
nq[i+dd*pp]=min(nq[i+dd*pp],q[i]+pp)
q=nq
for qq in q:
print(qq if qq<n+1 else -1)
n,m=map(int,input().split())
s=0
d={}
for i in range(n):
a,b=map(int,input().split())
s+=a
if b-a not in d:
d[b-a]=0
d[b-a]+=1
p=[]
for dd in d:
pp=1
while pp<=d[dd]:
p.append((dd,pp))
d[dd]-=pp
pp*=2
if d[dd]>0:
p.append((dd,d[dd]))
q=[n+1]*(m+1)
q[s]=0
for dd,pp in p:
nq=[n+1]*(m+1)
for i in range(m+1):
if q[i]<n+1:
nq[i]=min(nq[i],q[i])
if 0<=i+dd*pp<=m and dd!=0:
nq[i+dd*pp]=min(nq[i+dd*pp],q[i]+pp)
q=nq
for qq in q:
print(qq if qq<n+1 else -1)
|
ConDefects/ConDefects/Code/abc269_g/Python/43509672
|
condefects-python_data_781
|
N = int(input())
P = list(map(int, input().split()))
cur_cost = 0
cur_slope = 0
slope_diff = [0]*N
for i in range(N):
# 料理 P[i] は位置 P[i] にあってほしいが，現在位置 i にある
cur_cost += min((P[i] - i) % N, (i - P[i]) % N)
if N % 2 == 1:
if 0 < (P[i] - i) % N <= N//2:
cur_slope -= 1
elif (P[i] - i) % N == N//2 + 1:
cur_slope = 0
else:
cur_slope += 1
slope_diff[(P[i] - i) % N] += 2
slope_diff[(P[i] - i + N//2) % N] -= 1
slope_diff[(P[i] - i + N//2 + 1) % N] -= 1
else:
if 0 < (P[i] - i) % N <= N//2:
cur_slope -= 1
else:
cur_slope += 1
slope_diff[(P[i] - i) % N] += 2
slope_diff[(P[i] - i + N//2) % N] -= 2
# print(i, cur_slope, slope_diff)
ans = cur_cost
# print("slope diff", slope_diff)
# print(0, ans, cur_cost, cur_slope)
for i in range(1, N):
cur_cost += cur_slope
ans = min(ans, cur_cost)
cur_slope += slope_diff[i]
# print(i, ans, cur_cost, cur_slope)
print(ans)
N = int(input())
P = list(map(int, input().split()))
cur_cost = 0
cur_slope = 0
slope_diff = [0]*N
for i in range(N):
# 料理 P[i] は位置 P[i] にあってほしいが，現在位置 i にある
cur_cost += min((P[i] - i) % N, (i - P[i]) % N)
if N % 2 == 1:
if 0 < (P[i] - i) % N <= N//2:
cur_slope -= 1
elif (P[i] - i) % N == N//2 + 1:
cur_slope += 0
else:
cur_slope += 1
slope_diff[(P[i] - i) % N] += 2
slope_diff[(P[i] - i + N//2) % N] -= 1
slope_diff[(P[i] - i + N//2 + 1) % N] -= 1
else:
if 0 < (P[i] - i) % N <= N//2:
cur_slope -= 1
else:
cur_slope += 1
slope_diff[(P[i] - i) % N] += 2
slope_diff[(P[i] - i + N//2) % N] -= 2
# print(i, cur_slope, slope_diff)
ans = cur_cost
# print("slope diff", slope_diff)
# print(0, ans, cur_cost, cur_slope)
for i in range(1, N):
cur_cost += cur_slope
ans = min(ans, cur_cost)
cur_slope += slope_diff[i]
# print(i, ans, cur_cost, cur_slope)
print(ans)
|
ConDefects/ConDefects/Code/abc268_e/Python/46052240
|
condefects-python_data_782
|
N = int(input())
m = [0]*N
p = [*map(int,input().split())]
for n in range(N):
m[(p[n]-n)%N]+=1
mid = N//2+N%2
fnsum,lnsum = sum(m[n] for n in range(mid)),sum(m[n] for n in range(mid,N))
fsum,lsum = sum(m[n]*n for n in range(mid)),sum(m[n]*(N-n) for n in range(mid,N))
ans = fsum+lsum
for n in range(N-1):
fsum = fsum - fnsum + m[(n+mid)%N]*(mid-1) + m[n]
fnsum = fnsum + m[(n+mid)%N] - m[n]
lsum = lsum + lnsum + m[n] - m[(n+mid)%N]*(mid+1)
lnsum = lnsum + m[n] - m[(n+mid)%N]
ans = min(ans,fsum+lsum)
print(ans)
N = int(input())
m = [0]*N
p = [*map(int,input().split())]
for n in range(N):
m[(p[n]-n)%N]+=1
mid = N//2+N%2
fnsum,lnsum = sum(m[n] for n in range(mid)),sum(m[n] for n in range(mid,N))
fsum,lsum = sum(m[n]*n for n in range(mid)),sum(m[n]*(N-n) for n in range(mid,N))
ans = fsum+lsum
for n in range(N-1):
fsum = fsum - fnsum + m[(n+mid)%N]*(mid-1) + m[n]
fnsum = fnsum + m[(n+mid)%N] - m[n]
lsum = lsum + lnsum + m[n] - m[(n+mid)%N]*(N-mid+1)
lnsum = lnsum + m[n] - m[(n+mid)%N]
ans = min(ans,fsum+lsum)
print(ans)
|
ConDefects/ConDefects/Code/abc268_e/Python/46000676
|
condefects-python_data_783
|
from collections import defaultdict
N = int(input())
p = list(map(int,input().split()))
ans = [0] * N
for i in range(N):
ans[0] += min((p[i]-i)%N, (i-p[i])%N)
diff = 0
change = defaultdict(int)
if N & 1:
for i in range(N):
x = (p[i]-i) % N
change[(N//2 - x - 1) % N] -= 1
change[(N//2 - x) % N] -= 1
change[(N - x) % N] += 2
if x < N//2:
diff += 1
elif x > N//2:
diff -= 1
else:
for i in range(N):
x = (p[i]-i) % N
change[(N//2 - x) % N] -= 2
change[(N - x) % N] += 2
if x < N//2:
diff += 1
else:
diff -= 1
for i in range(N-1):
ans[i+1] = ans[i] + diff
diff += change[i+1]
print(min(ans))
from collections import defaultdict
N = int(input())
p = list(map(int,input().split()))
ans = [0] * N
for i in range(N):
ans[0] += min((p[i]-i)%N, (i-p[i])%N)
diff = 0
change = defaultdict(int)
if N & 1:
for i in range(N):
x = (p[i]-i) % N
change[(N//2 - x) % N] -= 1
change[(N//2 - x + 1) % N] -= 1
change[(N - x) % N] += 2
if x < N//2:
diff += 1
elif x > N//2:
diff -= 1
else:
for i in range(N):
x = (p[i]-i) % N
change[(N//2 - x) % N] -= 2
change[(N - x) % N] += 2
if x < N//2:
diff += 1
else:
diff -= 1
for i in range(N-1):
ans[i+1] = ans[i] + diff
diff += change[i+1]
print(min(ans))
|
ConDefects/ConDefects/Code/abc268_e/Python/45307852
|
condefects-python_data_784
|
def solve_sub(n, a, b, c, p_list):
if n == 1:
return "Yes"
if c % 2 == 1:
return "No"
depth = [0] * n
is_leaf = [1] * n
parents = [0] * n
children = [[] for _ in range(n)]
for i, p in enumerate(p_list):
depth[i + 1] = depth[p - 1] + 1
is_leaf[p - 1] = 0
parents[i + 1] = p - 1
children[p - 1].append(i + 1)
dp_x = [[-1] * (n // 2 + 2) for _ in range(n)]
dp_y = [[-1] * (n // 2 + 2) for _ in range(n)]
count_leaves = [0] * n
# pを根として、leafにi個のYを書いたとしてあと何個Yを書けるか
for p in range(n - 1, -1, -1):
if is_leaf[p]:
dp_x[p][0] = 0
dp_y[p][1] = 0
count_leaves[p] = 1
else:
q, r = children[p]
count_leaves[p] = count_leaves[q] + count_leaves[r]
for i in range(count_leaves[q] + 1):
if dp_x[q][i] == -1:
continue
for j in range(count_leaves[r] + 1):
if dp_x[r][j] == -1:
continue
dp_y[p][i + j] = max(dp_y[p][i + j], dp_x[q][i] + dp_x[r][j]) + 1
for i in range(count_leaves[q] + 1):
if max(dp_x[q][i], dp_y[q][i]) == -1:
continue
for j in range(count_leaves[r] + 1):
if max(dp_x[r][j], dp_y[r][j]) == -1:
continue
dp_x[p][i + j] = max(dp_x[p][i + j], max(dp_x[q][i], dp_y[q][i]) + max(dp_x[r][j], dp_y[r][j]))
# print(dp_x)
# print(dp_y)
# 根がXの場合
# leafのYの個数
y_leaf_count = b - (c // 2)
y_non_leaf_count = c // 2
if 0 <= y_leaf_count < n // 2 + 2:
if dp_x[0][y_leaf_count] >= y_non_leaf_count:
return "Yes"
# 根がYの場合
# leafのYの個数
y_leaf_count = b - (c // 2) + 1
y_non_leaf_count = c // 2
if 0 <= y_leaf_count < n // 2 + 2:
if dp_y[0][y_leaf_count] >= y_non_leaf_count:
return "Yes"
return "No"
def solve(t, case_list):
res = []
for n, a, b, c, p_list in case_list:
res.append(solve_sub(n, a, b, c, p_list))
# print(res)
return res
def main():
t = int(input())
case_list = []
for _ in range(t):
n, a, b, c = map(int, input().split())
p_list = list(map(int, input().split()))
case_list.append((n, a, b, c, p_list))
res = solve(t, case_list)
for r in res:
print(r)
def test():
assert solve(3, [
(7, 2, 2, 2, [1, 1, 2, 2, 3, 3]),
(7, 0, 2, 4, [1, 1, 2, 2, 3, 3]),
(7, 2, 0, 4, [1, 1, 2, 2, 4, 4]),
]) == ["Yes", "Yes", "No"]
if __name__ == "__main__":
test()
main()
def solve_sub(n, a, b, c, p_list):
if n == 1:
return "Yes"
if c % 2 == 1:
return "No"
depth = [0] * n
is_leaf = [1] * n
parents = [0] * n
children = [[] for _ in range(n)]
for i, p in enumerate(p_list):
depth[i + 1] = depth[p - 1] + 1
is_leaf[p - 1] = 0
parents[i + 1] = p - 1
children[p - 1].append(i + 1)
dp_x = [[-1] * (n // 2 + 2) for _ in range(n)]
dp_y = [[-1] * (n // 2 + 2) for _ in range(n)]
count_leaves = [0] * n
# pを根として、leafにi個のYを書いたとしてあと何個Yを書けるか
for p in range(n - 1, -1, -1):
if is_leaf[p]:
dp_x[p][0] = 0
dp_y[p][1] = 0
count_leaves[p] = 1
else:
q, r = children[p]
count_leaves[p] = count_leaves[q] + count_leaves[r]
for i in range(count_leaves[q] + 1):
if dp_x[q][i] == -1:
continue
for j in range(count_leaves[r] + 1):
if dp_x[r][j] == -1:
continue
dp_y[p][i + j] = max(dp_y[p][i + j], dp_x[q][i] + dp_x[r][j] + 1)
for i in range(count_leaves[q] + 1):
if max(dp_x[q][i], dp_y[q][i]) == -1:
continue
for j in range(count_leaves[r] + 1):
if max(dp_x[r][j], dp_y[r][j]) == -1:
continue
dp_x[p][i + j] = max(dp_x[p][i + j], max(dp_x[q][i], dp_y[q][i]) + max(dp_x[r][j], dp_y[r][j]))
# print(dp_x)
# print(dp_y)
# 根がXの場合
# leafのYの個数
y_leaf_count = b - (c // 2)
y_non_leaf_count = c // 2
if 0 <= y_leaf_count < n // 2 + 2:
if dp_x[0][y_leaf_count] >= y_non_leaf_count:
return "Yes"
# 根がYの場合
# leafのYの個数
y_leaf_count = b - (c // 2) + 1
y_non_leaf_count = c // 2
if 0 <= y_leaf_count < n // 2 + 2:
if dp_y[0][y_leaf_count] >= y_non_leaf_count:
return "Yes"
return "No"
def solve(t, case_list):
res = []
for n, a, b, c, p_list in case_list:
res.append(solve_sub(n, a, b, c, p_list))
# print(res)
return res
def main():
t = int(input())
case_list = []
for _ in range(t):
n, a, b, c = map(int, input().split())
p_list = list(map(int, input().split()))
case_list.append((n, a, b, c, p_list))
res = solve(t, case_list)
for r in res:
print(r)
def test():
assert solve(3, [
(7, 2, 2, 2, [1, 1, 2, 2, 3, 3]),
(7, 0, 2, 4, [1, 1, 2, 2, 3, 3]),
(7, 2, 0, 4, [1, 1, 2, 2, 4, 4]),
]) == ["Yes", "Yes", "No"]
if __name__ == "__main__":
test()
main()
|
ConDefects/ConDefects/Code/arc157_e/Python/39201856
|
condefects-python_data_785
|
n=int(input())
print('YNeos'[n<-2**31 or n>2**31::2])
n=int(input())
print('YNeos'[n<-2**31 or n>=2**31::2])
|
ConDefects/ConDefects/Code/abc237_a/Python/45125955
|
condefects-python_data_786
|
N=int(input())
if -2**31<N<2**31:
print("Yes")
else:
print("No")
N=int(input())
if -2**31<=N<2**31:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc237_a/Python/45710805
|
condefects-python_data_787
|
print("Yes" if (a:=int(input()))<4294967296 and a>=-4294967296 else "No")
print("Yes" if (a:=int(input()))<(1<<31) and a>=-(1<<31) else "No")
|
ConDefects/ConDefects/Code/abc237_a/Python/45267148
|
condefects-python_data_788
|
N=int(input())
print("Yes" if -2**31<=N<=2**31 else "No")
N=int(input())
print("Yes" if -2**31<=N<2**31 else "No")
|
ConDefects/ConDefects/Code/abc237_a/Python/46166262
|
condefects-python_data_789
|
n, q = map(int, input().split())
record = [(i, 0) for i in reversed(range(1,n+1))]
dict = {"R":(-1,0), "L":(1,0), "U":(0,1), "D":(0,-1)}
for i in range(q):
select, part = input().split()
if select == "1":
x,y = record[-1]
dx, dy = dict[part]
record.append((x+dx, y+dy))
else:
part = int(part)
print(*record[-part])
n, q = map(int, input().split())
record = [(i, 0) for i in reversed(range(1,n+1))]
dict = {"R":(1,0), "L":(-1,0), "U":(0,1), "D":(0,-1)}
for i in range(q):
select, part = input().split()
if select == "1":
x,y = record[-1]
dx, dy = dict[part]
record.append((x+dx, y+dy))
else:
part = int(part)
print(*record[-part])
|
ConDefects/ConDefects/Code/abc335_c/Python/54505569
|
condefects-python_data_790
|
s=input().split()
n=int(s[0])
a=[[n-i,0] for i in range(n)]
q=int(s[1])
str="LURD"
d=[1,0,-1,0]
for _ in range(q):
s=input().split()
if s[0]=='1':
a.append([a[-1][0]+d[str.index(s[1])],a[-1][1]+d[str.index(s[1])-1]])
else:
print(a[-int(s[1])][0],a[-int(s[1])][1])
s=input().split()
n=int(s[0])
a=[[n-i,0] for i in range(n)]
q=int(s[1])
str="RULD"
d=[1,0,-1,0]
for _ in range(q):
s=input().split()
if s[0]=='1':
a.append([a[-1][0]+d[str.index(s[1])],a[-1][1]+d[str.index(s[1])-1]])
else:
print(a[-int(s[1])][0],a[-int(s[1])][1])
|
ConDefects/ConDefects/Code/abc335_c/Python/54761839
|
condefects-python_data_791
|
class SegmentTree:
def __init__(self, a):
self.padding = 0
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.seg_data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.seg_data[(i-1)//2] = self.seg_data[i] + self.seg_data[i-1]
def __len__(self):
return self.n
def __getitem__(self, i):
return self.seg_data[self.N-1+i]
def __setitem__(self, i, x):
idx = self.N - 1 + i
self.seg_data[idx] = x
while idx:
idx = (idx-1) // 2
self.seg_data[idx] = self.seg_data[2*idx+1] + self.seg_data[2*idx+2]
def query(self, i, j):
# [i, j)
if i == j:
return 0
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # 閉区間にする
result = self.padding
while idx1 < idx2 + 1:
if idx1&1 == 0: # idx1が偶数
result = result + self.seg_data[idx1]
if idx2&1 == 1: # idx2が奇数
result = result + self.seg_data[idx2]
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
return result
def kth_left_idx(self, fr, k):
if self.query(0, fr+1) < k:
return -1
remain = k
now = fr + self.N - 1
while self.seg_data[now] < remain:
if now % 2:
remain -= self.seg_data[now]
now -= 1
else:
now = (now - 1) // 2
while now < self.N - 1:
nl = 2*now + 1
nr = nl + 1
if self.seg_data[nr] < remain:
remain -= self.seg_data[nr]
now = nl
else:
now = nr
return now - (self.N - 1)
def kth_right_idx(self, fr, k):
if self.query(fr, self.n) < k:
return -1
remain = k
now = fr + self.N - 1
while self.seg_data[now] < remain:
if now % 2 == 0:
remain -= self.seg_data[now]
now += 1
else:
now //= 2
while now < self.N - 1:
nl = 2*now + 1
nr = nl + 1
if self.seg_data[nl] < remain:
remain -= self.seg_data[nl]
now = nr
else:
now = nl
return now - (self.N - 1)
def compress(data):
s = sorted(set(data))
idx = dict(zip(s, range(len(s))))
return s, idx
Q, K = map(int, input().split())
INF = K+10
query = [list(map(int, input().split())) for _ in range(Q)]
X = [x for _,x in query]
X += [-INF, max(X)+INF]
X, x2id = compress(X)
N = len(X)
In = SegmentTree([0]*N)
Left = SegmentTree([0]*N)
In[0] = In[N-1] = Left[0] = Left[N-1] = 1
for t, x in query:
i = x2id[x]
if t == 1:
if In[i]:
In[i] = 0
if Left[i]:
Left[i] = 0
ri = In.kth_right_idx(i, 1)
Left[ri] = 1
else:
li = In.kth_left_idx(i, 1)
ri = In.kth_left_idx(i, 1)
if X[ri] - X[li] > K:
Left[ri] = 1
else:
li = In.kth_left_idx(i, 1)
ri = In.kth_right_idx(i, 1)
In[i] = 1
if Left[ri]:
marge_left = x - X[li] <= K
marge_right = X[ri] - x <= K
if marge_left:
if marge_right:
Left[ri] = 0
else:
Left[i] = 1
if marge_right:
Left[ri] = 0
else:
li = Left.kth_left_idx(i, 1)
ri = Left.kth_right_idx(i+1, 1)
ans = In.query(li, ri) - int(li==0)
print(ans)
class SegmentTree:
def __init__(self, a):
self.padding = 0
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.seg_data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.seg_data[(i-1)//2] = self.seg_data[i] + self.seg_data[i-1]
def __len__(self):
return self.n
def __getitem__(self, i):
return self.seg_data[self.N-1+i]
def __setitem__(self, i, x):
idx = self.N - 1 + i
self.seg_data[idx] = x
while idx:
idx = (idx-1) // 2
self.seg_data[idx] = self.seg_data[2*idx+1] + self.seg_data[2*idx+2]
def query(self, i, j):
# [i, j)
if i == j:
return 0
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # 閉区間にする
result = self.padding
while idx1 < idx2 + 1:
if idx1&1 == 0: # idx1が偶数
result = result + self.seg_data[idx1]
if idx2&1 == 1: # idx2が奇数
result = result + self.seg_data[idx2]
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
return result
def kth_left_idx(self, fr, k):
if self.query(0, fr+1) < k:
return -1
remain = k
now = fr + self.N - 1
while self.seg_data[now] < remain:
if now % 2:
remain -= self.seg_data[now]
now -= 1
else:
now = (now - 1) // 2
while now < self.N - 1:
nl = 2*now + 1
nr = nl + 1
if self.seg_data[nr] < remain:
remain -= self.seg_data[nr]
now = nl
else:
now = nr
return now - (self.N - 1)
def kth_right_idx(self, fr, k):
if self.query(fr, self.n) < k:
return -1
remain = k
now = fr + self.N - 1
while self.seg_data[now] < remain:
if now % 2 == 0:
remain -= self.seg_data[now]
now += 1
else:
now //= 2
while now < self.N - 1:
nl = 2*now + 1
nr = nl + 1
if self.seg_data[nl] < remain:
remain -= self.seg_data[nl]
now = nr
else:
now = nl
return now - (self.N - 1)
def compress(data):
s = sorted(set(data))
idx = dict(zip(s, range(len(s))))
return s, idx
Q, K = map(int, input().split())
INF = K+10
query = [list(map(int, input().split())) for _ in range(Q)]
X = [x for _,x in query]
X += [-INF, max(X)+INF]
X, x2id = compress(X)
N = len(X)
In = SegmentTree([0]*N)
Left = SegmentTree([0]*N)
In[0] = In[N-1] = Left[0] = Left[N-1] = 1
for t, x in query:
i = x2id[x]
if t == 1:
if In[i]:
In[i] = 0
if Left[i]:
Left[i] = 0
ri = In.kth_right_idx(i, 1)
Left[ri] = 1
else:
li = In.kth_left_idx(i, 1)
ri = In.kth_right_idx(i, 1)
if X[ri] - X[li] > K:
Left[ri] = 1
else:
li = In.kth_left_idx(i, 1)
ri = In.kth_right_idx(i, 1)
In[i] = 1
if Left[ri]:
marge_left = x - X[li] <= K
marge_right = X[ri] - x <= K
if marge_left:
if marge_right:
Left[ri] = 0
else:
Left[i] = 1
if marge_right:
Left[ri] = 0
else:
li = Left.kth_left_idx(i, 1)
ri = Left.kth_right_idx(i+1, 1)
ans = In.query(li, ri) - int(li==0)
print(ans)
|
ConDefects/ConDefects/Code/abc356_f/Python/54283471
|
condefects-python_data_792
|
import sys
input = sys.stdin.readline
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size *
(i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
################################
from bisect import *
from copy import deepcopy
def compress(lst):
'''
B: lstを座圧したリスト
idx_to_val: indexから元の値を取得するリスト
val_to_idx: 元の値からindexを取得する辞書
'''
B = []
val_to_idx = {}
idx_to_val = deepcopy(lst)
idx_to_val = list(set(idx_to_val))
idx_to_val.sort()
for i in range(len(lst)):
ind = bisect_left(idx_to_val, lst[i])
B.append(ind)
for i in range(len(B)):
val_to_idx[lst[i]] = B[i]
return B, idx_to_val, val_to_idx
class Fenwick_Tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p, x):
assert 0 <= p < self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l, r):
assert 0 <= l <= r <= self._n
return self._sum(r) - self._sum(l)
def _sum(self, r):
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
# T.sum(0, x) <= kとなる最大のxを返す。
def get(self, k):
k += 1
x, r = 0, 1
while r < self._n:
r <<= 1
len = r
while len:
if x + len - 1 < self._n:
if self.data[x + len - 1] < k:
k -= self.data[x + len - 1]
x += len
len >>= 1
return x
def __str__(self):
temp = []
for i in range(self._n):
temp.append(str(self.sum(i, i + 1)))
return ' '.join(temp)
Q, K = map(int, input().split())
query = [None] * Q
inf = 10 ** 19 + 5
D = [inf, -inf]
for i in range(Q):
query[i] = list(map(int, input().split()))
D.append(query[i][1])
D, iv, vi = compress(D)
SS = SortedSet()
SS.add(inf)
SS.add(-inf)
N = len(iv) + 1
seen = [0] * N
Tn, Ts = Fenwick_Tree(N), Fenwick_Tree(N)
Tn.add(0, 1)
Tn.add(N-1, 1)
seen[0] = seen[N - 1] = 1
def BinarySearch(check, yes, no, i):
while abs(yes - no) != 1:
mid = (yes + no)//2
if check(mid, i):
yes = mid
else:
no = mid
return yes
def check(m, i):
mi = min(m, i)
ma = max(m, i)
return Tn.sum(mi, ma) == Ts.sum(mi, ma)
for f, x in query:
ix = vi[x]
if f == 1:
if seen[ix] == 0:
r = SS.gt(x)
l = SS.lt(x)
il = vi[l]
Ts.add(il, -Ts.sum(il, il+1))
if x - l <= K:
Ts.add(il, 1)
if r - x <= K:
Ts.add(ix, 1)
Tn.add(ix, 1)
SS.add(x)
else:
r = SS.gt(x)
l = SS.lt(x)
il = vi[l]
Ts.add(il, -Ts.sum(il, il+1))
Ts.add(ix, -Ts.sum(ix, ix+1))
if r - l <= K:
Ts.add(il, 1)
Tn.add(ix, -1)
SS.discard(x)
seen[ix] ^= 1
else:
r = BinarySearch(check, ix, N, ix)
l = BinarySearch(check, ix, 0, ix)
print(r - l + 1)
import sys
input = sys.stdin.readline
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None:
a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size *
(i + 1) // bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i:
yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i):
yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]:
return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0:
return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
return False
a.pop(i)
self.size -= 1
if len(a) == 0:
self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0:
x += self.size
if x < 0:
raise IndexError
for a in self.a:
if x < len(a):
return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
################################
from bisect import *
from copy import deepcopy
def compress(lst):
'''
B: lstを座圧したリスト
idx_to_val: indexから元の値を取得するリスト
val_to_idx: 元の値からindexを取得する辞書
'''
B = []
val_to_idx = {}
idx_to_val = deepcopy(lst)
idx_to_val = list(set(idx_to_val))
idx_to_val.sort()
for i in range(len(lst)):
ind = bisect_left(idx_to_val, lst[i])
B.append(ind)
for i in range(len(B)):
val_to_idx[lst[i]] = B[i]
return B, idx_to_val, val_to_idx
class Fenwick_Tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p, x):
assert 0 <= p < self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l, r):
assert 0 <= l <= r <= self._n
return self._sum(r) - self._sum(l)
def _sum(self, r):
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
# T.sum(0, x) <= kとなる最大のxを返す。
def get(self, k):
k += 1
x, r = 0, 1
while r < self._n:
r <<= 1
len = r
while len:
if x + len - 1 < self._n:
if self.data[x + len - 1] < k:
k -= self.data[x + len - 1]
x += len
len >>= 1
return x
def __str__(self):
temp = []
for i in range(self._n):
temp.append(str(self.sum(i, i + 1)))
return ' '.join(temp)
Q, K = map(int, input().split())
query = [None] * Q
inf = 10 ** 19 + 5
D = [inf, -inf]
for i in range(Q):
query[i] = list(map(int, input().split()))
D.append(query[i][1])
D, iv, vi = compress(D)
SS = SortedSet()
SS.add(inf)
SS.add(-inf)
N = len(iv) + 1
seen = [0] * N
Tn, Ts = Fenwick_Tree(N), Fenwick_Tree(N)
Tn.add(0, 1)
Tn.add(N-1, 1)
seen[0] = seen[N - 1] = 1
def BinarySearch(check, yes, no, i):
while abs(yes - no) != 1:
mid = (yes + no)//2
if check(mid, i):
yes = mid
else:
no = mid
return yes
def check(m, i):
mi = min(m, i)
ma = max(m, i)
return Tn.sum(mi, ma) == Ts.sum(mi, ma)
for f, x in query:
ix = vi[x]
if f == 1:
if seen[ix] == 0:
r = SS.gt(x)
l = SS.lt(x)
il = vi[l]
Ts.add(il, -Ts.sum(il, il+1))
if x - l <= K:
Ts.add(il, 1)
if r - x <= K:
Ts.add(ix, 1)
Tn.add(ix, 1)
SS.add(x)
else:
r = SS.gt(x)
l = SS.lt(x)
il = vi[l]
Ts.add(il, -Ts.sum(il, il+1))
Ts.add(ix, -Ts.sum(ix, ix+1))
if r - l <= K:
Ts.add(il, 1)
Tn.add(ix, -1)
SS.discard(x)
seen[ix] ^= 1
else:
r = BinarySearch(check, ix, N, ix)
l = BinarySearch(check, ix, 0, ix)
print(Tn.sum(l, r) + 1)
|
ConDefects/ConDefects/Code/abc356_f/Python/54486041
|
condefects-python_data_793
|
from functools import lru_cache
from math import inf, ceil
def read_ints():
return [int(x) for x in input().split(' ')]
def slv():
s=input()
K=int(input())
n=len(s)
@lru_cache(None)
def dfs(i,j):
if j<i:return 0
if j==i:return 1
res=j-i+1
if s[i]=='o':
for x in range(i+1,j+1):
if s[x]=='f' and dfs(i+1,x-1)==0:
res=min(res,dfs(min(x+K+1,j+1),j))
for x in range(i+1,j+1):
if s[x]=='o':
res=min(res,x-i+dfs(x,j))
return res
print(dfs(0,n-1))
T = 1
for _ in range(T):
slv()
from functools import lru_cache
from math import inf, ceil
def read_ints():
return [int(x) for x in input().split(' ')]
def slv():
s=input()
K=int(input())
n=len(s)
@lru_cache(None)
def dfs(i,j):
if j<i:return 0
if j==i:return 1
res=j-i+1
if s[i]=='o':
for x in range(i+1,j+1):
if s[x]=='f' and dfs(i+1,x-1)==0:
res=min(res,max(0,dfs(x+1,j)-K))
for x in range(i+1,j+1):
if s[x]=='o':
res=min(res,x-i+dfs(x,j))
return res
print(dfs(0,n-1))
T = 1
for _ in range(T):
slv()
|
ConDefects/ConDefects/Code/abc325_g/Python/46914169
|
condefects-python_data_794
|
s = input()
k = int(input())
n = len(s)
dp = [[0] * (n + 1) for _ in range(n + 1)]
for length in range(1, n + 1):
for l in range(n - length + 1):
r = l + length
mi = length
for mid in range(l + 1, r):
mi = min(mi, dp[l][mid] + dp[mid][r])
if s[l] == 'o':
for mid in range(l + 1, r):
if s[mid] == 'f' and dp[l + 1][mid] == 0:
mi = min(mi, dp[l + 1][mid] + dp[min(r, mid + k + 1)][r])
dp[l][r] = mi
print(dp[0][n])
s = input()
k = int(input())
n = len(s)
dp = [[0] * (n + 1) for _ in range(n + 1)]
for length in range(1, n + 1):
for l in range(n - length + 1):
r = l + length
mi = length
for mid in range(l + 1, r):
mi = min(mi, dp[l][mid] + dp[mid][r])
if s[l] == 'o':
for mid in range(l + 1, r):
if s[mid] == 'f' and dp[l + 1][mid] == 0:
mi = min(mi, dp[l + 1][mid] + max(0, dp[mid + 1][r] - k))
dp[l][r] = mi
print(dp[0][n])
|
ConDefects/ConDefects/Code/abc325_g/Python/47132370
|
condefects-python_data_795
|
s=input()
n=len(s)
x=int(input())
q=[[0]*n for i in range(n)]
for i in range(1,n+1):
for j in range(n):
l=j
r=j+i-1
if not (0<=l<=r<n):
break
q[l][r]=r-l+1
for k in range(l,r):
q[l][r]=min(q[l][r],q[l][k]+q[k+1][r])
if s[l]=="o":
for k in range(l+1,r+1):
if s[k]=="f" and q[l+1][k-1]==0:
if k+x<r:
q[l][r]=min(q[l][r],q[k+1+x][r])
else:
q[l][r]=0
print(q[0][n-1])
s=input()
n=len(s)
x=int(input())
q=[[0]*n for i in range(n)]
for i in range(1,n+1):
for j in range(n):
l=j
r=j+i-1
if not (0<=l<=r<n):
break
q[l][r]=r-l+1
for k in range(l,r):
q[l][r]=min(q[l][r],q[l][k]+q[k+1][r])
if s[l]=="o":
for k in range(l+1,r+1):
if s[k]=="f" and q[l+1][k-1]==0:
if k+x<r:
q[l][r]=min(q[l][r],max(q[k+1][r]-x,0))
else:
q[l][r]=0
print(q[0][n-1])
|
ConDefects/ConDefects/Code/abc325_g/Python/46924310
|
condefects-python_data_796
|
t=int(input())
for i in range(t):
a,b,c=map(int,input().split())
p=(a+b+c)/3
if p.is_integer():
d=(abs(a-p)+abs(b-p)+abs(c-p))//4
print(int(d))
else:
print(-1)
t=int(input())
for i in range(t):
a,b,c=map(int,input().split())
p=(a+b+c)/3
if p.is_integer() and (a-b)%2==0 and (b-c)%2==0 and (c-a)%2==0:
d=(abs(a-p)+abs(b-p)+abs(c-p))//4
print(int(d))
else:
print(-1)
|
ConDefects/ConDefects/Code/arc158_a/Python/43732374
|
condefects-python_data_797
|
T = int(input())
for i in range(T):
x1,x2,x3 = map(int,input().split())
#a > b > c
a = max(x1,x2,x3)
c = min(x1,x2,x3)
b = x1+x2+x3-a-c
if not(a % 6 == b % 6 == c % 6):
print(-1)
continue
ans = 0
if a - b > b - c:
ans = (b - c) // 2
else:
ans = (a - b) // 2
a = a + ans * 3
b = b + ans * 5
c = c + ans * 7
if b == a:
ans = ans + (b - c) // 6 * 2
if b == c:
ans = ans + (a - b) // 6 * 2
print(ans)
T = int(input())
for i in range(T):
x1,x2,x3 = map(int,input().split())
#a > b > c
a = max(x1,x2,x3)
c = min(x1,x2,x3)
b = x1+x2+x3-a-c
if not( (a+b+c)%3==0 and a%2==b%2==c%2):
print(-1)
continue
ans = 0
if a - b > b - c:
ans = (b - c) // 2
else:
ans = (a - b) // 2
a = a + ans * 3
b = b + ans * 5
c = c + ans * 7
if b == a:
ans = ans + (b - c) // 6 * 2
if b == c:
ans = ans + (a - b) // 6 * 2
print(ans)
|
ConDefects/ConDefects/Code/arc158_a/Python/45550808
|
condefects-python_data_798
|
T = int(input())
for i in range(T):
x1, x2, x3 = map(int, input().split())
S = x1+x2+x3
if S % 3 == 0:
D = abs(S//3-x1) + abs(S//3-x2) + abs(S//3-x3)
print(D//4)
else:
print(-1)
T = int(input())
for i in range(T):
x1, x2, x3 = map(int, input().split())
S = x1+x2+x3
if S % 3 == 0 and S % 2 == x1 % 2 == x2 % 2 == x3 % 2:
D = abs(S//3-x1) + abs(S//3-x2) + abs(S//3-x3)
print(D//4)
else:
print(-1)
|
ConDefects/ConDefects/Code/arc158_a/Python/43216127
|
condefects-python_data_799
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def solve(L):
if sum(L) % 3:
return -1
num = sum(L) // 3
tmp1 = 0
tmp2 = 0
for x in L:
if x - num < 0:
tmp1 += (num - x) // 2
else:
tmp2 += (x - num) // 2
return tmp1
T = int(readline())
for _ in range(T):
L = list(map(int, readline().split()))
ans = solve(L)
print(ans)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def solve(L):
if sum(L) % 3:
return -1
num = sum(L) // 3
tmp1 = 0
tmp2 = 0
for x in L:
if abs(num - x) % 2:
return -1
if x - num < 0:
tmp1 += (num - x) // 2
else:
tmp2 += (x - num) // 2
return tmp1
T = int(readline())
for _ in range(T):
L = list(map(int, readline().split()))
ans = solve(L)
print(ans)
|
ConDefects/ConDefects/Code/arc158_a/Python/42775332
|
condefects-python_data_800
|
def solve():
n,x,k = list(map(int, input().split(' ')))
# print(n,x,k)
n += 1
k = min(100,k)
ans = 0
depth = k
prev = -1
while x and depth >= 0:
# print(f'{x=} {depth=} {prev=}')
if prev == -1:
L = x*(1<<depth)
R = L + (1<<depth)
else:
if depth == 0:
L = x
R = x+1
else:
another_way = prev^1
# print(f'{another_way=}')
L = another_way*(1<<(depth-1))
R = L + (1<<(depth-1))
# print(L,R)
intersection = max(0,min(R,n)-max(0,L))
# print(f'{intersection=}')
ans += intersection
prev = x
x //= 2
depth -= 1
# print(f'{ans=}')
return ans
t = int(input())
for _ in range(t):
print(solve())
def solve():
n,x,k = list(map(int, input().split(' ')))
# print(n,x,k)
n += 1
k = min(1000,k)
ans = 0
depth = k
prev = -1
while x and depth >= 0:
# print(f'{x=} {depth=} {prev=}')
if prev == -1:
L = x*(1<<depth)
R = L + (1<<depth)
else:
if depth == 0:
L = x
R = x+1
else:
another_way = prev^1
# print(f'{another_way=}')
L = another_way*(1<<(depth-1))
R = L + (1<<(depth-1))
# print(L,R)
intersection = max(0,min(R,n)-max(0,L))
# print(f'{intersection=}')
ans += intersection
prev = x
x //= 2
depth -= 1
# print(f'{ans=}')
return ans
t = int(input())
for _ in range(t):
print(solve())
|
ConDefects/ConDefects/Code/abc321_e/Python/54658079
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.