id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_1301
|
s = input()
row = [1]*7
if s[0]=='1':
print('No')
else:
if s[6]=='0':
row[0]=0
if s[3]=='0':
row[1]=0
if s[1]=='0' and s[7]=='0':
row[2]=0
if s[4]=='0':
row[3]=0
if s[2]=='0' and s[8]=='0':
row[4]=0
if s[5]=='0':
row[5]=0
if s[9]=='0':
row[6]=0
f_s, e_s=None, None
for i in range(7):
if row[i]==1:
f_s = i
break
for i in reversed(range(7)):
if row[i]==1:
e_s = i
break
if f_s and e_s and any(row[i]==0 for i in range(f_s, e_s)):
print('Yes')
else:
print('No')
s = input()
row = [1]*7
if s[0]=='1':
print('No')
else:
if s[6]=='0':
row[0]=0
if s[3]=='0':
row[1]=0
if s[1]=='0' and s[7]=='0':
row[2]=0
if s[4]=='0':
row[3]=0
if s[2]=='0' and s[8]=='0':
row[4]=0
if s[5]=='0':
row[5]=0
if s[9]=='0':
row[6]=0
f_s, e_s=None, None
for i in range(7):
if row[i]==1:
f_s = i
break
for i in reversed(range(7)):
if row[i]==1:
e_s = i
break
if f_s!=None and e_s!=None and any(row[i]==0 for i in range(f_s, e_s)):
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc267_b/Python/45233540
|
condefects-python_data_1302
|
S = list(map(int, input()))
if S[0]:
exit(print("No"))
column = [S[6], S[3], S[1] | S[8], S[0] | S[4], S[2] | S[8], S[5], S[9]]
for i in range(7):
for j in range(i + 1, 7):
for k in range(j + 1, 7):
if column[i] and not column[j] and column[k]:
exit(print("Yes"))
print("No")
S = list(map(int, input()))
if S[0]:
exit(print("No"))
column = [S[6], S[3], S[1] | S[7], S[0] | S[4], S[2] | S[8], S[5], S[9]]
for i in range(7):
for j in range(i + 1, 7):
for k in range(j + 1, 7):
if column[i] and not column[j] and column[k]:
exit(print("Yes"))
print("No")
|
ConDefects/ConDefects/Code/abc267_b/Python/45086999
|
condefects-python_data_1303
|
import sys
S=list(input())
L=[0,0,0,0,0,0,0]
for i in range(10):
if S[i]=="1":
if i+1 in [1,5]:
L[3]=1
if i+1 in [2,8]:
L[2]=1
if i+1 in [3,9]:
L[4]=1
if i+1==4:
L[1]=1
if i+1==6:
L[5]=1
if i+1==7:
L[0]=1
if i+1==10:
L[6]=1
if S[0]==1:
print("No")
sys.exit()
flag=0
for i in range(7):
if flag==0 and L[i]==1:
flag=1
if flag==1 and L[i]==0:
flag=2
if flag==2 and L[i]==1:
flag=3
if flag==3:
print("Yes")
else:
print("No")
import sys
S=list(input())
L=[0,0,0,0,0,0,0]
for i in range(10):
if S[i]=="1":
if i+1 in [1,5]:
L[3]=1
if i+1 in [2,8]:
L[2]=1
if i+1 in [3,9]:
L[4]=1
if i+1==4:
L[1]=1
if i+1==6:
L[5]=1
if i+1==7:
L[0]=1
if i+1==10:
L[6]=1
if S[0]=="1":
print("No")
sys.exit()
flag=0
for i in range(7):
if flag==0 and L[i]==1:
flag=1
if flag==1 and L[i]==0:
flag=2
if flag==2 and L[i]==1:
flag=3
if flag==3:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc267_b/Python/45974485
|
condefects-python_data_1304
|
def solve(h, w, m, t, a, x):
a = [_-1 for _ in a]
cnt = {color: 0 for color in x} # 色ごとの塗られたマスの個数
S_row = set() # すでに塗られた行の集合
S_col = set() # すでに塗られた列の集合
# 逆順に塗られたマスの数を調べていく
for k in range(m-1, -1, -1):
if t[k] == 1: # a[k]列目のマスを色x[k]で塗る
if not a[k] in S_row:
S_row.add(a[k])
cnt[x[k]] += w - len(S_col)
else: # a[k]行目のマスを色x[k]で塗る
if not a[k] in S_col:
S_col.add(a[k])
cnt[x[k]] += h - len(S_row)
cnt[0] = h * w - sum(cnt.values())
return {color: num for color, num in cnt.items() if num > 0}
h, w, m = map(int, input().split())
t, a, x = zip(*[map(int, input().split()) for i in range(m)])
color_num_mapping = solve(h, w, m, t, a, x)
print(len(color_num_mapping))
for color, num in sorted(color_num_mapping.items()):
print(color, num)
def solve(h, w, m, t, a, x):
a = [_-1 for _ in a]
cnt = {color: 0 for color in x} # 色ごとの塗られたマスの個数
S_row = set() # すでに塗られた行の集合
S_col = set() # すでに塗られた列の集合
# 逆順に塗られたマスの数を調べていく
for k in range(m-1, -1, -1):
if t[k] == 1: # a[k]列目のマスを色x[k]で塗る
if not a[k] in S_row:
S_row.add(a[k])
cnt[x[k]] += w - len(S_col)
else: # a[k]行目のマスを色x[k]で塗る
if not a[k] in S_col:
S_col.add(a[k])
cnt[x[k]] += h - len(S_row)
cnt[0] = h * w - sum(num for color, num in cnt.items() if color != 0)
return {color: num for color, num in cnt.items() if num > 0}
h, w, m = map(int, input().split())
t, a, x = zip(*[map(int, input().split()) for i in range(m)])
color_num_mapping = solve(h, w, m, t, a, x)
print(len(color_num_mapping))
for color, num in sorted(color_num_mapping.items()):
print(color, num)
|
ConDefects/ConDefects/Code/abc346_e/Python/52762677
|
condefects-python_data_1305
|
import sys
stdin = sys.stdin.readline
stdout = sys.stdout.write
MOD = 10 ** 9 + 7
INF = float("inf")
def next_int(): return int(stdin().strip())
def next_float(): return float(stdin().strip())
def next_array(): return list(map(int, stdin().split()))
def next_string(): return stdin().strip()
def solve():
h, w, m = next_array()
count = [0] * 200001
count[0] = h * w
ops = []
for i in range(m):
t, a, x = next_array()
ops.append([t, a-1, x])
r = h
c = w
row_visited = [False] * h
col_visited = [False] * w
for i in range(m - 1, -1, -1):
t, a, x = ops[i]
if t == 1:
if not row_visited[a]:
row_visited[a] = True
count[0] -= c
count[x] += c
r -= 1
else:
if not col_visited[a]:
col_visited[a] = True
count[0] -= r
count[x] += r
c -= 1
res = []
for i in range(200000):
if count[i] > 0:
res.append([str(i), str(count[i])])
print(len(res))
for p in res:
print(" ".join(p))
if __name__ == "__main__":
total_num_tests = 1
for test_index in range(0, total_num_tests):
solve()
import sys
stdin = sys.stdin.readline
stdout = sys.stdout.write
MOD = 10 ** 9 + 7
INF = float("inf")
def next_int(): return int(stdin().strip())
def next_float(): return float(stdin().strip())
def next_array(): return list(map(int, stdin().split()))
def next_string(): return stdin().strip()
def solve():
h, w, m = next_array()
count = [0] * 200001
count[0] = h * w
ops = []
for i in range(m):
t, a, x = next_array()
ops.append([t, a-1, x])
r = h
c = w
row_visited = [False] * h
col_visited = [False] * w
for i in range(m - 1, -1, -1):
t, a, x = ops[i]
if t == 1:
if not row_visited[a]:
row_visited[a] = True
count[0] -= c
count[x] += c
r -= 1
else:
if not col_visited[a]:
col_visited[a] = True
count[0] -= r
count[x] += r
c -= 1
res = []
for i in range(200001):
if count[i] > 0:
res.append([str(i), str(count[i])])
print(len(res))
for p in res:
print(" ".join(p))
if __name__ == "__main__":
total_num_tests = 1
for test_index in range(0, total_num_tests):
solve()
|
ConDefects/ConDefects/Code/abc346_e/Python/54144246
|
condefects-python_data_1306
|
from sys import stdin
input=lambda :stdin.readline()[:-1]
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 collections import defaultdict
import bisect
mod=998244353
def fpow(x,k):
res=1
while k:
if k&1:
res=res*x%mod
x=x*x%mod
k>>=1
return res
n,m,q=map(int,input().split())
query=defaultdict(list)
s=set()
for _ in range(q):
l,r,x=map(int,input().split())
query[x].append((l-1,r-1))
s.add(x)
s=sorted(list(s))
S=SortedSet(list(range(n)))
ans=1
for i in s:
idx=[]
for l,r in query[i]:
while S.ge(l)!=None and S.ge(l)<=r:
j=S.ge(l)
idx.append(j)
S.discard(j)
idx.sort()
N=len(idx)
task=[[] for i in range(N)]
for l,r in query[i]:
L=bisect.bisect_left(idx,l)
R=bisect.bisect_right(idx,r)
if R==0:
print(0)
exit()
task[R-1].append(L)
dp=[0]*(N+1)
dp[0]=1
res=1
L=0
inv=fpow(i,mod-2)
for j in range(N):
dp[j+1]=res*inv%mod
res+=res*inv
res%=mod
for l in task[j]:
while L<=l:
res-=dp[L]
L+=1
ans*=res*fpow(i,N)
ans%=mod
print(ans)
from sys import stdin
input=lambda :stdin.readline()[:-1]
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 collections import defaultdict
import bisect
mod=998244353
def fpow(x,k):
res=1
while k:
if k&1:
res=res*x%mod
x=x*x%mod
k>>=1
return res
n,m,q=map(int,input().split())
query=defaultdict(list)
s=set()
for _ in range(q):
l,r,x=map(int,input().split())
query[x].append((l-1,r-1))
s.add(x)
s=sorted(list(s))
S=SortedSet(list(range(n)))
ans=1
for i in s:
idx=[]
for l,r in query[i]:
while S.ge(l)!=None and S.ge(l)<=r:
j=S.ge(l)
idx.append(j)
S.discard(j)
idx.sort()
N=len(idx)
task=[[] for i in range(N)]
for l,r in query[i]:
L=bisect.bisect_left(idx,l)
R=bisect.bisect_right(idx,r)
if R==0:
print(0)
exit()
task[R-1].append(L)
dp=[0]*(N+1)
dp[0]=1
res=1
L=0
inv=fpow(i,mod-2)
for j in range(N):
dp[j+1]=res*inv%mod
res+=res*inv
res%=mod
for l in task[j]:
while L<=l:
res-=dp[L]
L+=1
ans*=res*fpow(i,N)
ans%=mod
ans*=fpow(m+1,len(S))
ans%=mod
print(ans)
|
ConDefects/ConDefects/Code/abc262_h/Python/40953311
|
condefects-python_data_1307
|
import sys
input = sys.stdin.readline
from operator import itemgetter
N,M,Q=map(int,input().split())
LRX=[list(map(int,input().split())) for i in range(Q)]
mod=998244353
seg_el=1<<((N+1).bit_length()) # Segment treeの台の要素数
SEG=[M]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def getvalue(n,seg_el): # 一点の値を取得
i=n+seg_el
ANS=1<<40
ANS=min(SEG[i],ANS)
i>>=1# 子ノードへ
while i!=0:
ANS=min(SEG[i],ANS)
i>>=1
return ANS
def updates(l,r,x): # 区間[l,r)のminを更新.
L=l+seg_el
R=r+seg_el
while L<R:
if L & 1:
SEG[L]=min(x,SEG[L])
L+=1
if R & 1:
R-=1
SEG[R]=min(x,SEG[R])
L>>=1
R>>=1
XLIST=[M]
for l,r,x in LRX:
updates(l,r+1,x)
XLIST.append(x)
XLIST=sorted(set(XLIST))
DICT={XLIST[i]:i for i in range(len(XLIST))}
ANS=1
LIST=[[] for i in range(len(XLIST))]
for i in range(1,N+1):
a=getvalue(i,seg_el)
LIST[DICT[a]].append(i)
LR=[[] for i in range(len(XLIST))]
for l,r,x in LRX:
LR[DICT[x]].append([l,r])
for i in range(len(XLIST)):
x=XLIST[i]
INV=pow(x,mod-2,mod)
if len(LIST[i])==0 and len(LR[i])>0:
ANS=0
continue
LR[i].sort(key=itemgetter(1))
DP=[1]*(len(LIST[i])+1)
TOTAL=1
ind=0
MINMAX=0
for j in range(len(LIST[i])):
while ind<len(LR[i]):
if j+1<len(LIST[i]) and LR[i][ind][1]<LIST[i][j+1]:
if MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
while MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
TOTAL-=DP[MINMAX]
MINMAX+=1
ind+=1
else:
break
#print(j,ind)
DP[j+1]=TOTAL*INV%mod
TOTAL+=DP[j+1]
while ind<len(LR[i]):
if MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
while MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
TOTAL-=DP[MINMAX]
MINMAX+=1
ind+=1
#print(TOTAL*pow(x,len(LIST[i]),mod)%mod)
ANS=ANS*TOTAL*pow(x,len(LIST[i]),mod)%mod
print(ANS%mod)
import sys
input = sys.stdin.readline
from operator import itemgetter
N,M,Q=map(int,input().split())
LRX=[list(map(int,input().split())) for i in range(Q)]
mod=998244353
seg_el=1<<((N+1).bit_length()) # Segment treeの台の要素数
SEG=[M]*(2*seg_el) # 1-indexedなので、要素数2*seg_el.Segment treeの初期値で初期化
def getvalue(n,seg_el): # 一点の値を取得
i=n+seg_el
ANS=1<<40
ANS=min(SEG[i],ANS)
i>>=1# 子ノードへ
while i!=0:
ANS=min(SEG[i],ANS)
i>>=1
return ANS
def updates(l,r,x): # 区間[l,r)のminを更新.
L=l+seg_el
R=r+seg_el
while L<R:
if L & 1:
SEG[L]=min(x,SEG[L])
L+=1
if R & 1:
R-=1
SEG[R]=min(x,SEG[R])
L>>=1
R>>=1
XLIST=[M]
for l,r,x in LRX:
updates(l,r+1,x)
XLIST.append(x)
XLIST=sorted(set(XLIST))
DICT={XLIST[i]:i for i in range(len(XLIST))}
ANS=1
LIST=[[] for i in range(len(XLIST))]
for i in range(1,N+1):
a=getvalue(i,seg_el)
LIST[DICT[a]].append(i)
LR=[[] for i in range(len(XLIST))]
for l,r,x in LRX:
LR[DICT[x]].append([l,r])
for i in range(len(XLIST)):
x=XLIST[i]
INV=pow(x,mod-2,mod)
if len(LIST[i])==0 and len(LR[i])>0:
ANS=0
continue
LR[i].sort(key=itemgetter(1))
DP=[1]*(len(LIST[i])+1)
TOTAL=1
ind=0
MINMAX=0
for j in range(len(LIST[i])):
while ind<len(LR[i]):
if j<len(LIST[i]) and LR[i][ind][1]<LIST[i][j]:
if MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
while MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
TOTAL-=DP[MINMAX]
MINMAX+=1
ind+=1
else:
break
#print(j,ind)
DP[j+1]=TOTAL*INV%mod
TOTAL+=DP[j+1]
while ind<len(LR[i]):
if MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
while MINMAX==0 or LIST[i][MINMAX-1]<LR[i][ind][0]:
TOTAL-=DP[MINMAX]
MINMAX+=1
ind+=1
#print(TOTAL*pow(x,len(LIST[i]),mod)%mod)
ANS=ANS*TOTAL*pow(x,len(LIST[i]),mod)%mod
print(ANS%mod)
|
ConDefects/ConDefects/Code/abc262_h/Python/37417222
|
condefects-python_data_1308
|
import math
n,m,k = (int(x) for x in input().split())
l = math.lcm(n,m)
low,high = 0,10**8
while high-low>1:
mid = (low+high)//2
if mid//n+mid//m-2*(mid//l) < k:
low = mid
else: high = mid
print(high)
import math
n,m,k = (int(x) for x in input().split())
l = math.lcm(n,m)
low,high = 0,10**18
while high-low>1:
mid = (low+high)//2
if mid//n+mid//m-2*(mid//l) < k:
low = mid
else: high = mid
print(high)
|
ConDefects/ConDefects/Code/abc341_d/Python/53726659
|
condefects-python_data_1309
|
import math
n,m,k=map(int,input().split())
q=(n*m)/math.gcd(n,m)
min=1
max=int(2e18)
while (max-min)>1:
x=(max+min)//2
if x//n + x//m - x//q*2 >= k:
max = x
else:
min = x
print(max)
import math
n,m,k=map(int,input().split())
q=(n*m)/math.gcd(n,m)
min=0
max=int(2e18)
while (max-min)>1:
x=(max+min)//2
if x//n + x//m - x//q*2 >= k:
max = x
else:
min = x
print(max)
|
ConDefects/ConDefects/Code/abc341_d/Python/54740423
|
condefects-python_data_1310
|
from math import lcm
def count_divisible_by_either(x, n, m):
cnt_n = x // n
cnt_m = x // m
cnt_d = x // lcm(n, m)
return cnt_n + cnt_m - cnt_d * 2
n, m, k = map(int, input().split())
l = 1
r = 10**18
while r - l > 1:
mid = (l + r) // 2
cnt = count_divisible_by_either(mid, n, m)
# print(l, r, mid, cnt)
if cnt >= k:
r = mid
else:
l = mid
print(r)
from math import lcm
def count_divisible_by_either(x, n, m):
cnt_n = x // n
cnt_m = x // m
cnt_d = x // lcm(n, m)
return cnt_n + cnt_m - cnt_d * 2
n, m, k = map(int, input().split())
l = 0
r = 10**18
while r - l > 1:
mid = (l + r) // 2
cnt = count_divisible_by_either(mid, n, m)
# print(l, r, mid, cnt)
if cnt >= k:
r = mid
else:
l = mid
print(r)
|
ConDefects/ConDefects/Code/abc341_d/Python/53927639
|
condefects-python_data_1311
|
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print(l, file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
big = 500000002500000000 + 10
n, m, kn = gl()
nm = lcm2(n, m)
def f(v):
return v // n + v // m - 2 * (v // nm)
ok = 0
ng = big
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid) <= kn - 1:
ok = mid
else:
ng = mid
print(ok + 1)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print(l, file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
big = 500000002500000000 * 100
n, m, kn = gl()
nm = lcm2(n, m)
def f(v):
return v // n + v // m - 2 * (v // nm)
ok = 0
ng = big
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid) <= kn - 1:
ok = mid
else:
ng = mid
print(ok + 1)
|
ConDefects/ConDefects/Code/abc341_d/Python/53931924
|
condefects-python_data_1312
|
import numpy as np
import scipy.optimize
n, m = map(int, input().split())
ab = [tuple(map(int, input().split())) for _ in range(n)]
xy = [(x-1, y-1) for _ in range(m) for x, y in [map(int, input().split())]]
for x, y in xy:
if x == y:
ab[x] = (max(ab[x]), min(ab[x]))
basis = sum(a for a, b in ab)
c = np.array([-(b-a)/2 for a, b in ab])
A_ub = np.eye(n)
b_ub = np.zeros([n])
for x, y in xy:
if x != y:
A_ub[x, y] = -1
A_ub[y, x] = -1
lp = scipy.optimize.linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(0, 1))
print(basis - c@lp.x)
import numpy as np
import scipy.optimize
n, m = map(int, input().split())
ab = [tuple(map(int, input().split())) for _ in range(n)]
xy = [(x-1, y-1) for _ in range(m) for x, y in [map(int, input().split())]]
for x, y in xy:
if x == y:
ab[x] = (max(ab[x]), min(ab[x]))
basis = sum(a for a, b in ab)
c = np.array([-(b-a)/2 for a, b in ab])
A_ub = np.eye(n)
b_ub = np.zeros([n])
for x, y in xy:
if x != y:
A_ub[x, y] = -1
A_ub[y, x] = -1
lp = scipy.optimize.linprog(c, A_ub=A_ub, b_ub=b_ub, bounds=(0, 1), integrality=1)
print(basis - c@lp.x)
|
ConDefects/ConDefects/Code/abc313_f/Python/45736506
|
condefects-python_data_1313
|
N = int(input())
A, B, C, D = 1, N, 1, N
count = N - 1
while B - A > 0:
M = (A + B) // 2
print(*["?", A, M, 1, N])
print("\n")
a = int(input())
if a <= count // 2:
B = M
count = a
else:
A = M + 1
count -= a
count = N - 1
while D - C > 0:
M = (C + D) // 2
print(*["?", 1, N, C, M])
print("\n")
a = int(input())
if a <= count // 2:
D = M
count = a
else:
C = M + 1
count -= a
print(*["!", A, D])
N = int(input())
A, B, C, D = 1, N, 1, N
count = N - 1
while B - A > 0:
M = (A + B) // 2
print(*["?", A, M, 1, N])
a = int(input())
if a <= count // 2:
B = M
count = a
else:
A = M + 1
count -= a
count = N - 1
while D - C > 0:
M = (C + D) // 2
print(*["?", 1, N, C, M])
a = int(input())
if a <= count // 2:
D = M
count = a
else:
C = M + 1
count -= a
print(*["!", A, D])
|
ConDefects/ConDefects/Code/abc269_e/Python/45055935
|
condefects-python_data_1314
|
# +-----------+--------------------------------------------------------------+
# | main | |
# +-----------+--------------------------------------------------------------+
def main():
global N
N = int(input())
x = query(0, N, axis=0)
x += 1
y = query(0, N, axis=1)
y += 1
print(x, y)
return
def query(lo, hi, axis):
while hi - lo > 1:
mi = (lo + hi) >> 1
abcd = [0, N, 0, N]
abcd[axis*2:axis*2+2] = [lo, mi]
abcd[0] += 1 # 1-index3
abcd[2] += 1 # 1-index
print('?', *abcd, flush=True)
T = int(input())
if T == mi-lo:
lo = mi
else:
hi = mi
return lo
# +-----------+--------------------------------------------------------------+
# | library | See Also : https://github.com/nodashin6/atcoder |
# +-----------+--------------------------------------------------------------+
# +-----------+--------------------------------------------------------------+
# | other | |
# +-----------+--------------------------------------------------------------+
import sys
input = lambda: sys.stdin.readline().rstrip()
__print = lambda *args, **kwargs: print(*args, **kwargs) if __debug else None
if __name__ == '__main__':
# for test on local PC
try:
# __file = open('./input.txt')
# input = lambda: __file.readline().rstrip()
__debug = True
except:
__debug = False
main()
# +-----------+--------------------------------------------------------------+
# | main | |
# +-----------+--------------------------------------------------------------+
def main():
global N
N = int(input())
x = query(0, N, axis=0)
x += 1
y = query(0, N, axis=1)
y += 1
print(f'! {x} {y}')
return
def query(lo, hi, axis):
while hi - lo > 1:
mi = (lo + hi) >> 1
abcd = [0, N, 0, N]
abcd[axis*2:axis*2+2] = [lo, mi]
abcd[0] += 1 # 1-index3
abcd[2] += 1 # 1-index
print('?', *abcd, flush=True)
T = int(input())
if T == mi-lo:
lo = mi
else:
hi = mi
return lo
# +-----------+--------------------------------------------------------------+
# | library | See Also : https://github.com/nodashin6/atcoder |
# +-----------+--------------------------------------------------------------+
# +-----------+--------------------------------------------------------------+
# | other | |
# +-----------+--------------------------------------------------------------+
import sys
input = lambda: sys.stdin.readline().rstrip()
__print = lambda *args, **kwargs: print(*args, **kwargs) if __debug else None
if __name__ == '__main__':
# for test on local PC
try:
# __file = open('./input.txt')
# input = lambda: __file.readline().rstrip()
__debug = True
except:
__debug = False
main()
|
ConDefects/ConDefects/Code/abc269_e/Python/45214207
|
condefects-python_data_1315
|
k = list(map(int, input().split()))
mod = 998244353
abc = (k[0]%mod)*(k[1]%mod)*(k[2]%mod)
deg = (k[3]%mod)*(k[4]%mod)*(k[5]%mod)
print((abc%mod)-(deg%mod))
k = list(map(int, input().split()))
mod = 998244353
abc = (k[0]%mod)*(k[1]%mod)*(k[2]%mod)
deg = (k[3]%mod)*(k[4]%mod)*(k[5]%mod)
print(((abc%mod)-(deg%mod))%mod)
|
ConDefects/ConDefects/Code/abc275_b/Python/45102302
|
condefects-python_data_1316
|
import bisect,collections,itertools,math,functools,heapq
import sys
# sys.setrecursionlimit(10**6)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LF(): return list(map(float,sys.stdin.readline().rstrip().split()))
def SI(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
"""
方針
"""
a,b,c,d,e,f=LI()
mod = 998244353
x = a%mod*b%mod*c%mod
y = d%mod*e%mod*f%mod
print(x-y)
import bisect,collections,itertools,math,functools,heapq
import sys
# sys.setrecursionlimit(10**6)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LF(): return list(map(float,sys.stdin.readline().rstrip().split()))
def SI(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
"""
方針
"""
a,b,c,d,e,f=LI()
mod = 998244353
x = a%mod*b%mod*c%mod
y = d%mod*e%mod*f%mod
print((x-y)%mod)
|
ConDefects/ConDefects/Code/abc275_b/Python/45275005
|
condefects-python_data_1317
|
a,b,c,d,e,f=map(int,input().split())
mod=998244353
a1=a%mod*b%mod*c%mod
a2=d%mod*e%mod*f%mod
print(a1-a2)
a,b,c,d,e,f=map(int,input().split())
mod=998244353
a1=a%mod*b%mod*c%mod
a2=d%mod*e%mod*f%mod
print((a1-a2)%mod)
|
ConDefects/ConDefects/Code/abc275_b/Python/44663231
|
condefects-python_data_1318
|
H,W,K = map(int,input().split())
S = [list(input()) for _ in [0]*H]
dic = {".":0,"o":1}
ans = -1
for s in S:
mx = -1
p = 0
leng = 0
for i in range(W):
if s[i] == "x" :
p,leng=0,0
else:
leng += 1
if 0<=leng<=K : p += dic[s[i]]
else :
p += dic[s[i]] - dic[s[i-K]]
if leng >= K and mx < p : mx = p
# print(s,s[i],mx,p,leng)
if ans < mx : ans = mx
S_t = [list(x) for x in zip(*S)]
# print(S)
# print(S_t)
for s in S_t:
mx = -1
p = 0
leng = 0
for i in range(H):
if s[i] == "x" :
p,leng=0,0
else:
leng += 1
if 0<=leng<=K : p += dic[s[i]]
else :
p += dic[s[i]] - dic[s[i-K]]
if mx < p : mx = p
if mx > ans : ans = mx
print(K-ans if ans!=-1 else -1)
H,W,K = map(int,input().split())
S = [list(input()) for _ in [0]*H]
dic = {".":0,"o":1}
ans = -1
for s in S:
mx = -1
p = 0
leng = 0
for i in range(W):
if s[i] == "x" :
p,leng=0,0
else:
leng += 1
if 0<=leng<=K : p += dic[s[i]]
else :
p += dic[s[i]] - dic[s[i-K]]
if leng >= K and mx < p : mx = p
# print(s,s[i],mx,p,leng)
if ans < mx : ans = mx
S_t = [list(x) for x in zip(*S)]
# print(S)
# print(S_t)
for s in S_t:
mx = -1
p = 0
leng = 0
for i in range(H):
if s[i] == "x" :
p,leng=0,0
else:
leng += 1
if 0<=leng<=K : p += dic[s[i]]
else :
p += dic[s[i]] - dic[s[i-K]]
if leng >= K and mx < p : mx = p
if mx > ans : ans = mx
print(K-ans if ans!=-1 else -1)
|
ConDefects/ConDefects/Code/abc337_d/Python/54495605
|
condefects-python_data_1319
|
H, W, K = list(map(int, input().split()))
N = (H+1)*(W+1)
ban = 2*(10**5)
line = [ban]*(2*N)
for h in range(H):
dh = h*(W+1) + N
for w, s in enumerate(input()):
if s == 'o':
line[dh+w] = 0
line[w*(H+1)+h] = 0
if s == '.':
line[dh+w] = 1
line[w*(H+1)+h] = 1
# print(line)
tmp = sum(line[:K])
ans = tmp
for i in range(K, 2*N):
tmp -= line[i-K]
tmp += line[i]
ans = min(ans, tmp)
if ans < ban:
print(ans)
else:
print(-1)
H, W, K = list(map(int, input().split()))
N = (H+1)*(W+1)
ban = 2*(10**5)+1
line = [ban]*(2*N)
for h in range(H):
dh = h*(W+1) + N
for w, s in enumerate(input()):
if s == 'o':
line[dh+w] = 0
line[w*(H+1)+h] = 0
if s == '.':
line[dh+w] = 1
line[w*(H+1)+h] = 1
# print(line)
tmp = sum(line[:K])
ans = tmp
for i in range(K, 2*N):
tmp -= line[i-K]
tmp += line[i]
ans = min(ans, tmp)
if ans < ban:
print(ans)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc337_d/Python/55025649
|
condefects-python_data_1320
|
H,W,K=map(int,input().split())
S=[input() for i in range(H)]
dic=dict({'o':0,'x':1,'.':2})
ans=10**10
for i in range(H):
chk=[0,0,0]
if W<K:
break
for j in range(K):
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for j in range(K,W):
chk[dic[S[i][j-K]]]-=1
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for j in range(W):
chk=[0,0,0]
if H<K:
break
for i in range(K):
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for i in range(K,H):
chk[dic[S[i-K][j]]]-=1
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
print(ans)
H,W,K=map(int,input().split())
S=[input() for i in range(H)]
dic=dict({'o':0,'x':1,'.':2})
ans=10**10
for i in range(H):
chk=[0,0,0]
if W<K:
break
for j in range(K):
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for j in range(K,W):
chk[dic[S[i][j-K]]]-=1
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for j in range(W):
chk=[0,0,0]
if H<K:
break
for i in range(K):
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
for i in range(K,H):
chk[dic[S[i-K][j]]]-=1
chk[dic[S[i][j]]]+=1
if chk[1]==0:
ans=min(ans,chk[2])
print(ans if ans<10**10 else -1)
|
ConDefects/ConDefects/Code/abc337_d/Python/54308671
|
condefects-python_data_1321
|
n, m = map(int, input().split())
for i in range(2**m, 0, -1):
co = bin(i)[2:].zfill(m)
if co.count("1") == n:
print(*[t+1 for t in range(m) if co[t]=="1"])
n, m = map(int, input().split())
for i in range(2**m-1, 0, -1):
co = bin(i)[2:].zfill(m)
if co.count("1") == n:
print(*[t+1 for t in range(m) if co[t]=="1"])
|
ConDefects/ConDefects/Code/abc263_c/Python/44826230
|
condefects-python_data_1322
|
N,M=map(int,input().split())
import itertools
for p in itertools.combinations(range(1,N+1),M):
print(*p)
N,M=map(int,input().split())
import itertools
for p in itertools.combinations(range(1,M+1),N):
print(*p)
|
ConDefects/ConDefects/Code/abc263_c/Python/45092514
|
condefects-python_data_1323
|
n,t=map(int,input().split())
s=[0 for _ in range(n)]
p={}
p[0]=n
for i in range(n):
a,b=map(int,input().split())
a-=1
p[s[a]]-=1
if p[s[a]]==0:
del p[s[a]]
s[a]+=b
if s[a] not in p:
p[s[a]]=0
p[s[a]]+=1
print(len(p))
n,t=map(int,input().split())
s=[0 for _ in range(n)]
p={}
p[0]=n
for i in range(t):
a,b=map(int,input().split())
a-=1
p[s[a]]-=1
if p[s[a]]==0:
del p[s[a]]
s[a]+=b
if s[a] not in p:
p[s[a]]=0
p[s[a]]+=1
print(len(p))
|
ConDefects/ConDefects/Code/abc343_d/Python/54888063
|
condefects-python_data_1324
|
A,M,L,R = map(int,input().split())
x1 = -(-(L-A)//M)
x2 = (R-A)//M
if (L-A)%M == 0:
print(abs(x1-x2)+1)
else:
print(abs(x1-x2))
A,M,L,R = map(int,input().split())
x1 = (L-A)//M
x2 = (R-A)//M
if (L-A)%M == 0:
print(abs(x1-x2)+1)
else:
print(abs(x1-x2))
|
ConDefects/ConDefects/Code/abc334_b/Python/54939914
|
condefects-python_data_1325
|
# coding: utf-8
# Your code here!
MOD = 998244353
from itertools import groupby
N = int(input())
S = input()
last = 1
ans = 0
for key,val in groupby(S):
val = list(val)
key = int(key)
if (key>1 and len(val)>1) or (last>1 and key>1):
break
if key==1:
ans += (last-1)*ans+len(val)
else:
ans += 1
ans %= MOD
last = key
else:
print((ans-1)%MOD)
exit()
print(-1)
# coding: utf-8
# Your code here!
MOD = 998244353
from itertools import groupby
N = int(input())
S = input()
last = 1
ans = 0
for key,val in groupby(S[::-1]):
val = list(val)
key = int(key)
if (key>1 and len(val)>1) or (last>1 and key>1):
break
if key==1:
ans += (last-1)*ans+len(val)
else:
ans += 1
ans %= MOD
last = key
else:
print((ans-1)%MOD)
exit()
print(-1)
|
ConDefects/ConDefects/Code/abc313_e/Python/45766127
|
condefects-python_data_1326
|
S = input()
T = input()
g1 = ["AB", "BC", "CD", "DE", "EA"]
if S in g1 and T in g1:
print("Yes")
elif S not in g1 and T not in g1:
print("Yes")
else:
print("No")
S = input()
T = input()
g1 = ["AB","BA", "BC", "CB", "CD", "DC", "DE", "ED", "EA", "AE"]
if S in g1 and T in g1:
print("Yes")
elif S not in g1 and T not in g1:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc333_b/Python/54528600
|
condefects-python_data_1327
|
s = input()
s1 = s[0]
s2 = s[1]
t = input()
t1 = t[0]
t2 = t[1]
if s1 == 'A' and s2 == 'C':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'C' and s2 == 'A':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'A' and s2 == 'D':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'A':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'E' and s2 == 'B':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'B' and s2 == 'E':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'B' and s2 == 'D':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'B':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'E' and s2 == 'C':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'C' and s2 == 'E':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'E':
if t1 == 'D' and t2 == 'E' and t1 == 'E' and t2 == 'D':
print("Yes")
else:
print("No")
elif s1 == 'A' and s2 == 'E':
if t1 == 'B' and t2 == 'C' or t1 == 'C' and t2 == 'B':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'C':
if t1 == 'A' and t2 == 'E' or t1 == 'E' and t2 == 'A':
print("Yes")
else:
print("No")
else:
print("No")
s = input()
s1 = s[0]
s2 = s[1]
t = input()
t1 = t[0]
t2 = t[1]
if s1 == 'A' and s2 == 'C':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'C' and s2 == 'A':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'A' and s2 == 'D':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'A':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'E' and s2 == 'B':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'B' and s2 == 'E':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'B' and s2 == 'D':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'B':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'E' and s2 == 'C':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'C' and s2 == 'E':
if t1 == 'E' and t2 == 'B' or t1 == 'B' and t2 == 'E' or t1 == 'D' and t2 == 'B' or t1 == 'B' and t2 == 'D' or t1 == 'A' and t2 == 'D' or t1 == 'D' and t2 == 'A' or t1 == 'E' and t2 == 'C' or t1 == 'C' and t2 == 'E' or t1 == 'A' and t2 == 'C' or t1 == 'C' and t2 == 'A':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'E':
if t1 == 'D' and t2 == 'E' or t1 == 'E' and t2 == 'D':
print("Yes")
else:
print("No")
elif s1 == 'A' and s2 == 'E':
if t1 == 'B' and t2 == 'C' or t1 == 'C' and t2 == 'B':
print("Yes")
else:
print("No")
elif s1 == 'D' and s2 == 'C':
if t1 == 'A' and t2 == 'E' or t1 == 'E' and t2 == 'A':
print("Yes")
else:
print("No")
else:
print("No")
|
ConDefects/ConDefects/Code/abc333_b/Python/54467069
|
condefects-python_data_1328
|
K = "ABCDEABCDE"
S = input()
T = input()
if (S in K) == (T in K):
print("Yes")
else:
print("No")
K = "ABCDEAEDCBA"
S = input()
T = input()
if (S in K) == (T in K):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc333_b/Python/54487746
|
condefects-python_data_1329
|
N = int(input())
MOD = 998244353
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)
def calc_dist(fr):
dist = [-1] * N
dist[fr] = 0
stack = [fr]
while stack:
node = stack.pop()
for nex in tree[node]:
if dist[nex] == -1:
dist[nex] = dist[node] + 1
stack.append(nex)
return dist
def solve_odd(node):
parent = [-1] * N
parent[node] = node
dist = [-1] * N
dist[node] = 0
stack = [node]
while stack:
node_ = stack.pop()
for nex in tree[node_]:
if dist[nex] == -1:
dist[nex] = dist[node_] + 1
parent[nex] = node_
stack.append(nex)
D = max(dist)
d1 = D // 2
now = dist.index(D)
for _ in range(d1):
now = parent[now]
now2 = parent[now]
dist = calc_dist(now)
cnt = dist.count(d1+1)
dist2 = calc_dist(now2)
cnt2 = dist2.count(d1+1)
return cnt * cnt2
def solve_even(node):
parent = [-1] * N
parent[node] = node
dist = [-1] * N
dist[node] = 0
stack = [node]
while stack:
node_ = stack.pop()
for nex in tree[node_]:
if dist[nex] == -1:
dist[nex] = dist[node_] + 1
parent[nex] = node_
stack.append(nex)
D = max(dist)
d1 = D // 2
now = dist.index(D)
for _ in range(d1):
now = parent[now]
dist = calc_dist(now)
cnt = []
for nex in tree[now]:
cnt.append(0)
stack = [(nex, now)]
while stack:
node, par = stack.pop()
if dist[node] == d1:
cnt[-1] += 1
for nex_ in tree[node]:
if nex_ == par:
continue
stack.append((nex_, node))
ans = 1
for c in cnt:
ans *= c + 1
ans %= MOD
ans -= 1
for c in cnt:
ans -= c
return ans%MOD
dist0 = calc_dist(0)
dmax = max(dist0)
node1 = dist0.index(dmax)
dist1 = calc_dist(node1)
D = max(dist1)
if D % 2:
ans = solve_odd(node1)
else:
ans = solve_even(node1)
print(ans)
N = int(input())
MOD = 998244353
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)
def calc_dist(fr):
dist = [-1] * N
dist[fr] = 0
stack = [fr]
while stack:
node = stack.pop()
for nex in tree[node]:
if dist[nex] == -1:
dist[nex] = dist[node] + 1
stack.append(nex)
return dist
def solve_odd(node):
parent = [-1] * N
parent[node] = node
dist = [-1] * N
dist[node] = 0
stack = [node]
while stack:
node_ = stack.pop()
for nex in tree[node_]:
if dist[nex] == -1:
dist[nex] = dist[node_] + 1
parent[nex] = node_
stack.append(nex)
D = max(dist)
d1 = D // 2
now = dist.index(D)
for _ in range(d1):
now = parent[now]
now2 = parent[now]
dist = calc_dist(now)
cnt = dist.count(d1+1)
dist2 = calc_dist(now2)
cnt2 = dist2.count(d1+1)
return cnt * cnt2 % MOD
def solve_even(node):
parent = [-1] * N
parent[node] = node
dist = [-1] * N
dist[node] = 0
stack = [node]
while stack:
node_ = stack.pop()
for nex in tree[node_]:
if dist[nex] == -1:
dist[nex] = dist[node_] + 1
parent[nex] = node_
stack.append(nex)
D = max(dist)
d1 = D // 2
now = dist.index(D)
for _ in range(d1):
now = parent[now]
dist = calc_dist(now)
cnt = []
for nex in tree[now]:
cnt.append(0)
stack = [(nex, now)]
while stack:
node, par = stack.pop()
if dist[node] == d1:
cnt[-1] += 1
for nex_ in tree[node]:
if nex_ == par:
continue
stack.append((nex_, node))
ans = 1
for c in cnt:
ans *= c + 1
ans %= MOD
ans -= 1
for c in cnt:
ans -= c
return ans%MOD
dist0 = calc_dist(0)
dmax = max(dist0)
node1 = dist0.index(dmax)
dist1 = calc_dist(node1)
D = max(dist1)
if D % 2:
ans = solve_odd(node1)
else:
ans = solve_even(node1)
print(ans)
|
ConDefects/ConDefects/Code/abc221_f/Python/45225814
|
condefects-python_data_1330
|
from collections import deque
import sys
ipt = sys.stdin.readline
def calcDiameter(g):
'''
g := 木、隣接リスト表記
'''
n = len(g)
inf = 10**9
dst1,dst2 = [inf]*n, [inf]*n
d = deque()
d.append(0)
visited = [0]*n
visited[0] = 1
while d:
cur = d.popleft()
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append(nxt)
d = deque()
d.append((cur,0))
visited = [0]*n
visited[cur] = 1
while d:
cur,dist = d.popleft()
dst1[cur] = dist
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append((nxt,dist+1))
d = deque()
d.append((cur,0))
visited = [0]*n
visited[cur] = 1
while d:
cur,dist = d.popleft()
dst2[cur] = dist
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append((nxt,dist+1))
return dist,dst1,dst2
N = int(ipt())
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = map(int,ipt().split())
u,v = u-1,v-1
G[u].append(v)
G[v].append(u)
D,dst1,dst2 = calcDiameter(G)
T = []
visited = [0]*N
if D%2:
for i in range(N):
if dst1[i] == D//2 and dst2[i] == D//2+1:
T.append(i)
visited[i] = 1
if dst2[i] == D//2 and dst1[i] == D//2+1:
T.append(i)
visited[i] = 1
else:
cen = None
for i in range(N):
if dst1[i] == D//2 and dst2[i] == D//2:
cen = i
break
for nxt in G[cen]:
T.append(nxt)
visited[i] = 1
visited[cen] = 1
U = []
for t in T:
cnt = 0
dq = deque()
dq.append((t,0))
while dq:
cur,dist = dq.popleft()
if dist == (D-1)//2:
cnt += 1
for nxt in G[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
dq.append((nxt,dist+1))
U.append(cnt)
dp = [0]*3
dp[0] = 1
MOD = 998244353
for c in U:
ndp = [0]*3
ndp[0] = dp[0]
ndp[1] = (dp[1] + dp[0]*c%MOD)%MOD
ndp[2] = (dp[2] + dp[2]*c%MOD + dp[1]*c%MOD)%MOD
dp = ndp
print(dp[2])
from collections import deque
import sys
ipt = sys.stdin.readline
def calcDiameter(g):
'''
g := 木、隣接リスト表記
'''
n = len(g)
inf = 10**9
dst1,dst2 = [inf]*n, [inf]*n
d = deque()
d.append(0)
visited = [0]*n
visited[0] = 1
while d:
cur = d.popleft()
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append(nxt)
d = deque()
d.append((cur,0))
visited = [0]*n
visited[cur] = 1
while d:
cur,dist = d.popleft()
dst1[cur] = dist
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append((nxt,dist+1))
d = deque()
d.append((cur,0))
visited = [0]*n
visited[cur] = 1
while d:
cur,dist = d.popleft()
dst2[cur] = dist
for nxt in g[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
d.append((nxt,dist+1))
return dist,dst1,dst2
N = int(ipt())
G = [[] for _ in range(N)]
for _ in range(N-1):
u,v = map(int,ipt().split())
u,v = u-1,v-1
G[u].append(v)
G[v].append(u)
D,dst1,dst2 = calcDiameter(G)
T = []
visited = [0]*N
if D%2:
for i in range(N):
if dst1[i] == D//2 and dst2[i] == D//2+1:
T.append(i)
visited[i] = 1
if dst2[i] == D//2 and dst1[i] == D//2+1:
T.append(i)
visited[i] = 1
else:
cen = None
for i in range(N):
if dst1[i] == D//2 and dst2[i] == D//2:
cen = i
break
for nxt in G[cen]:
T.append(nxt)
visited[nxt] = 1
visited[cen] = 1
U = []
for t in T:
cnt = 0
dq = deque()
dq.append((t,0))
while dq:
cur,dist = dq.popleft()
if dist == (D-1)//2:
cnt += 1
for nxt in G[cur]:
if visited[nxt]:
continue
visited[nxt] = 1
dq.append((nxt,dist+1))
U.append(cnt)
dp = [0]*3
dp[0] = 1
MOD = 998244353
for c in U:
ndp = [0]*3
ndp[0] = dp[0]
ndp[1] = (dp[1] + dp[0]*c%MOD)%MOD
ndp[2] = (dp[2] + dp[2]*c%MOD + dp[1]*c%MOD)%MOD
dp = ndp
print(dp[2])
|
ConDefects/ConDefects/Code/abc221_f/Python/40898300
|
condefects-python_data_1331
|
N, X = map(int, input().split())
S = list(map(int, input().split()))
count = 0
for s in S:
if s <= X:
count += 1
print(count)
N, X = map(int, input().split())
S = list(map(int, input().split()))
count = 0
for s in S:
if s <= X:
count += s
print(count)
|
ConDefects/ConDefects/Code/abc328_a/Python/55126003
|
condefects-python_data_1332
|
A,B=map(int,input().split())
L=list(map(int,input().split()))
count=0
for i in range(A):
if L[i] <= B:
count+=B
print(count)
A,B=map(int,input().split())
L=list(map(int,input().split()))
count=0
for i in range(A):
if L[i] <= B:
count+=L[i]
print(count)
|
ConDefects/ConDefects/Code/abc328_a/Python/54463412
|
condefects-python_data_1333
|
N, X = map(int, input().split())
S = list(map(int, input().split()))
ans = 0
for i in range(N):
if S[i] <= X:
ans += 1
print(ans)
N, X = map(int, input().split())
S = list(map(int, input().split()))
ans = 0
for i in range(N):
if S[i] <= X:
ans += S[i]
print(ans)
|
ConDefects/ConDefects/Code/abc328_a/Python/55136049
|
condefects-python_data_1334
|
import itertools
def diff(A, B):
res = 0
for a, b in zip(A, B):
if a != b:
res += 1
return res
N, M = map(int, input().split())
S = [input() for _ in range(N)]
for T in itertools.permutations(S):
ok = True
for i in range(N-1):
if diff(T[i], T[i+1]) != 1:
ok = False
if ok:
print("Yes")
break
print("No")
import itertools
def diff(A, B):
res = 0
for a, b in zip(A, B):
if a != b:
res += 1
return res
N, M = map(int, input().split())
S = [input() for _ in range(N)]
for T in itertools.permutations(S):
ok = True
for i in range(N-1):
if diff(T[i], T[i+1]) != 1:
ok = False
if ok:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc302_c/Python/45989052
|
condefects-python_data_1335
|
import itertools
S = []
N,M = map(int,input().split())
for _ in range(N):
s = list(input())
S.append(s)
com = itertools.product(S,repeat = N)
for co in com:
ans = "Yes"
for k in range(len(co)-1):
no = 0
for j in range(M):
if co[k][j] != co[k+1][j]:
no+=1
if no != 1:
ans = "No"
if ans == "Yes":
print(ans)
exit()
print(ans)
import itertools
S = []
N,M = map(int,input().split())
for _ in range(N):
s = list(input())
S.append(s)
com = itertools.permutations(S)
for co in com:
ans = "Yes"
for k in range(len(co)-1):
no = 0
for j in range(M):
if co[k][j] != co[k+1][j]:
no+=1
if no != 1:
ans = "No"
if ans == "Yes":
print(ans)
exit()
print(ans)
|
ConDefects/ConDefects/Code/abc302_c/Python/45476546
|
condefects-python_data_1336
|
import sys
from atcoder.dsu import DSU
MOD = 998_244_353
N, M = map(int, sys.stdin.readline().rstrip().split())
P = [int(x) - 1 for x in sys.stdin.readline().rstrip().split()]
uf = DSU(N)
for i in range(N):
uf.merge(i, P[i])
C = len(uf.groups())
ans = (pow(M, N, MOD) - pow(M, C, MOD)) // 2
print(ans % MOD)
import sys
from atcoder.dsu import DSU
MOD = 998_244_353
N, M = map(int, sys.stdin.readline().rstrip().split())
P = [int(x) - 1 for x in sys.stdin.readline().rstrip().split()]
uf = DSU(N)
for i in range(N):
uf.merge(i, P[i])
C = len(uf.groups())
ans = (pow(M, N, MOD) - pow(M, C, MOD)) * pow(2, MOD - 2, MOD)
print(ans % MOD)
|
ConDefects/ConDefects/Code/arc151_b/Python/45906391
|
condefects-python_data_1337
|
class UnionFind:
def __init__(self, n):
self.par = [-1]*n
self.rank = [0]*n
self.size = [1]*n
def root(self,x):
if self.par[x]==-1:
return x
else:
stack=[]
while self.par[x]!=-1:
stack.append(x)
x=self.par[x]
for y in stack:
self.par[y]=x
return x
def unite(self, x, y):
rx=self.root(x)
ry=self.root(y)
if rx==ry:
return False
if self.rank[y]>self.rank[x]:
rx,ry=ry,rx
self.par[ry]=rx
if self.rank[rx] == self.rank[ry]: # rx 側の rank を調整する
self.rank[rx] += 1
self.size[rx] += self.size[ry] # rx 側の siz を調整する
return True
def getsize(self, x):
return self.size[self.root(x)]
def issame(self, x, y):
if self.root(x)==self.root(y): return True
else: return False
N,M=map(int,input().split())
P=[0]+list(map(int,input().split()))
unf=UnionFind(N+1)
MOD=998244353
for i in range(1,N+1):
unf.unite(i,P[i])
se=set()
for i in range(1,N+1):
se.add(unf.root(i))
print(((pow(M,N,MOD)-pow(M,len(se),MOD))//2)%MOD)
class UnionFind:
def __init__(self, n):
self.par = [-1]*n
self.rank = [0]*n
self.size = [1]*n
def root(self,x):
if self.par[x]==-1:
return x
else:
stack=[]
while self.par[x]!=-1:
stack.append(x)
x=self.par[x]
for y in stack:
self.par[y]=x
return x
def unite(self, x, y):
rx=self.root(x)
ry=self.root(y)
if rx==ry:
return False
if self.rank[y]>self.rank[x]:
rx,ry=ry,rx
self.par[ry]=rx
if self.rank[rx] == self.rank[ry]: # rx 側の rank を調整する
self.rank[rx] += 1
self.size[rx] += self.size[ry] # rx 側の siz を調整する
return True
def getsize(self, x):
return self.size[self.root(x)]
def issame(self, x, y):
if self.root(x)==self.root(y): return True
else: return False
N,M=map(int,input().split())
P=[0]+list(map(int,input().split()))
unf=UnionFind(N+1)
MOD=998244353
for i in range(1,N+1):
unf.unite(i,P[i])
se=set()
for i in range(1,N+1):
se.add(unf.root(i))
print(((pow(M,N,MOD)-pow(M,len(se),MOD))*pow(2,-1,MOD)%MOD))
|
ConDefects/ConDefects/Code/arc151_b/Python/45494468
|
condefects-python_data_1338
|
from collections import defaultdict
def pow2(x, n,mod):
ans = 1
while n:
if n % 2:
ans *= x
ans %= mod
x *= x
x %= mod
n >>= 1
return ans
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n)
self.rank = [0]*(n)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N,M=map(int,input().split())
P=list(map(int,input().split()))
mod=998244353
uf=UnionFind(N)
for i in range(N):
uf.unite(i,P[i]-1)
print((pow2(M,N,mod)-pow2(M,uf.group_size(),mod))//2)
from collections import defaultdict
def pow2(x, n,mod):
ans = 1
while n:
if n % 2:
ans *= x
ans %= mod
x *= x
x %= mod
n >>= 1
return ans
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n)
self.rank = [0]*(n)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N,M=map(int,input().split())
P=list(map(int,input().split()))
mod=998244353
uf=UnionFind(N)
for i in range(N):
uf.unite(i,P[i]-1)
print((pow2(M,N,mod)-pow2(M,uf.group_size(),mod))*(pow(2,mod-2,mod)*1)%mod)
|
ConDefects/ConDefects/Code/arc151_b/Python/41325604
|
condefects-python_data_1339
|
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。
# par[x]<0の時そのノードは根で、par[x]の絶対値はグループのサイズ
self.parents = [-1] * n
self.length = n
# 親の親の...を辿って根を見つける
def find(self, x):
if self.parents[x] < 0:
return x
else:
# 再度検索する時に手間がかからないよう根を繋ぎかえる
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# xの属するグループとyの属するグループを併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
self.length -= 1
return True
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# xが属するグループのサイズを返す
def size(self, x):
x = self.find(x)
return -self.parents[x]
# treeの数を返す
def __len__(self):
return self.length
n, m = map(int, input().split())
P = list(map(lambda x: int(x)-1, input().split()))
mod = 998244353
UF = UnionFind(n)
for i, p in enumerate(P):
UF.union(i, p)
ans = (pow(m, n, mod)-pow(m, len(UF), mod))//2%mod
print(ans)
class UnionFind:
def __init__(self, n):
# 親要素のノード番号を格納。
# par[x]<0の時そのノードは根で、par[x]の絶対値はグループのサイズ
self.parents = [-1] * n
self.length = n
# 親の親の...を辿って根を見つける
def find(self, x):
if self.parents[x] < 0:
return x
else:
# 再度検索する時に手間がかからないよう根を繋ぎかえる
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
# xの属するグループとyの属するグループを併合
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
self.length -= 1
return True
# 同じ集合に属するか判定
def same(self, x, y):
return self.find(x) == self.find(y)
# xが属するグループのサイズを返す
def size(self, x):
x = self.find(x)
return -self.parents[x]
# treeの数を返す
def __len__(self):
return self.length
n, m = map(int, input().split())
P = list(map(lambda x: int(x)-1, input().split()))
mod = 998244353
UF = UnionFind(n)
for i, p in enumerate(P):
UF.union(i, p)
ans = (pow(m, n, mod)-pow(m, len(UF), mod))*pow(2, mod-2, mod)%mod
print(ans)
|
ConDefects/ConDefects/Code/arc151_b/Python/36899282
|
condefects-python_data_1340
|
A,X,M = map(int,input().split())
if A == 1:
print(X%M)
else:
print(pow(A,X,M*(A-1))//(A-1)%M)
A,X,M = map(int,input().split())
if A == 1:
print(X%M)
else:
print((pow(A,X,M*(A-1))-1)//(A-1)%M)
|
ConDefects/ConDefects/Code/abc293_e/Python/45509559
|
condefects-python_data_1341
|
a,x,m=map(int,input().split())
if a==1:print(x)
else:
t=pow(a,x,(a-1)*m)
if t==0:t+=(a-1)*m
print((t-1)//(a-1))
a,x,m=map(int,input().split())
if a==1:print(x% m)
else:
t=pow(a,x,(a-1)*m)
if t==0:t+=(a-1)*m
print((t-1)//(a-1))
|
ConDefects/ConDefects/Code/abc293_e/Python/45709875
|
condefects-python_data_1342
|
a,x,m = map(int,input().split())
A = [[a,1]]
for i in range(60):
t = A[-1]
A.append([(t[0] ** 2) % m,(t[0]*t[1] + t[1]) % m])
x = bin(x - 1)
x = list(x[2:])
x.reverse()
ans = 1
for i,v in enumerate(x):
if v == "1":
ans = (ans * A[i][0] + A[i][1]) % m
print(ans)
a,x,m = map(int,input().split())
if m == 1:
exit(print(0))
A = [[a,1]]
for i in range(60):
t = A[-1]
A.append([(t[0] ** 2) % m,(t[0]*t[1] + t[1]) % m])
x = bin(x - 1)
x = list(x[2:])
x.reverse()
ans = 1
for i,v in enumerate(x):
if v == "1":
ans = (ans * A[i][0] + A[i][1]) % m
print(ans)
|
ConDefects/ConDefects/Code/abc293_e/Python/45811552
|
condefects-python_data_1343
|
A, X, MOD = map(int, input().split())
def f(x):
if x == 0:
return 0
if x == 1:
return 1
res = f(x//2)
res += res * pow(A, x//2, MOD)
if x % 2 == 1:
res += pow(A, x-1, MOD)
res %= MOD
return res
print(f(X))
A, X, MOD = map(int, input().split())
def f(x):
if x == 0:
return 0
if x == 1:
return 1 % MOD
res = f(x//2)
res += res * pow(A, x//2, MOD)
if x % 2 == 1:
res += pow(A, x-1, MOD)
res %= MOD
return res
print(f(X))
|
ConDefects/ConDefects/Code/abc293_e/Python/45453097
|
condefects-python_data_1344
|
A, X, M = map(int, input().split())
if A == 1:
print(X % M)
else:
print(
(pow(A, X, M * (A-1)-1) // (A-1)) % M
)
A, X, M = map(int, input().split())
if A == 1:
print(X % M)
else:
print(
((pow(A, X, M * (A-1))-1) // (A-1)) % M
)
|
ConDefects/ConDefects/Code/abc293_e/Python/46204765
|
condefects-python_data_1345
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
A, X, M = map(int, readline().split())
def f(X):
if X == 1:
return 1
num = f(X // 2)
ret = num + pow(A, X // 2, M) * num
ret %= M
if X % 2:
ret += pow(A, X - 1, M)
ret %= M
return ret
print(f(X))
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
A, X, M = map(int, readline().split())
def f(X):
if X == 1:
return 1
num = f(X // 2)
ret = num + pow(A, X // 2, M) * num
ret %= M
if X % 2:
ret += pow(A, X - 1, M)
ret %= M
return ret
print(f(X) % M)
|
ConDefects/ConDefects/Code/abc293_e/Python/45761832
|
condefects-python_data_1346
|
N = int(input())
H = list(map(int,input().split()))
ans = 0
M = 0
for i in range(1,N+1):
if H[i-1] > M:
M = H[i-1]
ans = i
print(i)
N = int(input())
H = list(map(int,input().split()))
ans = 0
M = 0
for i in range(1,N+1):
if H[i-1] > M:
M = H[i-1]
ans = i
print(ans)
|
ConDefects/ConDefects/Code/abc275_a/Python/45305644
|
condefects-python_data_1347
|
N=int(input())
P=[]
T=0
total=0
for _ in range(N):
x,y,z=list(map(int, input().split()))
if x>y:
T+=z
else:
P.append((x,y,z))
total+=z
need = total//2+1
if need<=T:
print(0)
exit()
need-=T
dp = [[10**15]*(need+1) for _ in range(len(P)+1)]
dp[0][0]=0
for i in range(len(P)):
x,y,z = P[i]
dxy=(y-x)//2+1
for j in range(need):
if dp[i][j]!=10**15:
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
dp[i+1][min(need,j+z)]=min(dp[i+1][min(need,j+z)],dp[i][j]+dxy)
print(dp[-1][-1])
N=int(input())
P=[]
T=0
total=0
for _ in range(N):
x,y,z=list(map(int, input().split()))
if x>y:
T+=z
else:
P.append((x,y,z))
total+=z
need = total//2+1
if need<=T:
print(0)
exit()
need-=T
dp = [[10**15]*(need+1) for _ in range(len(P)+1)]
dp[0][0]=0
for i in range(len(P)):
x,y,z = P[i]
dxy=(y-x)//2+1
for j in range(need+1):
if dp[i][j]!=10**15:
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
dp[i+1][min(need,j+z)]=min(dp[i+1][min(need,j+z)],dp[i][j]+dxy)
print(dp[-1][-1])
|
ConDefects/ConDefects/Code/abc317_d/Python/52056192
|
condefects-python_data_1348
|
n = int(input())
x, y, z = [None] * n, [None] * n, [None] * n
for i in range(n):
x[i], y[i], z[i] = map(int, input().split())
v = [None] * n
for i in range(n):
v[i] = max(0, y[i] - (x[i] + y[i]) // 2)
m = sum(z)
dp = [[10**10] * (m + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i in range(1, n + 1):
for j in range(m + 1):
dp[i][j] = dp[i - 1][j]
if j - z[i - 1] >= 0:
dp[i][j] = min(dp[i][j], dp[i - 1][j - z[i - 1]] + v[i - 1])
print(min([dp[i][j] for j in range(m // 2 + 1, m + 1)]))
n = int(input())
x, y, z = [None] * n, [None] * n, [None] * n
for i in range(n):
x[i], y[i], z[i] = map(int, input().split())
v = [None] * n
for i in range(n):
v[i] = max(0, y[i] - (x[i] + y[i]) // 2)
m = sum(z)
dp = [[10**30] * (m + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i in range(1, n + 1):
for j in range(m + 1):
dp[i][j] = dp[i - 1][j]
if j - z[i - 1] >= 0:
dp[i][j] = min(dp[i][j], dp[i - 1][j - z[i - 1]] + v[i - 1])
print(min([dp[i][j] for j in range(m // 2 + 1, m + 1)]))
|
ConDefects/ConDefects/Code/abc317_d/Python/53253616
|
condefects-python_data_1349
|
N = int(input())
XYZ = [[int(x) for x in input().split()] for _ in range(N)]
lst = []
total = 0
for x, y, z in XYZ:
lst.append((max((y-x)//2+1, 0), z))
total += z
# dp[i][j]: i個目までの選挙区を見て、j議席を獲得するときに必要な最小コスト
dp = [[10**10]*(total+1) for _ in range(N+1)]
dp[0][0] = 0
for i, (c, w) in enumerate(lst):
for j in range(total+1):
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
if j+w <= total:
dp[i+1][j+w] = min(dp[i+1][j+w], dp[i][j]+c)
print(min(dp[N][total//2+1:]))
N = int(input())
XYZ = [[int(x) for x in input().split()] for _ in range(N)]
lst = []
total = 0
for x, y, z in XYZ:
lst.append((max((y-x)//2+1, 0), z))
total += z
# dp[i][j]: i個目までの選挙区を見て、j議席を獲得するときに必要な最小コスト
dp = [[10**18]*(total+1) for _ in range(N+1)]
dp[0][0] = 0
for i, (c, w) in enumerate(lst):
for j in range(total+1):
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
if j+w <= total:
dp[i+1][j+w] = min(dp[i+1][j+w], dp[i][j]+c)
print(min(dp[N][total//2+1:]))
|
ConDefects/ConDefects/Code/abc317_d/Python/52641231
|
condefects-python_data_1350
|
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1<<32 else [2, 3, 5, 7, 11, 13, 17] if n < 1<<48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def mult(A, B):
n = len(A)
L = [0] * n
for i, a in enumerate(A):
for j, b in enumerate(B):
ij = min(i + j, n - 1)
L[ij] = (L[ij] + a * b) % P
return L
def power(A, k):
if k == 1:
return A
if k % 2 == 0:
return power(mult(A, A), k // 2)
return mult(power(A, k - 1), A)
P = 998244353
K, N, M = map(int, input().split())
if M == 1:
print(1)
exit()
pf = primeFactor(M)
primes = [p for p in pf]
n = len(primes)
A = [0] * n
if N == 0:
for i in range(n):
A[i] = pf[primes[i]]
else:
for i in range(n):
p = primes[i]
c = 0
NN = N
while NN % p == 0:
NN //= p
c += 1
A[i] = c
ans = 1
for k, p in enumerate(primes):
a = min(A[k], pf[p])
C = [0] * (pf[p] + 1)
nn = p ** pf[p] * (p - 1) // p
for i in range(pf[p]):
C[i] = nn
nn //= p
C[-1] = p ** pf[p] - sum(C)
D = power(C, K)
s = D[a] % P * pow(C[a], P - 2, P) % P
ans = ans * s % P
if 0:
print("A =", A)
print("C =", C)
print("D =", D)
print("p, ans =", p, ans)
print(ans)
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1<<32 else [2, 3, 5, 7, 11, 13, 17] if n < 1<<48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def mult(A, B):
n = len(A)
L = [0] * n
for i, a in enumerate(A):
for j, b in enumerate(B):
ij = min(i + j, n - 1)
L[ij] = (L[ij] + a * b) % P
return L
def power(A, k):
if k == 1:
return A
if k % 2 == 0:
return power(mult(A, A), k // 2)
return mult(power(A, k - 1), A)
P = 998244353
K, N, M = map(int, input().split())
if M == 1 or K == 1:
print(1)
exit()
pf = primeFactor(M)
primes = [p for p in pf]
n = len(primes)
A = [0] * n
if N == 0:
for i in range(n):
A[i] = pf[primes[i]]
else:
for i in range(n):
p = primes[i]
c = 0
NN = N
while NN % p == 0:
NN //= p
c += 1
A[i] = c
ans = 1
for k, p in enumerate(primes):
a = min(A[k], pf[p])
C = [0] * (pf[p] + 1)
nn = p ** pf[p] * (p - 1) // p
for i in range(pf[p]):
C[i] = nn
nn //= p
C[-1] = p ** pf[p] - sum(C)
D = power(C, K)
s = D[a] % P * pow(C[a], P - 2, P) % P
ans = ans * s % P
if 0:
print("A =", A)
print("C =", C)
print("D =", D)
print("p, ans =", p, ans)
print(ans)
|
ConDefects/ConDefects/Code/abc245_h/Python/30480849
|
condefects-python_data_1351
|
mod=998244353
def comb(n,r):
if r>n:
return 0
tmp1=1
tmp2=1
for i in range(r):
tmp1*=n-i
tmp2*=i+1
tmp1%=mod
tmp2%=mod
return (tmp1*pow(tmp2,mod-2,mod)%mod)
def fact(n):
if n==1:
return []
arr=[]
temp=n
for i in range(2,int(-(-n**0.5//1))+2):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp//=i
arr.append([i,cnt])
if temp!=1:
arr.append([temp,1])
if arr==[]:
arr.append([n,1])
return arr
def pow_mod(p,k):
if p%mod==0:
return 0
return pow(p,k,mod)
def calc(p,a,k,x):
return comb(k+x-1,x)*pow_mod(p-1,k-1)%mod*pow_mod(p,(a-1)*(k-1))%mod
k,n,m=map(int,input().split())
if k==1:
print(1)
exit()
ans=1
f=fact(m)
for p,a in f:
N=n%(p**a)
if N!=0:
x=0
while N%p==0:
x+=1
N//=p
ans*=calc(p,a,k,x)
ans%=mod
else:
tmp=pow_mod(p**a,k)
for i in range(a):
tmp-=calc(p,a,k,i)*(p-1)%mod*pow_mod(p,a-i-1)
tmp%=mod
ans*=tmp
ans%=mod
print(ans)
mod=998244353
def comb(n,r):
if r>n:
return 0
tmp1=1
tmp2=1
for i in range(r):
tmp1*=n-i
tmp2*=i+1
tmp1%=mod
tmp2%=mod
return (tmp1*pow(tmp2,mod-2,mod)%mod)
def fact(n):
if n==1:
return []
arr=[]
temp=n
for i in range(2,int(-(-n**0.5//1))+2):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp//=i
arr.append([i,cnt])
if temp!=1:
arr.append([temp,1])
if arr==[]:
arr.append([n,1])
return arr
def pow_mod(p,k):
if k==0:
return 1
if p%mod==0:
return 0
return pow(p,k,mod)
def calc(p,a,k,x):
return comb(k+x-1,x)*pow_mod(p-1,k-1)%mod*pow_mod(p,(a-1)*(k-1))%mod
k,n,m=map(int,input().split())
if k==1:
print(1)
exit()
ans=1
f=fact(m)
for p,a in f:
N=n%(p**a)
if N!=0:
x=0
while N%p==0:
x+=1
N//=p
ans*=calc(p,a,k,x)
ans%=mod
else:
tmp=pow_mod(p**a,k)
for i in range(a):
tmp-=calc(p,a,k,i)*(p-1)%mod*pow_mod(p,a-i-1)
tmp%=mod
ans*=tmp
ans%=mod
print(ans)
|
ConDefects/ConDefects/Code/abc245_h/Python/30541714
|
condefects-python_data_1352
|
# For the sake of speed,
# this convolution is specialized to mod 998244353.
import math
import itertools
import functools
import collections
_fft_mod = 998244353
_fft_sum_e = (911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601,
842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0, 0, 0, 0, 0, 0, 0, 0)
_fft_sum_ie = (86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543,
109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0, 0, 0, 0, 0, 0, 0, 0)
def _butterfly(a):
n = len(a)
h = (n - 1).bit_length()
for ph in range(1, h + 1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
now = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * now % _fft_mod
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) % _fft_mod
now *= _fft_sum_e[(~s & -~s).bit_length() - 1]
now %= _fft_mod
def _butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
for ph in range(h, 0, -1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
inow = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) * inow % _fft_mod
inow *= _fft_sum_ie[(~s & -~s).bit_length() - 1]
inow %= _fft_mod
def _convolution_naive(a, b):
n = len(a)
m = len(b)
ans = [0] * (n + m - 1)
if n < m:
for j in range(m):
for i in range(n):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % _fft_mod
else:
for i in range(n):
for j in range(m):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % _fft_mod
return ans
def _convolution_fft(a, b):
a = a.copy()
b = b.copy()
n = len(a)
m = len(b)
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
b += [0] * (z - m)
_butterfly(b)
for i in range(z):
a[i] = a[i] * b[i] % _fft_mod
_butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(n + m - 1):
a[i] = a[i] * iz % _fft_mod
return a
def _convolution_square(a):
a = a.copy()
n = len(a)
z = 1 << (2 * n - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
for i in range(z):
a[i] = a[i] * a[i] % _fft_mod
_butterfly_inv(a)
a = a[:2 * n - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(2 * n - 1):
a[i] = a[i] * iz % _fft_mod
return a
def convolution(a, b):
"""It calculates (+, x) convolution in mod 998244353.
Given two arrays a[0], a[1], ..., a[n - 1] and b[0], b[1], ..., b[m - 1],
it calculates the array c of length n + m - 1, defined by
> c[i] = sum(a[j] * b[i - j] for j in range(i + 1)) % 998244353.
It returns an empty list if at least one of a and b are empty.
Complexity
----------
> O(n log n), where n = len(a) + len(b).
"""
n = len(a)
m = len(b)
if n == 0 or m == 0:
return []
if min(n, m) <= 100:
return _convolution_naive(a, b)
if a is b:
return _convolution_square(a)
return _convolution_fft(a, b)
# Reference: https://opt-cp.com/fps-fast-algorithms/
def inv(a):
"""It calculates the inverse of formal power series in O(n log n) time, where n = len(a).
"""
n = len(a)
assert n > 0 and a[0] != 0
res = [pow(a[0], _fft_mod - 2, _fft_mod)]
m = 1
while m < n:
f = a[:min(n, 2 * m)]
g = res.copy()
f += [0] * (2 * m - len(f))
_butterfly(f)
g += [0] * (2 * m - len(g))
_butterfly(g)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[m:] + [0] * m
_butterfly(f)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[:m]
iz = pow(2 * m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m):
f[i] = f[i] * iz % _fft_mod
res.extend(f)
m *= 2
res = res[:n]
return res
def integ_inplace(a):
n = len(a)
assert n > 0
if n == 1:
return []
a.pop()
a.insert(0, 0)
inv = [1, 1]
for i in range(2, n):
inv.append(-inv[_fft_mod % i] * (_fft_mod//i) % _fft_mod)
a[i] = a[i] * inv[i] % _fft_mod
def deriv_inplace(a):
n = len(a)
assert n > 0
for i in range(2, n):
a[i] = a[i] * i % _fft_mod
a.pop(0)
a.append(0)
def log(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 1
a_inv = inv(a)
deriv_inplace(a)
a = convolution(a, a_inv)[:n]
integ_inplace(a)
return a
def exp(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 0
g = [1]
a[0] = 1
h_drv = a.copy()
deriv_inplace(h_drv)
m = 1
while m < n:
f_fft = a[:m] + [0] * m
_butterfly(f_fft)
if m > 1:
_f = [f_fft[i] * g_fft[i] % _fft_mod for i in range(m)]
_butterfly_inv(_f)
_f = _f[m // 2:] + [0] * (m // 2)
_butterfly(_f)
for i in range(m):
_f[i] = _f[i] * g_fft[i] % _fft_mod
_butterfly_inv(_f)
_f = _f[:m//2]
iz = pow(m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m//2):
_f[i] = _f[i] * iz % _fft_mod
g.extend(_f)
t = a[:m]
deriv_inplace(t)
r = h_drv[:m - 1]
r.append(0)
_butterfly(r)
for i in range(m):
r[i] = r[i] * f_fft[i] % _fft_mod
_butterfly_inv(r)
im = pow(-m, _fft_mod - 2, _fft_mod)
for i in range(m):
r[i] = r[i] * im % _fft_mod
for i in range(m):
t[i] = (t[i] + r[i]) % _fft_mod
t = [t[-1]] + t[:-1]
t += [0] * m
_butterfly(t)
g_fft = g + [0] * (2 * m - len(g))
_butterfly(g_fft)
for i in range(2 * m):
t[i] = t[i] * g_fft[i] % _fft_mod
_butterfly_inv(t)
t = t[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
t[i] = t[i] * i2m % _fft_mod
v = a[m:min(n, 2 * m)]
v += [0] * (m - len(v))
t = [0] * (m - 1) + t + [0]
integ_inplace(t)
for i in range(m):
v[i] = (v[i] - t[m + i]) % _fft_mod
v += [0] * m
_butterfly(v)
for i in range(2 * m):
v[i] = v[i] * f_fft[i] % _fft_mod
_butterfly_inv(v)
v = v[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
v[i] = v[i] * i2m % _fft_mod
for i in range(min(n - m, m)):
a[m + i] = v[i]
m *= 2
return a
def pow_fps(a, k):
a = a.copy()
n = len(a)
l = 0
while l < len(a) and not a[l]:
l += 1
if l * k >= n:
return [0] * n
ic = pow(a[l], _fft_mod - 2, _fft_mod)
pc = pow(a[l], k, _fft_mod)
a = log([a[i] * ic % _fft_mod for i in range(l, len(a))])
for i in range(len(a)):
a[i] = a[i] * k % _fft_mod
a = exp(a)
for i in range(len(a)):
a[i] = a[i] * pc % _fft_mod
a = [0] * (l * k) + a[:n - l * k]
return a
# 素因数をcollections.Counterで返す。
# -----ここからρ法ライブラリ-----
def is_prime(n):
"Miller Rabin primality test. 2 <= n <= 2 ** 64 is required"
if n % 2 == 0:
return n == 2
d = n - 1
r = (d & -d).bit_length() - 1
d >>= r
# witnesses をいい感じに決める。
if n < 2152302898747:
if n < 9080191:
if n < 2047:
witnesses = [2]
else:
witnesses = [31, 73]
else:
if n < 4759123141:
witnesses = [2, 7, 61]
else:
witnesses = [2, 3, 5, 7, 11]
else:
if n < 341550071728321:
if n < 3474749660383:
witnesses = [2, 3, 5, 7, 11, 13]
else:
witnesses = [2, 3, 5, 7, 11, 13, 17]
else:
if n < 3825123056546413051:
witnesses = [2, 3, 5, 7, 11, 13, 17, 19]
else:
witnesses = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
# witnesses の決定終了
for a in witnesses:
x = pow(a, d, n)
if x == 1 or x == n - 1:
continue
for _ in range(r - 1):
x *= x
x %= n
if x == n - 1:
break
else:
return False
return True
@functools.lru_cache() # お好みで。
def find_factor(n):
"Find a non-trivial factor of n by using Pollard's rho algorithm."
m = int(n ** 0.125) + 1
c = 1
while True:
y = 1
r = 1
q = 1
g = 1
while g == 1:
x = y
for _ in range(r):
y = (y * y + c) % n
for k in range(0, r, m):
ys = y
for _ in range(m):
y = (y * y + c) % n
q = q * (x - y) % n
g = math.gcd(q, n)
if g != 1:
break
else: # 残りの k から r までをやる
ys = y
for _ in range(r-k):
y = (y * y + c) % n
q = q * (x - y) % n
g = math.gcd(q, n)
r *= 2
if g == n:
g = 1
while g == 1:
ys = (ys * ys + c) % n
g = math.gcd(x - ys, n)
if g == n:
c += 1 # c を変えて続行。
else: # g は n の非自明な約数。
return g
_prime_numbers_200 = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
89, 97, 101, 103, 107, 109, 113, 127, 131,
137, 139, 149, 151, 157, 163, 167, 173, 179,
181, 191, 193, 197, 199
]
def factorize(n, try_small_factor=True):
"""
引数 n の素因数分解をして、素因数のカウンター(collections.Counter)を返す。\n
e.g. `factorize(60) == Counter({2: 2, 3: 1, 5: 1})`\n
計算量は O(n ^ 1/4) 程度。
"""
if n == 1:
return collections.Counter()
if is_prime(n):
return collections.Counter({n: 1})
ret = collections.Counter()
if try_small_factor:
for p in _prime_numbers_200:
if n % p == 0:
ret[p] = 1
n //= p
while n % p == 0:
ret[p] += 1
n //= p
if n == 1:
return ret
while n != 1 and not is_prime(n):
f = find_factor(n)
if is_prime(f):
ret[f] = 1
n //= f
while n % f == 0:
ret[f] += 1
n //= f
elif is_prime(n // f):
g = n // f
n = f
ret[g] = 1
while n % g == 0:
ret[g] += 1
n //= g
else:
return ret + factorize(f, False) + factorize(n // f, False)
if n == 1:
return ret
else:
ret[n] = 1
return ret
def divisors(n_or_factors):
if isinstance(n_or_factors, int):
n_or_factors = factorize(n_or_factors)
iters = [[p ** i for i in range(e + 1)] for p, e in n_or_factors.items()]
ret = []
for ts in itertools.product(*iters):
div = 1
for t in ts:
div *= t
ret.append(div)
ret.sort()
return ret
# -----ここまでρ法ライブラリ-----
MOD = 998244353
K, N, M = map(int, input().split())
M_factors = factorize(M)
N_factors = collections.Counter()
for f, e in M_factors.items():
fe = f ** e
N_tmp = N % fe + fe
while N_tmp % f == 0:
N_factors[f] += 1
N_tmp //= f
N_factors[f] = min(N_factors[f], e)
# print(N_factors, M_factors)
answer = 1
inv_val = 1
for f, e in M_factors.items():
g = [1]
for _ in range(e):
g.append(g[-1] * f % MOD)
g.reverse()
fe = g[0]
for i in range(e):
g[i] -= g[i + 1]
inv_val *= g[N_factors[f]]
inv_val %= MOD
gK = pow_fps(g, K)
gK.pop()
s = sum(gK)
gK.append((pow(fe, K, MOD) - s) % MOD)
# print(g, gK, N_factors[f])
answer *= gK[N_factors[f]]
answer %= MOD
# print(inv_val)
if inv_val == 0:
answer = (K == 1)
else:
answer *= pow(inv_val, MOD - 2, MOD)
answer %= MOD
print(answer)
# For the sake of speed,
# this convolution is specialized to mod 998244353.
import math
import itertools
import functools
import collections
_fft_mod = 998244353
_fft_sum_e = (911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601,
842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0, 0, 0, 0, 0, 0, 0, 0)
_fft_sum_ie = (86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543,
109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0, 0, 0, 0, 0, 0, 0, 0)
def _butterfly(a):
n = len(a)
h = (n - 1).bit_length()
for ph in range(1, h + 1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
now = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * now % _fft_mod
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) % _fft_mod
now *= _fft_sum_e[(~s & -~s).bit_length() - 1]
now %= _fft_mod
def _butterfly_inv(a):
n = len(a)
h = (n - 1).bit_length()
for ph in range(h, 0, -1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
inow = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % _fft_mod
a[i + offset + p] = (l - r) * inow % _fft_mod
inow *= _fft_sum_ie[(~s & -~s).bit_length() - 1]
inow %= _fft_mod
def _convolution_naive(a, b):
n = len(a)
m = len(b)
ans = [0] * (n + m - 1)
if n < m:
for j in range(m):
for i in range(n):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % _fft_mod
else:
for i in range(n):
for j in range(m):
ans[i + j] = (ans[i + j] + a[i] * b[j]) % _fft_mod
return ans
def _convolution_fft(a, b):
a = a.copy()
b = b.copy()
n = len(a)
m = len(b)
z = 1 << (n + m - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
b += [0] * (z - m)
_butterfly(b)
for i in range(z):
a[i] = a[i] * b[i] % _fft_mod
_butterfly_inv(a)
a = a[:n + m - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(n + m - 1):
a[i] = a[i] * iz % _fft_mod
return a
def _convolution_square(a):
a = a.copy()
n = len(a)
z = 1 << (2 * n - 2).bit_length()
a += [0] * (z - n)
_butterfly(a)
for i in range(z):
a[i] = a[i] * a[i] % _fft_mod
_butterfly_inv(a)
a = a[:2 * n - 1]
iz = pow(z, _fft_mod - 2, _fft_mod)
for i in range(2 * n - 1):
a[i] = a[i] * iz % _fft_mod
return a
def convolution(a, b):
"""It calculates (+, x) convolution in mod 998244353.
Given two arrays a[0], a[1], ..., a[n - 1] and b[0], b[1], ..., b[m - 1],
it calculates the array c of length n + m - 1, defined by
> c[i] = sum(a[j] * b[i - j] for j in range(i + 1)) % 998244353.
It returns an empty list if at least one of a and b are empty.
Complexity
----------
> O(n log n), where n = len(a) + len(b).
"""
n = len(a)
m = len(b)
if n == 0 or m == 0:
return []
if min(n, m) <= 100:
return _convolution_naive(a, b)
if a is b:
return _convolution_square(a)
return _convolution_fft(a, b)
# Reference: https://opt-cp.com/fps-fast-algorithms/
def inv(a):
"""It calculates the inverse of formal power series in O(n log n) time, where n = len(a).
"""
n = len(a)
assert n > 0 and a[0] != 0
res = [pow(a[0], _fft_mod - 2, _fft_mod)]
m = 1
while m < n:
f = a[:min(n, 2 * m)]
g = res.copy()
f += [0] * (2 * m - len(f))
_butterfly(f)
g += [0] * (2 * m - len(g))
_butterfly(g)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[m:] + [0] * m
_butterfly(f)
for i in range(2 * m):
f[i] = f[i] * g[i] % _fft_mod
_butterfly_inv(f)
f = f[:m]
iz = pow(2 * m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m):
f[i] = f[i] * iz % _fft_mod
res.extend(f)
m *= 2
res = res[:n]
return res
def integ_inplace(a):
n = len(a)
assert n > 0
if n == 1:
return []
a.pop()
a.insert(0, 0)
inv = [1, 1]
for i in range(2, n):
inv.append(-inv[_fft_mod % i] * (_fft_mod//i) % _fft_mod)
a[i] = a[i] * inv[i] % _fft_mod
def deriv_inplace(a):
n = len(a)
assert n > 0
for i in range(2, n):
a[i] = a[i] * i % _fft_mod
a.pop(0)
a.append(0)
def log(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 1
a_inv = inv(a)
deriv_inplace(a)
a = convolution(a, a_inv)[:n]
integ_inplace(a)
return a
def exp(a):
a = a.copy()
n = len(a)
assert n > 0 and a[0] == 0
g = [1]
a[0] = 1
h_drv = a.copy()
deriv_inplace(h_drv)
m = 1
while m < n:
f_fft = a[:m] + [0] * m
_butterfly(f_fft)
if m > 1:
_f = [f_fft[i] * g_fft[i] % _fft_mod for i in range(m)]
_butterfly_inv(_f)
_f = _f[m // 2:] + [0] * (m // 2)
_butterfly(_f)
for i in range(m):
_f[i] = _f[i] * g_fft[i] % _fft_mod
_butterfly_inv(_f)
_f = _f[:m//2]
iz = pow(m, _fft_mod - 2, _fft_mod)
iz *= -iz
iz %= _fft_mod
for i in range(m//2):
_f[i] = _f[i] * iz % _fft_mod
g.extend(_f)
t = a[:m]
deriv_inplace(t)
r = h_drv[:m - 1]
r.append(0)
_butterfly(r)
for i in range(m):
r[i] = r[i] * f_fft[i] % _fft_mod
_butterfly_inv(r)
im = pow(-m, _fft_mod - 2, _fft_mod)
for i in range(m):
r[i] = r[i] * im % _fft_mod
for i in range(m):
t[i] = (t[i] + r[i]) % _fft_mod
t = [t[-1]] + t[:-1]
t += [0] * m
_butterfly(t)
g_fft = g + [0] * (2 * m - len(g))
_butterfly(g_fft)
for i in range(2 * m):
t[i] = t[i] * g_fft[i] % _fft_mod
_butterfly_inv(t)
t = t[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
t[i] = t[i] * i2m % _fft_mod
v = a[m:min(n, 2 * m)]
v += [0] * (m - len(v))
t = [0] * (m - 1) + t + [0]
integ_inplace(t)
for i in range(m):
v[i] = (v[i] - t[m + i]) % _fft_mod
v += [0] * m
_butterfly(v)
for i in range(2 * m):
v[i] = v[i] * f_fft[i] % _fft_mod
_butterfly_inv(v)
v = v[:m]
i2m = pow(2 * m, _fft_mod - 2, _fft_mod)
for i in range(m):
v[i] = v[i] * i2m % _fft_mod
for i in range(min(n - m, m)):
a[m + i] = v[i]
m *= 2
return a
def pow_fps(a, k):
a = a.copy()
n = len(a)
l = 0
while l < len(a) and not a[l]:
l += 1
if l * k >= n:
return [0] * n
ic = pow(a[l], _fft_mod - 2, _fft_mod)
pc = pow(a[l], k, _fft_mod)
a = log([a[i] * ic % _fft_mod for i in range(l, len(a))])
for i in range(len(a)):
a[i] = a[i] * k % _fft_mod
a = exp(a)
for i in range(len(a)):
a[i] = a[i] * pc % _fft_mod
a = [0] * (l * k) + a[:n - l * k]
return a
# 素因数をcollections.Counterで返す。
# -----ここからρ法ライブラリ-----
def is_prime(n):
"Miller Rabin primality test. 2 <= n <= 2 ** 64 is required"
if n % 2 == 0:
return n == 2
d = n - 1
r = (d & -d).bit_length() - 1
d >>= r
# witnesses をいい感じに決める。
if n < 2152302898747:
if n < 9080191:
if n < 2047:
witnesses = [2]
else:
witnesses = [31, 73]
else:
if n < 4759123141:
witnesses = [2, 7, 61]
else:
witnesses = [2, 3, 5, 7, 11]
else:
if n < 341550071728321:
if n < 3474749660383:
witnesses = [2, 3, 5, 7, 11, 13]
else:
witnesses = [2, 3, 5, 7, 11, 13, 17]
else:
if n < 3825123056546413051:
witnesses = [2, 3, 5, 7, 11, 13, 17, 19]
else:
witnesses = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
# witnesses の決定終了
for a in witnesses:
x = pow(a, d, n)
if x == 1 or x == n - 1:
continue
for _ in range(r - 1):
x *= x
x %= n
if x == n - 1:
break
else:
return False
return True
@functools.lru_cache() # お好みで。
def find_factor(n):
"Find a non-trivial factor of n by using Pollard's rho algorithm."
m = int(n ** 0.125) + 1
c = 1
while True:
y = 1
r = 1
q = 1
g = 1
while g == 1:
x = y
for _ in range(r):
y = (y * y + c) % n
for k in range(0, r, m):
ys = y
for _ in range(m):
y = (y * y + c) % n
q = q * (x - y) % n
g = math.gcd(q, n)
if g != 1:
break
else: # 残りの k から r までをやる
ys = y
for _ in range(r-k):
y = (y * y + c) % n
q = q * (x - y) % n
g = math.gcd(q, n)
r *= 2
if g == n:
g = 1
while g == 1:
ys = (ys * ys + c) % n
g = math.gcd(x - ys, n)
if g == n:
c += 1 # c を変えて続行。
else: # g は n の非自明な約数。
return g
_prime_numbers_200 = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37,
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
89, 97, 101, 103, 107, 109, 113, 127, 131,
137, 139, 149, 151, 157, 163, 167, 173, 179,
181, 191, 193, 197, 199
]
def factorize(n, try_small_factor=True):
"""
引数 n の素因数分解をして、素因数のカウンター(collections.Counter)を返す。\n
e.g. `factorize(60) == Counter({2: 2, 3: 1, 5: 1})`\n
計算量は O(n ^ 1/4) 程度。
"""
if n == 1:
return collections.Counter()
if is_prime(n):
return collections.Counter({n: 1})
ret = collections.Counter()
if try_small_factor:
for p in _prime_numbers_200:
if n % p == 0:
ret[p] = 1
n //= p
while n % p == 0:
ret[p] += 1
n //= p
if n == 1:
return ret
while n != 1 and not is_prime(n):
f = find_factor(n)
if is_prime(f):
ret[f] = 1
n //= f
while n % f == 0:
ret[f] += 1
n //= f
elif is_prime(n // f):
g = n // f
n = f
ret[g] = 1
while n % g == 0:
ret[g] += 1
n //= g
else:
return ret + factorize(f, False) + factorize(n // f, False)
if n == 1:
return ret
else:
ret[n] = 1
return ret
def divisors(n_or_factors):
if isinstance(n_or_factors, int):
n_or_factors = factorize(n_or_factors)
iters = [[p ** i for i in range(e + 1)] for p, e in n_or_factors.items()]
ret = []
for ts in itertools.product(*iters):
div = 1
for t in ts:
div *= t
ret.append(div)
ret.sort()
return ret
# -----ここまでρ法ライブラリ-----
MOD = 998244353
K, N, M = map(int, input().split())
M_factors = factorize(M)
N_factors = collections.Counter()
for f, e in M_factors.items():
fe = f ** e
N_tmp = N % fe + fe
while N_tmp % f == 0:
N_factors[f] += 1
N_tmp //= f
N_factors[f] = min(N_factors[f], e)
# print(N_factors, M_factors)
answer = 1
inv_val = 1
for f, e in M_factors.items():
g = [1]
for _ in range(e):
g.append(g[-1] * f % MOD)
g.reverse()
fe = g[0]
for i in range(e):
g[i] -= g[i + 1]
inv_val *= g[N_factors[f]]
inv_val %= MOD
gK = pow_fps(g, K)
gK.pop()
s = sum(gK)
gK.append((pow(fe, K, MOD) - s) % MOD)
# print(g, gK, N_factors[f])
answer *= gK[N_factors[f]]
answer %= MOD
# print(inv_val)
if inv_val == 0:
answer = int(K == 1)
else:
answer *= pow(inv_val, MOD - 2, MOD)
answer %= MOD
print(answer)
|
ConDefects/ConDefects/Code/abc245_h/Python/30483110
|
condefects-python_data_1353
|
N,X,Y,*A=map(int,open(0).read().split());f=0;s=["Second","First"]
for a in A:
if a%(X+Y)>=max(X,Y):f=1
elif a%(X+Y)>=min(X,Y):print([X<Y]);exit()
print(s[f])
N,X,Y,*A=map(int,open(0).read().split());f=0;s=["Second","First"]
for a in A:
if a%(X+Y)>=max(X,Y):f=1
elif a%(X+Y)>=min(X,Y):print(s[X<Y]);exit()
print(s[f])
|
ConDefects/ConDefects/Code/arc143_c/Python/33642213
|
condefects-python_data_1354
|
n, x, y = map(int, input().split())
a_list = list(map(int, input().split()))
for i in range(n):
a_list[i] %= x+y
flag = True
for i in range(n):
if a_list[i] // x == 0 and a_list[i] // y > 0:
print("Second")
exit()
elif a_list[i] // x > 0 and a_list[i] // y > 0:
print("First")
exit()
elif a_list[i] // x > 0:
flag = False
if flag:
print("Second")
else:
print("First")
n, x, y = map(int, input().split())
a_list = list(map(int, input().split()))
for i in range(n):
a_list[i] %= x+y
flag = True
for i in range(n):
if a_list[i] // x == 0 and a_list[i] // y > 0:
print("Second")
exit()
elif a_list[i] // x > 0 and a_list[i] // y == 0:
print("First")
exit()
elif a_list[i] // x > 0:
flag = False
if flag:
print("Second")
else:
print("First")
|
ConDefects/ConDefects/Code/arc143_c/Python/37392747
|
condefects-python_data_1355
|
a = input()
b = int(a[0])
c = int(a[-1])
d = []
e = []
for j in range(b):
d.append(input())
for j in range(b):
e.append(input())
def f(x, y):
for i in range(b):
for j in range(c):
if d[(i+x)%b][(j+y)%c] == e[i][j]:
pass
else:
return 0
return 1
ans = 0
for i in range(b):
for j in range(c):
if f(i, j):
ans = 1
if ans:
print('Yes')
else:
print('No')
a = input().split()
b = int(a[0])
c = int(a[-1])
d = []
e = []
for j in range(b):
d.append(input())
for j in range(b):
e.append(input())
def f(x, y):
for i in range(b):
for j in range(c):
if d[(i+x)%b][(j+y)%c] == e[i][j]:
pass
else:
return 0
return 1
ans = 0
for i in range(b):
for j in range(c):
if f(i, j):
ans = 1
if ans:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc300_b/Python/45723196
|
condefects-python_data_1356
|
def fprint(arys):
for i in range(len(arys)):
print(*arys[i])
print("-"*len(arys)*5)
return
h, w = map(int, input().split())
tableA = [[] for i in range(h)]
tableB = [[] for i in range(h)]
mp1 = [[""]*w for i in range(h)]
mp2 = [[""]*w for i in range(h)]
for i in range(h):
s = list(input())
tableA[i].extend(s)
for i in range(h):
s = list(input())
tableB[i].extend(s)
for dy in range(h):
for dx in range(w):
if dy == 0 and dx == 0:
continue
for i in range(h):
for j in range(w):
k = (j-dx)%w
mp1[i][k] = tableA[i][j]
for j in range(w):
for i in range(h):
k = (i-dy)%h
mp2[k][j] = mp1[i][j]
#print(dy, dx)
#fprint(mp2)
if mp2 == tableB:
print("Yes")
exit()
else:
print("No")
def fprint(arys):
for i in range(len(arys)):
print(*arys[i])
print("-"*len(arys)*5)
return
h, w = map(int, input().split())
tableA = [[] for i in range(h)]
tableB = [[] for i in range(h)]
mp1 = [[""]*w for i in range(h)]
mp2 = [[""]*w for i in range(h)]
for i in range(h):
s = list(input())
tableA[i].extend(s)
for i in range(h):
s = list(input())
tableB[i].extend(s)
for dy in range(h):
for dx in range(w):
for i in range(h):
for j in range(w):
k = (j-dx)%w
mp1[i][k] = tableA[i][j]
for j in range(w):
for i in range(h):
k = (i-dy)%h
mp2[k][j] = mp1[i][j]
#print(dy, dx)
#fprint(mp2)
if mp2 == tableB:
print("Yes")
exit()
else:
print("No")
|
ConDefects/ConDefects/Code/abc300_b/Python/45110485
|
condefects-python_data_1357
|
def check(x):
sub = 0
for i in range(N):
a,b = ab[i]
if x<=a:
sub+=b
#print(sub)
if sub<=K:
return 1
else:
return 0
N,K = map(int,input().split())
ab = [list(map(int,input().split())) for _ in range(N)]
ng,ok = 0,10**9
while abs(ok-ng)>1:
ic = (ok+ng)//2
#print(ok,ic,ng)
if check(ic):
ok = ic
else:
ng = ic
print(ok)
def check(x):
sub = 0
for i in range(N):
a,b = ab[i]
if x<=a:
sub+=b
#print(sub)
if sub<=K:
return 1
else:
return 0
N,K = map(int,input().split())
ab = [list(map(int,input().split())) for _ in range(N)]
ng,ok = 0,10**9+1
while abs(ok-ng)>1:
ic = (ok+ng)//2
#print(ok,ic,ng)
if check(ic):
ok = ic
else:
ng = ic
print(ok)
|
ConDefects/ConDefects/Code/abc309_c/Python/46123600
|
condefects-python_data_1358
|
N, K = map(int, input().split())
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort()
medicines = 0
for i in range(N):
medicines += AB[i][1]
for i in range(N):
if medicines <= K:
if i == 0:
print(1)
exit(0)
else:
print(AB[i - 1][0] + 1)
exit(0)
medicines -= AB[i][1]
N, K = map(int, input().split())
AB = [tuple(map(int, input().split())) for _ in range(N)]
AB.sort()
medicines = 0
for i in range(N):
medicines += AB[i][1]
for i in range(N):
if medicines <= K:
if i == 0:
print(1)
exit(0)
else:
print(AB[i - 1][0] + 1)
exit(0)
medicines -= AB[i][1]
# i == N - 1までprintされなかった
print(AB[i][0] + 1)
|
ConDefects/ConDefects/Code/abc309_c/Python/45772102
|
condefects-python_data_1359
|
N, K = map(int, input().split())
arr = []
total = 0
for i in range(N):
tmp1, tmp2 = map(int, input().split())
arr.append([tmp1,tmp2])
total += tmp2
arr.sort()
if total < K:
print(1)
exit()
i = 0
while 1:
total -= arr[i][1]
if total <= K:
print(arr[i][0]+1)
exit()
i += 1
N, K = map(int, input().split())
arr = []
total = 0
for i in range(N):
tmp1, tmp2 = map(int, input().split())
arr.append([tmp1,tmp2])
total += tmp2
arr.sort()
if total <= K:
print(1)
exit()
i = 0
while 1:
total -= arr[i][1]
if total <= K:
print(arr[i][0]+1)
exit()
i += 1
|
ConDefects/ConDefects/Code/abc309_c/Python/45738581
|
condefects-python_data_1360
|
n, k = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]
def calc(num):
global ab
res = 0
for j in range(n):
if ab[j][0] <= num:
continue
res += ab[j][1]
return res
l = -1
r = 9999999999999999
m = 0
while r > l + 1:
m = (r + l) // 2
if calc(m) < k:
r = m
else:
l = m
print(r + 1)
n, k = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(n)]
def calc(num):
global ab
res = 0
for j in range(n):
if ab[j][0] <= num:
continue
res += ab[j][1]
return res
l = -1
r = 9999999999999999
m = 0
while r > l + 1:
m = (r + l) // 2
if calc(m) <= k:
r = m
else:
l = m
print(r + 1)
|
ConDefects/ConDefects/Code/abc309_c/Python/46182298
|
condefects-python_data_1361
|
# python3 answer.py < input.txt
# =list(map(int, input().split()))
#=int(input())
#import collections
#import itertools
#import numpy
#from collections import deque
#import heapq
#inf=10**100
#isok=True
#import numpy as np
#np.set_printoptions(suppress=True)
#k=int(input())
#n=int(input())
#lis=[]
n,k=list(map(int, input().split()))
def cal(x,li):
res=0
for i in range(n):
if li[i][0]>=x:
res+=li[i][1]
#print(res>k)
return res>k
maxday=0
lis=[]
for i in range(n):
a,b=list(map(int, input().split()))
maxday=max(maxday,a)
lis.append([a,b])
l=-1
r=maxday
while abs(r-l)>1:
mid=(l+r)//2
#print(l,r,mid)
if cal(mid,lis):#飲む量が多いか
l=mid
else:
r=mid
if r<=0:
print(1)
else:
print(r)
# python3 answer.py < input.txt
# =list(map(int, input().split()))
#=int(input())
#import collections
#import itertools
#import numpy
#from collections import deque
#import heapq
#inf=10**100
#isok=True
#import numpy as np
#np.set_printoptions(suppress=True)
#k=int(input())
#n=int(input())
#lis=[]
n,k=list(map(int, input().split()))
def cal(x,li):
res=0
for i in range(n):
if li[i][0]>=x:
res+=li[i][1]
#print(res>k)
return res>k
maxday=0
lis=[]
for i in range(n):
a,b=list(map(int, input().split()))
maxday=max(maxday,a)
lis.append([a,b])
l=-1
r=maxday+1
while abs(r-l)>1:
mid=(l+r)//2
#print(l,r,mid)
if cal(mid,lis):#飲む量が多いか
l=mid
else:
r=mid
if r<=0:
print(1)
else:
print(r)
|
ConDefects/ConDefects/Code/abc309_c/Python/45895898
|
condefects-python_data_1362
|
DEBUG = False
testcase = r"""
15 158260522
877914575 2436426
24979445 61648772
623690081 33933447
476190629 62703497
211047202 71407775
628894325 31963982
822804784 50968417
430302156 82631932
161735902 80895728
923078537 7723857
189330739 10286918
802329211 4539679
303238506 17063340
492686568 73361868
125660016 50287940
"""[1:]
from collections import Counter, deque
import bisect
import heapq
import copy
import itertools
from distutils.util import strtobool
from pprint import pprint
from typing import *
import math
import sys
def main():
N, K = map(int, input().split())
Q = []
for _ in range(N):
a, b = map(int, input().split())
Q.append((a, b))
sum_b = sum(b for a, b in Q)
if sum_b <= K:
print(1)
return
Q.sort(key=lambda x: x[0])
day = Q[-1][0] + 1
num = 0
for a, b in reversed(Q):
if num + b < K:
num += b
else:
day = a + 1
break
print(day)
# infinity
INF = int(1e20)
# recursion setting
sys.setrecursionlimit(2_000_000_000)
# make primes
def make_primes(n: int) -> List[int]:
""" make primes lesser equal than n """
is_prime = [True] * (n + 1)
is_prime[0], is_prime[1] = False, False
for i in range(2, int(math.sqrt(n)) + 1):
if is_prime[i]:
for j in range(2 * i, n + 1, i):
is_prime[j] = False
prime_list = [i for i in range(n + 1) if is_prime[i]]
return prime_list
# binary search
# This is Memorandum-like function. So it supports ascending order only.
def binary_search(ok: int, ng: int, is_ok: Callable) -> int:
while ok + 1 != ng:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return mid
# bit shift
def bit_shift(number: int, shift: int, shift_right=False) -> int:
if not shift_right:
return int(number * (2 ** shift))
else:
return int(number / (2 ** shift))
# convert given number into list of bits
# when num_bit is 3, number: 1 -> [0, 0, 1], number: 2 -> [0, 1, 0], number: 3 -> [0, 1, 1]
def num_to_bits(number: int, num_bit: int) -> List[int]:
return list(map(strtobool, format(number, f"0{num_bit}b")))
# convert given bits to number
# [0, 1] -> 1, [1, 0, 1] -> 5, [1, 0, 1, 0] -> 6
def bits_to_num(bits: List[int]) -> int:
num = bits[0]
for i in range(1, len(bits)):
num *= 2
num += bits[i]
return num
# for bit exhaustive search
# if "num_bit" == 2, returns [[0, 0], [0, 1], [1, 0], [1, 1]]
def bit_exhaustive_enumerate(num_bit: int) -> Iterable[List[int]]:
for i in range(2 ** num_bit):
yield list(map(strtobool, format(i, f"0{num_bit}b")))
# for exhaustive permutation
# if "num_elem" == 3, returns [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
def exhaustive_permutation(num_elem: int) -> Iterable[Tuple[int]]:
numbers = list(range(num_elem))
for p in itertools.permutations(numbers):
yield p
#######################################################
# debug configuration
#######################################################
def debug_warn():
if DEBUG:
print("DEBUGGING!!! Please rewite variable DEBUG before submission!!!")
# by this operation, input() returns testcase
if DEBUG:
import sys, io
sys.stdin = io.StringIO(testcase)
debug_warn()
#######################################################
if __name__ == "__main__":
main()
debug_warn()
DEBUG = False
testcase = r"""
15 158260522
877914575 2436426
24979445 61648772
623690081 33933447
476190629 62703497
211047202 71407775
628894325 31963982
822804784 50968417
430302156 82631932
161735902 80895728
923078537 7723857
189330739 10286918
802329211 4539679
303238506 17063340
492686568 73361868
125660016 50287940
"""[1:]
from collections import Counter, deque
import bisect
import heapq
import copy
import itertools
from distutils.util import strtobool
from pprint import pprint
from typing import *
import math
import sys
def main():
N, K = map(int, input().split())
Q = []
for _ in range(N):
a, b = map(int, input().split())
Q.append((a, b))
sum_b = sum(b for a, b in Q)
if sum_b <= K:
print(1)
return
Q.sort(key=lambda x: x[0])
day = Q[-1][0] + 1
num = 0
for a, b in reversed(Q):
if num + b <= K:
num += b
else:
day = a + 1
break
print(day)
# infinity
INF = int(1e20)
# recursion setting
sys.setrecursionlimit(2_000_000_000)
# make primes
def make_primes(n: int) -> List[int]:
""" make primes lesser equal than n """
is_prime = [True] * (n + 1)
is_prime[0], is_prime[1] = False, False
for i in range(2, int(math.sqrt(n)) + 1):
if is_prime[i]:
for j in range(2 * i, n + 1, i):
is_prime[j] = False
prime_list = [i for i in range(n + 1) if is_prime[i]]
return prime_list
# binary search
# This is Memorandum-like function. So it supports ascending order only.
def binary_search(ok: int, ng: int, is_ok: Callable) -> int:
while ok + 1 != ng:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return mid
# bit shift
def bit_shift(number: int, shift: int, shift_right=False) -> int:
if not shift_right:
return int(number * (2 ** shift))
else:
return int(number / (2 ** shift))
# convert given number into list of bits
# when num_bit is 3, number: 1 -> [0, 0, 1], number: 2 -> [0, 1, 0], number: 3 -> [0, 1, 1]
def num_to_bits(number: int, num_bit: int) -> List[int]:
return list(map(strtobool, format(number, f"0{num_bit}b")))
# convert given bits to number
# [0, 1] -> 1, [1, 0, 1] -> 5, [1, 0, 1, 0] -> 6
def bits_to_num(bits: List[int]) -> int:
num = bits[0]
for i in range(1, len(bits)):
num *= 2
num += bits[i]
return num
# for bit exhaustive search
# if "num_bit" == 2, returns [[0, 0], [0, 1], [1, 0], [1, 1]]
def bit_exhaustive_enumerate(num_bit: int) -> Iterable[List[int]]:
for i in range(2 ** num_bit):
yield list(map(strtobool, format(i, f"0{num_bit}b")))
# for exhaustive permutation
# if "num_elem" == 3, returns [(0, 1, 2), (0, 2, 1), (1, 0, 2), (1, 2, 0), (2, 0, 1), (2, 1, 0)]
def exhaustive_permutation(num_elem: int) -> Iterable[Tuple[int]]:
numbers = list(range(num_elem))
for p in itertools.permutations(numbers):
yield p
#######################################################
# debug configuration
#######################################################
def debug_warn():
if DEBUG:
print("DEBUGGING!!! Please rewite variable DEBUG before submission!!!")
# by this operation, input() returns testcase
if DEBUG:
import sys, io
sys.stdin = io.StringIO(testcase)
debug_warn()
#######################################################
if __name__ == "__main__":
main()
debug_warn()
|
ConDefects/ConDefects/Code/abc309_c/Python/45788753
|
condefects-python_data_1363
|
x, y, z = map(int, input().split())
s = input()
dp = [[0]*(len(s)) for _ in range(2)]
if s[0] == "A":
dp[0][0] = z+x
dp[1][0] = y
else:
dp[0][0] = z+y
dp[1][0] = x
for j in range(1, len(s)):
if s[j] == "A":
dp[0][j] = min(dp[0][j-1]+x, dp[1][j-1]+z+x)
dp[1][j] = min(dp[0][j-1]+z+x, dp[1][j-1]+y)
else:
dp[0][j] = min(dp[0][j-1]+y, dp[1][j-1]+z+y)
dp[1][j] = min(dp[0][j-1]+z+x, dp[1][j-1]+x)
print(min(dp[0][-1], dp[1][-1]))
x, y, z = map(int, input().split())
s = input()
dp = [[0]*(len(s)) for _ in range(2)]
if s[0] == "A":
dp[0][0] = z+x
dp[1][0] = y
else:
dp[0][0] = z+y
dp[1][0] = x
for j in range(1, len(s)):
if s[j] == "A":
dp[0][j] = min(dp[0][j-1]+x, dp[1][j-1]+z+x)
dp[1][j] = min(dp[0][j-1]+z+y, dp[1][j-1]+y)
else:
dp[0][j] = min(dp[0][j-1]+y, dp[1][j-1]+z+y)
dp[1][j] = min(dp[0][j-1]+z+x, dp[1][j-1]+x)
print(min(dp[0][-1], dp[1][-1]))
|
ConDefects/ConDefects/Code/abc303_d/Python/45744343
|
condefects-python_data_1364
|
import sys
import math
from collections import deque
sys.setrecursionlimit(10**6) #pythonの無限再起を防ぐための上限変更
input = sys.stdin.readline
# 303 D
X, Y , Z = map(int, input().split())
S = input()[:-1]
INF = 10000000000
Slen = len(S)
res = [[INF]*2 for i in range(Slen+1)]
res[0][0] = 0
for i in range(Slen):
if S[i] == 'a':
if res[i][0] != INF:
res[i+1][0] = min(res[i+1][0], res[i][0] + X)
res[i+1][1] = min(res[i+1][1], res[i][0] + Z + Y)
if res[i][1] != INF:
res[i+1][0] = min(res[i+1][0], res[i][1] + Z + X)
res[i+1][1] = min(res[i+1][1], res[i][1] + Y)
elif S[i] == 'A':
if res[i][0] != INF:
res[i+1][1] = min(res[i+1][1], res[i][0] + Z + X)
res[i+1][0] = min(res[i+1][0], res[i][0] + Y)
if res[i][1] != INF:
res[i+1][1] = min(res[i+1][1], res[i][1] + X)
res[i+1][0] = min(res[i+1][0], res[i][1] + Z + Y)
print(min(res[Slen][0], res[Slen][1]))
import sys
import math
from collections import deque
sys.setrecursionlimit(10**6) #pythonの無限再起を防ぐための上限変更
input = sys.stdin.readline
# 303 D
X, Y , Z = map(int, input().split())
S = input()[:-1]
INF = 1000000000000000
Slen = len(S)
res = [[INF]*2 for i in range(Slen+1)]
res[0][0] = 0
for i in range(Slen):
if S[i] == 'a':
if res[i][0] != INF:
res[i+1][0] = min(res[i+1][0], res[i][0] + X)
res[i+1][1] = min(res[i+1][1], res[i][0] + Z + Y)
if res[i][1] != INF:
res[i+1][0] = min(res[i+1][0], res[i][1] + Z + X)
res[i+1][1] = min(res[i+1][1], res[i][1] + Y)
elif S[i] == 'A':
if res[i][0] != INF:
res[i+1][1] = min(res[i+1][1], res[i][0] + Z + X)
res[i+1][0] = min(res[i+1][0], res[i][0] + Y)
if res[i][1] != INF:
res[i+1][1] = min(res[i+1][1], res[i][1] + X)
res[i+1][0] = min(res[i+1][0], res[i][1] + Z + Y)
print(min(res[Slen][0], res[Slen][1]))
|
ConDefects/ConDefects/Code/abc303_d/Python/45489398
|
condefects-python_data_1365
|
#Six characters
def solution(string):
if len(string) == 1:
return string * 6
elif len(string) == 2:
return string * 3
else:
return string * 2
#Six characters
def solution(string):
if len(string) == 1:
return string * 6
elif len(string) == 2:
return string * 3
else:
return string * 2
string = str(input("")).lower()
print(solution(string))
|
ConDefects/ConDefects/Code/abc251_a/Python/44626841
|
condefects-python_data_1366
|
S = input()
for i in range(6):
SS = S*i
if len(SS) == 6:
print(SS)
break
S = input()
for i in range(6+1):
SS = S*i
if len(SS) == 6:
print(SS)
break
|
ConDefects/ConDefects/Code/abc251_a/Python/45011950
|
condefects-python_data_1367
|
DEBUG = 0
N, M, X = map(int, input().split())
if DEBUG:
print("N, M, X =", N, M, X)
K = 30
P = 998244353
nn = 1010
fa = [1] * (nn + 1)
fainv = [1] * (nn + 1)
for i in range(nn):
fa[i+1] = fa[i] * (i + 1) % P
fainv[-1] = pow(fa[-1], P - 2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i + 1) % P
def C(a, b):
if a <= 1000:
return fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
s = 1
for i in range(b):
s = s * (a - i) % P
return s * fainv[b] % P
cc = [[0] * (i + 3) for i in range(N + 1)]
cc[0][0] = 1
for i in range(1, N + 1):
for j in range(i + 1):
cc[i][j] = (j * cc[i-1][j-1] + (M + 1 - j) * cc[i-1][j+1])
if DEBUG:
print("cc =")
for ccc in cc:
print(ccc)
po2 = [1]
for _ in range(1010):
po2.append(po2[-1] * 2 % P)
def calc_arr(n):
if not n:
return [0]
Y = [0] * (n + 1)
Y[0] = 1
for i in range(K)[::-1]:
Mi = (M >> i) & 1
Xi = (X >> i) & 1
nY = [0] * (n + 1)
if Mi:
j = 0
for nj in range(j, n + 1):
f = C(n - j, n - nj)
if nj & 1 == Xi:
nY[nj] = (nY[nj] + Y[j] * f) % P
else:
j = 0
nj = 0
if Xi == 0:
nY[nj] = Y[j]
if Mi:
for j in range(1, n + 1):
for nj in range(j, n + 1):
f = C(n - j, n - nj) * po2[j-1] % P
nY[nj] = (nY[nj] + Y[j] * f) % P
else:
for j in range(1, n + 1):
nj = j
f = po2[j-1]
nY[nj] = (nY[nj] + Y[j] * f) % P
Y = nY
if 0:
print("Y =", Y)
return Y
for n in range(N + 1):
if 0:
print("-" * 10, "n =", n, "-" * 10)
calc_arr(n)
ARR = [sum(calc_arr(n)) % P for n in range(N + 1)]
if DEBUG:
print("ARR =", ARR)
def calc_set():
SET = [0] * (N + 1)
SET[0] = 0 if X else 1
for n in range(1, N + 1):
s = ARR[n]
for i in range(n):
s -= SET[i] * cc[n][i] % P
SET[n] = s % P * fainv[n] % P
return SET
SET = calc_set()
if DEBUG:
print("SET =", SET)
def calc_mul(n):
s = 0
for i in range(n // 2 + 1):
s += C(i + M, i) * SET[n - 2 * i] % P
return s % P
print(calc_mul(N))
DEBUG = 0
N, M, X = map(int, input().split())
if DEBUG:
print("N, M, X =", N, M, X)
K = 30
P = 998244353
nn = 1010
fa = [1] * (nn + 1)
fainv = [1] * (nn + 1)
for i in range(nn):
fa[i+1] = fa[i] * (i + 1) % P
fainv[-1] = pow(fa[-1], P - 2, P)
for i in range(nn)[::-1]:
fainv[i] = fainv[i+1] * (i + 1) % P
def C(a, b):
if a <= 1000:
return fa[a] * fainv[b] % P * fainv[a-b] % P if 0 <= b <= a else 0
s = 1
for i in range(b):
s = s * (a - i) % P
return s * fainv[b] % P
cc = [[0] * (i + 3) for i in range(N + 1)]
cc[0][0] = 1
for i in range(1, N + 1):
for j in range(i + 1):
cc[i][j] = (j * cc[i-1][j-1] + (M + 1 - j) * cc[i-1][j+1])
if DEBUG:
print("cc =")
for ccc in cc:
print(ccc)
po2 = [1]
for _ in range(1010):
po2.append(po2[-1] * 2 % P)
def calc_arr(n):
if not n:
return [0]
Y = [0] * (n + 1)
Y[0] = 1
for i in range(K)[::-1]:
Mi = (M >> i) & 1
Xi = (X >> i) & 1
nY = [0] * (n + 1)
if Mi:
j = 0
for nj in range(j, n + 1):
f = C(n - j, n - nj)
if (n - nj) & 1 == Xi:
nY[nj] = (nY[nj] + Y[j] * f) % P
else:
j = 0
nj = 0
if Xi == 0:
nY[nj] = Y[j]
if Mi:
for j in range(1, n + 1):
for nj in range(j, n + 1):
f = C(n - j, n - nj) * po2[j-1] % P
nY[nj] = (nY[nj] + Y[j] * f) % P
else:
for j in range(1, n + 1):
nj = j
f = po2[j-1]
nY[nj] = (nY[nj] + Y[j] * f) % P
Y = nY
if 0:
print("Y =", Y)
return Y
for n in range(N + 1):
if 0:
print("-" * 10, "n =", n, "-" * 10)
calc_arr(n)
ARR = [sum(calc_arr(n)) % P for n in range(N + 1)]
if DEBUG:
print("ARR =", ARR)
def calc_set():
SET = [0] * (N + 1)
SET[0] = 0 if X else 1
for n in range(1, N + 1):
s = ARR[n]
for i in range(n):
s -= SET[i] * cc[n][i] % P
SET[n] = s % P * fainv[n] % P
return SET
SET = calc_set()
if DEBUG:
print("SET =", SET)
def calc_mul(n):
s = 0
for i in range(n // 2 + 1):
s += C(i + M, i) * SET[n - 2 * i] % P
return s % P
print(calc_mul(N))
|
ConDefects/ConDefects/Code/abc288_h/Python/38697040
|
condefects-python_data_1368
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
Q = int(input())
queries = []
for i in range(Q):
l, r = map(lambda x:int(x)-1, input().split())
queries.append([l, r])
S = [[0] for i in range(K)]
for k in range(K):
for i in range(N):
if ((i*K+k)<N):
new = S[k][-1] + (A[i*K+k])
S[k].append(new)
for i in range(Q):
now = set()
l, r = queries[i]
for k in range(K):
m = (r-k)%K
lk = l//K
if k < l%K:
lk += 1
res = S[m][(r-k)//K+1] - S[m][lk]
now.add(res)
# print(now, res, (r-k)//K+1, lk, m)
if len(now)==1:
print('Yes')
else:
print('No')
N, K = map(int, input().split())
A = list(map(int, input().split()))
Q = int(input())
queries = []
for i in range(Q):
l, r = map(lambda x:int(x)-1, input().split())
queries.append([l, r])
S = [[0] for i in range(K)]
for k in range(K):
for i in range(N):
if ((i*K+k)<N):
new = S[k][-1] + (A[i*K+k])
S[k].append(new)
for i in range(Q):
now = set()
l, r = queries[i]
for k in range(K):
m = (r-k)%K
lk = l//K
if m < l%K:
lk += 1
res = S[m][(r-k)//K+1] - S[m][lk]
now.add(res)
# print(now, res, (r-k)//K+1, lk, m)
if len(now)==1:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc288_d/Python/45491325
|
condefects-python_data_1369
|
N, K = map(int,input().split())
A=list(map(int,input().split()))
Q=int(input())
S = [[0] for i in range(K)]
for i in range(N):
S[i%K].append(S[i%K][-1]+A[i])
for i in range(Q):
l, r = map(lambda x:int(x)-1,input().split())
s=set()
for k in range(K):
# s.add(S[k][(r-k)//K+1] - S[k][(l-k-1)//K+1])
# print(S[k][(r-k)//K+1],S[k][(l-k-1)//K+1])
s.add(S[k][(r-k)//K+1] - S[k][max(0, l-k-1)//K+1])
# print(S[k][(r-k)//K+1],S[k][(l-k-1)//K+1])
if len(s)==1:
print('Yes')
else:
print('No')
N, K = map(int,input().split())
A=list(map(int,input().split()))
Q=int(input())
S = [[0] for i in range(K)]
for i in range(N):
S[i%K].append(S[i%K][-1]+A[i])
for i in range(Q):
l, r = map(lambda x:int(x)-1,input().split())
s=set()
for k in range(K):
# s.add(S[k][(r-k)//K+1] - S[k][(l-k-1)//K+1])
# print(S[k][(r-k)//K+1],S[k][(l-k-1)//K+1])
s.add(S[k][(r-k)//K+1] - S[k][(l-k-1)//K+1])
# print(S[k][(r-k)//K+1],S[k][(l-k-1)//K+1])
if len(s)==1:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc288_d/Python/45491126
|
condefects-python_data_1370
|
class segtreelazy3:
# 要素数、乗せる演算、単位元、作用、作用素の演算、恒等写像になる作用素
def __init__(self, N, op, e, act, comp, identity, A = []):
self.N = N
self.op = op
self.e = e
self.act = act
self.comp = comp
self.identity = identity
self.dat = [self.e] * (2 * self.N)
self.lazy = [self.identity] * (2 * self.N)
for i in range(len(A)):
self.dat[i + self.N] = A[i]
for i in range(self.N - 1, 0, -1):
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
def _getidx1(self, i):
i >>= 1
while i:
yield i
i >>= 1
def _getidx2(self, l, r):
l0 = l // (l & -l)
r0 = r // (r & -r)
while l < r:
if l < l0:
yield l
if r < r0:
yield r
l >>= 1
r >>= 1
while l:
yield l
l >>= 1
def eval(self, idx):
for i in reversed(idx):
x = self.lazy[i]
if x == self.identity: continue
if i < self.N:
self.lazy[i << 1] = self.comp(self.lazy[i << 1], x)
self.dat[i << 1] = self.act(self.dat[i << 1], x)
self.lazy[i << 1 | 1] = self.comp(self.lazy[i << 1 | 1], x)
self.dat[i << 1 | 1] = self.act(self.dat[i << 1 | 1], x)
self.lazy[i] = self.identity
def apply(self, l, r, x):
l += self.N
r += self.N
*idx, = self._getidx2(l, r)
self.eval(idx)
while l < r:
if l & 1:
self.lazy[l] = self.comp(self.lazy[l], x)
self.dat[l] = self.act(self.dat[l], x)
l += 1
if r & 1:
r -= 1
self.lazy[r] = self.comp(self.lazy[r], x)
self.dat[r] = self.act(self.dat[r], x)
l >>= 1
r >>= 1
for i in idx:
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
def prod(self, l, r):
l += self.N
r += self.N
*idx, = self._getidx2(l, r)
self.eval(idx)
lres = self.e
rres = self.e
while l < r:
if l & 1:
lres = self.op(lres, self.dat[l])
l += 1
if r & 1:
r -= 1
rres = self.op(rres, self.dat[r])
l >>= 1
r >>= 1
return self.op(lres, rres)
def set(self, i, a):
i += self.N
*idx, = self._getidx1(i)
self.eval(idx)
self.dat[i] = a
self.lazy[i] = self.identity
for i in idx:
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
N, Q = map(int, input().split())
# 0, 1, 2, (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)
A = [
(1, 0, 0, 0, 0, 0, 0, 0, 0),
(0, 1, 0, 0, 0, 0, 0, 0, 0),
(0, 0, 1, 0, 0, 0, 0, 0, 0)
]
B = list(map(lambda x: A[int(x)], input().split()))
idx = [-1, 3, 4, 5, -1, 6, 7, 8, -1]
def op(A, B):
return (
A[0] + B[0],
A[1] + B[1],
A[2] + B[2],
A[3] + B[3] + A[0] * B[1],
A[4] + B[4] + A[0] * B[2],
A[5] + B[5] + A[1] * B[0],
A[6] + B[6] + A[1] * B[2],
A[7] + B[7] + A[2] * B[0],
A[8] + B[8] + A[2] * B[1]
)
def act(A, F):
res = [0] * 9
for i in range(3): res[F[i]] += A[i]
for i, a, b in ((3, 0, 1), (4, 0, 2), (5, 1, 0), (6, 1, 2), (7, 2, 0), (8, 2, 1)):
j = idx[F[a] * 3 + F[b]]
if j != -1: res[j] += A[i]
return tuple(res)
def comp(F, G):
return (G[F[0]], G[F[1]], G[F[2]])
e = (0, 0, 0, 0, 0, 0, 0, 0, 0)
identity = (0, 1, 2)
tree = segtreelazy3(N, op, e, act, comp, identity, B)
for _ in range(Q):
k, *query = map(int, input().split())
if k == 1:
l, r = query
l -= 1
res = tree.prod(l, r)
print(res[5] + res[7] + res[8])
else:
l, r, s, t, u = query
l -= 1
tree.apply(l, r, (s, t, u))
class segtreelazy3:
# 要素数、乗せる演算、単位元、作用、作用素の演算、恒等写像になる作用素
def __init__(self, N, op, e, act, comp, identity, A = []):
self.N = N
self.op = op
self.e = e
self.act = act
self.comp = comp
self.identity = identity
self.dat = [self.e] * (2 * self.N)
self.lazy = [self.identity] * (2 * self.N)
for i in range(len(A)):
self.dat[i + self.N] = A[i]
for i in range(self.N - 1, 0, -1):
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
def _getidx1(self, i):
i >>= 1
while i:
yield i
i >>= 1
def _getidx2(self, l, r):
l0 = l // (l & -l)
r0 = r // (r & -r)
while l < r:
if l < l0:
yield l
if r < r0:
yield r
l >>= 1
r >>= 1
while l:
yield l
l >>= 1
def eval(self, idx):
for i in reversed(idx):
x = self.lazy[i]
if x == self.identity: continue
if i < self.N:
self.lazy[i << 1] = self.comp(self.lazy[i << 1], x)
self.dat[i << 1] = self.act(self.dat[i << 1], x)
self.lazy[i << 1 | 1] = self.comp(self.lazy[i << 1 | 1], x)
self.dat[i << 1 | 1] = self.act(self.dat[i << 1 | 1], x)
self.lazy[i] = self.identity
def apply(self, l, r, x):
l += self.N
r += self.N
*idx, = self._getidx2(l, r)
self.eval(idx)
while l < r:
if l & 1:
self.lazy[l] = self.comp(self.lazy[l], x)
self.dat[l] = self.act(self.dat[l], x)
l += 1
if r & 1:
r -= 1
self.lazy[r] = self.comp(self.lazy[r], x)
self.dat[r] = self.act(self.dat[r], x)
l >>= 1
r >>= 1
for i in idx:
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
def prod(self, l, r):
l += self.N
r += self.N
*idx, = self._getidx2(l, r)
self.eval(idx)
lres = self.e
rres = self.e
while l < r:
if l & 1:
lres = self.op(lres, self.dat[l])
l += 1
if r & 1:
r -= 1
rres = self.op(self.dat[r], rres)
l >>= 1
r >>= 1
return self.op(lres, rres)
def set(self, i, a):
i += self.N
*idx, = self._getidx1(i)
self.eval(idx)
self.dat[i] = a
self.lazy[i] = self.identity
for i in idx:
self.dat[i] = self.op(self.dat[i << 1], self.dat[i << 1 | 1])
N, Q = map(int, input().split())
# 0, 1, 2, (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)
A = [
(1, 0, 0, 0, 0, 0, 0, 0, 0),
(0, 1, 0, 0, 0, 0, 0, 0, 0),
(0, 0, 1, 0, 0, 0, 0, 0, 0)
]
B = list(map(lambda x: A[int(x)], input().split()))
idx = [-1, 3, 4, 5, -1, 6, 7, 8, -1]
def op(A, B):
return (
A[0] + B[0],
A[1] + B[1],
A[2] + B[2],
A[3] + B[3] + A[0] * B[1],
A[4] + B[4] + A[0] * B[2],
A[5] + B[5] + A[1] * B[0],
A[6] + B[6] + A[1] * B[2],
A[7] + B[7] + A[2] * B[0],
A[8] + B[8] + A[2] * B[1]
)
def act(A, F):
res = [0] * 9
for i in range(3): res[F[i]] += A[i]
for i, a, b in ((3, 0, 1), (4, 0, 2), (5, 1, 0), (6, 1, 2), (7, 2, 0), (8, 2, 1)):
j = idx[F[a] * 3 + F[b]]
if j != -1: res[j] += A[i]
return tuple(res)
def comp(F, G):
return (G[F[0]], G[F[1]], G[F[2]])
e = (0, 0, 0, 0, 0, 0, 0, 0, 0)
identity = (0, 1, 2)
tree = segtreelazy3(N, op, e, act, comp, identity, B)
for _ in range(Q):
k, *query = map(int, input().split())
if k == 1:
l, r = query
l -= 1
res = tree.prod(l, r)
print(res[5] + res[7] + res[8])
else:
l, r, s, t, u = query
l -= 1
tree.apply(l, r, (s, t, u))
|
ConDefects/ConDefects/Code/abc265_g/Python/46700668
|
condefects-python_data_1371
|
class UnionFind():
def __init__(self, n):
self.n = n
self.PA = [-1] * n
def root(self, a):
L = []
while self.PA[a] >= 0:
L.append(a)
a = self.PA[a]
for l in L:
self.PA[l] = a
return a
def unite(self, a, b):
ra, rb = self.root(a), self.root(b)
if ra != rb:
if self.PA[rb] >= self.PA[ra]:
self.PA[ra] += self.PA[rb]
self.PA[rb] = ra
else:
self.PA[rb] += self.PA[ra]
self.PA[ra] = rb
def same(self, a, b):
return 1 if self.root(a) == self.root(b) else 0
def size(self, a):
return -self.PA[self.root(a)]
def groups(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [g for g in G if g]
def groups_index(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
cnt = 0
GG = []
I = [-1] * self.n
for i in range(self.n):
if G[i]:
GG.append(G[i])
I[i] = cnt
cnt += 1
for i in range(self.n):
I[i] = I[self.root(i)]
return GG, I
def group_size(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [len(g) for g in G if g]
def roots(self):
return [i for i in range(self.n) if self.PA[i] < 0]
class UnionFindDict():
def __init__(self):
self.PA = {}
def root(self, a):
L = []
while self.PA[a] >= 0:
L.append(a)
a = self.PA[a]
for l in L:
self.PA[l] = a
return a
def addNode(self, a):
if a not in self.PA:
self.PA[a] = -1
def unite(self, a, b):
self.addNode(a)
self.addNode(b)
ra, rb = self.root(a), self.root(b)
if ra != rb:
if self.PA[rb] >= self.PA[ra]:
self.PA[ra] += self.PA[rb]
self.PA[rb] = ra
else:
self.PA[rb] += self.PA[ra]
self.PA[ra] = rb
def same(self, a, b):
self.addNode(a)
self.addNode(b)
return 1 if self.root(a) == self.root(b) else 0
def size(self, a):
self.addNode(a)
return -self.PA[self.root(a)]
def groups(self):
G = {}
for i in self.PA:
rt = self.root(i)
if rt in G:
G[rt].append(i)
else:
G[rt] = [i]
return {g: G[g] for g in G}
def groups_index(self):
G = {}
for i in self.PA:
rt = self.root(i)
if rt in G:
G[rt].append(i)
else:
G[rt] = [i]
cnt = 0
GG = []
# I = [-1] * self.n
I = {}
for i in self.PA:
if i in G:
GG.append(G[i])
I[i] = cnt
cnt += 1
for i in self.PA:
I[i] = I[self.root(i)]
return GG, I
def group_size(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [len(g) for g in G if g]
P = 998244353
def convolve(a, b, k = -1):
n0 = len(a) + len(b) - 1
if k >= 0:
n0 = min(n0, k)
ret = [0] * n0
if len(a) > len(b): a, b = b, a
for i, aa in enumerate(a):
for j, bb in enumerate(b):
if i + j < n0:
ret[i+j] = (ret[i+j] + aa * bb) % P
return ret
import sys
input = lambda: sys.stdin.readline().rstrip()
N, M, K = map(int, input().split())
I = []
S = set()
for _ in range(M):
a, b, c = map(int, input().split())
a, b = a-1, b-1
I.append((a, b, c))
S.add(c)
SS = sorted(S)
n = len(SS)
D = {a: i for i, a in enumerate(SS)}
E = [[] for _ in range(n)]
for a, b, c in I:
E[D[c]].append((a, b))
X = [[1, 1] for _ in range(N)]
uf = UnionFind(N)
for EE in E:
ufd = UnionFindDict()
for a, b in EE:
ra = uf.root(a)
rb = uf.root(b)
if ra != rb:
ufd.unite(ra, rb)
for a, b in EE:
ra = uf.root(a)
rb = uf.root(b)
uf.unite(ra, rb)
G = ufd.groups()
for g, L in G.items():
nrt = uf.root(g)
c = 0
A = [1]
for i in L:
c += 1
A = convolve(A, X[i], K + 3)
if c < len(A):
A[c] = (A[c] - 1) % P
A[1] = (A[1] + 1) % P
X[nrt] = A
A = [1]
for i in uf.roots():
A = convolve(A, X[i], K + 1)
print(sum(A))
class UnionFind():
def __init__(self, n):
self.n = n
self.PA = [-1] * n
def root(self, a):
L = []
while self.PA[a] >= 0:
L.append(a)
a = self.PA[a]
for l in L:
self.PA[l] = a
return a
def unite(self, a, b):
ra, rb = self.root(a), self.root(b)
if ra != rb:
if self.PA[rb] >= self.PA[ra]:
self.PA[ra] += self.PA[rb]
self.PA[rb] = ra
else:
self.PA[rb] += self.PA[ra]
self.PA[ra] = rb
def same(self, a, b):
return 1 if self.root(a) == self.root(b) else 0
def size(self, a):
return -self.PA[self.root(a)]
def groups(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [g for g in G if g]
def groups_index(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
cnt = 0
GG = []
I = [-1] * self.n
for i in range(self.n):
if G[i]:
GG.append(G[i])
I[i] = cnt
cnt += 1
for i in range(self.n):
I[i] = I[self.root(i)]
return GG, I
def group_size(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [len(g) for g in G if g]
def roots(self):
return [i for i in range(self.n) if self.PA[i] < 0]
class UnionFindDict():
def __init__(self):
self.PA = {}
def root(self, a):
L = []
while self.PA[a] >= 0:
L.append(a)
a = self.PA[a]
for l in L:
self.PA[l] = a
return a
def addNode(self, a):
if a not in self.PA:
self.PA[a] = -1
def unite(self, a, b):
self.addNode(a)
self.addNode(b)
ra, rb = self.root(a), self.root(b)
if ra != rb:
if self.PA[rb] >= self.PA[ra]:
self.PA[ra] += self.PA[rb]
self.PA[rb] = ra
else:
self.PA[rb] += self.PA[ra]
self.PA[ra] = rb
def same(self, a, b):
self.addNode(a)
self.addNode(b)
return 1 if self.root(a) == self.root(b) else 0
def size(self, a):
self.addNode(a)
return -self.PA[self.root(a)]
def groups(self):
G = {}
for i in self.PA:
rt = self.root(i)
if rt in G:
G[rt].append(i)
else:
G[rt] = [i]
return {g: G[g] for g in G}
def groups_index(self):
G = {}
for i in self.PA:
rt = self.root(i)
if rt in G:
G[rt].append(i)
else:
G[rt] = [i]
cnt = 0
GG = []
# I = [-1] * self.n
I = {}
for i in self.PA:
if i in G:
GG.append(G[i])
I[i] = cnt
cnt += 1
for i in self.PA:
I[i] = I[self.root(i)]
return GG, I
def group_size(self):
G = [[] for _ in range(self.n)]
for i in range(self.n):
G[self.root(i)].append(i)
return [len(g) for g in G if g]
P = 998244353
def convolve(a, b, k = -1):
n0 = len(a) + len(b) - 1
if k >= 0:
n0 = min(n0, k)
ret = [0] * n0
if len(a) > len(b): a, b = b, a
for i, aa in enumerate(a):
for j, bb in enumerate(b):
if i + j < n0:
ret[i+j] = (ret[i+j] + aa * bb) % P
return ret
import sys
input = lambda: sys.stdin.readline().rstrip()
N, M, K = map(int, input().split())
I = []
S = set()
for _ in range(M):
a, b, c = map(int, input().split())
a, b = a-1, b-1
I.append((a, b, c))
S.add(c)
SS = sorted(S)
n = len(SS)
D = {a: i for i, a in enumerate(SS)}
E = [[] for _ in range(n)]
for a, b, c in I:
E[D[c]].append((a, b))
X = [[1, 1] for _ in range(N)]
uf = UnionFind(N)
for EE in E:
ufd = UnionFindDict()
for a, b in EE:
ra = uf.root(a)
rb = uf.root(b)
if ra != rb:
ufd.unite(ra, rb)
for a, b in EE:
ra = uf.root(a)
rb = uf.root(b)
uf.unite(ra, rb)
G = ufd.groups()
for g, L in G.items():
nrt = uf.root(g)
c = 0
A = [1]
for i in L:
c += 1
A = convolve(A, X[i], K + 3)
if c < len(A):
A[c] = (A[c] - 1) % P
A[1] = (A[1] + 1) % P
X[nrt] = A
A = [1]
for i in uf.roots():
A = convolve(A, X[i], K + 1)
print(sum(A) % P)
|
ConDefects/ConDefects/Code/abc235_h/Python/29171105
|
condefects-python_data_1372
|
h,w=map(int,input().split())
g=[]
for i in range(h):
tmp=input()
g.append(list(tmp))
visited=[[False]*w for _ in range(h)]
i,j=0,0
for k in range(10**6):
if visited[i][j]==True:
print(-1)
exit()
if g[i][j]=="U":
if i==0:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
i-=1
if g[i][j]=="D":
if i==h-1:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
i+=1
if g[i][j]=="L":
if j==0:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
j-=1
if g[i][j]=="W":
if j==w-1:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
j+=1
h,w=map(int,input().split())
g=[]
for i in range(h):
tmp=input()
g.append(list(tmp))
visited=[[False]*w for _ in range(h)]
i,j=0,0
for k in range(10**6):
if visited[i][j]==True:
print(-1)
exit()
if g[i][j]=="U":
if i==0:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
i-=1
if g[i][j]=="D":
if i==h-1:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
i+=1
if g[i][j]=="L":
if j==0:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
j-=1
if g[i][j]=="R":
if j==w-1:
print(i+1,j+1)
exit()
else:
visited[i][j]=True
j+=1
|
ConDefects/ConDefects/Code/abc265_c/Python/46154642
|
condefects-python_data_1373
|
import sys
import math
N, M = map(int, input().split())
S = [[0]*500 for _ in range(500)]
base = list(range(23))
for i in range(500):
for j in range(500):
x = j//23
S[i][j] = (i+j+(x*(i//23)))%23
for i in range(N):
print(*S[i][:M])
import sys
import math
N, M = map(int, input().split())
S = [[0]*500 for _ in range(500)]
base = list(range(23))
for i in range(500):
for j in range(500):
x = j//23
S[i][j] = (i+j+(x*(i//23)))%23
for i in range(N):
print(*map(lambda x: x+1, S[i][:M]))
|
ConDefects/ConDefects/Code/arc140_e/Python/31730234
|
condefects-python_data_1374
|
import copy
import gc
import itertools
from array import array
from fractions import Fraction
import heapq
import math
import operator
import os, sys
import profile
import cProfile
import random
import re
import string
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
from functools import reduce
from io import IOBase, BytesIO
from itertools import count, groupby, accumulate, permutations, combinations_with_replacement, product
from math import gcd
from operator import xor, add
from typing import List
input = lambda: sys.stdin.readline().rstrip("\r\n")
# print = lambda d: sys.stdout.write(str(d)+"\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
### CODE HERE
# f = open('inputs', 'r')
# def input(): return f.readline().rstrip("\r\n")
# sys.setrecursionlimit(212345)
P = 23
def solve(n, m):
for i in range(n):
print(*[(i // P * j // P + i + j) % P + 1 for j in range(m)])
def main():
n, m = read_int_tuple()
solve(n, m)
if __name__ == "__main__":
main()
# cProfile.run("main()")
import copy
import gc
import itertools
from array import array
from fractions import Fraction
import heapq
import math
import operator
import os, sys
import profile
import cProfile
import random
import re
import string
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
from functools import reduce
from io import IOBase, BytesIO
from itertools import count, groupby, accumulate, permutations, combinations_with_replacement, product
from math import gcd
from operator import xor, add
from typing import List
input = lambda: sys.stdin.readline().rstrip("\r\n")
# print = lambda d: sys.stdout.write(str(d)+"\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
### CODE HERE
# f = open('inputs', 'r')
# def input(): return f.readline().rstrip("\r\n")
# sys.setrecursionlimit(212345)
P = 23
def solve(n, m):
for i in range(n):
print(*[((i // P) * (j // P) + i + j) % P + 1 for j in range(m)])
def main():
n, m = read_int_tuple()
solve(n, m)
if __name__ == "__main__":
main()
# cProfile.run("main()")
|
ConDefects/ConDefects/Code/arc140_e/Python/31744615
|
condefects-python_data_1375
|
import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
INF = 2 ** 63 - 1
mod = 998244353
n, m = mi()
a = [[0] * (m) for _ in range(n)]
for i in range(n):
for j in range(m):
a[i][j] = (i // 23 + j // 23 + i + j) % 23 + 1
for v in a:
print(*v)
import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
INF = 2 ** 63 - 1
mod = 998244353
n, m = mi()
a = [[0] * (m) for _ in range(n)]
for i in range(n):
for j in range(m):
a[i][j] = ((i // 23) * (j // 23) + i + j) % 23 + 1
for v in a:
print(*v)
|
ConDefects/ConDefects/Code/arc140_e/Python/32291548
|
condefects-python_data_1376
|
n,m=map(int,input().split())
ans=[]
for i in range(n):
ans.append([])
for j in range(m):
ans[-1].append(1)
for i in range(n):
for j in range(m):
ans[i][j]=(i+j+i//23*j//23)%23+1
for i in range(n):
print(' '.join(map(str,ans[i])))
n,m=map(int,input().split())
ans=[]
for i in range(n):
ans.append([])
for j in range(m):
ans[-1].append(1)
for i in range(n):
for j in range(m):
ans[i][j]=(i+j+(i//23)*(j//23))%23+1
for i in range(n):
print(' '.join(map(str,ans[i])))
|
ConDefects/ConDefects/Code/arc140_e/Python/31727392
|
condefects-python_data_1377
|
n = int(input())
c = input()
head = c[0]
tail = c[1:]
if head == "B":
# tail中のAとBを反転
tail = tail.replace("A", "C").replace("B", "A").replace("C", "B")
def sign2char(n):
if n == 0:
return "C"
elif n > 0:
return "A"
else:
return "B"
# 初期化
count = [1]
for t in tail:
if t == "A":
count.append(count[-1] + 1)
else: # "B"
count.append(count[-1] - 1)
ans = 1
# 先頭を1つずつ後ろにずらしていく
for i in range(n-1):
before = count[i]
if head != tail[i]:
after = before - 2
else:
after = before
if sign2char(before) != sign2char(after):
ans += 1
print(ans)
n = int(input())
c = input()
head = c[0]
tail = c[1:]
if head == "B":
# tail中のAとBを反転
tail = tail.replace("A", "C").replace("B", "A").replace("C", "B")
def sign2char(n):
if n == 0:
return "C"
elif n > 0:
return "A"
else:
return "B"
# 初期化
count = [1]
for t in tail:
if t == "A":
count.append(count[-1] + 1)
else: # "B"
count.append(count[-1] - 1)
ans = 1
# 先頭を1つずつ後ろにずらしていく
for i in range(n-1):
before = count[i]
if tail[i] != "A":
after = before - 2
else:
after = before
if sign2char(before) != sign2char(after):
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/arc172_c/Python/51141760
|
condefects-python_data_1378
|
from collections import deque
import sys
import math
import heapq
import random
import itertools
from functools import cmp_to_key
from fractions import Fraction
def gs():
return sys.stdin.readline().split()[0]
def gd():
return float(sys.stdin.readline())
def gi():
return int(sys.stdin.readline())
def gia():
return list(map(int,sys.stdin.readline().split()))
def gsa():
return sys.stdin.readline().split()
def readGraph(N,M, idx=0, hasDirect=False, hasCost=False):
G=[]
if(hasCost):
G=Graph(N)
else:
for i in range(N):
G.append([])
for i in range(M):
E=gia()
if(not hasCost):
u=E[0]-(1-idx)
v=E[1]-(1-idx)
G[u].append(v)
if(not hasDirect):
G[v].append(u)
else:
u=E[0]-(1-idx)
v=E[1]-(1-idx)
c=E[2]
G.addEdge(u,v,c)
if(not hasDirect):
G.addEdge(v,u,c)
return G
def ceil_pow2(n):
x=0
while((1<<x)<n):
x+=1
return x
def uclid(m, n):
if(n==0):
return m
else:
return uclid(n, m%n)
#拡張ユークリッドの互除法
def invGcd(a, b):
a%=b
if a==0: return b,0
s, t=b, a
m0, m1=0,1
while(t):
u=s//t
s-=t*u
m0-=m1*u
s,t=t,s
m0,m1=m1,m0
if m0<0: m0+=b//s
return s,m0
# 逆元を求める。存在しないときは-1を返す
def invMod(x, m):
z=invGcd(x,m)
if(z[0]!=1):return -1
return z[1]
#約数取得
def yakusu(n):
l=[]
for i in range(1, n+1):
if(i*i>n):
break;
if(n%i==0):
l.append(i)
if(n/i!=i):
l.append(n//i)
return l
def insuB(n):
l=[]
i=2
while(i*i<=n):
if(n%i==0):
l.append(i)
n=n//i
else:
i+=1
if(n!=1):
l.append(n)
return l
def insuBm(n):
m=dict()
for i in range(2, n):
if(i*i>n):break
while(n%i==0):
if(not(i in m)):
m[i]=1
else:
m[i]+=1
n=n//i
if(n!=1):
if(not(n in m)):
m[n]=1
else:
m[n]+=1
return m
KAIJO_DP=[0]*4000000
def kaijo(n, mod):
if(n<=1):
return 1
if(KAIJO_DP[n]!=0):
return KAIJO_DP[n]
ans=n*kaijo(n-1, mod)
ans%=mod
KAIJO_DP[n]=ans
return ans
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def beforeCmb(num,mod):
for i in range( 2, num + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
def isP(n):
if(n==1):
return False
for i in range(2, math.floor(math.sqrt(n))+1):
if(n%i==0):
return False
return True
def nextCombination(sub):
x=sub & (-sub)
y=sub+x
return (((sub & ~y) // x) >> 1) | y
class FenwickTree:
def __init__(self, n):
self.N = n
self.data = [0] * n
def add(self, p, x):
if(p<0 or p >= self.N):
return None
p+=1
while(p<=self.N):
self.data[p-1]+=x
p+=p&-p;
def get(self, l, r):
if(l<0 or l>r or r>self.N):
return -(1<<64)
return self._innerSum(r) - self._innerSum(l)
def _innerSum(self, r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
class FenwickTreeImos:
def __init__(self, n):
self.fw = FenwickTree(n+1)
def add(self, s, t, x):
self.fw.add(s, x)
self.fw.add(t, -x)
def get(self, i):
return self[i]
def __getitem__(self, key):
return self.fw.get(0, key+1)
class Edge:
def __init__(self, f, t, c):
self._from=f
self._to=t
self._cost=c
def getStart(self):
return self._from
def getEnd(self):
return self._to
def getDistance(self):
return self._cost
def setDistance(self, c):
self._cost =c
class Graph:
def __init__(self, n):
self.gla=[]
self.prev=[-1]*n
for i in range(n):
self.gla.append([])
def addEdge(self, u, v, l):
e=Edge(u, v, l)
self.gla[u].append(e)
def removeEdge(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
l.remove(edge)
def changeLength(self, u, v, d):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
edge.setDistance(d)
break
def getVertexNum(self):
return len(self.gla)
def getEdgeLength(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
return edge.getDistance()
return 1<<64
def dijkstra(self, start):
d=[1<<64] * self.getVertexNum()
d[start]=0
q=[]
heapq.heappush(q, (0, start))
self.prev[start]=-1
while(len(q)!=0):
p=heapq.heappop(q)
if(p[0]>d[p[1]]):
continue
el=self.gla[p[1]]
for edge in el:
to=edge.getEnd()
fr=edge.getStart()
cost=edge.getDistance()
if(d[to]>d[fr]+cost):
d[to]=d[fr]+cost
self.prev[to]=fr
heapq.heappush(q, (d[to], to))
return d
def getPath(self, v):
path=[]
while(v!=-1):
path.append(v)
v=self.prev[v]
path.reverse()
return path
class SegTree:
def __init__(self, v, op, e):
self.n=len(v)
self.log=ceil_pow2(self.n)
self.size=1<<self.log
self.op=op
self.e=e
self.d=[e]*(2*self.size)
for i in range(self.n):
self.d[self.size+i]=v[i]
for i in range(self.size-1, 0, -1):
self._update(i)
def setVal(self, p, x):
p+=self.size
self.d[p]=x
for i in range(1, self.log+1):
self._update(p>>i)
def getVal(self, p):
return self.d[p+self.size]
def prod(self, l, r):
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if(l&1 != 0):
sml=self.op(sml, self.d[l])
l+=1
if(r&1 != 0):
r-=1
smr=self.op(self.d[r], smr)
l>>=1
r>>=1
return self.op(sml,smr)
def allProd(self):
return self.d[1]
def maxRight(self, l, f):
if(l==self.n):return self.n
l+=self.size
sm=self.e
while True:
while(l%2==0):
l>>=1
if(not f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if(f(self.op(sm, self.d[l]))):
sm=self.op(sm, self.d[l])
l+=1
return l-self.size
sm=self.op(sm, self.d[l])
l+=1
if((l & -l) == l):break
return self.n
def minLeft(self, r, f):
if(r==0):return 0
r+=self.size
sm=self.e
while(True):
r-=1
while(r>1 and r%2==1):
r>>=1
if(not f(self.op(self.d[r], sm))):
while(r<self.size):
r=2*r+1
if(f(self.op(self.d[r],sm))):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r], sm)
if((r&-r)==r):break
return 0
def _update(self, k):
self.d[k]=self.op(self.d[2*k], self.d[2*k+1])
def main_():
N=gi()
S=gs()
T=gs()
ans=[]
zo=0
oz=0
for i in range(N):
if(S[i]!=T[i]):
if(S[i]=='0'):
zo+=1
else:
oz+=1
if((zo+oz)%2==1):
print(-1)
return
sa=abs(oz-zo)//2
for i in range(N):
ans.append('0')
if(zo>oz):
for i in range(N-1,-1,-1):
if(S[i]=='0' and T[i]=='1'):
ans[i]='1'
sa-=1
if(sa==0):
break
else:
for i in range(N-1,-1,-1):
if(S[i]=='1' and T[i]=='0'):
ans[i]='1'
sa-=1
if(sa==0):
break
print(''.join(ans))
main_()
from collections import deque
import sys
import math
import heapq
import random
import itertools
from functools import cmp_to_key
from fractions import Fraction
def gs():
return sys.stdin.readline().split()[0]
def gd():
return float(sys.stdin.readline())
def gi():
return int(sys.stdin.readline())
def gia():
return list(map(int,sys.stdin.readline().split()))
def gsa():
return sys.stdin.readline().split()
def readGraph(N,M, idx=0, hasDirect=False, hasCost=False):
G=[]
if(hasCost):
G=Graph(N)
else:
for i in range(N):
G.append([])
for i in range(M):
E=gia()
if(not hasCost):
u=E[0]-(1-idx)
v=E[1]-(1-idx)
G[u].append(v)
if(not hasDirect):
G[v].append(u)
else:
u=E[0]-(1-idx)
v=E[1]-(1-idx)
c=E[2]
G.addEdge(u,v,c)
if(not hasDirect):
G.addEdge(v,u,c)
return G
def ceil_pow2(n):
x=0
while((1<<x)<n):
x+=1
return x
def uclid(m, n):
if(n==0):
return m
else:
return uclid(n, m%n)
#拡張ユークリッドの互除法
def invGcd(a, b):
a%=b
if a==0: return b,0
s, t=b, a
m0, m1=0,1
while(t):
u=s//t
s-=t*u
m0-=m1*u
s,t=t,s
m0,m1=m1,m0
if m0<0: m0+=b//s
return s,m0
# 逆元を求める。存在しないときは-1を返す
def invMod(x, m):
z=invGcd(x,m)
if(z[0]!=1):return -1
return z[1]
#約数取得
def yakusu(n):
l=[]
for i in range(1, n+1):
if(i*i>n):
break;
if(n%i==0):
l.append(i)
if(n/i!=i):
l.append(n//i)
return l
def insuB(n):
l=[]
i=2
while(i*i<=n):
if(n%i==0):
l.append(i)
n=n//i
else:
i+=1
if(n!=1):
l.append(n)
return l
def insuBm(n):
m=dict()
for i in range(2, n):
if(i*i>n):break
while(n%i==0):
if(not(i in m)):
m[i]=1
else:
m[i]+=1
n=n//i
if(n!=1):
if(not(n in m)):
m[n]=1
else:
m[n]+=1
return m
KAIJO_DP=[0]*4000000
def kaijo(n, mod):
if(n<=1):
return 1
if(KAIJO_DP[n]!=0):
return KAIJO_DP[n]
ans=n*kaijo(n-1, mod)
ans%=mod
KAIJO_DP[n]=ans
return ans
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
def beforeCmb(num,mod):
for i in range( 2, num + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
def isP(n):
if(n==1):
return False
for i in range(2, math.floor(math.sqrt(n))+1):
if(n%i==0):
return False
return True
def nextCombination(sub):
x=sub & (-sub)
y=sub+x
return (((sub & ~y) // x) >> 1) | y
class FenwickTree:
def __init__(self, n):
self.N = n
self.data = [0] * n
def add(self, p, x):
if(p<0 or p >= self.N):
return None
p+=1
while(p<=self.N):
self.data[p-1]+=x
p+=p&-p;
def get(self, l, r):
if(l<0 or l>r or r>self.N):
return -(1<<64)
return self._innerSum(r) - self._innerSum(l)
def _innerSum(self, r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
class FenwickTreeImos:
def __init__(self, n):
self.fw = FenwickTree(n+1)
def add(self, s, t, x):
self.fw.add(s, x)
self.fw.add(t, -x)
def get(self, i):
return self[i]
def __getitem__(self, key):
return self.fw.get(0, key+1)
class Edge:
def __init__(self, f, t, c):
self._from=f
self._to=t
self._cost=c
def getStart(self):
return self._from
def getEnd(self):
return self._to
def getDistance(self):
return self._cost
def setDistance(self, c):
self._cost =c
class Graph:
def __init__(self, n):
self.gla=[]
self.prev=[-1]*n
for i in range(n):
self.gla.append([])
def addEdge(self, u, v, l):
e=Edge(u, v, l)
self.gla[u].append(e)
def removeEdge(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
l.remove(edge)
def changeLength(self, u, v, d):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
edge.setDistance(d)
break
def getVertexNum(self):
return len(self.gla)
def getEdgeLength(self, u, v):
l=self.gla[u]
for edge in l:
if(edge.getStart() == u and edge.getEnd()==v):
return edge.getDistance()
return 1<<64
def dijkstra(self, start):
d=[1<<64] * self.getVertexNum()
d[start]=0
q=[]
heapq.heappush(q, (0, start))
self.prev[start]=-1
while(len(q)!=0):
p=heapq.heappop(q)
if(p[0]>d[p[1]]):
continue
el=self.gla[p[1]]
for edge in el:
to=edge.getEnd()
fr=edge.getStart()
cost=edge.getDistance()
if(d[to]>d[fr]+cost):
d[to]=d[fr]+cost
self.prev[to]=fr
heapq.heappush(q, (d[to], to))
return d
def getPath(self, v):
path=[]
while(v!=-1):
path.append(v)
v=self.prev[v]
path.reverse()
return path
class SegTree:
def __init__(self, v, op, e):
self.n=len(v)
self.log=ceil_pow2(self.n)
self.size=1<<self.log
self.op=op
self.e=e
self.d=[e]*(2*self.size)
for i in range(self.n):
self.d[self.size+i]=v[i]
for i in range(self.size-1, 0, -1):
self._update(i)
def setVal(self, p, x):
p+=self.size
self.d[p]=x
for i in range(1, self.log+1):
self._update(p>>i)
def getVal(self, p):
return self.d[p+self.size]
def prod(self, l, r):
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if(l&1 != 0):
sml=self.op(sml, self.d[l])
l+=1
if(r&1 != 0):
r-=1
smr=self.op(self.d[r], smr)
l>>=1
r>>=1
return self.op(sml,smr)
def allProd(self):
return self.d[1]
def maxRight(self, l, f):
if(l==self.n):return self.n
l+=self.size
sm=self.e
while True:
while(l%2==0):
l>>=1
if(not f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if(f(self.op(sm, self.d[l]))):
sm=self.op(sm, self.d[l])
l+=1
return l-self.size
sm=self.op(sm, self.d[l])
l+=1
if((l & -l) == l):break
return self.n
def minLeft(self, r, f):
if(r==0):return 0
r+=self.size
sm=self.e
while(True):
r-=1
while(r>1 and r%2==1):
r>>=1
if(not f(self.op(self.d[r], sm))):
while(r<self.size):
r=2*r+1
if(f(self.op(self.d[r],sm))):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r], sm)
if((r&-r)==r):break
return 0
def _update(self, k):
self.d[k]=self.op(self.d[2*k], self.d[2*k+1])
def main_():
N=gi()
S=gs()
T=gs()
ans=[]
zo=0
oz=0
for i in range(N):
if(S[i]!=T[i]):
if(S[i]=='0'):
zo+=1
else:
oz+=1
if((zo+oz)%2==1):
print(-1)
return
sa=abs(oz-zo)//2
for i in range(N):
ans.append('0')
if(zo>oz):
for i in range(N-1,-1,-1):
if(S[i]=='0' and T[i]=='1'):
ans[i]='1'
sa-=1
if(sa==0):
break
elif(oz>zo):
for i in range(N-1,-1,-1):
if(S[i]=='1' and T[i]=='0'):
ans[i]='1'
sa-=1
if(sa==0):
break
print(''.join(ans))
main_()
|
ConDefects/ConDefects/Code/arc151_a/Python/42888318
|
condefects-python_data_1379
|
N = int(input())
S = input()
T = input()
diff = 0
for s, t in zip(S, T):
if s != t:
diff += 1
if diff % 2 == 1:
print(-1)
exit()
ds = diff // 2
dt = diff // 2
ans = []
for s, t in zip(S, T):
if s == t:
ans.append(s)
elif ds > 0 and s == "1":
ans.append("0")
ds -= 1
elif dt > 0 and t == "1":
ans.append("0")
dt -= 1
elif ds > 0:
ans.append(t)
ds -= 1
elif dt > 0:
ans.append(s)
dt -= 1
else:
assert False
print("".join(ans))
N = int(input())
S = input()
T = input()
diff = 0
for s, t in zip(S, T):
if s != t:
diff += 1
if diff % 2 == 1:
print(-1)
exit()
ds = diff // 2
dt = diff // 2
ans = []
for s, t in zip(S, T):
if s == t:
ans.append("0")
elif ds > 0 and s == "1":
ans.append("0")
ds -= 1
elif dt > 0 and t == "1":
ans.append("0")
dt -= 1
elif ds > 0:
ans.append(t)
ds -= 1
elif dt > 0:
ans.append(s)
dt -= 1
else:
assert False
print("".join(ans))
|
ConDefects/ConDefects/Code/arc151_a/Python/44645744
|
condefects-python_data_1380
|
n=int(input())
s=list(input())
t=list(input())
L=[False for i in range(n)]
ans=["0" for i in range(n)]
miss=0
for i in range(n):
if s[i]==t[i]:
ans[i]=s[i]
L[i]=True
else:
miss+=1
if miss%2==1:
print(-1)
else:
SU=0
TU=0
for i in range(n):
if L[i]==False:
if s[i]=="1":
SU+=1
else:
TU+=1
num=abs(SU-TU)//2
for i in range(1,n+1):
if num==0:
break
i=n-i
if SU>TU:
if L[i]==False and t[i]=="0":
ans[i]="1"
num-=1
else:
if L[i]==False and s[i]=="0":
ans[i]="1"
num-=1
print("".join(ans))
n=int(input())
s=list(input())
t=list(input())
L=[False for i in range(n)]
ans=["0" for i in range(n)]
miss=0
for i in range(n):
if s[i]==t[i]:
ans[i]="0"
L[i]=True
else:
miss+=1
if miss%2==1:
print(-1)
else:
SU=0
TU=0
for i in range(n):
if L[i]==False:
if s[i]=="1":
SU+=1
else:
TU+=1
num=abs(SU-TU)//2
for i in range(1,n+1):
if num==0:
break
i=n-i
if SU>TU:
if L[i]==False and t[i]=="0":
ans[i]="1"
num-=1
else:
if L[i]==False and s[i]=="0":
ans[i]="1"
num-=1
print("".join(ans))
|
ConDefects/ConDefects/Code/arc151_a/Python/45669333
|
condefects-python_data_1381
|
n=int(input())
s=input()
t=input()
cnt=0
ans=''
for i in range(n):
if(s[i]!=t[i]):
cnt+=1
if(cnt%2==1):
ans='-1'
else:
hum_s=0
hum_t=0
for i in range(n):
if(s[i]==t[i]):
ans+='0'
elif(s[i]==0):
if(hum_t<cnt//2):
ans+='0'
hum_t+=1
else:
ans+='1'
hum_s+=1
else:
if(hum_s<cnt//2):
ans+='0'
hum_s+=1
else:
ans+='1'
hum_t+=1
print(ans)
n=int(input())
s=input()
t=input()
cnt=0
ans=''
for i in range(n):
if(s[i]!=t[i]):
cnt+=1
if(cnt%2==1):
ans='-1'
else:
hum_s=0
hum_t=0
for i in range(n):
if(s[i]==t[i]):
ans+='0'
elif(s[i]=='0'):
if(hum_t<cnt//2):
ans+='0'
hum_t+=1
else:
ans+='1'
hum_s+=1
else:
if(hum_s<cnt//2):
ans+='0'
hum_s+=1
else:
ans+='1'
hum_t+=1
print(ans)
|
ConDefects/ConDefects/Code/arc151_a/Python/44901492
|
condefects-python_data_1382
|
import sys
input = sys.stdin.readline
def ii(): return int(input())
def fi(): return float(input())
def si(): return input().rstrip()
def mii(): return map(int, input().split())
def fii(): return map(float, input().split())
def mii1(): return map(lambda x: int(x)-1, input().split())
def lii(): return list(map(int, input().split()))
def lii1(): return list(map(lambda x: int(x)-1, input().split()))
def lfi(): return list(map(float, input().split()))
def lsi(): return list(input().rstrip())
def lmsi(): return list(map(str, input().split()))
def iir(n): return [int(input()) for _ in range(n)]
def fir(n): return [float(input()) for _ in range(n)]
def sir(n): return [input().rstrip() for _ in range(n)]
def liir(n): return [list(map(int, input().split())) for _ in range(n)]
def lii1r(n): return [list(map(lambda x: int(x)-1, input().split())) for _ in range(n)]
def lfir(n): return [list(map(float, input().split())) for _ in range(n)]
def lsir(n): return [list(input().rstrip()) for _ in range(n)]
def lmsir(n): return [list(map(str, input().split())) for _ in range(n)]
def lii_alp(): return list(map(lambda x: ord(x)-97, input().rstrip()))
def lii_ALP(): return list(map(lambda x: ord(x)-65, input().rstrip()))
around = [[-1,0],[0,1],[1,0],[0,-1]]
# module
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right, insort
from heapq import heapify, heappop, heappush
from math import ceil, floor, gcd, sin, cos, radians, log, sqrt
from itertools import product, combinations, permutations, accumulate, groupby
from decimal import Decimal, ROUND_HALF_UP
sys.setrecursionlimit(10**7)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# [[key,len(list(group))] for key, group in groupby(A)]
# your code
N = ii()
S = si()
T = si()
diff = set([i for i in range(N) if S[i]!=T[i]])
if len(diff)&1:
print(-1)
else:
U = []
balance = 0
flag = 0
for i in range(N):
if i in diff:
if balance == len(diff):
U.append(T[i])
balance -= 1
elif -balance == len(diff):
U.append(S[i])
balance += 1
else:
U.append("0")
balance += (-1)**(S[i]!="0")
diff.remove(i)
else:
U.append(S[i])
# print(balance)
print("".join(U))
import sys
input = sys.stdin.readline
def ii(): return int(input())
def fi(): return float(input())
def si(): return input().rstrip()
def mii(): return map(int, input().split())
def fii(): return map(float, input().split())
def mii1(): return map(lambda x: int(x)-1, input().split())
def lii(): return list(map(int, input().split()))
def lii1(): return list(map(lambda x: int(x)-1, input().split()))
def lfi(): return list(map(float, input().split()))
def lsi(): return list(input().rstrip())
def lmsi(): return list(map(str, input().split()))
def iir(n): return [int(input()) for _ in range(n)]
def fir(n): return [float(input()) for _ in range(n)]
def sir(n): return [input().rstrip() for _ in range(n)]
def liir(n): return [list(map(int, input().split())) for _ in range(n)]
def lii1r(n): return [list(map(lambda x: int(x)-1, input().split())) for _ in range(n)]
def lfir(n): return [list(map(float, input().split())) for _ in range(n)]
def lsir(n): return [list(input().rstrip()) for _ in range(n)]
def lmsir(n): return [list(map(str, input().split())) for _ in range(n)]
def lii_alp(): return list(map(lambda x: ord(x)-97, input().rstrip()))
def lii_ALP(): return list(map(lambda x: ord(x)-65, input().rstrip()))
around = [[-1,0],[0,1],[1,0],[0,-1]]
# module
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right, insort
from heapq import heapify, heappop, heappush
from math import ceil, floor, gcd, sin, cos, radians, log, sqrt
from itertools import product, combinations, permutations, accumulate, groupby
from decimal import Decimal, ROUND_HALF_UP
sys.setrecursionlimit(10**7)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# [[key,len(list(group))] for key, group in groupby(A)]
# your code
N = ii()
S = si()
T = si()
diff = set([i for i in range(N) if S[i]!=T[i]])
if len(diff)&1:
print(-1)
else:
U = []
balance = 0
flag = 0
for i in range(N):
if i in diff:
if balance == len(diff):
U.append(T[i])
balance -= 1
elif -balance == len(diff):
U.append(S[i])
balance += 1
else:
U.append("0")
balance += (-1)**(S[i]!="0")
diff.remove(i)
else:
U.append("0")
# print(balance)
print("".join(U))
|
ConDefects/ConDefects/Code/arc151_a/Python/45098095
|
condefects-python_data_1383
|
N = int(input())
AB = [list(map(int, input().split())) for _ in range(N)]
mod = 998244353
dp = [[0] * 2 for _ in range(N)]
dp[0][0] = 1
dp[0][1] = 1
for i in range(1, N):
if AB[i][0] != AB[i - 1][0]:
dp[i][0] += dp[i - 1][0]
if AB[i][0] != AB[i - 1][1]:
dp[i][0] += dp[i - 1][1]
if AB[i][1] != AB[i-1][0]:
dp[i][1] += dp[i-1][0]
if AB[i][1]!= AB[i-1][1]:
dp[i][1] += dp[i-1][1]
dp[i][0] %= mod
dp[i][1] %= mod
# print(dp)
ans = sum(dp[-1])
print(ans)
N = int(input())
AB = [list(map(int, input().split())) for _ in range(N)]
mod = 998244353
dp = [[0] * 2 for _ in range(N)]
dp[0][0] = 1
dp[0][1] = 1
for i in range(1, N):
if AB[i][0] != AB[i - 1][0]:
dp[i][0] += dp[i - 1][0]
if AB[i][0] != AB[i - 1][1]:
dp[i][0] += dp[i - 1][1]
if AB[i][1] != AB[i-1][0]:
dp[i][1] += dp[i-1][0]
if AB[i][1]!= AB[i-1][1]:
dp[i][1] += dp[i-1][1]
dp[i][0] %= mod
dp[i][1] %= mod
# print(dp)
ans = sum(dp[-1])%mod
print(ans)
|
ConDefects/ConDefects/Code/abc291_d/Python/46165699
|
condefects-python_data_1384
|
import sys
def input(): return sys.stdin.readline().rstrip()
def read(): return int(input())
def reads(): return list(map(int, input().split()))
def main():
MOD = 998244353
N = read()
AB = [reads() for _ in range(N)]
dp = [[0]*2 for _ in range(N)]
dp[0][0] = 1
dp[0][1] = 1
for i in range(1, N):
for j in range(2):
for k in range(2):
if AB[i][j] != AB[i-1][k]:
dp[i][j] += dp[i-1][k]
dp[i][j] %= MOD
print(sum(dp[N-1]))
if __name__ == '__main__':
main()
import sys
def input(): return sys.stdin.readline().rstrip()
def read(): return int(input())
def reads(): return list(map(int, input().split()))
def main():
MOD = 998244353
N = read()
AB = [reads() for _ in range(N)]
dp = [[0]*2 for _ in range(N)]
dp[0][0] = 1
dp[0][1] = 1
for i in range(1, N):
for j in range(2):
for k in range(2):
if AB[i][j] != AB[i-1][k]:
dp[i][j] += dp[i-1][k]
dp[i][j] %= MOD
print(sum(dp[N-1])%MOD)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc291_d/Python/45745122
|
condefects-python_data_1385
|
n=int(input())
mod=998244353
c=[]
for i in range(n):
a,b=map(int,input().split())
c.append((a,b))
if n==1:
print(0)
else:
dp=[[0]*2 for i in range(n)]
for j in range(2):
if c[1][j]!=c[0][j]:
dp[1][j]+=1
if c[1][j]!=c[0][(j+1)%2]:
dp[1][j]+=1
for i in range(1,n-1):
for j in range(2):
if c[i+1][j]!=c[i][j]:
dp[i+1][j]+=dp[i][j]
dp[i+1][j]%=mod
if c[i+1][j]!=c[i][(j+1)%2]:
dp[i+1][j]+=dp[i][(j+1)%2]
dp[i+1][j]%=mod
ans=dp[n-1][0]+dp[n-1][1]
print(ans%mod)
n=int(input())
mod=998244353
c=[]
for i in range(n):
a,b=map(int,input().split())
c.append((a,b))
if n==1:
print(2)
else:
dp=[[0]*2 for i in range(n)]
for j in range(2):
if c[1][j]!=c[0][j]:
dp[1][j]+=1
if c[1][j]!=c[0][(j+1)%2]:
dp[1][j]+=1
for i in range(1,n-1):
for j in range(2):
if c[i+1][j]!=c[i][j]:
dp[i+1][j]+=dp[i][j]
dp[i+1][j]%=mod
if c[i+1][j]!=c[i][(j+1)%2]:
dp[i+1][j]+=dp[i][(j+1)%2]
dp[i+1][j]%=mod
ans=dp[n-1][0]+dp[n-1][1]
print(ans%mod)
|
ConDefects/ConDefects/Code/abc291_d/Python/45489809
|
condefects-python_data_1386
|
import sys, heapq, math, bisect, itertools
from collections import defaultdict, deque
def main():
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 998244353
N = int(input())
cards = []
for _ in range(N):
A, B = map(int, input().split())
cards.append((A, B))
dp = [[0, 0] for _ in range(N)]
dp[0] = [1, 1]
for i in range(1, N):
for j in [0, 1]:
if cards[i][j] != cards[i-1][0]:
dp[i][j] += dp[i-1][0]
dp[i][j] %= MOD
if cards[i][j] != cards[i-1][1]:
dp[i][j] += dp[i-1][1]
dp[i][j] %= MOD
print(sum(dp[-1]))
if __name__ == "__main__":
main()
import sys, heapq, math, bisect, itertools
from collections import defaultdict, deque
def main():
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 998244353
N = int(input())
cards = []
for _ in range(N):
A, B = map(int, input().split())
cards.append((A, B))
dp = [[0, 0] for _ in range(N)]
dp[0] = [1, 1]
for i in range(1, N):
for j in [0, 1]:
if cards[i][j] != cards[i-1][0]:
dp[i][j] += dp[i-1][0]
dp[i][j] %= MOD
if cards[i][j] != cards[i-1][1]:
dp[i][j] += dp[i-1][1]
dp[i][j] %= MOD
print(sum(dp[-1]) % MOD)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc291_d/Python/46206336
|
condefects-python_data_1387
|
import sys
input = sys.stdin.buffer.readline
N = int(input())
MOD = 998244353
dp = [[0] * 2 for _ in range(N)]
dp[0] = [1,1]
for i in range(N):
if i == 0:
old_a, old_b = map(int, input().split())
else:
A, B = map(int, input().split())
if old_a != A:
dp[i][0] += dp[i-1][0]
if old_b != A:
dp[i][0] += dp[i-1][1]
if old_a != B:
dp[i][1] += dp[i-1][0]
if old_b != B:
dp[i][1] += dp[i-1][1]
dp[i][0] %= MOD
dp[i][1] %= MOD
old_a, old_b = A, B
print(sum(dp[N-1]))
import sys
input = sys.stdin.buffer.readline
N = int(input())
MOD = 998244353
dp = [[0] * 2 for _ in range(N)]
dp[0] = [1,1]
for i in range(N):
if i == 0:
old_a, old_b = map(int, input().split())
else:
A, B = map(int, input().split())
if old_a != A:
dp[i][0] += dp[i-1][0]
if old_b != A:
dp[i][0] += dp[i-1][1]
if old_a != B:
dp[i][1] += dp[i-1][0]
if old_b != B:
dp[i][1] += dp[i-1][1]
dp[i][0] %= MOD
dp[i][1] %= MOD
old_a, old_b = A, B
print(sum(dp[N-1]) % MOD)
|
ConDefects/ConDefects/Code/abc291_d/Python/45519163
|
condefects-python_data_1388
|
N = int(input())
S = [list(map(int, input().split())) for _ in range(N)]
MOD = 998244353
# dp[i][j]: i番目まで見たときに、カードが表か裏か(j=0:表, j=1:裏)の時の数
dp = [[0] * 2 for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
if i == 0:
dp[i+1][0] += dp[i][0]
dp[i+1][1] += dp[i][0]
else:
preA, preB = S[i-1]
nowA, nowB = S[i]
if preA != nowA:
dp[i+1][0] += dp[i][0]
if preA != nowB:
dp[i+1][1] += dp[i][0]
if preB != nowA:
dp[i+1][0] += dp[i][1]
if preB != nowB:
dp[i+1][1] += dp[i][1]
dp[i+1][0] %= MOD
dp[i+1][1] %= MOD
print(sum(dp[N]))
N = int(input())
S = [list(map(int, input().split())) for _ in range(N)]
MOD = 998244353
# dp[i][j]: i番目まで見たときに、カードが表か裏か(j=0:表, j=1:裏)の時の数
dp = [[0] * 2 for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
if i == 0:
dp[i+1][0] += dp[i][0]
dp[i+1][1] += dp[i][0]
else:
preA, preB = S[i-1]
nowA, nowB = S[i]
if preA != nowA:
dp[i+1][0] += dp[i][0]
if preA != nowB:
dp[i+1][1] += dp[i][0]
if preB != nowA:
dp[i+1][0] += dp[i][1]
if preB != nowB:
dp[i+1][1] += dp[i][1]
dp[i+1][0] %= MOD
dp[i+1][1] %= MOD
print(sum(dp[N]) % MOD)
|
ConDefects/ConDefects/Code/abc291_d/Python/45954675
|
condefects-python_data_1389
|
def main():
n = int(input())
a = list(map(int, input().split()))
q = int(input())
ans = {}
tmp = {
'value': -1,
'list': set()
}
for _ in range(n):
i = list(map(int, input().split()))
if i[0] == 1:
tmp['value'] = i[1]
tmp['list'] = set()
elif i[0] == 2:
x, y = i[1]-1, i[2]
aa = ans.get(x, a[x])
if tmp['value'] == -1 or x in tmp['list']:
ans[x] = aa + y
else:
ans[x] = tmp['value'] + y
tmp['list'].add(x)
elif i[0] == 3:
x = i[1]-1
aa = ans.get(x, a[x])
if tmp['value'] == -1 or x in tmp['list']:
print(aa)
else:
print(tmp['value'])
if __name__ == '__main__':
main()
def main():
n = int(input())
a = list(map(int, input().split()))
q = int(input())
ans = {}
tmp = {
'value': -1,
'list': set()
}
for _ in range(q):
i = list(map(int, input().split()))
if i[0] == 1:
tmp['value'] = i[1]
tmp['list'] = set()
elif i[0] == 2:
x, y = i[1]-1, i[2]
aa = ans.get(x, a[x])
if tmp['value'] == -1 or x in tmp['list']:
ans[x] = aa + y
else:
ans[x] = tmp['value'] + y
tmp['list'].add(x)
elif i[0] == 3:
x = i[1]-1
aa = ans.get(x, a[x])
if tmp['value'] == -1 or x in tmp['list']:
print(aa)
else:
print(tmp['value'])
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc278_d/Python/44926075
|
condefects-python_data_1390
|
import sys
input = sys.stdin.readline
N=int(input())
LR=[list(map(int,input().split())) for i in range(N)]
for i in range(N-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-2,-1,-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-2,-1,-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
ANS=[-1]*N
for i in range(N):
if LR[i][0]==LR[i][1]:
ANS[i]=LR[i][0]
mae=-1
maeind=-1
for i in range(N):
if ANS[i]!=-1:
now=ANS[i]
nowind=i
if mae==-1:
for j in range(i-1,maeind,-1):
if LR[j][0]<=ANS[j+1]<=LR[j][1]:
ANS[j]=ANS[j+1]
else:
ANS[j]=LR[j][1]
mae=now
maeind=i
else:
while nowind>maeind+1:
if mae<now:
if LR[maeind+1][1]<=mae:
ANS[maeind+1]=LR[maeind+1][1]
elif LR[maeind+1][0]<=mae<=LR[maeind+1][1]:
ANS[maeind+1]=mae
else:
ANS[maeind+1]=LR[maeind+1][0]
maeind+=1
mae=ANS[maeind]
else:
if LR[nowind-1][1]<=now:
ANS[nowind-1]=LR[nowind-1][1]
elif LR[nowind-1][0]<=now<=LR[nowind-1][1]:
ANS[nowind-1]=now
else:
ANS[nowind-1]=LR[nowind-1][0]
nowind-=1
now=ANS[nowind]
mae=ANS[i]
maeind=i
#print(ANS)
if mae==-1:
MAX=-1
for l,r in LR:
MAX=max(l,MAX)
print(*[MAX]*N)
exit()
for i in range(maeind+1,N):
if LR[i][0]<=mae<=LR[i][1]:
ANS[i]=mae
else:
ANS[i]=max(mae,LR[i][1])
mae=ANS[i]
print(*ANS)
import sys
input = sys.stdin.readline
N=int(input())
LR=[list(map(int,input().split())) for i in range(N)]
for i in range(N-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-2,-1,-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
for i in range(N-2,-1,-1):
x,y=LR[i]
z,w=LR[i+1]
if y>w:
LR[i][1]=max(w,x)
if w>y:
LR[i+1][1]=max(y,z)
ANS=[-1]*N
for i in range(N):
if LR[i][0]==LR[i][1]:
ANS[i]=LR[i][0]
mae=-1
maeind=-1
for i in range(N):
if ANS[i]!=-1:
now=ANS[i]
nowind=i
if mae==-1:
for j in range(i-1,maeind,-1):
if LR[j][0]<=ANS[j+1]<=LR[j][1]:
ANS[j]=ANS[j+1]
else:
ANS[j]=LR[j][1]
mae=now
maeind=i
else:
while nowind>maeind+1:
if mae<now:
if LR[maeind+1][1]<=mae:
ANS[maeind+1]=LR[maeind+1][1]
elif LR[maeind+1][0]<=mae<=LR[maeind+1][1]:
ANS[maeind+1]=mae
else:
ANS[maeind+1]=LR[maeind+1][0]
maeind+=1
mae=ANS[maeind]
else:
if LR[nowind-1][1]<=now:
ANS[nowind-1]=LR[nowind-1][1]
elif LR[nowind-1][0]<=now<=LR[nowind-1][1]:
ANS[nowind-1]=now
else:
ANS[nowind-1]=LR[nowind-1][0]
nowind-=1
now=ANS[nowind]
mae=ANS[i]
maeind=i
#print(ANS)
if mae==-1:
MAX=-1
for l,r in LR:
MAX=max(l,MAX)
print(*[MAX]*N)
exit()
for i in range(maeind+1,N):
if LR[i][0]<=mae<=LR[i][1]:
ANS[i]=mae
else:
ANS[i]=LR[i][1]
mae=ANS[i]
print(*ANS)
|
ConDefects/ConDefects/Code/arc175_c/Python/51662167
|
condefects-python_data_1391
|
from bisect import bisect,bisect_left
from collections import *
from heapq import *
from math import gcd,ceil,sqrt,floor,inf,pi
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#----------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
# x.bit_count()
def popcnt(x):
ans=0
while x:
ans+=1
x&=x-1
return ans
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
class UF:#秩+路径+容量，边数
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
self.size=AI(n,1)
self.edge=A(n)
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
self.edge[pu]+=1
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
self.edge[pu]+=self.edge[pv]+1
self.size[pu]+=self.size[pv]
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
self.edge[pv]+=self.edge[pu]+1
self.size[pv]+=self.size[pu]
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d=AI(n,inf)
d[s]=0
heap=[(0,s)]
while heap:
dis,u=heappop(heap)
if dis>d[u]:
continue
for v,w in graph[u]:
if d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
def michange(a,b):
d=defaultdict(deque)
for i,x in enumerate(b):
d[x].append(i)
order=A(len(a))
for i,x in enumerate(a):
if not d:
return -1
order[i]=d[x].popleft()
return RP(order)
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
'''
from random import randint,shuffle
def ra(n,a,b):
return [randint(a,b) for i in range(n)]
def check():
vis=0
arr=[]
dfs(0,arr)
'''
mod=998244353
t=1
for i in range(t):
n=N()
l=A(n)
r=A(n)
for i in range(n):
l[i],r[i]=RL()
up=A(n)
dw=A(n)
up[-1],dw[-1]=r[-1],l[-1]
for i in range(n-2,-1,-1):
if r[i]<dw[i+1]:
dw[i]=up[i]=r[i]
elif l[i]>up[i+1]:
dw[i]=up[i]=l[i]
else:
dw[i]=max(dw[i+1],l[i])
up[i]=min(r[i],up[i+1])
ans=A(n)
ans[0]=dw[0]
for i in range(1,n):
opt=min(ans[i-1],up[i])
ans[i]=max(dw[i],opt)
print(*ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.sta1ck_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
2
1 1
1 1
1
1
1 1
'''
from bisect import bisect,bisect_left
from collections import *
from heapq import *
from math import gcd,ceil,sqrt,floor,inf,pi
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *
#----------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
mod=10**9+7
farr=[1]
ifa=[]
def fact(x,mod=0):
if mod:
while x>=len(farr):
farr.append(farr[-1]*len(farr)%mod)
else:
while x>=len(farr):
farr.append(farr[-1]*len(farr))
return farr[x]
def ifact(x,mod):
global ifa
fact(x,mod)
ifa.append(pow(farr[-1],mod-2,mod))
for i in range(x,0,-1):
ifa.append(ifa[-1]*i%mod)
ifa.reverse()
def per(i,j,mod=0):
if i<j: return 0
if not mod:
return fact(i)//fact(i-j)
return farr[i]*ifa[i-j]%mod
def com(i,j,mod=0):
if i<j: return 0
if not mod:
return per(i,j)//fact(j)
return per(i,j,mod)*ifa[j]%mod
def catalan(n):
return com(2*n,n)//(n+1)
def isprime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
if a==0:return b//c*(n+1)
if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
m=(a*n+b)//c
return n*m-floorsum(c,c-b-1,a,m-1)
def inverse(a,m):
a%=m
if a<=1: return a
return ((1-inverse(m,a)*m)//a)%m
# x.bit_count()
def popcnt(x):
ans=0
while x:
ans+=1
x&=x-1
return ans
def lowbit(n):
return n&-n
class BIT:
def __init__(self,arr):
self.arr=arr
self.n=len(arr)-1
def update(self,x,v):
while x<=self.n:
self.arr[x]+=v
x+=x&-x
def query(self,x):
ans=0
while x:
ans+=self.arr[x]
x&=x-1
return ans
class ST:
def __init__(self,arr):#n!=0
n=len(arr)
mx=n.bit_length()#取不到
self.st=[[0]*mx for i in range(n)]
for i in range(n):
self.st[i][0]=arr[i]
for j in range(1,mx):
for i in range(n-(1<<j)+1):
self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
def query(self,l,r):
if l>r:return -inf
s=(r+1-l).bit_length()-1
return max(self.st[l][s],self.st[r-(1<<s)+1][s])
class DSU:#容量+路径压缩
def __init__(self,n):
self.c=[-1]*n
def same(self,x,y):
return self.find(x)==self.find(y)
def find(self,x):
if self.c[x]<0:
return x
self.c[x]=self.find(self.c[x])
return self.c[x]
def union(self,u,v):
u,v=self.find(u),self.find(v)
if u==v:
return False
if self.c[u]>self.c[v]:
u,v=v,u
self.c[u]+=self.c[v]
self.c[v]=u
return True
def size(self,x): return -self.c[self.find(x)]
class UFS:#秩+路径
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
class UF:#秩+路径+容量，边数
def __init__(self,n):
self.parent=[i for i in range(n)]
self.ranks=[0]*n
self.size=AI(n,1)
self.edge=A(n)
def find(self,x):
if x!=self.parent[x]:
self.parent[x]=self.find(self.parent[x])
return self.parent[x]
def union(self,u,v):
pu,pv=self.find(u),self.find(v)
if pu==pv:
self.edge[pu]+=1
return False
if self.ranks[pu]>=self.ranks[pv]:
self.parent[pv]=pu
self.edge[pu]+=self.edge[pv]+1
self.size[pu]+=self.size[pv]
if self.ranks[pv]==self.ranks[pu]:
self.ranks[pu]+=1
else:
self.parent[pu]=pv
self.edge[pv]+=self.edge[pu]+1
self.size[pv]+=self.size[pu]
def Prime(n):
c=0
prime=[]
flag=[0]*(n+1)
for i in range(2,n+1):
if not flag[i]:
prime.append(i)
c+=1
for j in range(c):
if i*prime[j]>n: break
flag[i*prime[j]]=prime[j]
if i%prime[j]==0: break
return flag
def dij(s,graph):
d=AI(n,inf)
d[s]=0
heap=[(0,s)]
while heap:
dis,u=heappop(heap)
if dis>d[u]:
continue
for v,w in graph[u]:
if d[v]>d[u]+w:
d[v]=d[u]+w
heappush(heap,(d[v],v))
return d
def bell(s,g):#bellman-Ford
dis=AI(n,inf)
dis[s]=0
for i in range(n-1):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change=A(n)
for i in range(n):
for u,v,w in edge:
if dis[v]>dis[u]+w:
dis[v]=dis[u]+w
change[v]=1
return dis
def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
res=[]
for k in nums:
i=bisect_left(res,k)
if i==len(res):
res.append(k)
else:
res[i]=k
return len(res)
def RP(nums):#逆序对
n = len(nums)
s=set(nums)
d={}
for i,k in enumerate(sorted(s),1):
d[k]=i
bi=BIT([0]*(len(s)+1))
ans=0
for i in range(n-1,-1,-1):
ans+=bi.query(d[nums[i]]-1)
bi.update(d[nums[i]],1)
return ans
def michange(a,b):
d=defaultdict(deque)
for i,x in enumerate(b):
d[x].append(i)
order=A(len(a))
for i,x in enumerate(a):
if not d:
return -1
order[i]=d[x].popleft()
return RP(order)
class DLN:
def __init__(self,val):
self.val=val
self.pre=None
self.next=None
def nb(i,j,n,m):
for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
if 0<=ni<n and 0<=nj<m:
yield ni,nj
def topo(n):
q=deque()
res=[]
for i in range(1,n+1):
if ind[i]==0:
q.append(i)
res.append(i)
while q:
u=q.popleft()
for v in g[u]:
ind[v]-=1
if ind[v]==0:
q.append(v)
res.append(v)
return res
@bootstrap
def gdfs(r,p):
for ch in g[r]:
if ch!=p:
yield gdfs(ch,r)
yield None
'''
from random import randint,shuffle
def ra(n,a,b):
return [randint(a,b) for i in range(n)]
def check():
vis=0
arr=[]
dfs(0,arr)
'''
mod=998244353
t=1
for i in range(t):
n=N()
l=A(n)
r=A(n)
for i in range(n):
l[i],r[i]=RL()
up=A(n)
dw=A(n)
up[-1],dw[-1]=r[-1],l[-1]
for i in range(n-2,-1,-1):
if r[i]<dw[i+1]:
dw[i]=up[i]=r[i]
elif l[i]>up[i+1]:
dw[i]=up[i]=l[i]
else:
dw[i]=max(dw[i+1],l[i])
up[i]=min(r[i],up[i+1])
ans=A(n)
ans[0]=dw[0]
for i in range(1,n):
opt=min(ans[i-1],up[i])
ans[i]=max(l[i],opt)
print(*ans)
'''
sys.setrecursionlimit(200000)
import threading
threading.sta1ck_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
2
1 1
1 1
1
1
1 1
'''
|
ConDefects/ConDefects/Code/arc175_c/Python/54525913
|
condefects-python_data_1392
|
import sys, random
input = lambda : sys.stdin.readline().rstrip()
write = lambda x: sys.stdout.write(x+"\n"); writef = lambda x: print("{:.12f}".format(x))
debug = lambda x: sys.stderr.write(x+"\n")
YES="Yes"; NO="No"; pans = lambda v: print(YES if v else NO); INF=10**18
LI = lambda v=0: list(map(lambda i: int(i)-v, input().split())); II=lambda : int(input()); SI=lambda : [ord(c)-ord("a") for c in input()]
def debug(_l_):
for s in _l_.split():
print(f"{s}={eval(s)}", end=" ")
print()
def dlist(*l, fill=0):
if len(l)==1:
return [fill]*l[0]
ll = l[1:]
return [dlist(*ll, fill=fill) for _ in range(l[0])]
n = int(input())
lr = [LI() for _ in range(n)] + [[1e12,1e12]]
vs = [[1e12,1e12,[]]] + [lr[0]+[[0]]] # [[l,r,[ind...]] ,...
for i in range(1,n+1):
l,r = lr[i]
while len(vs)>=2:
if i==n and len(vs)==2:
break
pl,pr,pind = vs[-1]
pl2,pr2,pind2 = vs[-2]
if pl<l and pl<pl2 and pl<pr:
if pl2<=l and pl2<=pr:
# pl2 まで上げる
pr = min(pr, pr2)
if len(pind)>len(pind2):
pind.extend(pind2)
else:
pind2.extend(pind)
pind = pind2
vs.pop()
vs.pop()
vs.append([pl2, pr, pind])
elif l<=pr:
# l まで上げる
pr = min(pr, r)
pind.append(i)
vs.pop()
vs.append([l,pr,pind])
break
else:
# pr まで上げて、lr を追加
vs.pop()
vs.append([pr,pr,pind])
vs.append([l,r,[i]])
break
else:
vs.append([l,r,[i]])
break
ans = [0]*n
for l,r,index in vs:
for i in index:
if i<n:
ans[i] = l
print(*ans)
import sys, random
input = lambda : sys.stdin.readline().rstrip()
write = lambda x: sys.stdout.write(x+"\n"); writef = lambda x: print("{:.12f}".format(x))
debug = lambda x: sys.stderr.write(x+"\n")
YES="Yes"; NO="No"; pans = lambda v: print(YES if v else NO); INF=10**18
LI = lambda v=0: list(map(lambda i: int(i)-v, input().split())); II=lambda : int(input()); SI=lambda : [ord(c)-ord("a") for c in input()]
def debug(_l_):
for s in _l_.split():
print(f"{s}={eval(s)}", end=" ")
print()
def dlist(*l, fill=0):
if len(l)==1:
return [fill]*l[0]
ll = l[1:]
return [dlist(*ll, fill=fill) for _ in range(l[0])]
n = int(input())
lr = [LI() for _ in range(n)] + [[1e12,1e12]]
vs = [[1e12,1e12,[]]] + [lr[0]+[[0]]] # [[l,r,[ind...]] ,...
for i in range(1,n+1):
l,r = lr[i]
while len(vs)>=2:
if i==n and len(vs)==2:
break
pl,pr,pind = vs[-1]
pl2,pr2,pind2 = vs[-2]
if pl<=l and pl<=pl2 and pl<pr:
if pl2<=l and pl2<=pr:
# pl2 まで上げる
pr = min(pr, pr2)
if len(pind)>len(pind2):
pind.extend(pind2)
else:
pind2.extend(pind)
pind = pind2
vs.pop()
vs.pop()
vs.append([pl2, pr, pind])
elif l<=pr:
# l まで上げる
pr = min(pr, r)
pind.append(i)
vs.pop()
vs.append([l,pr,pind])
break
else:
# pr まで上げて、lr を追加
vs.pop()
vs.append([pr,pr,pind])
vs.append([l,r,[i]])
break
else:
vs.append([l,r,[i]])
break
ans = [0]*n
for l,r,index in vs:
for i in index:
if i<n:
ans[i] = l
print(*ans)
|
ConDefects/ConDefects/Code/arc175_c/Python/53001483
|
condefects-python_data_1393
|
N = int(input())
LR = []
for _ in range(N):
l, r = map(int, input().split())
LR.append((l, r))
D = []
INF = 10**18
mi, ma = -INF, INF
for l, r in reversed(LR):
if ma < l:
mi = ma = l
elif r < mi:
mi = ma = r
else:
mi = max(mi, l)
ma = min(ma, r)
D.append((mi, ma))
D.reverse()
ans = []
v = INF
for (mi, ma), (l, r) in zip(D, LR):
v = max(l, min(v, ma))
ans.append(v)
print(*ans)
N = int(input())
LR = []
for _ in range(N):
l, r = map(int, input().split())
LR.append((l, r))
D = []
INF = 10**18
mi, ma = -INF, INF
for l, r in reversed(LR):
if ma < l:
mi = ma = l
elif r < mi:
mi = ma = r
else:
mi = max(mi, l)
ma = min(ma, r)
D.append((mi, ma))
D.reverse()
ans = []
v = D[0][0]
for (mi, ma), (l, r) in zip(D, LR):
v = max(l, min(v, ma))
ans.append(v)
print(*ans)
|
ConDefects/ConDefects/Code/arc175_c/Python/51756772
|
condefects-python_data_1394
|
import io,os
from copy import deepcopy
import heapq
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def getpattern(grid,d,sym):
n = len(grid)
newgrid = [[0 for _ in range(n)] for _ in range(n)]
ans = 0
for i in range(n):
for j in range(n):
rest = grid[i][j] % (2*d)
if (i+j)%2==sym:
if rest <= d:
newgrid[i][j] = grid[i][j] - rest
ans += abs(rest)
else:
newgrid[i][j] = grid[i][j] + 2 * d - rest
ans += abs(2*d - rest)
else:
newgrid[i][j] = grid[i][j] + d - rest
ans += abs(d-rest)
return ans, newgrid
def main():
n,d = map(int,input().split())
grid = []
for i in range(n):
temp = list(map(int,input().split()))
grid.append(temp)
ans1, grid1 = getpattern(grid,d,0)
ans2, grid2 = getpattern(grid,d,1)
print(min(ans1,ans2))
if ans1 < ans2:
for ele in grid1: print(*ele)
else:
for ele in grid2: print(*ele)
main()
import io,os
from copy import deepcopy
import heapq
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def getpattern(grid,d,sym):
n = len(grid)
newgrid = [[0 for _ in range(n)] for _ in range(n)]
ans = 0
for i in range(n):
for j in range(n):
rest = grid[i][j] % (2*d)
if (i+j)%2==sym:
if rest <= d:
newgrid[i][j] = grid[i][j] - rest
ans += abs(rest)
else:
newgrid[i][j] = grid[i][j] + 2 * d - rest
ans += abs(2*d - rest)
else:
newgrid[i][j] = grid[i][j] + d - rest
ans += abs(d-rest)
return ans, newgrid
def main():
n,d = map(int,input().split())
grid = []
for i in range(n):
temp = list(map(int,input().split()))
grid.append(temp)
ans1, grid1 = getpattern(grid,d,0)
ans2, grid2 = getpattern(grid,d,1)
# print(min(ans1,ans2))
if ans1 < ans2:
for ele in grid1: print(*ele)
else:
for ele in grid2: print(*ele)
main()
|
ConDefects/ConDefects/Code/agc066_a/Python/51924137
|
condefects-python_data_1395
|
n,d=map(int,input().split())
a=[list(map(int,input().split())) for _ in range(n)]
a2=[[0]*n for _ in range(n)]
for r in range(n):
for c in range(n):
tmp=0
x=(a[r][c]+d*(r+c&1))%(2*d)
if x<=d:
tmp+=x
a2[r][c]=a[r][c]-x
else:
tmp+=2*d-x
a2[r][c]=a[r][c]+(2*d-x)
if tmp<=((n**2)*d)//2:
for i in a2:
print (*i)
exit()
for r in range(n):
for c in range(n):
x=(a[r][c]+d*(r+c+1&1))%(2*d)
if x<=d:
a2[r][c]=a[r][c]-x
else:
a2[r][c]=a[r][c]+(2*d-x)
for i in a2:
print (*i)
n,d=map(int,input().split())
a=[list(map(int,input().split())) for _ in range(n)]
a2=[[0]*n for _ in range(n)]
tmp=0
for r in range(n):
for c in range(n):
x=(a[r][c]+d*(r+c&1))%(2*d)
if x<=d:
tmp+=x
a2[r][c]=a[r][c]-x
else:
tmp+=2*d-x
a2[r][c]=a[r][c]+(2*d-x)
if tmp<=((n**2)*d)//2:
for i in a2:
print (*i)
exit()
for r in range(n):
for c in range(n):
x=(a[r][c]+d*(r+c+1&1))%(2*d)
if x<=d:
a2[r][c]=a[r][c]-x
else:
a2[r][c]=a[r][c]+(2*d-x)
for i in a2:
print (*i)
|
ConDefects/ConDefects/Code/agc066_a/Python/53570827
|
condefects-python_data_1396
|
N,C = map(int,input().split())
op = [tuple(map(int,input().split())) for _ in range(N)]
L = [[0]*2 for _ in range(N+1)]
n = C.bit_length()
L[0][0] = 0
L[0][1] = (1<<n)-1
for i in range(N):
t,a = op[i]
for j in range(2):
if t == 1:
L[i+1][j] = L[i][j]&a
if t == 2:
L[i+1][j] = L[i][j]|a
if t == 3:
L[i+1][j] = L[i][j]^a
ans = C
for i in range(N):
tmp = 0
for j in range(n):
if ans&(1<<j):
tmp += L[i+1][1]&(1<<j)
else:
tmp += L[i+1][0]&(1<<j)
print(tmp)
ans = tmp
N,C = map(int,input().split())
op = [tuple(map(int,input().split())) for _ in range(N)]
L = [[0]*2 for _ in range(N+1)]
n = 32
L[0][0] = 0
L[0][1] = (1<<n)-1
for i in range(N):
t,a = op[i]
for j in range(2):
if t == 1:
L[i+1][j] = L[i][j]&a
if t == 2:
L[i+1][j] = L[i][j]|a
if t == 3:
L[i+1][j] = L[i][j]^a
ans = C
for i in range(N):
tmp = 0
for j in range(n):
if ans&(1<<j):
tmp += L[i+1][1]&(1<<j)
else:
tmp += L[i+1][0]&(1<<j)
print(tmp)
ans = tmp
|
ConDefects/ConDefects/Code/abc261_e/Python/46034687
|
condefects-python_data_1397
|
N,K = map(int,input().split())
RK = int(str(K)[::-1])
ans = 0
if K%10!=0:
if K!=RK:
while RK<=N:
ans += 1
RK *= 10
while K<=N:
ans += 1
K *= 10
print(ans)
N,K = map(int,input().split())
RK = int(str(K)[::-1])
ans = 0
if K<=RK:
if K!=RK:
while RK<=N:
ans += 1
RK *= 10
while K<=N:
ans += 1
K *= 10
print(ans)
|
ConDefects/ConDefects/Code/arc142_a/Python/44935143
|
condefects-python_data_1398
|
import bisect
import collections
import copy
import heapq
import itertools
import math
import string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
n, k = LI()
if k % 10 == 0:
print(0)
sys.exit()
s = str(k)
nums = set()
ans = 0
while int(s) <= n:
if not int(s) in nums:
ans += 1
nums.add(int(s))
s += '0'
s = str(k)[::-1]
while int(s) <= n:
if not int(s) in nums:
ans += 1
nums.add(int(s))
s += '0'
print(ans)
import bisect
import collections
import copy
import heapq
import itertools
import math
import string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int, sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
n, k = LI()
if k % 10 == 0 or k > int(str(k)[::-1]):
print(0)
sys.exit()
s = str(k)
nums = set()
ans = 0
while int(s) <= n:
if not int(s) in nums:
ans += 1
nums.add(int(s))
s += '0'
s = str(k)[::-1]
while int(s) <= n:
if not int(s) in nums:
ans += 1
nums.add(int(s))
s += '0'
print(ans)
|
ConDefects/ConDefects/Code/arc142_a/Python/44825978
|
condefects-python_data_1399
|
def solve(N, K):
def rev(x):
return int(''.join(reversed(list(str(x)))))
def cnt(x):
res = 0
while x <= N:
res += 1
x *= 10
return res
if K % 10 == 0:
return 0
if K > rev(K):
return 0
return cnt(K) + cnt(rev(K))
N, K = map(int, input().split())
print(solve(N, K))
def solve(N, K):
def rev(x):
return int(''.join(reversed(list(str(x)))))
def cnt(x):
res = 0
while x <= N:
res += 1
x *= 10
return res
if K % 10 == 0:
return 0
if K > rev(K):
return 0
return cnt(K) + (cnt(rev(K)) if K != rev(K) else 0)
N, K = map(int, input().split())
print(solve(N, K))
|
ConDefects/ConDefects/Code/arc142_a/Python/44613596
|
condefects-python_data_1400
|
N, K = map(int, input().split())
sk = list(str(K))
rk = ''.join(reversed(sk))
if K > int(rk):
print(0)
exit()
array = []
for i in range(12):
array.append(int(rk + '0' * i))
array.append(int(''.join(sk) + '0' * i))
ans = 0
for a in array:
if a <= N:
ans += 1
print(ans)
N, K = map(int, input().split())
sk = list(str(K))
rk = ''.join(reversed(sk))
if K > int(rk):
print(0)
exit()
array = []
for i in range(12):
array.append(int(rk + '0' * i))
array.append(int(''.join(sk) + '0' * i))
ans = 0
for a in set(array):
if a <= N:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/arc142_a/Python/43246085
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.