id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_501
|
def main():
from sys import stdin, setrecursionlimit
# setrecursionlimit(1000000)
input = stdin.readline
def iinput(): return int(input())
def sinput(): return input().rstrip()
def i0input(): return int(input()) - 1
def linput(): return list(input().split())
def liinput(): return list(map(int, input().split()))
def miinput(): return map(int, input().split())
def li0input(): return list(map(lambda x: int(x) - 1, input().split()))
def mi0input(): return map(lambda x: int(x) - 1, input().split())
INF = 1000000000000000000
MOD = 1000000007
N, K = miinput()
A = liinput()
intervals = [[0, 1]]
A.sort()
for a in A:
tmp = []
for l, r in intervals:
tmp.append([l+a, r+a])
intervals = merger(intervals + tmp)
if len(intervals) > 10 * K:
break
ans = []
for (_, r), (l, _) in zip(intervals, intervals[1:]):
for x in range(r, l):
ans.append(x)
if len(ans) == K:
print(*ans)
return
tmp = intervals[-1][1]
while len(ans) < K:
ans.append(tmp)
tmp += 1
print(*ans)
def merger(intervals):
intervals.sort(key=lambda interval: interval[0])
merged = [intervals[0]]
for w in intervals:
if w[0] > merged[-1][1]:
merged.append(w)
elif w[1] > merged[-1][1]:
merged[-1][1] = w[1]
return merged
main()
def main():
from sys import stdin, setrecursionlimit
# setrecursionlimit(1000000)
input = stdin.readline
def iinput(): return int(input())
def sinput(): return input().rstrip()
def i0input(): return int(input()) - 1
def linput(): return list(input().split())
def liinput(): return list(map(int, input().split()))
def miinput(): return map(int, input().split())
def li0input(): return list(map(lambda x: int(x) - 1, input().split()))
def mi0input(): return map(lambda x: int(x) - 1, input().split())
INF = 1000000000000000000
MOD = 1000000007
N, K = miinput()
A = liinput()
intervals = [[0, 1]]
A.sort()
for a in A:
tmp = []
for l, r in intervals:
tmp.append([l+a, r+a])
intervals = merger(intervals + tmp)
if len(intervals) > K ** 2:
break
ans = []
for (_, r), (l, _) in zip(intervals, intervals[1:]):
for x in range(r, l):
ans.append(x)
if len(ans) == K:
print(*ans)
return
tmp = intervals[-1][1]
while len(ans) < K:
ans.append(tmp)
tmp += 1
print(*ans)
def merger(intervals):
intervals.sort(key=lambda interval: interval[0])
merged = [intervals[0]]
for w in intervals:
if w[0] > merged[-1][1]:
merged.append(w)
elif w[1] > merged[-1][1]:
merged[-1][1] = w[1]
return merged
main()
|
ConDefects/ConDefects/Code/agc062_c/Python/41610915
|
condefects-python_data_502
|
'''
tatyamさん作の、SortedSetです。
使わせていただき、ありがとうございます！
https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
・使い方(個人的まとめ)
s=SortedSet()
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
・使い方URL
https://github.com/tatyam-prime/SortedSet
'''
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for
i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
A.append(1 << 50)
# print(f'{A=}')
ss = SortedSet()
total_value = 0
for a in A:
if total_value < a:
# 出力が確定したよ。
if len(ss) + (a - total_value - 1) >= K:
while len(ss) < K:
total_value += 1
ss.add(total_value)
cnt = 0
for el in ss:
print(el, end=' ')
cnt += 1
if cnt == K:
exit()
# 出力はおあずけです。
for v in range(total_value + 1, a):
ss.add(v)
for v in ss:
x = v + a
if a <= x < total_value + a:
ss.add(x)
else:
definition_cnt = ss.index(a)
# 出力が確定したよ。
if definition_cnt >= K:
cnt = 0
for el in ss:
print(el, end=' ')
cnt += 1
if cnt == K:
exit()
# 出力はおあずけです。
nss = SortedSet()
for el in ss:
if el < a:
nss.add(el)
elif el <= total_value:
if el - a in ss:
nss.add(el)
for el in ss:
x = el + a
if total_value < x <= total_value + a:
nss.add(x)
ss = nss
total_value += a
# print(*ss)
'''
tatyamさん作の、SortedSetです。
使わせていただき、ありがとうございます！
https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
・使い方(個人的まとめ)
s=SortedSet()
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
・使い方URL
https://github.com/tatyam-prime/SortedSet
'''
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for
i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1: len(s) - 1] + "}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
N, K = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
A.append(1 << 80)
# print(f'{A=}')
ss = SortedSet()
total_value = 0
for a in A:
if total_value < a:
# 出力が確定したよ。
if len(ss) + (a - total_value - 1) >= K:
while len(ss) < K:
total_value += 1
ss.add(total_value)
cnt = 0
for el in ss:
print(el, end=' ')
cnt += 1
if cnt == K:
exit()
# 出力はおあずけです。
for v in range(total_value + 1, a):
ss.add(v)
for v in ss:
x = v + a
if a <= x < total_value + a:
ss.add(x)
else:
definition_cnt = ss.index(a)
# 出力が確定したよ。
if definition_cnt >= K:
cnt = 0
for el in ss:
print(el, end=' ')
cnt += 1
if cnt == K:
exit()
# 出力はおあずけです。
nss = SortedSet()
for el in ss:
if el < a:
nss.add(el)
elif el <= total_value:
if el - a in ss:
nss.add(el)
for el in ss:
x = el + a
if total_value < x <= total_value + a:
nss.add(x)
ss = nss
total_value += a
# print(*ss)
|
ConDefects/ConDefects/Code/agc062_c/Python/41651640
|
condefects-python_data_503
|
import copy
def UP(M):
New=[[0]*4 for i in range(4)]
for i in range(3):
New[i]=M[i+1].copy()
return New
def DOWN(M):
New=[[0]*4 for i in range(4)]
for i in reversed(range(1,4)):
New[i]=M[i-1].copy()
return New
def LEFT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(3):
New[i][j]=M[i][j+1]
return New
def RIGHT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in reversed(range(1,4)):
New[i][j]=M[i][j-1]
return New
def ROT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
New[i][j]=M[j][-1-i]
return New
def SUM(M):
ret=0
for i in range(4):
for j in range(4):
ret+=M[i][j]
return ret
def OR(M1,M2,M3):
ret=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
ret[i][j]=M1[i][j]|M2[i][j]|M3[i][j]
return ret
P1=[list(input()) for i in range(4)]
P2=[list(input()) for i in range(4)]
P3=[list(input()) for i in range(4)]
P1i=[[0]*4 for i in range(4)]
P2i=[[0]*4 for i in range(4)]
P3i=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
P1i[i][j]=int(P1[i][j]=="#")
P2i[i][j]=int(P2[i][j]=="#")
P3i[i][j]=int(P3[i][j]=="#")
P0=[]
P0.append(P1i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(P2i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(P3i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P_init=[]
for M in P0:
while True:
New=UP(copy.deepcopy(M))
if SUM(M)!=SUM(New):
break
M=New.copy()
while True:
New=LEFT(copy.deepcopy(M))
if SUM(M)!=SUM(New):
break
M=New.copy()
P_init.append(copy.deepcopy(M))
P1n=[]
for M1 in P_init[0:4]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P1n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
P2n=[]
for M1 in P_init[4:8]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P2n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
P3n=[]
for M1 in P_init[8:12]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P3n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
for M1 in P1n:
for M2 in P2n:
for M3 in P3n:
if SUM(OR(M1,M2,M3))==16:
print("Yes")
exit()
print("No")
import copy
def UP(M):
New=[[0]*4 for i in range(4)]
for i in range(3):
New[i]=M[i+1].copy()
return New
def DOWN(M):
New=[[0]*4 for i in range(4)]
for i in reversed(range(1,4)):
New[i]=M[i-1].copy()
return New
def LEFT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(3):
New[i][j]=M[i][j+1]
return New
def RIGHT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in reversed(range(1,4)):
New[i][j]=M[i][j-1]
return New
def ROT(M):
New=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
New[i][j]=M[j][-1-i]
return New
def SUM(M):
ret=0
for i in range(4):
for j in range(4):
ret+=M[i][j]
return ret
def OR(M1,M2,M3):
ret=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
ret[i][j]=int(M1[i][j]+M2[i][j]+M3[i][j]==1)
return ret
P1=[list(input()) for i in range(4)]
P2=[list(input()) for i in range(4)]
P3=[list(input()) for i in range(4)]
P1i=[[0]*4 for i in range(4)]
P2i=[[0]*4 for i in range(4)]
P3i=[[0]*4 for i in range(4)]
for i in range(4):
for j in range(4):
P1i[i][j]=int(P1[i][j]=="#")
P2i[i][j]=int(P2[i][j]=="#")
P3i[i][j]=int(P3[i][j]=="#")
P0=[]
P0.append(P1i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(P2i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(P3i.copy())
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P0.append(ROT(P0[-1].copy()))
P_init=[]
for M in P0:
while True:
New=UP(copy.deepcopy(M))
if SUM(M)!=SUM(New):
break
M=New.copy()
while True:
New=LEFT(copy.deepcopy(M))
if SUM(M)!=SUM(New):
break
M=New.copy()
P_init.append(copy.deepcopy(M))
P1n=[]
for M1 in P_init[0:4]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P1n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
P2n=[]
for M1 in P_init[4:8]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P2n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
P3n=[]
for M1 in P_init[8:12]:
M_init=copy.deepcopy(M1)
for i in range(4):
if SUM(M1)!=SUM(M_init):
break
M_test=copy.deepcopy(M_init)
for j in range(4):
if SUM(M_test)!=SUM(M_init):
break
P3n.append(M_test)
M_test=RIGHT(copy.deepcopy(M_test))
M_init=DOWN(copy.deepcopy(M_init))
for M1 in P1n:
for M2 in P2n:
for M3 in P3n:
if SUM(OR(M1,M2,M3))==16:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc322_d/Python/53313253
|
condefects-python_data_504
|
import itertools
import sys
P = []
for i in range(3):
p = []
for j in range(4):
p.append(list(map(lambda x: int(x == '#'), input())))
P.append(p)
cnt = 0
for p in P:
cnt += sum(itertools.chain.from_iterable(p))
if cnt != 16:
print('No')
sys.exit()
def rotate(piece: list, n):
if n == 0:
return piece
if n == 1:
return list(map(list, zip(*piece[::-1])))
if n == 2:
return list(reversed([p[::-1] for p in piece]))
if n == 3:
return list(map(list, zip(*piece)))[::-1]
R = []
for p in P:
R.append([rotate(p, i) for i in range(4)])
def slide(p, n):
rotated = R[p][n // 49]
row = (n % 49) // 7 - 3
col = (n % 49) % 7 - 3
result = [[0] * 4 for _ in range(4)]
for i, r in enumerate(rotated):
for j, e in enumerate(r):
if 0 <= i + row <= 3 and 0 <= j + col <= 3:
result[i + row][j + col] = e
elif e:
return None
return result
def can_merge(p1, p2, p3):
for i in range(4):
for j in range(4):
if p1[i][j] + p2[i][j] + p3[i][j] != 1:
return False
return True
for i in range(196):
p1 = slide(0, i)
if p1 is None:
continue
for j in range(196):
p2 = slide(1, j)
if p2 is None:
continue
for k in range(196):
p3 = slide(2, k)
if p3 is None:
continue
if can_merge(p1, p2, p3):
# print('Yes')
# print(*p1, sep='\n')
# print()
# print(*p2, sep='\n')
# print()
# print(*p3, sep='\n')
sys.exit()
print('No')
import itertools
import sys
P = []
for i in range(3):
p = []
for j in range(4):
p.append(list(map(lambda x: int(x == '#'), input())))
P.append(p)
cnt = 0
for p in P:
cnt += sum(itertools.chain.from_iterable(p))
if cnt != 16:
print('No')
sys.exit()
def rotate(piece: list, n):
if n == 0:
return piece
if n == 1:
return list(map(list, zip(*piece[::-1])))
if n == 2:
return list(reversed([p[::-1] for p in piece]))
if n == 3:
return list(map(list, zip(*piece)))[::-1]
R = []
for p in P:
R.append([rotate(p, i) for i in range(4)])
def slide(p, n):
rotated = R[p][n // 49]
row = (n % 49) // 7 - 3
col = (n % 49) % 7 - 3
result = [[0] * 4 for _ in range(4)]
for i, r in enumerate(rotated):
for j, e in enumerate(r):
if 0 <= i + row <= 3 and 0 <= j + col <= 3:
result[i + row][j + col] = e
elif e:
return None
return result
def can_merge(p1, p2, p3):
for i in range(4):
for j in range(4):
if p1[i][j] + p2[i][j] + p3[i][j] != 1:
return False
return True
for i in range(196):
p1 = slide(0, i)
if p1 is None:
continue
for j in range(196):
p2 = slide(1, j)
if p2 is None:
continue
for k in range(196):
p3 = slide(2, k)
if p3 is None:
continue
if can_merge(p1, p2, p3):
print('Yes')
# print(*p1, sep='\n')
# print()
# print(*p2, sep='\n')
# print()
# print(*p3, sep='\n')
sys.exit()
print('No')
|
ConDefects/ConDefects/Code/abc322_d/Python/46190250
|
condefects-python_data_505
|
n = int(input())
if n%5 ==0:
print(0)
elif n % 5 >=3:
print(n+5-n%5)
else:
print(n-n%5)
n = int(input())
if n%5 ==0:
print(n)
elif n % 5 >=3:
print(n+5-n%5)
else:
print(n-n%5)
|
ConDefects/ConDefects/Code/abc305_a/Python/45785540
|
condefects-python_data_506
|
N=int(input())
a=N%5
if a==0:
print(N)
else:
if a <3:
ans=N-a
else:
ans=N+a-1
print(ans)
N=int(input())
a=N%5
if a==0:
print(N)
else:
if a <3:
ans=N-a
else:
ans=N+(5-a)
print(ans)
|
ConDefects/ConDefects/Code/abc305_a/Python/45542217
|
condefects-python_data_507
|
n=int(input())
print((n//5)*5+5 if n%5>=2 else (n//5)*5)
n=int(input())
print((n//5)*5+5 if n%5>2 else (n//5)*5)
|
ConDefects/ConDefects/Code/abc305_a/Python/46173794
|
condefects-python_data_508
|
print(abs(5-int(input())%5))
print(int((int(input())+2)/5)*5)
|
ConDefects/ConDefects/Code/abc305_a/Python/45768286
|
condefects-python_data_509
|
n=100
if n%5<3:
ans=n-(n%5)
else:
ans=n+5-(n%5)
print(ans)
n=int(input())
if n%5<3:
ans=n-(n%5)
else:
ans=n+5-(n%5)
print(ans)
|
ConDefects/ConDefects/Code/abc305_a/Python/45435091
|
condefects-python_data_510
|
N=int(input())
list=[]
for i in range(20):
list.append(abs(N-i*5))
In=list.index(min(list))
print(In*5)
N=int(input())
list=[]
for i in range(21):
list.append(abs(N-i*5))
In=list.index(min(list))
print(In*5)
|
ConDefects/ConDefects/Code/abc305_a/Python/46193789
|
condefects-python_data_511
|
a = list(input())
b = list(input())
n = len(a)
m = len(b)
if n < m:
print('No')
elif n == m:
print('Yes' if a == b else 'No')
else:
for i in range(n-m):
t = a[i:i+m]
if t == b:
print('Yes')
break
else:
print('No')
a = list(input())
b = list(input())
n = len(a)
m = len(b)
if n < m:
print('No')
elif n == m:
print('Yes' if a == b else 'No')
else:
for i in range(n-m+1):
t = a[i:i+m]
if t == b:
print('Yes')
break
else:
print('No')
|
ConDefects/ConDefects/Code/abc279_b/Python/45923979
|
condefects-python_data_512
|
s = input()
t = input()
if len(s) > len(t) or (len(s) == len(t) and s != t):
print("No")
exit()
else:
for i in range(len(s) - len(t) + 1):
if s[i:i+len(t)] == t:
print("Yes")
exit()
print("No")
s = input()
t = input()
if len(t) > len(s) or (len(s) == len(t) and s != t):
print("No")
exit()
else:
for i in range(len(s) - len(t) + 1):
if s[i:i+len(t)] == t:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc279_b/Python/44853654
|
condefects-python_data_513
|
n, m, k = map(int, input().split())
z = [[] for _ in range(n)]
for i in range(k):
p, x, q, y = [int(a) - 1 for a in input().split()]
z[p].append([x + 1, q, y + 1])
z[p].append([x + 2, q, y + 2])
z[q].append([y + 1, p, x + 1])
z[q].append([y + 2, p, x + 2])
for i in z:
i.sort(key = lambda x: -x[0])
print(i)
f = [1] * n
for i, x in enumerate(z):
print(i, f[i]);
l = []
while x and x[-1][0] <= f[i]:
l.append(x.pop())
while l:
_, j, a = l.pop()
f[j] = max(f[j], a)
w = z[j]
while w and w[-1][0] <= f[j]:
l.append(w.pop())
print(-1 if max(f) > m else sum(f))
n, m, k = map(int, input().split())
z = [[] for _ in range(n)]
for i in range(k):
p, x, q, y = [int(a) - 1 for a in input().split()]
z[p].append([x + 1, q, y + 1])
z[p].append([x + 2, q, y + 2])
z[q].append([y + 1, p, x + 1])
z[q].append([y + 2, p, x + 2])
for i in z:
i.sort(key = lambda x: -x[0])
f = [1] * n
for i, x in enumerate(z):
l = []
while x and x[-1][0] <= f[i]:
l.append(x.pop())
while l:
_, j, a = l.pop()
f[j] = max(f[j], a)
w = z[j]
while w and w[-1][0] <= f[j]:
l.append(w.pop())
print(-1 if max(f) > m else sum(f))
|
ConDefects/ConDefects/Code/arc146_d/Python/34275405
|
condefects-python_data_514
|
n = int(input())
results = "0"
for i in range(1, n + 1):
if i % 3 == 0:
results += "x"
else:
results += "o"
print(results)
n = int(input())
results = ""
for i in range(1, n + 1):
if i % 3 == 0:
results += "x"
else:
results += "o"
print(results)
|
ConDefects/ConDefects/Code/abc348_a/Python/54770076
|
condefects-python_data_515
|
N = int(input())
list=[]
for i in range(N):
if (i+1) % 3 == 0:
list.append("x")
else:
list.append("o")
print(" ".join(list))
N = int(input())
list=[]
for i in range(N):
if (i+1) % 3 == 0:
list.append("x")
else:
list.append("o")
print("".join(list))
|
ConDefects/ConDefects/Code/abc348_a/Python/54898289
|
condefects-python_data_516
|
n=int(input())
for i in range(1, n+1):
if i*3==0:
print("x", end="")
else:
print("o", end="")
n=int(input())
for i in range(1, n+1):
if i%3==0:
print("x", end="")
else:
print("o", end="")
|
ConDefects/ConDefects/Code/abc348_a/Python/54752579
|
condefects-python_data_517
|
n = int(input())
ans = ""
for i in range(1, n+1):
ans += 'x' if i % 3 == 0 else '○'
print(ans)
n = int(input())
ans = ""
for i in range(1, n+1):
ans += 'x' if i % 3 == 0 else 'o'
print(ans)
|
ConDefects/ConDefects/Code/abc348_a/Python/54751581
|
condefects-python_data_518
|
from collections import deque
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
class Dinic:
def __init__(self,V):
self.V = V
self.E = [[] for i in range(V)]
self.P = [0 for i in range(V)]
def add_edge(self,u,v,cap):
self.E[u].append((v,cap,self.P[v]))
self.E[v].append((u,0,self.P[u]))
self.P[u] += 1
self.P[v] += 1
def flow(self,s,t):
G = self.E
P = self.P
def bfs(s): #始点から各頂点への最短距離をBFSで求める。
dist = [-1 for i in range(self.V)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
u = Q.popleft()
for v,cap,rev in G[u]:
if cap > 0 and dist[v] < 0:
dist[v] = dist[u] + 1
Q.append(v)
return dist
def dfs(u,t,f,removed,dist):
if u == t:
return f
while removed[u] < P[u]:
v,cap,rev = G[u][removed[u]]
if cap > 0 and dist[u] < dist[v]:
ff = dfs(v,t,min(f,cap),removed,dist)
if ff > 0:
G[u][removed[u]] = (v,cap-ff,rev)
u,Cap,Rev = G[v][rev]
G[v][rev] = (u,Cap+ff,Rev)
return ff
removed[u] += 1
return 0
f = 0
while True:
dist = bfs(s)
if dist[t] < 0:
return f
removed = [0 for i in range(self.V)]
while True:
ff = dfs(s,t,10000000000,removed,dist)
if ff == 0:
break
f += ff
def Eratosthenes(N):
is_prime = [1 for i in range(N+1)]
is_prime[0] = is_prime[1] = 0
P = []
for p in range(2,N+1):
if is_prime[p] == 0:
continue
P.append(p)
for d in range(2,N//p+1):
q = p*d
is_prime[q] = 0
return is_prime
inf = 10**18
N = int(input())
X,Y = [],[]
gf = Dinic(N+2)
gf_ = Dinic(N+2)
P = Eratosthenes(3*(10**7))
for i in range(N):
a,b = map(int,input().split())
if a % 2 == 1:
X.append((a,b))
else:
Y.append((a,b))
nx = len(X)
ny = len(Y)
C = 0
for i in range(nx):
a,b = X[i]
gf.add_edge(0,i+1,b)
if a == 1:
C = b
continue
gf_.add_edge(0,i+1,b)
for j in range(ny):
a,b = Y[j]
gf.add_edge(j+nx+1,N+1,b)
gf_.add_edge(j+nx+1,N+1,b)
for i in range(nx):
u = i + 1
a,b = X[i]
for j in range(ny):
v = j + nx + 1
aa,bb = Y[j]
if P[a+aa]:
gf.add_edge(u,v,inf)
gf_.add_edge(u,v,inf)
Fc = gf.flow(0,N+1)
F0 = gf_.flow(0,N+1)
ans = Fc + (C - (Fc - F0))//2
print(Fc)
from collections import deque
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
class Dinic:
def __init__(self,V):
self.V = V
self.E = [[] for i in range(V)]
self.P = [0 for i in range(V)]
def add_edge(self,u,v,cap):
self.E[u].append((v,cap,self.P[v]))
self.E[v].append((u,0,self.P[u]))
self.P[u] += 1
self.P[v] += 1
def flow(self,s,t):
G = self.E
P = self.P
def bfs(s): #始点から各頂点への最短距離をBFSで求める。
dist = [-1 for i in range(self.V)]
dist[s] = 0
Q = deque()
Q.append(s)
while len(Q) > 0:
u = Q.popleft()
for v,cap,rev in G[u]:
if cap > 0 and dist[v] < 0:
dist[v] = dist[u] + 1
Q.append(v)
return dist
def dfs(u,t,f,removed,dist):
if u == t:
return f
while removed[u] < P[u]:
v,cap,rev = G[u][removed[u]]
if cap > 0 and dist[u] < dist[v]:
ff = dfs(v,t,min(f,cap),removed,dist)
if ff > 0:
G[u][removed[u]] = (v,cap-ff,rev)
u,Cap,Rev = G[v][rev]
G[v][rev] = (u,Cap+ff,Rev)
return ff
removed[u] += 1
return 0
f = 0
while True:
dist = bfs(s)
if dist[t] < 0:
return f
removed = [0 for i in range(self.V)]
while True:
ff = dfs(s,t,10000000000,removed,dist)
if ff == 0:
break
f += ff
def Eratosthenes(N):
is_prime = [1 for i in range(N+1)]
is_prime[0] = is_prime[1] = 0
P = []
for p in range(2,N+1):
if is_prime[p] == 0:
continue
P.append(p)
for d in range(2,N//p+1):
q = p*d
is_prime[q] = 0
return is_prime
inf = 10**18
N = int(input())
X,Y = [],[]
gf = Dinic(N+2)
gf_ = Dinic(N+2)
P = Eratosthenes(3*(10**7))
for i in range(N):
a,b = map(int,input().split())
if a % 2 == 1:
X.append((a,b))
else:
Y.append((a,b))
nx = len(X)
ny = len(Y)
C = 0
for i in range(nx):
a,b = X[i]
gf.add_edge(0,i+1,b)
if a == 1:
C = b
continue
gf_.add_edge(0,i+1,b)
for j in range(ny):
a,b = Y[j]
gf.add_edge(j+nx+1,N+1,b)
gf_.add_edge(j+nx+1,N+1,b)
for i in range(nx):
u = i + 1
a,b = X[i]
for j in range(ny):
v = j + nx + 1
aa,bb = Y[j]
if P[a+aa]:
gf.add_edge(u,v,inf)
gf_.add_edge(u,v,inf)
Fc = gf.flow(0,N+1)
F0 = gf_.flow(0,N+1)
ans = Fc + (C - (Fc - F0))//2
print(ans)
|
ConDefects/ConDefects/Code/abc263_g/Python/49799392
|
condefects-python_data_519
|
import sys
readline = sys.stdin.readline
#エラトステネスの篩と素因数分解
from collections import Counter
M = 2*10**7 + 20
prime = [0]*M
for i in range(2, M):
if prime[i]:
continue
for j in range(i, M, i):
if not prime[j]:
prime[j] = i
import collections
class Dinic:
def __init__(self, vnum):
self.edge = [[] for i in range(vnum)]
self.n = vnum
# infはint型の方が良いかもね
self.inf = float('inf')
def addedge(self, st, en, c):
self.edge[st].append([en, c, len(self.edge[en])])
self.edge[en].append([st, 0, len(self.edge[st])-1])
def bfs(self, vst):
dist = [-1]*self.n
dist[vst] = 0
Q = collections.deque([vst])
while Q:
nv = Q.popleft()
for vt, c, r in self.edge[nv]:
if dist[vt] == -1 and c > 0:
dist[vt] = dist[nv] + 1
Q.append(vt)
self.dist = dist
def dfs(self, nv, en, nf):
nextv = self.nextv
if nv == en:
return nf
dist = self.dist
ist = nextv[nv]
for i, (vt, c, r) in enumerate(self.edge[nv][ist:], ist):
if dist[nv] < dist[vt] and c > 0:
df = self.dfs(vt, en, min(nf, c))
if df > 0:
self.edge[nv][i][1] -= df
self.edge[vt][r][1] += df
return df
nextv[nv] += 1
return 0
def getmf(self, st, en):
mf = 0
while True:
self.bfs(st)
if self.dist[en] == -1:
break
self.nextv = [0]*self.n
while True:
fl = self.dfs(st, en, self.inf)
if fl > 0:
mf += fl
else:
break
return mf
def calc(x):
N = len(D)
oner = N
st = N+1
en = N+2
As = list(D.keys())
T = Dinic(en+1)
for i, a in enumerate(As):
if a == 1:
T.addedge(st, i, x)
T.addedge(oner, en, D[1] - x)
T.addedge(i, oner, INF)
else:
if a&1:
T.addedge(i, en, D[a])
else:
T.addedge(st, i, D[a])
for i in range(N):
for j in range(i):
if prime[As[i] + As[j]] == As[i]+As[j]:
ic, jc = i, j
if i&1 and i != 1:
ic, jc = jc, ic
T.addedge(ic, jc, INF)
return T.getmf(st, en)
INF = 2*10**9+7
N = int(readline())
D = Counter()
for _ in range(N):
a, b = map(int, readline().split())
D[a] = b
l = 0
r = D[1]
D[1] = D[1]
while abs(r-l) > 10:
m1 = (l*2+r)//3
m2 = (l+r*2)//3
c1 = calc(m1)
c2 = calc(m2)
if c1 < c2:
l = m1
else:
r = m2
ans = 0
for m in range(l, r+1):
ans = max(ans, calc(m))
print(ans)
import sys
readline = sys.stdin.readline
#エラトステネスの篩と素因数分解
from collections import Counter
M = 2*10**7 + 20
prime = [0]*M
for i in range(2, M):
if prime[i]:
continue
for j in range(i, M, i):
if not prime[j]:
prime[j] = i
import collections
class Dinic:
def __init__(self, vnum):
self.edge = [[] for i in range(vnum)]
self.n = vnum
# infはint型の方が良いかもね
self.inf = float('inf')
def addedge(self, st, en, c):
self.edge[st].append([en, c, len(self.edge[en])])
self.edge[en].append([st, 0, len(self.edge[st])-1])
def bfs(self, vst):
dist = [-1]*self.n
dist[vst] = 0
Q = collections.deque([vst])
while Q:
nv = Q.popleft()
for vt, c, r in self.edge[nv]:
if dist[vt] == -1 and c > 0:
dist[vt] = dist[nv] + 1
Q.append(vt)
self.dist = dist
def dfs(self, nv, en, nf):
nextv = self.nextv
if nv == en:
return nf
dist = self.dist
ist = nextv[nv]
for i, (vt, c, r) in enumerate(self.edge[nv][ist:], ist):
if dist[nv] < dist[vt] and c > 0:
df = self.dfs(vt, en, min(nf, c))
if df > 0:
self.edge[nv][i][1] -= df
self.edge[vt][r][1] += df
return df
nextv[nv] += 1
return 0
def getmf(self, st, en):
mf = 0
while True:
self.bfs(st)
if self.dist[en] == -1:
break
self.nextv = [0]*self.n
while True:
fl = self.dfs(st, en, self.inf)
if fl > 0:
mf += fl
else:
break
return mf
def calc(x):
N = len(D)
oner = N
st = N+1
en = N+2
As = list(D.keys())
T = Dinic(en+1)
for i, a in enumerate(As):
if a == 1:
T.addedge(st, i, x)
T.addedge(oner, en, D[1] - x)
T.addedge(i, oner, INF)
else:
if a&1:
T.addedge(i, en, D[a])
else:
T.addedge(st, i, D[a])
for i in range(N):
for j in range(i):
if prime[As[i] + As[j]] == As[i]+As[j]:
ic, jc = i, j
if As[i]&1:
ic, jc = jc, ic
T.addedge(ic, jc, INF)
return T.getmf(st, en)
INF = 2*10**9+7
N = int(readline())
D = Counter()
for _ in range(N):
a, b = map(int, readline().split())
D[a] = b
l = 0
r = D[1]
D[1] = D[1]
while abs(r-l) > 10:
m1 = (l*2+r)//3
m2 = (l+r*2)//3
c1 = calc(m1)
c2 = calc(m2)
if c1 < c2:
l = m1
else:
r = m2
ans = 0
for m in range(l, r+1):
ans = max(ans, calc(m))
print(ans)
|
ConDefects/ConDefects/Code/abc263_g/Python/34042464
|
condefects-python_data_520
|
def Ternary_Search_Maximize_Integer(L, R, f, arg=False):
""" 三分探索によって, 整数を定義域とする関数 f の [L,R] における最大値を求める.
f: [L,R] 内で上に凸または単調増加
"""
while (R-L)>3:
a=(2*L+R)//3
b=(L+2*R)//3
p=f(a); q=f(b)
if p>=q:
R=b
else:
L=a
a=(2*L+R)//3
b=(L+2*R)//3
if arg:
y,argx=f(L),L
for x in [a,b,R]:
p=f(x)
if y<p:
y,argx=p,x
return y,argx
else:
return max(f(L),f(a),f(b),f(R))
#素数判定
def Is_Prime(N):
N=abs(N)
if N<=1: return False
if (N==2) or (N==3) or (N==5): return True
r=N%6
if not(r==1 or r==5): return False
k=5
Flag=0
while k*k<=N:
if N%k==0: return False
k+=2+2*Flag
Flag^=1
return True
#==================================================
from collections import deque
class MaxFlow:
inf = float("inf")
class Arc:
def __init__(self, source, target, cap, base, direction, id):
self.source=source
self.target=target
self.cap = cap
self.base = base
self.rev = None
self.direction=direction
self.id=id
def __repr__(self):
if self.direction==1:
return "id: {}, {} -> {}, {} / {}".format(self.id, self.source, self.target, self.cap, self.base)
else:
return "id: {}, {} <- {}, {} / {}".format(self.id, self.target, self.source, self.cap, self.base)
def __init__(self, N=0):
""" N 頂点のフロー場を生成する.
"""
self.arc = [[] for _ in range(N)]
self.__arc_list=[]
def add_vertex(self):
self.arc.append([])
return self.vertex_count()-1
def add_vertices(self, k):
n=self.vertex_count()
self.arc.extend([[] for _ in range(k)])
return list(range(n,n+k))
def add_arc(self, v, w, cap):
""" 容量 cap の有向辺 v → w を加える.
"""
m=len(self.__arc_list)
a=self.Arc(v,w,cap,cap,1,m)
b=self.Arc(w,v,0,cap,-1,m)
a.rev=b; b.rev=a
self.arc[v].append(a)
self.arc[w].append(b)
self.__arc_list.append(a)
return m
def get_arc(self, i, mode=0):
""" i 番目の辺の情報を得る.
"""
assert 0<=i<len(self.__arc_list)
a=self.__arc_list[i]
if mode:
return a,a.rev
else:
return a
def get_all_arcs(self):
return [self.get_arc(i) for i in range(len(self.__arc_list))]
def vertex_count(self):
return len(self.arc)
def arc_count(self):
return len(self.__arc_list)
def change_arc(self, i, new_cap, new_flow):
""" i 番目の辺の情報を変更する.
"""
assert 0<=i<len(self.__arc_list)
assert 0<=new_flow<=new_cap
a=self.__arc_list[i]
a.base=new_cap; a.cap=new_cap-new_flow
a.rev.base=new_cap; a.rev.cap=new_flow
def add_edge(self, v, w, cap):
""" 容量 cap の無向辺 v → w を加える."""
self.add_arc(v,w,cap)
self.add_arc(w,v,cap)
def __bfs(self, s, t):
level=self.level=[-1]*self.vertex_count()
Q=deque([s])
level[s]=0
while Q:
v=Q.popleft()
next_level=level[v]+1
for a in self.arc[v]:
if a.cap and level[a.target]==-1:
level[a.target]=next_level
if a.target==t:
return True
Q.append(a.target)
return False
def __dfs(self, s, t, up):
arc = self.arc
it = self.it
level = self.level
st = deque([t])
while st:
v = st[-1]
if v == s:
st.pop()
flow = up
for w in st:
a = arc[w][it[w]].rev
flow = min(flow, a.cap)
for w in st:
a = arc[w][it[w]]
a.cap += flow
a.rev.cap -= flow
return flow
lv = level[v]-1
while it[v] < len(arc[v]):
a = arc[v][it[v]]
ra = a.rev
if ra.cap == 0 or lv != level[a.target]:
it[v] += 1
continue
st.append(a.target)
break
if it[v] == len(arc[v]):
st.pop()
level[v]=-1
return 0
def max_flow(self, source, target, flow_limit=inf):
""" source から target に高々 flow_limit の水流を流すとき, "新たに流れる" 水流の大きさ"""
flow = 0
while flow < flow_limit and self.__bfs(source, target):
self.it = [0]*self.vertex_count()
while flow < flow_limit:
f = self.__dfs(source, target, flow_limit-flow)
if f == 0:
break
flow += f
return flow
def get_flow(self, mode=0):
if mode==0:
return [a.base-a.cap for a in self.__arc_list]
else:
F=[[] for _ in range(self.vertex_count())]
for i,a in enumerate(self.__arc_list):
F[a.source].append((i, a.target, a.base-a.cap))
return F
def min_cut(self,s):
""" s を 0 に含める最小カットを求める.
"""
group = [1]*self.vertex_count()
Q = deque([s])
while Q:
v = Q.pop()
group[v] = 0
for a in self.arc[v]:
if a.cap and group[a.target]:
Q.append(a.target)
return group
def refresh(self):
for a in self.__arc_list:
a.cap=a.base
a.rev.cap=0
#==================================================
def calc(k):
F=MaxFlow()
source=F.add_vertex()
I=F.add_vertices(N)
target=F.add_vertex()
for i in range(N):
if A[i]==1:
B[i]-=2*k
if A[i]%2==1:
F.add_arc(source, I[i], B[i])
else:
F.add_arc(I[i], target, B[i])
inf=float("inf")
for i in range(N):
for j in range(N):
if (A[i]%2==1) and (A[j]%2==0) and P[i][j]:
F.add_arc(I[i], I[j], inf)
return F.max_flow(source, target)+k
#==================================================
N=int(input())
A=[0]*N; B=[0]*N
for i in range(N):
A[i],B[i]=map(int,input().split())
if 1 in A:
count_1=B[A.index(1)]
else:
count_1=0
P=[[Is_Prime(A[i]+A[j]) for j in range(N)] for i in range(N)]
print(Ternary_Search_Maximize_Integer(0,count_1//2, calc))
def Ternary_Search_Maximize_Integer(L, R, f, arg=False):
""" 三分探索によって, 整数を定義域とする関数 f の [L,R] における最大値を求める.
f: [L,R] 内で上に凸または単調増加
"""
while (R-L)>3:
a=(2*L+R)//3
b=(L+2*R)//3
p=f(a); q=f(b)
if p>=q:
R=b
else:
L=a
a=(2*L+R)//3
b=(L+2*R)//3
if arg:
y,argx=f(L),L
for x in [a,b,R]:
p=f(x)
if y<p:
y,argx=p,x
return y,argx
else:
return max(f(L),f(a),f(b),f(R))
#素数判定
def Is_Prime(N):
N=abs(N)
if N<=1: return False
if (N==2) or (N==3) or (N==5): return True
r=N%6
if not(r==1 or r==5): return False
k=5
Flag=0
while k*k<=N:
if N%k==0: return False
k+=2+2*Flag
Flag^=1
return True
#==================================================
from collections import deque
class MaxFlow:
inf = float("inf")
class Arc:
def __init__(self, source, target, cap, base, direction, id):
self.source=source
self.target=target
self.cap = cap
self.base = base
self.rev = None
self.direction=direction
self.id=id
def __repr__(self):
if self.direction==1:
return "id: {}, {} -> {}, {} / {}".format(self.id, self.source, self.target, self.cap, self.base)
else:
return "id: {}, {} <- {}, {} / {}".format(self.id, self.target, self.source, self.cap, self.base)
def __init__(self, N=0):
""" N 頂点のフロー場を生成する.
"""
self.arc = [[] for _ in range(N)]
self.__arc_list=[]
def add_vertex(self):
self.arc.append([])
return self.vertex_count()-1
def add_vertices(self, k):
n=self.vertex_count()
self.arc.extend([[] for _ in range(k)])
return list(range(n,n+k))
def add_arc(self, v, w, cap):
""" 容量 cap の有向辺 v → w を加える.
"""
m=len(self.__arc_list)
a=self.Arc(v,w,cap,cap,1,m)
b=self.Arc(w,v,0,cap,-1,m)
a.rev=b; b.rev=a
self.arc[v].append(a)
self.arc[w].append(b)
self.__arc_list.append(a)
return m
def get_arc(self, i, mode=0):
""" i 番目の辺の情報を得る.
"""
assert 0<=i<len(self.__arc_list)
a=self.__arc_list[i]
if mode:
return a,a.rev
else:
return a
def get_all_arcs(self):
return [self.get_arc(i) for i in range(len(self.__arc_list))]
def vertex_count(self):
return len(self.arc)
def arc_count(self):
return len(self.__arc_list)
def change_arc(self, i, new_cap, new_flow):
""" i 番目の辺の情報を変更する.
"""
assert 0<=i<len(self.__arc_list)
assert 0<=new_flow<=new_cap
a=self.__arc_list[i]
a.base=new_cap; a.cap=new_cap-new_flow
a.rev.base=new_cap; a.rev.cap=new_flow
def add_edge(self, v, w, cap):
""" 容量 cap の無向辺 v → w を加える."""
self.add_arc(v,w,cap)
self.add_arc(w,v,cap)
def __bfs(self, s, t):
level=self.level=[-1]*self.vertex_count()
Q=deque([s])
level[s]=0
while Q:
v=Q.popleft()
next_level=level[v]+1
for a in self.arc[v]:
if a.cap and level[a.target]==-1:
level[a.target]=next_level
if a.target==t:
return True
Q.append(a.target)
return False
def __dfs(self, s, t, up):
arc = self.arc
it = self.it
level = self.level
st = deque([t])
while st:
v = st[-1]
if v == s:
st.pop()
flow = up
for w in st:
a = arc[w][it[w]].rev
flow = min(flow, a.cap)
for w in st:
a = arc[w][it[w]]
a.cap += flow
a.rev.cap -= flow
return flow
lv = level[v]-1
while it[v] < len(arc[v]):
a = arc[v][it[v]]
ra = a.rev
if ra.cap == 0 or lv != level[a.target]:
it[v] += 1
continue
st.append(a.target)
break
if it[v] == len(arc[v]):
st.pop()
level[v]=-1
return 0
def max_flow(self, source, target, flow_limit=inf):
""" source から target に高々 flow_limit の水流を流すとき, "新たに流れる" 水流の大きさ"""
flow = 0
while flow < flow_limit and self.__bfs(source, target):
self.it = [0]*self.vertex_count()
while flow < flow_limit:
f = self.__dfs(source, target, flow_limit-flow)
if f == 0:
break
flow += f
return flow
def get_flow(self, mode=0):
if mode==0:
return [a.base-a.cap for a in self.__arc_list]
else:
F=[[] for _ in range(self.vertex_count())]
for i,a in enumerate(self.__arc_list):
F[a.source].append((i, a.target, a.base-a.cap))
return F
def min_cut(self,s):
""" s を 0 に含める最小カットを求める.
"""
group = [1]*self.vertex_count()
Q = deque([s])
while Q:
v = Q.pop()
group[v] = 0
for a in self.arc[v]:
if a.cap and group[a.target]:
Q.append(a.target)
return group
def refresh(self):
for a in self.__arc_list:
a.cap=a.base
a.rev.cap=0
#==================================================
def calc(k):
F=MaxFlow()
source=F.add_vertex()
I=F.add_vertices(N)
target=F.add_vertex()
for i in range(N):
if A[i]==1:
B[i]=count_1-2*k
if A[i]%2==1:
F.add_arc(source, I[i], B[i])
else:
F.add_arc(I[i], target, B[i])
inf=float("inf")
for i in range(N):
for j in range(N):
if (A[i]%2==1) and (A[j]%2==0) and P[i][j]:
F.add_arc(I[i], I[j], inf)
return F.max_flow(source, target)+k
#==================================================
N=int(input())
A=[0]*N; B=[0]*N
for i in range(N):
A[i],B[i]=map(int,input().split())
if 1 in A:
count_1=B[A.index(1)]
else:
count_1=0
P=[[Is_Prime(A[i]+A[j]) for j in range(N)] for i in range(N)]
print(Ternary_Search_Maximize_Integer(0,count_1//2, calc))
|
ConDefects/ConDefects/Code/abc263_g/Python/34500524
|
condefects-python_data_521
|
import sys
input = sys.stdin.readline
def isPrime(x):
p = 2
while p * p <= x:
if x % p == 0:
return False
p += 1
return True
n = int(input())
li = [list(map(int, input().split())) for _ in range(n)]
from collections import deque
from math import inf
class Dinic:
"""
Usage:
mf = Dinic(n)
-> mf.add_link(from, to, capacity)
-> mf.max_flow(source, target)
"""
def __init__(self, n):
self.n = n
self.links = [[] for _ in range(n)]
def add_edge(self, from_, to, capacity):
self.links[from_].append([capacity, to, len(self.links[to])])
self.links[to].append([0, from_, len(self.links[from_]) - 1])
def bfs(self, s):
depth = [-1] * self.n
depth[s] = 0
q = deque([s])
while q:
v = q.popleft()
for cap, to, rev in self.links[v]:
if cap > 0 and depth[to] < 0:
depth[to] = depth[v] + 1
q.append(to)
return depth
def dfs(self, s, t, depth, progress, link_counts):
links = self.links
stack = [s]
while stack:
v = stack[-1]
if v == t:
break
for i in range(progress[v], link_counts[v]):
progress[v] = i
cap, to, rev = links[v][i]
if cap == 0 or depth[v] >= depth[to] or progress[to] >= link_counts[to]:
continue
stack.append(to)
break
else:
progress[v] += 1
stack.pop()
else:
return 0
f = 1 << 60
fwd_links = []
bwd_links = []
for v in stack[:-1]:
cap, to, rev = link = links[v][progress[v]]
f = min(f, cap)
fwd_links.append(link)
bwd_links.append(links[to][rev])
for link in fwd_links:
link[0] -= f
for link in bwd_links:
link[0] += f
return f
def flow(self, s, t):
link_counts = list(map(len, self.links))
flow = 0
while True:
depth = self.bfs(s)
if depth[t] < 0:
break
progress = [0] * self.n
current_flow = self.dfs(s, t, depth, progress, link_counts)
while current_flow > 0:
flow += current_flow
current_flow = self.dfs(s, t, depth, progress, link_counts)
return flow
mf = Dinic(2 * n + 2)
start = 0
end = 2 * n + 1
for i in range(1, n + 1):
mf.add_edge(start, i, li[i - 1][1])
mf.add_edge(i + n, end, li[i - 1][1])
for i in range(n):
for j in range(n):
if isPrime(li[i][0] + li[j][1]):
mf.add_edge(i + 1, j + n + 1, inf)
print(mf.flow(start, end)//2)
import sys
input = sys.stdin.readline
def isPrime(x):
p = 2
while p * p <= x:
if x % p == 0:
return False
p += 1
return True
n = int(input())
li = [list(map(int, input().split())) for _ in range(n)]
from collections import deque
from math import inf
class Dinic:
"""
Usage:
mf = Dinic(n)
-> mf.add_link(from, to, capacity)
-> mf.max_flow(source, target)
"""
def __init__(self, n):
self.n = n
self.links = [[] for _ in range(n)]
def add_edge(self, from_, to, capacity):
self.links[from_].append([capacity, to, len(self.links[to])])
self.links[to].append([0, from_, len(self.links[from_]) - 1])
def bfs(self, s):
depth = [-1] * self.n
depth[s] = 0
q = deque([s])
while q:
v = q.popleft()
for cap, to, rev in self.links[v]:
if cap > 0 and depth[to] < 0:
depth[to] = depth[v] + 1
q.append(to)
return depth
def dfs(self, s, t, depth, progress, link_counts):
links = self.links
stack = [s]
while stack:
v = stack[-1]
if v == t:
break
for i in range(progress[v], link_counts[v]):
progress[v] = i
cap, to, rev = links[v][i]
if cap == 0 or depth[v] >= depth[to] or progress[to] >= link_counts[to]:
continue
stack.append(to)
break
else:
progress[v] += 1
stack.pop()
else:
return 0
f = 1 << 60
fwd_links = []
bwd_links = []
for v in stack[:-1]:
cap, to, rev = link = links[v][progress[v]]
f = min(f, cap)
fwd_links.append(link)
bwd_links.append(links[to][rev])
for link in fwd_links:
link[0] -= f
for link in bwd_links:
link[0] += f
return f
def flow(self, s, t):
link_counts = list(map(len, self.links))
flow = 0
while True:
depth = self.bfs(s)
if depth[t] < 0:
break
progress = [0] * self.n
current_flow = self.dfs(s, t, depth, progress, link_counts)
while current_flow > 0:
flow += current_flow
current_flow = self.dfs(s, t, depth, progress, link_counts)
return flow
mf = Dinic(2 * n + 2)
start = 0
end = 2 * n + 1
for i in range(1, n + 1):
mf.add_edge(start, i, li[i - 1][1])
mf.add_edge(i + n, end, li[i - 1][1])
for i in range(n):
for j in range(n):
if isPrime(li[i][0] + li[j][0]):
mf.add_edge(i + 1, j + n + 1, inf)
print(mf.flow(start, end)//2)
|
ConDefects/ConDefects/Code/abc263_g/Python/43726575
|
condefects-python_data_522
|
n,d,p=map(int,input().split())
f=list(map(int,input().split()))
f.sort(reverse=True)
i=0
ans=0
while d*i<n:
ans+=min(p,sum(f[d*i:d*(i+1)+1]))
i+=1
print(ans)
n,d,p=map(int,input().split())
f=list(map(int,input().split()))
f.sort(reverse=True)
i=0
ans=0
while d*i<n:
ans+=min(p,sum(f[d*i:d*(i+1)]))
i+=1
print(ans)
|
ConDefects/ConDefects/Code/abc318_c/Python/45939362
|
condefects-python_data_523
|
n,d,p=map(int,input().split())
f=list(map(int,input().split()))
f.sort(reverse=True)
ans=0
i=0
while d*i<n:
ans+=min(ans,sum(f[d*i:d*(i+1)]))
i+=1
print(ans)
n,d,p=map(int,input().split())
f=list(map(int,input().split()))
f.sort(reverse=True)
ans=0
i=0
while d*i<n:
ans+=min(p,sum(f[d*i:d*(i+1)]))
i+=1
print(ans)
|
ConDefects/ConDefects/Code/abc318_c/Python/45929513
|
condefects-python_data_524
|
N=int(input())
from collections import *
class SegTree: #右開区間による実装
def __init__(self,init_val,segfunc,ide_ele):
n=len(init_val)
self.segfunc=segfunc
self.ide_ele=ide_ele
self.num=1<<(n-1).bit_length()
self.tree=[ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i]=init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i]=self.segfunc(self.tree[2*i],self.tree[2*i+1])
def add(self,k,x):
k+=self.num
self.tree[k]+=x
k>>=1
while k>0:
self.tree[k]=self.segfunc(self.tree[2*k],self.tree[2*k+1])
k>>=1
def update(self,k,x):
k+=self.num
self.tree[k]=x
k>>=1
while k>0:
self.tree[k]=self.segfunc(self.tree[2*k],self.tree[2*k+1])
k>>=1
def query(self,l,r):
l=max(l,0)
r=min(r,self.num)
res=self.ide_ele
l+=self.num
r+=self.num
while l<r:
if l&1:
res=self.segfunc(res,self.tree[l])
l+=1
if r&1:
r-=1
res=self.segfunc(res,self.tree[r])
l>>=1
r>>=1
return res
xd=defaultdict(int)
Q=[]
for i in range(N):
lr=list(map(int,input().split()))
Q.append(lr)
for i,j in Q:
xd[i]=0
xd[j]=0
for i,j in enumerate(sorted(list(xd.keys()))):
xd[j]=i
else:
nor=SegTree([-10**18]*(i+2),max,-10**18)
pot=SegTree([-10**18]*(i+2),max,-10**18)
for l,r in Q:
length=r-l+1
left=nor.query(0,xd[l])+length
middle=pot.query(xd[l],xd[r])+r
if left<0 and middle<0:
g=nor.query(xd[r],xd[r]+1)
if g<length:
nor.update(xd[r],length)
pot.update(xd[r],length-r)
else:
ml=max(left,middle)
g=nor.query(xd[r],xd[r]+1)
if g<ml:
nor.update(xd[r],ml)
pot.update(xd[r],ml-r)
print(nor.query(0,i+2))
N=int(input())
from collections import *
class SegTree: #右開区間による実装
def __init__(self,init_val,segfunc,ide_ele):
n=len(init_val)
self.segfunc=segfunc
self.ide_ele=ide_ele
self.num=1<<(n-1).bit_length()
self.tree=[ide_ele]*2*self.num
for i in range(n):
self.tree[self.num+i]=init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i]=self.segfunc(self.tree[2*i],self.tree[2*i+1])
def add(self,k,x):
k+=self.num
self.tree[k]+=x
k>>=1
while k>0:
self.tree[k]=self.segfunc(self.tree[2*k],self.tree[2*k+1])
k>>=1
def update(self,k,x):
k+=self.num
self.tree[k]=x
k>>=1
while k>0:
self.tree[k]=self.segfunc(self.tree[2*k],self.tree[2*k+1])
k>>=1
def query(self,l,r):
l=max(l,0)
r=min(r,self.num)
res=self.ide_ele
l+=self.num
r+=self.num
while l<r:
if l&1:
res=self.segfunc(res,self.tree[l])
l+=1
if r&1:
r-=1
res=self.segfunc(res,self.tree[r])
l>>=1
r>>=1
return res
xd=defaultdict(int)
Q=[]
for i in range(N):
lr=list(map(int,input().split()))
Q.append(lr)
for i,j in Q:
xd[i]=0
xd[j]=0
for i,j in enumerate(sorted(list(xd.keys()))):
xd[j]=i
else:
nor=SegTree([-10**18]*(i+2),max,-10**18)
pot=SegTree([-10**18]*(i+2),max,-10**18)
for l,r in Q:
length=r-l+1
left=nor.query(0,xd[l])+length
middle=pot.query(xd[l],xd[r])+r
if left<0 and middle<0:
g=nor.query(xd[r],xd[r]+1)
if g<length:
nor.update(xd[r],length)
pot.update(xd[r],length-r)
else:
ml=max(left,middle,length)
g=nor.query(xd[r],xd[r]+1)
if g<ml:
nor.update(xd[r],ml)
pot.update(xd[r],ml-r)
print(nor.query(0,i+2))
|
ConDefects/ConDefects/Code/arc159_d/Python/41124657
|
condefects-python_data_525
|
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size/self.BUCKET_RATIO)))
self.a = [a[size*i//bucket_size: size*(i+1)//bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i+1] for i in range(len(a)-1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet"+str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{"+s[1: len(s)-1]+"}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a)*self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x)-1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x)-1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans+bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans+bisect_right(a, x)
ans += len(a)
return ans
from collections import defaultdict
v = SortedSet()
v.add((10**9+5<<30)+0)
ar = defaultdict(int)
n = int(input())
mask = (1 << 30) - 1
for i in range(n):
l, r = map(int,input().split())
r += 1
tt = v.lt(l<<30) # l 未満
te = v.ge(l<<30) # l 以上
if tt == None:
while te != None:
teval = te >> 30
teind = te & mask
if teval == 10**9+5:
v.discard(te)
v.add((10**9+5<<30)+r-l)
break
tr = te
te = v.gt(te)
tenind = te & mask
if r-l < tenind:
v.discard(tr)
v.add((teval+r-l-teind<<30)+r-l)
break
v.discard(tr)
v.add((l<<30)+0)
continue
ttval = tt>>30
ttind = tt&mask
teval = te>>30
teind = te&mask
if ttval + teind - ttind <= l:
gogo = teind
else:
gogo = ttind + l - ttval
while te != None:
teval = te >> 30
teind = te & mask
if teval == 10**9+5:
v.discard(te)
v.add((10**9+5<<30)+gogo+r-l)
break
tr = te
te = v.gt(te)
tenind = te & mask
if tenind > gogo+r-l:
v.discard(tr)
v.add((teval+gogo+r-l-teind<<30)+gogo+r-l)
break
v.discard(tr)
v.add((l<<30)+gogo)
print(v.ge((10**9+2)<<30)&mask)
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
class SortedSet(Generic[T]):
BUCKET_RATIO = 50
REBUILD_RATIO = 170
def _build(self, a=None) -> None:
"Evenly divide `a` into buckets."
if a is None: a = list(self)
size = self.size = len(a)
bucket_size = int(math.ceil(math.sqrt(size/self.BUCKET_RATIO)))
self.a = [a[size*i//bucket_size: size*(i+1)//bucket_size] for i in range(bucket_size)]
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
if not all(a[i] < a[i+1] for i in range(len(a)-1)):
a = sorted(set(a))
self._build(a)
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet"+str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{"+s[1: len(s)-1]+"}"
def _find_bucket(self, x: T) -> List[T]:
"Find the bucket which should contain x. self must not be empty."
for a in self.a:
if x <= a[-1]: return a
return a
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a = self._find_bucket(x)
i = bisect_left(a, x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a)*self.REBUILD_RATIO:
self._build()
return True
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a = self._find_bucket(x)
i = bisect_left(a, x)
if i == len(a) or a[i] != x: return False
a.pop(i)
self.size -= 1
if len(a) == 0: self._build()
return True
def lt(self, x: T) -> Union[T, None]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x)-1]
def le(self, x: T) -> Union[T, None]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x)-1]
def gt(self, x: T) -> Union[T, None]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Union[T, None]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, x: int) -> T:
"Return the x-th element, or IndexError if it doesn't exist."
if x < 0: x += self.size
if x < 0: raise IndexError
for a in self.a:
if x < len(a): return a[x]
x -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans+bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans+bisect_right(a, x)
ans += len(a)
return ans
from collections import defaultdict
v = SortedSet()
v.add((10**9+5<<30)+0)
ar = defaultdict(int)
n = int(input())
mask = (1 << 30) - 1
for i in range(n):
l, r = map(int,input().split())
r += 1
tt = v.lt(l<<30) # l 未満
te = v.ge(l<<30) # l 以上
if tt == None:
while te != None:
teval = te >> 30
teind = te & mask
if teval == 10**9+5:
v.discard(te)
v.add((10**9+5<<30)+r-l)
break
tr = te
te = v.gt(te)
tenind = te & mask
if r-l < tenind:
v.discard(tr)
v.add((teval+r-l-teind<<30)+r-l)
break
v.discard(tr)
v.add((l<<30)+0)
continue
ttval = tt>>30
ttind = tt&mask
teval = te>>30
teind = te&mask
if ttval + teind - ttind <= l:
gogo = teind
else:
gogo = ttind + l - ttval
if gogo+r-l < teind:
continue
while te != None:
teval = te >> 30
teind = te & mask
if teval == 10**9+5:
v.discard(te)
v.add((10**9+5<<30)+gogo+r-l)
break
tr = te
te = v.gt(te)
tenind = te & mask
if tenind > gogo+r-l:
v.discard(tr)
v.add((teval+gogo+r-l-teind<<30)+gogo+r-l)
break
v.discard(tr)
v.add((l<<30)+gogo)
print(v.ge((10**9+2)<<30)&mask)
|
ConDefects/ConDefects/Code/arc159_d/Python/40430885
|
condefects-python_data_526
|
class segtree:
"""It is the data structure for monoids (S, op), i.e., the algebraic structure that satisfies the following properties.
> associativity: op(op(a, b), c) = op(a, op(b, c)) for all a, b, c in S
> existence of the identity element: op(a, e) = op(e, a) = a for all a in S
Given an array of length n, it processes the following queries in O(log n) time
(see Appendix in the document of AC Library for further details).
> Updating an element
> Calculating the product of the elements of an interval
For simplicity, in this document, we assume that the oracles `op` and `e` work in constant time.
If these oracles work in O(T) time, each time complexity appear in this document is multipled by O(T).
"""
__slots__ = ["op", "e", "n", "size", "d"]
def __init__(self, n_or_list, op, e):
"""The following should be defined.
> The binary operation `op(a, b)`
> The identity element `e()`
For example, for Range Minimum Query, the definitions are as follows.
```python
seg = segtree(10, min, lambda: 10 ** 9)
```
> If `n_or_list` is an integer, it creates an array `a` of length `n_or_list`. All the elements are initialized to `e()`.
> If `n_or_list` is a list, it creates an array `a` of length `len(n_or_list)`, initialized to `n_or_list`.
> Otherwise, it raises `TypeError`.
Constraints
-----------
> 0 <= n <= 10 ** 8
Complexity
-----------
> O(n)
"""
self.op = op
self.e = e
if isinstance(n_or_list, int):
self.n = n_or_list
self.size = 1 << ((self.n - 1).bit_length())
self.d = [self.e() for _ in range(self.size * 2)]
elif isinstance(n_or_list, list):
self.n = len(n_or_list)
self.size = 1 << ((self.n - 1).bit_length())
self.d = (
[self.e() for _ in range(self.size)]
+ n_or_list
+ [self.e() for _ in range(self.size - self.n)]
)
for i in range(self.size - 1, 0, -1):
self._update(i)
else:
raise TypeError(
f"The argument 'n_or_list' must be an integer or a list, not {type(n_or_list).__name__}"
)
def set(self, p, x):
"""It assigns x to `a[p]`.
Constraints
-----------
> 0 <= p < n
Complexity
----------
> O(log n)
"""
assert 0 <= p < self.n
p += self.size
self.d[p] = x
p //= 2
while p > 0:
self._update(p)
p //= 2
def get(self, p):
"""It returns `a[p]`.
Constraints
-----------
> 0 <= p < n
Complexity
----------
> O(1)
"""
assert 0 <= p < self.n
return self.d[p + self.size]
def prod(self, l, r):
"""It returns `op(a[l], ..., a[r - 1])`, assuming the properties of the monoid.
It returns `e()` if l = r.
Constraints
-----------
> 0 <= l <= r <= n
Complexity
----------
> O(log n)
"""
assert 0 <= l <= r <= self.n
sml = self.e()
smr = self.e()
l += self.size
r += self.size
while l < r:
if l % 2:
sml = self.op(sml, self.d[l])
l += 1
if r % 2:
r -= 1
smr = self.op(self.d[r], smr)
l //= 2
r //= 2
return self.op(sml, smr)
def all_prod(self):
"""It returns `op(a[0], ..., a[n - 1])`, assuming the properties of the monoid.
It returns `e()` if n = 0.
Complexity
----------
> O(1)
"""
return self.d[1]
def max_right(self, l, f):
"""It returns an index `r` that satisfies both of the following.
> `r == l` or `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`
> `r == n` or `f(op(a[l], a[l + 1], ..., a[r])) == False`
If `f` is monotone, this is the maximum `r` that satisfies `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`.
Constraints
-----------
> if `f` is called with the same argument, it returns the same value, i.e., `f` has no side effect.
> `f(e()) == True`
> 0 <= l <= n
Complexity
----------
> O(log n)
"""
assert 0 <= l <= self.n
assert f(self.e())
if l == self.n:
return self.n
l += self.size
sm = self.e()
while True:
while l % 2 == 0:
l //= 2
if not f(self.op(sm, self.d[l])):
while l < self.size:
l *= 2
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if l == l & -l:
break
return self.n
def min_left(self, r, f):
"""It returns an index `l` that satisfies both of the following.
> `l == r` or `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`
> `l == 0` or `f(op(a[l - 1], a[l], ..., a[r - 1])) == False`
If `f` is monotone, this is the minimum `l` that satisfies `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`.
Constraints
-----------
> if `f` is called with the same argument, it returns the same value, i.e., `f` has no side effect.
> `f(e()) == True`
> 0 <= r <= n
Complexity
----------
> O(log n)
"""
assert 0 <= r <= self.n
assert f(self.e())
if r == 0:
return 0
r += self.size
sm = self.e()
while True:
r -= 1
while r > 1 and r % 2:
r //= 2
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])
# 「LIS の最終値」から「LIS の長さ」を管理する。
#
# [l_i, r_i] を採用する場合の更新を考える。
#
# r_j <= l_i なる r_j については、
# 右端から長さへの情報を管理すればよい。
#
# それ以外は、
# l_i <= r_j となる区間 [l_j, r_j] のうち、
# 切片の最大値を取ってくればよい。
# これを用いて、右端から長さへの情報も更新
N = int(input())
lrs = []
Xs = set()
for _ in range(N):
l, r = map(int, input().split())
l -= 1
lrs.append((l, r))
Xs.add(l)
Xs.add(r)
x2X = sorted(Xs)
X2x = {X: x for x, X in enumerate(Xs)}
seg_len = len(x2X)
INF = 10**18
disjoint_seg = segtree(seg_len, max, lambda: 0)
slice_seg = segtree(seg_len, max, lambda: -INF)
for L, R in lrs:
l = X2x[L]
r = X2x[R]
disjoint_lef_len = disjoint_seg.prod(0, l)
disjoint_rig_len = disjoint_lef_len + R - L
slice_max = slice_seg.prod(l, seg_len)
slice_rig_len = R + slice_max
new_len = max(disjoint_rig_len, slice_rig_len)
new_slice = new_len - R
# print(new_len, new_slice)
disjoint_seg.set(r, max(disjoint_seg.get(r), new_len))
slice_seg.set(r, max(slice_seg.get(r), new_slice))
# print([disjoint_seg.get(i) for i in range(seg_len)])
# print([slice_seg.get(i) for i in range(seg_len)])
print(disjoint_seg.all_prod())
class segtree:
"""It is the data structure for monoids (S, op), i.e., the algebraic structure that satisfies the following properties.
> associativity: op(op(a, b), c) = op(a, op(b, c)) for all a, b, c in S
> existence of the identity element: op(a, e) = op(e, a) = a for all a in S
Given an array of length n, it processes the following queries in O(log n) time
(see Appendix in the document of AC Library for further details).
> Updating an element
> Calculating the product of the elements of an interval
For simplicity, in this document, we assume that the oracles `op` and `e` work in constant time.
If these oracles work in O(T) time, each time complexity appear in this document is multipled by O(T).
"""
__slots__ = ["op", "e", "n", "size", "d"]
def __init__(self, n_or_list, op, e):
"""The following should be defined.
> The binary operation `op(a, b)`
> The identity element `e()`
For example, for Range Minimum Query, the definitions are as follows.
```python
seg = segtree(10, min, lambda: 10 ** 9)
```
> If `n_or_list` is an integer, it creates an array `a` of length `n_or_list`. All the elements are initialized to `e()`.
> If `n_or_list` is a list, it creates an array `a` of length `len(n_or_list)`, initialized to `n_or_list`.
> Otherwise, it raises `TypeError`.
Constraints
-----------
> 0 <= n <= 10 ** 8
Complexity
-----------
> O(n)
"""
self.op = op
self.e = e
if isinstance(n_or_list, int):
self.n = n_or_list
self.size = 1 << ((self.n - 1).bit_length())
self.d = [self.e() for _ in range(self.size * 2)]
elif isinstance(n_or_list, list):
self.n = len(n_or_list)
self.size = 1 << ((self.n - 1).bit_length())
self.d = (
[self.e() for _ in range(self.size)]
+ n_or_list
+ [self.e() for _ in range(self.size - self.n)]
)
for i in range(self.size - 1, 0, -1):
self._update(i)
else:
raise TypeError(
f"The argument 'n_or_list' must be an integer or a list, not {type(n_or_list).__name__}"
)
def set(self, p, x):
"""It assigns x to `a[p]`.
Constraints
-----------
> 0 <= p < n
Complexity
----------
> O(log n)
"""
assert 0 <= p < self.n
p += self.size
self.d[p] = x
p //= 2
while p > 0:
self._update(p)
p //= 2
def get(self, p):
"""It returns `a[p]`.
Constraints
-----------
> 0 <= p < n
Complexity
----------
> O(1)
"""
assert 0 <= p < self.n
return self.d[p + self.size]
def prod(self, l, r):
"""It returns `op(a[l], ..., a[r - 1])`, assuming the properties of the monoid.
It returns `e()` if l = r.
Constraints
-----------
> 0 <= l <= r <= n
Complexity
----------
> O(log n)
"""
assert 0 <= l <= r <= self.n
sml = self.e()
smr = self.e()
l += self.size
r += self.size
while l < r:
if l % 2:
sml = self.op(sml, self.d[l])
l += 1
if r % 2:
r -= 1
smr = self.op(self.d[r], smr)
l //= 2
r //= 2
return self.op(sml, smr)
def all_prod(self):
"""It returns `op(a[0], ..., a[n - 1])`, assuming the properties of the monoid.
It returns `e()` if n = 0.
Complexity
----------
> O(1)
"""
return self.d[1]
def max_right(self, l, f):
"""It returns an index `r` that satisfies both of the following.
> `r == l` or `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`
> `r == n` or `f(op(a[l], a[l + 1], ..., a[r])) == False`
If `f` is monotone, this is the maximum `r` that satisfies `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`.
Constraints
-----------
> if `f` is called with the same argument, it returns the same value, i.e., `f` has no side effect.
> `f(e()) == True`
> 0 <= l <= n
Complexity
----------
> O(log n)
"""
assert 0 <= l <= self.n
assert f(self.e())
if l == self.n:
return self.n
l += self.size
sm = self.e()
while True:
while l % 2 == 0:
l //= 2
if not f(self.op(sm, self.d[l])):
while l < self.size:
l *= 2
if f(self.op(sm, self.d[l])):
sm = self.op(sm, self.d[l])
l += 1
return l - self.size
sm = self.op(sm, self.d[l])
l += 1
if l == l & -l:
break
return self.n
def min_left(self, r, f):
"""It returns an index `l` that satisfies both of the following.
> `l == r` or `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`
> `l == 0` or `f(op(a[l - 1], a[l], ..., a[r - 1])) == False`
If `f` is monotone, this is the minimum `l` that satisfies `f(op(a[l], a[l + 1], ..., a[r - 1])) == True`.
Constraints
-----------
> if `f` is called with the same argument, it returns the same value, i.e., `f` has no side effect.
> `f(e()) == True`
> 0 <= r <= n
Complexity
----------
> O(log n)
"""
assert 0 <= r <= self.n
assert f(self.e())
if r == 0:
return 0
r += self.size
sm = self.e()
while True:
r -= 1
while r > 1 and r % 2:
r //= 2
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])
# 「LIS の最終値」から「LIS の長さ」を管理する。
#
# [l_i, r_i] を採用する場合の更新を考える。
#
# r_j <= l_i なる r_j については、
# 右端から長さへの情報を管理すればよい。
#
# それ以外は、
# l_i <= r_j となる区間 [l_j, r_j] のうち、
# 切片の最大値を取ってくればよい。
# これを用いて、右端から長さへの情報も更新
N = int(input())
lrs = []
Xs = set()
for _ in range(N):
l, r = map(int, input().split())
l -= 1
lrs.append((l, r))
Xs.add(l)
Xs.add(r)
x2X = sorted(Xs)
X2x = {X: x for x, X in enumerate(x2X)}
seg_len = len(x2X)
INF = 10**18
disjoint_seg = segtree(seg_len, max, lambda: 0)
slice_seg = segtree(seg_len, max, lambda: -INF)
for L, R in lrs:
l = X2x[L]
r = X2x[R]
disjoint_lef_len = disjoint_seg.prod(0, l)
disjoint_rig_len = disjoint_lef_len + R - L
slice_max = slice_seg.prod(l, seg_len)
slice_rig_len = R + slice_max
new_len = max(disjoint_rig_len, slice_rig_len)
new_slice = new_len - R
# print(new_len, new_slice)
disjoint_seg.set(r, max(disjoint_seg.get(r), new_len))
slice_seg.set(r, max(slice_seg.get(r), new_slice))
# print([disjoint_seg.get(i) for i in range(seg_len)])
# print([slice_seg.get(i) for i in range(seg_len)])
print(disjoint_seg.all_prod())
|
ConDefects/ConDefects/Code/arc159_d/Python/40431476
|
condefects-python_data_527
|
class SegmentTree:
# n->要素数, l->リスト, e->単位元, comp->二項関数
def __init__(self, n, l, e, comp):
self.e = e
self.comp = comp
self.length = 1 << (n - 1).bit_length()
self.tree = [self.e] * self.length + l + [self.e] * (self.length - len(l))
for i in range(self.length - 1, 0, -1):
self.tree[i] = comp(self.tree[2 * i], self.tree[2 * i + 1])
# 0-indexedでidx番目の要素をxに更新
def _set(self, idx, x):
idx += self.length
self.tree[idx] = x
idx >>= 1
while idx > 0:
self.tree[idx] = self.comp(self.tree[2 * idx], self.tree[2 * idx + 1])
idx >>= 1
# 0-indexedで[l, r)の値を求める
def _get(self, left, right):
left += self.length
right += self.length
res = self.e
while right > left:
if left & 1:
res = self.comp(res, self.tree[left])
left += 1
if right & 1:
res = self.comp(res, self.tree[right - 1])
right -= 1
left >>= 1
right >>= 1
return res
def __repr__(self) -> str:
return str(self.tree[self.length :])
class SegmentTreeR:
# n->要素数, l->リスト, e_upd->単位元(更新用), fun_upd->二項関数(更新用), e_acq->単位元(取得用), fun_acq->二項関数(取得用)
def __init__(self, n, l, e_upd, fun_upd, e_acq, fun_acq):
self.e_upd = e_upd
self.fun_upd = fun_upd
self.e_acq = e_acq
self.fun_acq = fun_acq
self.length = 1 << (n - 1).bit_length()
self.tree = (
[self.e_upd] * self.length + l + [self.e_upd] * (self.length - len(l))
)
# 0-indexedで[l, r)の要素をxに更新
def _set(self, l, r, x):
l += self.length
r += self.length
while r > l:
if l & 1:
self.tree[l] = self.fun_upd(x, self.tree[l])
l += 1
if r & 1:
self.tree[r - 1] = self.fun_upd(x, self.tree[r - 1])
r -= 1
l >>= 1
r >>= 1
# 0-indexedで idx の値を求める
def _get(self, idx):
idx += self.length
res = self.e_acq
while idx > 0:
res = self.fun_acq(res, self.tree[idx])
idx >>= 1
return res
def __repr__(self) -> str:
return str(self.tree[self.length :])
n = int(input())
lr = []
s = set()
for i in range(n):
l, r = map(int, input().split())
lr.append((l, r))
for j in range(-1, 2):
s.add(l + j)
s.add(r + j)
s = sorted(list(s))
d = {}
for idx, i in enumerate(s):
d[i] = idx + 1
l = len(s) + 3
seg = SegmentTree(l, [], 0, max)
segr = SegmentTreeR(l, [0] + [i for i in s], 1 << 30, min, 1 << 30, min)
for l, r in lr:
mx = seg._get(0, d[l])
mx = max(mx, l - 1 - segr._get(d[l - 1]))
segr._set(d[l], d[r] + 1, l - mx)
seg._set(d[r], mx + r - l + 1)
print(seg._get(0, len(s) + 2))
class SegmentTree:
# n->要素数, l->リスト, e->単位元, comp->二項関数
def __init__(self, n, l, e, comp):
self.e = e
self.comp = comp
self.length = 1 << (n - 1).bit_length()
self.tree = [self.e] * self.length + l + [self.e] * (self.length - len(l))
for i in range(self.length - 1, 0, -1):
self.tree[i] = comp(self.tree[2 * i], self.tree[2 * i + 1])
# 0-indexedでidx番目の要素をxに更新
def _set(self, idx, x):
idx += self.length
self.tree[idx] = x
idx >>= 1
while idx > 0:
self.tree[idx] = self.comp(self.tree[2 * idx], self.tree[2 * idx + 1])
idx >>= 1
# 0-indexedで[l, r)の値を求める
def _get(self, left, right):
left += self.length
right += self.length
res = self.e
while right > left:
if left & 1:
res = self.comp(res, self.tree[left])
left += 1
if right & 1:
res = self.comp(res, self.tree[right - 1])
right -= 1
left >>= 1
right >>= 1
return res
def __repr__(self) -> str:
return str(self.tree[self.length :])
class SegmentTreeR:
# n->要素数, l->リスト, e_upd->単位元(更新用), fun_upd->二項関数(更新用), e_acq->単位元(取得用), fun_acq->二項関数(取得用)
def __init__(self, n, l, e_upd, fun_upd, e_acq, fun_acq):
self.e_upd = e_upd
self.fun_upd = fun_upd
self.e_acq = e_acq
self.fun_acq = fun_acq
self.length = 1 << (n - 1).bit_length()
self.tree = (
[self.e_upd] * self.length + l + [self.e_upd] * (self.length - len(l))
)
# 0-indexedで[l, r)の要素をxに更新
def _set(self, l, r, x):
l += self.length
r += self.length
while r > l:
if l & 1:
self.tree[l] = self.fun_upd(x, self.tree[l])
l += 1
if r & 1:
self.tree[r - 1] = self.fun_upd(x, self.tree[r - 1])
r -= 1
l >>= 1
r >>= 1
# 0-indexedで idx の値を求める
def _get(self, idx):
idx += self.length
res = self.e_acq
while idx > 0:
res = self.fun_acq(res, self.tree[idx])
idx >>= 1
return res
def __repr__(self) -> str:
return str(self.tree[self.length :])
n = int(input())
lr = []
s = set()
for i in range(n):
l, r = map(int, input().split())
lr.append((l, r))
for j in range(-1, 2):
s.add(l + j)
s.add(r + j)
s = sorted(list(s))
d = {}
for idx, i in enumerate(s):
d[i] = idx + 1
l = len(s) + 3
seg = SegmentTree(l, [], 0, max)
segr = SegmentTreeR(l, [0] + [i for i in s], 1 << 30, min, 1 << 30, min)
for l, r in lr:
mx = seg._get(0, d[l])
mx = max(mx, l - 1 - segr._get(d[l - 1]))
segr._set(d[l], d[r] + 1, l - mx- 1)
seg._set(d[r], mx + r - l + 1)
print(seg._get(0, len(s) + 2))
|
ConDefects/ConDefects/Code/arc159_d/Python/45445288
|
condefects-python_data_528
|
n, m, t = map(int, input().split())
a = list(map(int, input().split()))
pos = 0
for i in range(m):
x, y = map(int, input().split())
t -= sum(a[pos : x - 1])
if t <= 0:
print("No")
exit()
else:
t += y
pos = x - 1
t -= sum(a[pos:])
if t < 0:
print("No")
else:
print("Yes")
n, m, t = map(int, input().split())
a = list(map(int, input().split()))
pos = 0
for i in range(m):
x, y = map(int, input().split())
t -= sum(a[pos : x - 1])
if t <= 0:
print("No")
exit()
else:
t += y
pos = x - 1
t -= sum(a[pos:])
if t <= 0:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc265_b/Python/45698748
|
condefects-python_data_529
|
n,m,t=map(int,input().split())
a=list(map(int,input().split()))
v=[0]*n
for i in range(m):
x,y=map(int,input().split())
v[x-1]=y
for i in range(n-1):
t+=v[i]
if t>i:
t-=a[i]
else:
print('No')
break
else:
print('Yes')
n,m,t=map(int,input().split())
a=list(map(int,input().split()))
v=[0]*n
for i in range(m):
x,y=map(int,input().split())
v[x-1]=y
for i in range(n-1):
t+=v[i]
if t>a[i]:
t-=a[i]
else:
print('No')
break
else:
print('Yes')
|
ConDefects/ConDefects/Code/abc265_b/Python/45498956
|
condefects-python_data_530
|
from collections import defaultdict
N, M, T = map(int, input().split())
A = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
d = defaultdict(int)
for x, y in XY:
d[x] = y
now = 1
while now != N:
T -= A[now-1]
now += 1
if T < 0:
print('No')
exit()
T += d[now]
# print(T)
print('Yes')
from collections import defaultdict
N, M, T = map(int, input().split())
A = list(map(int, input().split()))
XY = [list(map(int, input().split())) for _ in range(M)]
d = defaultdict(int)
for x, y in XY:
d[x] = y
now = 1
while now != N:
T -= A[now-1]
now += 1
if T <= 0:
print('No')
exit()
T += d[now]
# print(T)
print('Yes')
|
ConDefects/ConDefects/Code/abc265_b/Python/45288123
|
condefects-python_data_531
|
N, M, T = map(int, input().split())
A = list(map(int, input().split()))
B = []
for i in range(M):
B.append(tuple(map(int, input().split())))
from collections import deque
queA = deque(A)
B.sort(key=lambda x: x[0])
queB = deque(B)
ans = "Yes"
nowT = T
nowP = 1
S = set([row[0] for row in B])
# print(S)
for i in range(N-1):
# print(nowT)
p = queA.popleft()
if nowP in S:
# print("inS")
pt = queB.popleft()
nowT += pt[1]
if nowT >= p:
nowT -= p
nowP += 1
else:
ans = "No"
break
print(ans)
N, M, T = map(int, input().split())
A = list(map(int, input().split()))
B = []
for i in range(M):
B.append(tuple(map(int, input().split())))
from collections import deque
queA = deque(A)
B.sort(key=lambda x: x[0])
queB = deque(B)
ans = "Yes"
nowT = T
nowP = 1
S = set([row[0] for row in B])
# print(S)
for i in range(N-1):
# print(nowT)
p = queA.popleft()
if nowP in S:
# print("inS")
pt = queB.popleft()
nowT += pt[1]
if nowT > p:
nowT -= p
nowP += 1
else:
ans = "No"
break
print(ans)
|
ConDefects/ConDefects/Code/abc265_b/Python/46016041
|
condefects-python_data_532
|
N,M,T=list(map(int, input().split()))
A=list(map(int, input().split()))
d={}
for _ in range(M):
x,y=list(map(int, input().split()))
d[x]=y
for i in range(N-1):
if i+1 in d:
T+=d[i+1]
if A[i]>T:
print("No")
exit()
T-=A[i]
print("Yes")
N,M,T=list(map(int, input().split()))
A=list(map(int, input().split()))
d={}
for _ in range(M):
x,y=list(map(int, input().split()))
d[x]=y
for i in range(N-1):
if i+1 in d:
T+=d[i+1]
if A[i]>=T:
print("No")
exit()
T-=A[i]
print("Yes")
|
ConDefects/ConDefects/Code/abc265_b/Python/46056659
|
condefects-python_data_533
|
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
# sys.setrecursionlimit(10**6)
input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LIS(): return list(map(int, SI()))
def LA(f): return list(map(f, input().split()))
def LLI(H): return [LI() for _ in range(H)] # H:列数
def SI(): return input().strip('\n')
### 数字文字交じりクエリを文字列のリストにする '1 19 G' -> ['1', '19', 'G']
# input()を含まず、受け取ったLLSのクエリの文字列に対し実行する
# l = ''.join(Strings).split(' ')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(H): return [LS() for _ in range(H)]
# 迷路の前後左右
#for y, x in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
def gen_matrix(h, w, init): return [[init] * w for _ in range(h)]
INF = float('inf')
# from bisect import bisect_left, bisect_right
# from heapq import heapify, heappop, heappush
import decimal
from decimal import Decimal
import math
from math import ceil, floor, log2, log, sqrt, gcd
def lcm(x, y): return (x * y) // gcd(x, y)
# At = list(zip(*A)) 転置行列
from itertools import combinations as comb, combinations_with_replacement as comb_w, product, permutations, accumulate
from collections import deque, defaultdict
from pprint import pprint
# import numpy as np # cumsum
from functools import reduce, lru_cache # decorator: 関数をメモ化再起してくれる. max_size=128
import operator
from copy import deepcopy
MOD = 10**9+7
MOD2 = 998244353
def y(): print('Yes'); exit()
def n(): print('No'); exit()
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
# 累積和 ans=list(itertools.accumulate(L))
# 順列 ans=list(itertools.permutation(L))
# 直積 ans=list(itertools.product(L,M))
# 重複なし組み合わせ ans=list(itertools.combinations(L,2))
# 重複あり組み合わせ ans=list(itertools.combinations_with_replacement(L,2))
# nCr ans=math.comb(n,r)
def solve():
ans = INF
n,m,t = MI()
A = LI()
L = LLI(m)
d = defaultdict(int)
for x, y in L:
d[x] = y
for i, a in enumerate(A):
room = i+1 # 1-index
if d[room]:
t += d[room]
t -= a
if t >= 0:
continue
else:
print("No")
exit()
print("Yes")
if __name__ == '__main__':
solve()
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
# sys.setrecursionlimit(10**6)
input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LIS(): return list(map(int, SI()))
def LA(f): return list(map(f, input().split()))
def LLI(H): return [LI() for _ in range(H)] # H:列数
def SI(): return input().strip('\n')
### 数字文字交じりクエリを文字列のリストにする '1 19 G' -> ['1', '19', 'G']
# input()を含まず、受け取ったLLSのクエリの文字列に対し実行する
# l = ''.join(Strings).split(' ')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(H): return [LS() for _ in range(H)]
# 迷路の前後左右
#for y, x in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
def gen_matrix(h, w, init): return [[init] * w for _ in range(h)]
INF = float('inf')
# from bisect import bisect_left, bisect_right
# from heapq import heapify, heappop, heappush
import decimal
from decimal import Decimal
import math
from math import ceil, floor, log2, log, sqrt, gcd
def lcm(x, y): return (x * y) // gcd(x, y)
# At = list(zip(*A)) 転置行列
from itertools import combinations as comb, combinations_with_replacement as comb_w, product, permutations, accumulate
from collections import deque, defaultdict
from pprint import pprint
# import numpy as np # cumsum
from functools import reduce, lru_cache # decorator: 関数をメモ化再起してくれる. max_size=128
import operator
from copy import deepcopy
MOD = 10**9+7
MOD2 = 998244353
def y(): print('Yes'); exit()
def n(): print('No'); exit()
from bisect import bisect_left, bisect_right, insort
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
T = TypeVar('T')
# 累積和 ans=list(itertools.accumulate(L))
# 順列 ans=list(itertools.permutation(L))
# 直積 ans=list(itertools.product(L,M))
# 重複なし組み合わせ ans=list(itertools.combinations(L,2))
# 重複あり組み合わせ ans=list(itertools.combinations_with_replacement(L,2))
# nCr ans=math.comb(n,r)
def solve():
ans = INF
n,m,t = MI()
A = LI()
L = LLI(m)
d = defaultdict(int)
for x, y in L:
d[x] = y
for i, a in enumerate(A):
room = i+1 # 1-index
if d[room]:
t += d[room]
t -= a
if t > 0:
continue
else:
print("No")
exit()
print("Yes")
if __name__ == '__main__':
solve()
|
ConDefects/ConDefects/Code/abc265_b/Python/45798886
|
condefects-python_data_534
|
n,m,t=map(int,input().split())
s=list(map(int,input().split()))
dic=dict()
for i in range(m):
a,b=map(int,input().split())
dic[a]=b
for now in range(1,n):
if t-s[now-1]<0:
print("No")
exit()
else:
t-=s[now-1]
if now+1 in dic:
t+=dic[now+1]
print("Yes")
n,m,t=map(int,input().split())
s=list(map(int,input().split()))
dic=dict()
for i in range(m):
a,b=map(int,input().split())
dic[a]=b
for now in range(1,n):
if t-s[now-1]<=0:
print("No")
exit()
else:
t-=s[now-1]
if now+1 in dic:
t+=dic[now+1]
print("Yes")
|
ConDefects/ConDefects/Code/abc265_b/Python/45487693
|
condefects-python_data_535
|
import copy
import itertools
n, m = map(int, input().split())
g1 = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
g1[u - 1][v - 1] = 1
g2 = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
g2[u - 1][v - 1] = 1
isok = False
for p in itertools.permutations(range(n), n):
g3 = copy.deepcopy(g2)
for u in range(n):
for v in range(n):
g3[p[u]][p[v]] = g2[u][v]
if g1 == g3:
isok |= True
print("Yes" if isok else "No")
import copy
import itertools
n, m = map(int, input().split())
g1 = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
g1[u - 1][v - 1] = 1
g1[v - 1][u - 1] = 1
g2 = [[0 for _ in range(n)] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
g2[u - 1][v - 1] = 1
g2[v - 1][u - 1] = 1
isok = False
for p in itertools.permutations(range(n), n):
g3 = copy.deepcopy(g2)
for u in range(n):
for v in range(n):
g3[p[u]][p[v]] = g2[u][v]
if g1 == g3:
isok |= True
print("Yes" if isok else "No")
|
ConDefects/ConDefects/Code/abc232_c/Python/44881913
|
condefects-python_data_536
|
def I(m):
M = [[0]*2 for _ in range(m)]
for i in range(m):
x, y = map(int, input().split())
M[i][0], M[i][1] = x-1, y-1
return M
import itertools
n,m = map(int,input().split())
if m==0:
print('Yes')
exit()
Takahashi, Aoki = I(m), I(m)
l = itertools.permutations(list(range(n)))
for i in l:
# print(i)
test = [[0]*2 for _ in range(m)]
for j in range(m):
for k in range(2):
test[j][k] = i[Aoki[j][k]]
test[j].sort()
test.sort()
if Takahashi == test:
print('Yes')
exit()
print('No')
def I(m):
M = [[0]*2 for _ in range(m)]
for i in range(m):
x, y = map(int, input().split())
M[i][0], M[i][1] = x-1, y-1
return M
import itertools
n,m = map(int,input().split())
if m==0:
print('Yes')
exit()
Takahashi, Aoki = I(m), I(m)
l = itertools.permutations(list(range(n)))
Takahashi.sort()
for i in l:
# print(i)
test = [[0]*2 for _ in range(m)]
for j in range(m):
for k in range(2):
test[j][k] = i[Aoki[j][k]]
test[j].sort()
test.sort()
# print(Takahashi, test)
if Takahashi == test:
print('Yes')
exit()
print('No')
|
ConDefects/ConDefects/Code/abc232_c/Python/44874195
|
condefects-python_data_537
|
def dfs(pos, seki, n, x, a):
global ans
if pos == n:
if seki == x:
ans += 1
return
for c in a[pos]:
if seki > x / c:
continue
dfs(pos+1, seki*c, n, x, a)
n, x = map(int, input().split())
L = []
a = []
for _ in range(n):
ball = list(map(int, input().split()))
L.append(ball[0])
a.append(ball[1:])
ans = 0
dfs(0, 1, n, x, a)
print(ans)
def dfs(pos, seki, n, x, a):
global ans
if pos == n:
if seki == x:
ans += 1
return
for c in a[pos]:
if seki * c > x:
continue
dfs(pos+1, seki*c, n, x, a)
n, x = map(int, input().split())
L = []
a = []
for _ in range(n):
ball = list(map(int, input().split()))
L.append(ball[0])
a.append(ball[1:])
ans = 0
dfs(0, 1, n, x, a)
print(ans)
|
ConDefects/ConDefects/Code/abc233_c/Python/45317107
|
condefects-python_data_538
|
l,n1,n2=map(int,input().split())
vl1=[list(map(int,input().split())) for _ in range(n1)]
vl2=[list(map(int,input().split())) for _ in range(n2)]
acc1,acc2=[0]*(n1+1),[0]*(n2+1)
for i in range(n1):
acc1[i+1]=acc1[i]+vl1[i][1]
for i in range(n2):
acc2[i+1]=acc2[i]+vl2[i][1]
print(vl1,vl2,sep='\n')
print(acc1,acc2,sep='\n')
i,j=0,0
ans=0
while i<n1 and j<n2:
a,b=vl1[i]
c,d=vl2[j]
if a==c:
max_l=max(acc1[i],acc2[j])
min_r=min(acc1[i+1],acc2[j+1])
ans+=min_r-max_l
if acc1[i+1]<acc2[j+1]:
i+=1
else:
j+=1
print(ans)
l,n1,n2=map(int,input().split())
vl1=[list(map(int,input().split())) for _ in range(n1)]
vl2=[list(map(int,input().split())) for _ in range(n2)]
acc1,acc2=[0]*(n1+1),[0]*(n2+1)
for i in range(n1):
acc1[i+1]=acc1[i]+vl1[i][1]
for i in range(n2):
acc2[i+1]=acc2[i]+vl2[i][1]
i,j=0,0
ans=0
while i<n1 and j<n2:
a,b=vl1[i]
c,d=vl2[j]
if a==c:
max_l=max(acc1[i],acc2[j])
min_r=min(acc1[i+1],acc2[j+1])
ans+=min_r-max_l
if acc1[i+1]<acc2[j+1]:
i+=1
else:
j+=1
print(ans)
|
ConDefects/ConDefects/Code/abc294_e/Python/51921412
|
condefects-python_data_539
|
# import系 ---
from more_itertools import distinct_permutations
# 入力用 ---
INT = lambda: int(input())
MI = lambda: map(int, input().split())
MI_DEC = lambda: map(lambda x: int(x) - 1, input().split())
LI = lambda: list(map(int, input().split()))
LI_DEC = lambda: list(map(lambda x: int(x) - 1, input().split()))
LS = lambda: list(input())
LSS = lambda: input().split()
# コード ---
H, W = MI()
field = []
for _ in range(H):
field.append(LI())
ans = 0
for perm in distinct_permutations([(0, 1)] * (H - 1) + [(1, 0)] * (W - 1)):
is_ok = True
visited = set([field[0][0]])
now_x, now_y = 0, 0
for x, y in perm:
now_x += x; now_y += y
if field[now_y][now_x] in visited:
is_ok = False
break
visited.add((now_x, now_y))
if is_ok:
ans += 1
print(ans)
# import系 ---
from more_itertools import distinct_permutations
# 入力用 ---
INT = lambda: int(input())
MI = lambda: map(int, input().split())
MI_DEC = lambda: map(lambda x: int(x) - 1, input().split())
LI = lambda: list(map(int, input().split()))
LI_DEC = lambda: list(map(lambda x: int(x) - 1, input().split()))
LS = lambda: list(input())
LSS = lambda: input().split()
# コード ---
H, W = MI()
field = []
for _ in range(H):
field.append(LI())
ans = 0
for perm in distinct_permutations([(0, 1)] * (H - 1) + [(1, 0)] * (W - 1)):
is_ok = True
visited = set([field[0][0]])
now_x, now_y = 0, 0
for x, y in perm:
now_x += x; now_y += y
if field[now_y][now_x] in visited:
is_ok = False
break
visited.add(field[now_y][now_x])
if is_ok:
ans += 1
print(ans)
|
ConDefects/ConDefects/Code/abc293_c/Python/45502821
|
condefects-python_data_540
|
#!/usr/bin/env python3
def r(a):
a = a[::-1]
a = list(map(list, zip(*a)))
return a
n = int(input())
a = [list(input().split()) for _ in range(n)]
b = [list(input().split()) for _ in range(n)]
f = True
for _ in range(3):
a = r(a)
f = True
for al, bl in zip(a, b):
for av, bv in zip(al, bl):
if av == "1":
if bv == "0":
f = False
break
if not f:
break
if f:
print("Yes")
exit()
print("No")
#!/usr/bin/env python3
def r(a):
a = a[::-1]
a = list(map(list, zip(*a)))
return a
n = int(input())
a = [list(input().split()) for _ in range(n)]
b = [list(input().split()) for _ in range(n)]
f = True
for _ in range(4):
a = r(a)
f = True
for al, bl in zip(a, b):
for av, bv in zip(al, bl):
if av == "1":
if bv == "0":
f = False
break
if not f:
break
if f:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc298_b/Python/45491531
|
condefects-python_data_541
|
import copy
n = int(input())
a = [input().split() for _ in range(n)]
b = [input().split() for _ in range(n)]
def is_same(m):
for i in range(n):
for j in range(n):
if m[i][j] != '1':
continue
if m[i][j] != b[i][j]:
return False
return True
def rotate(m):
rotated = [[-1 for _ in range(n)] for _ in range(n)]
for i in range(n):
for j in range(n):
rotated[i][j] = m[n-1-j][i]
return rotated
prev = a
for i in range(3):
rotated = rotate(prev)
if is_same(rotated):
print("Yes")
exit(0)
prev = rotated
print("No")
import copy
n = int(input())
a = [input().split() for _ in range(n)]
b = [input().split() for _ in range(n)]
def is_same(m):
for i in range(n):
for j in range(n):
if m[i][j] != '1':
continue
if m[i][j] != b[i][j]:
return False
return True
def rotate(m):
rotated = [[-1 for _ in range(n)] for _ in range(n)]
for i in range(n):
for j in range(n):
rotated[i][j] = m[n-1-j][i]
return rotated
prev = a
for i in range(4):
rotated = rotate(prev)
if is_same(rotated):
print("Yes")
exit(0)
prev = rotated
print("No")
|
ConDefects/ConDefects/Code/abc298_b/Python/45279577
|
condefects-python_data_542
|
# B
n = int(input())
a = []
for _ in range(n):
cur_a = list(map(int, input().split()))
a.append(cur_a)
b = []
for _ in range(n):
cur_b = list(map(int, input().split()))
b.append(cur_b)
'''
n = 3
a = [[0, 1, 1], [1, 0, 0], [0, 1, 0]]
b = [[1, 1, 0], [0, 0, 1], [1, 1, 1]]
'''
'''
n = 5
a = [[0, 0, 1, 1, 0], [1, 0, 0, 1, 0], [0, 0, 1, 0, 1], [0, 1, 0, 1, 0], [0, 1, 0, 0, 1]]
b = [[1, 1, 0, 0, 1], [0, 1, 1, 1, 0], [0, 0, 1, 1, 1], [1, 0, 1, 0, 1], [1, 1, 0, 1, 0]]
'''
#print(a)
#print(b)
import numpy as np
for i in range(1,4):
#print("=====================")
#print(i)
a90 = np.rot90(a, k = -i)
#print(a90)
ans = True
for j in range(n):
for k in range(n):
#ans = True
#print("-----------------")
#print("j, k", j, k)
#print("a90:::::::::", a90[j][k])
if a90[j][k] == 1:
#print("b[j][j]:::::", b[j][k])
if b[j][k] != 1:
ans = False
#print("NG::::::::::::::::::::::")
if ans:
break
if ans:
print("Yes")
else:
print("No")
# B
n = int(input())
a = []
for _ in range(n):
cur_a = list(map(int, input().split()))
a.append(cur_a)
b = []
for _ in range(n):
cur_b = list(map(int, input().split()))
b.append(cur_b)
'''
n = 3
a = [[0, 1, 1], [1, 0, 0], [0, 1, 0]]
b = [[1, 1, 0], [0, 0, 1], [1, 1, 1]]
'''
'''
n = 5
a = [[0, 0, 1, 1, 0], [1, 0, 0, 1, 0], [0, 0, 1, 0, 1], [0, 1, 0, 1, 0], [0, 1, 0, 0, 1]]
b = [[1, 1, 0, 0, 1], [0, 1, 1, 1, 0], [0, 0, 1, 1, 1], [1, 0, 1, 0, 1], [1, 1, 0, 1, 0]]
'''
#print(a)
#print(b)
import numpy as np
for i in range(0,4):
#print("=====================")
#print(i)
a90 = np.rot90(a, k = -i)
#print(a90)
ans = True
for j in range(n):
for k in range(n):
#ans = True
#print("-----------------")
#print("j, k", j, k)
#print("a90:::::::::", a90[j][k])
if a90[j][k] == 1:
#print("b[j][j]:::::", b[j][k])
if b[j][k] != 1:
ans = False
#print("NG::::::::::::::::::::::")
if ans:
break
if ans:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc298_b/Python/45996525
|
condefects-python_data_543
|
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
B = [list(map(int, input().split())) for _ in range(N)]
A_t = A
l = 0
for i in range(3):
#print(A_t)
for j in range(N):
for k in range(N):
if (A_t[j][k] == 1) and (B[j][k] != 1):
#print(A_t[j][k],B[j][k] )
l += 1
if l == 0:
print('Yes')
#print(B)
#print(A_t)
exit()
A_t = []
for x in zip(*A[::-1]):
A_t.append(list(x))
A = A_t
l = 0
print('No')
N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]
B = [list(map(int, input().split())) for _ in range(N)]
A_t = A
l = 0
for i in range(4):
#print(A_t)
for j in range(N):
for k in range(N):
if (A_t[j][k] == 1) and (B[j][k] != 1):
#print(A_t[j][k],B[j][k] )
l += 1
if l == 0:
print('Yes')
#print(B)
#print(A_t)
exit()
A_t = []
for x in zip(*A[::-1]):
A_t.append(list(x))
A = A_t
l = 0
print('No')
|
ConDefects/ConDefects/Code/abc298_b/Python/45483068
|
condefects-python_data_544
|
n,a,b=map(int,input().split())
ans = [[] for _ in range(a*n)]
for i in range(a*n):
for j in range(b*n):
if ((i//a)%2==0 and (j//b)%2==0) or ((i//a)%2!=0 and (j//b)%2!=0):
ans[i].append('.')
else:
ans[i].append('#')
for i in range(a*n):
print(*ans[i])
n,a,b=map(int,input().split())
ans = [[] for _ in range(a*n)]
for i in range(a*n):
for j in range(b*n):
if ((i//a)%2==0 and (j//b)%2==0) or ((i//a)%2!=0 and (j//b)%2!=0):
ans[i].append('.')
else:
ans[i].append('#')
for i in range(a*n):
print(''.join(ans[i]))
|
ConDefects/ConDefects/Code/abc250_b/Python/45692958
|
condefects-python_data_545
|
N, M, v = map(int,input().split())
I = [[] for _ in range(2*N)]
R = [[] for _ in range(2*N)]
D = [0] * (2*N)
for _ in range(M):
a, b, c = map(int,input().split())
a -= 1
b -= 1
I[a].append((b + N, c))
I[a + N].append((b, c))
R[b].append((a + N, c))
R[b + N].append((a, c))
D[a] += 1
D[a+N] += 1
inf = 1 << 60
cost = [inf] * (2*N)
from heapq import heappop, heappush
task = []
for i, d in enumerate(D):
if d == 0:
heappush(task, (0, i))
vis = [False] * (2*N)
vol = [0] * (2*N)
while task:
c, p = heappop(task)
if vis[p]: continue
cost[p] = c
vis[p] = True
for q, c0 in R[p]:
if q < N:
D[q] -= 1
vol[q] = max(c + c0, D[q])
if D[q] == 0:
heappush(task, (vol[q], q))
else:
heappush(task, (c + c0, q))
print(cost[v-1 + N] if cost[v-1 + N] < inf else "INFINITY")
N, M, v = map(int,input().split())
I = [[] for _ in range(2*N)]
R = [[] for _ in range(2*N)]
D = [0] * (2*N)
for _ in range(M):
a, b, c = map(int,input().split())
a -= 1
b -= 1
I[a].append((b + N, c))
I[a + N].append((b, c))
R[b].append((a + N, c))
R[b + N].append((a, c))
D[a] += 1
D[a+N] += 1
inf = 1 << 60
cost = [inf] * (2*N)
from heapq import heappop, heappush
task = []
for i, d in enumerate(D):
if d == 0:
heappush(task, (0, i))
vis = [False] * (2*N)
vol = [0] * (2*N)
while task:
c, p = heappop(task)
if vis[p]: continue
cost[p] = c
vis[p] = True
for q, c0 in R[p]:
if q < N:
D[q] -= 1
vol[q] = max(c + c0, vol[q])
if D[q] == 0:
heappush(task, (vol[q], q))
else:
heappush(task, (c + c0, q))
print(cost[v-1 + N] if cost[v-1 + N] < inf else "INFINITY")
|
ConDefects/ConDefects/Code/abc261_h/Python/33475139
|
condefects-python_data_546
|
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 : list(map(int, 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,m,start = map(int, input().split())
start -= 1
ns = [[] for _ in range(2*n)]
rns = [[] for _ in range(2*n)]
odeg = [0]*(2*n)
for _ in range(m):
u,v,c = map(int, input().split())
u -= 1
v -= 1
ns[u+n].append((c,v))
ns[u].append((c,n+v))
rns[v+n].append((c,u))
rns[v].append((c,u+n))
odeg[u] += 1
odeg[u+n] += 1
odeg0 = odeg[:]
# INF : 未確定 (終了しない)
# >=0 : 有限解で終了し、値は vals[u]
from heapq import heappop as hpp, heappush as hp
q = []
end = [0]*(2*n)
vals = [INF]*n + [-INF]*n
for u in range(2*n):
if odeg[u]==0:
q.append((0,u))
vals[u] = 0
end[u] = 1
while q:
val,u = hpp(q)
assert end[u]==1
for val,v in rns[u]:
if v<n:
# 有限で終わらせたい
end[v] = 1
if val+vals[u]<vals[v]:
vals[v] = val+vals[u]
hp(q, (vals[v], v))
else:
# 無限にやりたい
odeg[v] -= 1
if odeg[v]==0:
end[v] = 1
tmp = -INF
for c,u in ns[v]:
tmp = max(tmp, vals[u]+val)
vals[v] = tmp
hp(q, (vals[v], v))
if end[start]!=1:
print("INFINITY")
else:
assert vals[start]!=-1
print(vals[start])
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 : list(map(int, 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,m,start = map(int, input().split())
start -= 1
ns = [[] for _ in range(2*n)]
rns = [[] for _ in range(2*n)]
odeg = [0]*(2*n)
for _ in range(m):
u,v,c = map(int, input().split())
u -= 1
v -= 1
ns[u+n].append((c,v))
ns[u].append((c,n+v))
rns[v+n].append((c,u))
rns[v].append((c,u+n))
odeg[u] += 1
odeg[u+n] += 1
odeg0 = odeg[:]
# INF : 未確定 (終了しない)
# >=0 : 有限解で終了し、値は vals[u]
from heapq import heappop as hpp, heappush as hp
q = []
end = [0]*(2*n)
vals = [INF]*n + [-INF]*n
for u in range(2*n):
if odeg[u]==0:
q.append((0,u))
vals[u] = 0
end[u] = 1
while q:
val,u = hpp(q)
assert end[u]==1
for val,v in rns[u]:
if v<n:
# 有限で終わらせたい
end[v] = 1
if val+vals[u]<vals[v]:
vals[v] = val+vals[u]
hp(q, (vals[v], v))
else:
# 無限にやりたい
odeg[v] -= 1
if odeg[v]==0:
end[v] = 1
tmp = -INF
for c,u in ns[v]:
tmp = max(tmp, vals[u]+c)
vals[v] = tmp
hp(q, (vals[v], v))
if end[start]!=1:
print("INFINITY")
else:
assert vals[start]!=-1
print(vals[start])
|
ConDefects/ConDefects/Code/abc261_h/Python/37948163
|
condefects-python_data_547
|
from heapq import heappop, heappush
n, m, s = map(int, input().split())
s -= 1
rev_g = [[] for _ in range(n)]
deg = [0] * n
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
rev_g[b].append((a, c))
deg[a] += 1
inf = 1 << 31
que_t = []
que_a = []
dp_t = [inf] * n
dp_a = [inf] * n
for u in range(n):
if deg[u] == 0:
que_t.append((0, u))
que_a.append((0, u))
dp_t[u] = 0
dp_a[u] = 0
dp_m = [-1] * n
while que_t or que_a:
if que_a:
d, u = heappop(que_a)
for v, c in rev_g[u]:
val = d + c
if dp_t[v] > val:
dp_t[v] = val
heappush(que_t, (val, v))
else:
d, u = heappop(que_t)
if dp_t[u] < d:
continue
for v, c in rev_g[u]:
val = max(dp_m[v], d + c)
dp_m[v] = val
deg[v] -= 1
if deg[v] == 0:
dp_a[v] = val
heappush(que_a, (val, v))
ans = dp_t[s]
if ans == inf:
ans = 'INFINITY'
print(ans)
from heapq import heappop, heappush
n, m, s = map(int, input().split())
s -= 1
rev_g = [[] for _ in range(n)]
deg = [0] * n
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
rev_g[b].append((a, c))
deg[a] += 1
inf = 1 << 48
que_t = []
que_a = []
dp_t = [inf] * n
dp_a = [inf] * n
for u in range(n):
if deg[u] == 0:
que_t.append((0, u))
que_a.append((0, u))
dp_t[u] = 0
dp_a[u] = 0
dp_m = [-1] * n
while que_t or que_a:
if que_a:
d, u = heappop(que_a)
for v, c in rev_g[u]:
val = d + c
if dp_t[v] > val:
dp_t[v] = val
heappush(que_t, (val, v))
else:
d, u = heappop(que_t)
if dp_t[u] < d:
continue
for v, c in rev_g[u]:
val = max(dp_m[v], d + c)
dp_m[v] = val
deg[v] -= 1
if deg[v] == 0:
dp_a[v] = val
heappush(que_a, (val, v))
ans = dp_t[s]
if ans == inf:
ans = 'INFINITY'
print(ans)
|
ConDefects/ConDefects/Code/abc261_h/Python/48707102
|
condefects-python_data_548
|
N, M = map(int, input().split())
P = [0] * N
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
P[b] += 1
ans = []
for i in range(N):
if P[i] == 0:
ans.append(i)
if len(ans) == 1:
print(ans[0])
else:
print(-1)
N, M = map(int, input().split())
P = [0] * N
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
P[b] += 1
ans = []
for i in range(N):
if P[i] == 0:
ans.append(i)
if len(ans) == 1:
print(ans[0] + 1)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc313_b/Python/45739272
|
condefects-python_data_549
|
N,M = map(int, input().split())
A = []
B = []
for _ in range(M):
A_,B_ = map(int, input().split())
A.append(A_)
B.append(B_)
res = [0]*N
for i in range(M):
res[B[i]-1] = 1
if res.count(0) == 1:
print(A[res.index(0)])
else:
print(-1)
N,M = map(int, input().split())
A = []
B = []
for _ in range(M):
A_,B_ = map(int, input().split())
A.append(A_)
B.append(B_)
res = [0]*N
for i in range(M):
res[B[i]-1] = 1
if res.count(0) == 1:
print(res.index(0) + 1)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc313_b/Python/45757869
|
condefects-python_data_550
|
N, M = map(int, input().split())
flag = [1] * N
for i in range(M):
a, b = map(int, input().split())
flag[b-1] = 0
if sum(flag) == 1:
print(flag.index(1))
else:
print(-1)
N, M = map(int, input().split())
flag = [1] * N
for i in range(M):
a, b = map(int, input().split())
flag[b-1] = 0
if sum(flag) == 1:
print(flag.index(1)+1)
else:
print(-1)
|
ConDefects/ConDefects/Code/abc313_b/Python/46182815
|
condefects-python_data_551
|
#最強の人を求めればいいだけなので、誰かに負けたかどうかを調べる
#負けたことがない人が複数人いたら最強は絞れない
N,M=list(map(int,input().split()))
player=[i for i in range(1,N+1)]
for i in range(M):
a,b=list(map(int,input().split()))
if b in player:
player.remove(b)
if player.count==1:
print(player[0])
else:
print(-1)
#最強の人を求めればいいだけなので、誰かに負けたかどうかを調べる
#負けたことがない人が複数人いたら最強は絞れない
N,M=list(map(int,input().split()))
player=[i for i in range(1,N+1)]
for i in range(M):
a,b=list(map(int,input().split()))
if b in player:
player.remove(b)
if len(player)==1:
print(player[0])
else:
print(-1)
|
ConDefects/ConDefects/Code/abc313_b/Python/45889938
|
condefects-python_data_552
|
n,m=map(int,input().split())
lst=[True]*(n+1);lst[0]=False
for i in range(m):
a,b=map(int,input().split())
lst[b]=False
print(-1 if sum(lst[1:])!=1 else lst.count(1))
# print(lst)
n,m=map(int,input().split())
lst=[True]*(n+1);lst[0]=False
for i in range(m):
a,b=map(int,input().split())
lst[b]=False
print(-1 if sum(lst)!=1 else lst.index(1))
# print(lst)
|
ConDefects/ConDefects/Code/abc313_b/Python/45691967
|
condefects-python_data_553
|
import sys
import numpy as np
readline = sys.stdin.readline
N = int(input())
xy = np.array([list(map(int, readline().split())) for _ in range(N)])
dxdy = np.diff(xy, axis=0, append=[xy[0]])
coef = np.array([dxdy[:, 1], -dxdy[:, 0]]).T
cons = np.sum(coef * xy, axis=1, keepdims=True)
M = int(input())
uv = np.array([list(map(int, readline().split())) for _ in range(M)])
dist = np.max(coef @ uv.T + cons, axis=1)
Q = int(input())
ab = np.array([list(map(int, readline().split())) for _ in range(Q)])
ans = np.all(ab @ coef.T <= dist, axis=1)
print(*np.where(ans, "Yes", "No"), sep='\n')
import sys
import numpy as np
readline = sys.stdin.readline
N = int(input())
xy = np.array([list(map(int, readline().split())) for _ in range(N)])
dxdy = np.diff(xy, axis=0, append=[xy[0]])
coef = np.array([dxdy[:, 1], -dxdy[:, 0]]).T
cons = np.sum(coef * xy, axis=1, keepdims=True)
M = int(input())
uv = np.array([list(map(int, readline().split())) for _ in range(M)])
dist = np.min(coef @ uv.T + cons, axis=1)
Q = int(input())
ab = np.array([list(map(int, readline().split())) for _ in range(Q)])
ans = np.all(ab @ coef.T <= dist, axis=1)
print(*np.where(ans, "Yes", "No"), sep='\n')
|
ConDefects/ConDefects/Code/abc251_g/Python/31757947
|
condefects-python_data_554
|
INF=pow(2,61)-1
N=int(input())
dot=[tuple(map(int,input().split())) for i in range(N)]
dot.append(dot[-1])
M=int(input())
move=[tuple(map(int,input().split())) for i in range(M)]
line=[]
for i in range(N):
maxi=-INF
a=0
b=0
for u,v in move:
x1=dot[i][0]+u
y1=dot[i][1]+v
x2=dot[i+1][0]+u
y2=dot[i+1][1]+v
a=(y2-y1)
b=-(x2-x1)
c=y2*(x2-x1)-x2*(y2-y1)
maxi=max(maxi,c)
line.append((a,b,maxi))
Q=int(input())
for i in range(Q):
a,b=map(int,input().split())
ans="Yes"
for A,B,C in line:
if A*a+B*b+C>0:
ans="No"
break
print(ans)
INF=pow(2,61)-1
N=int(input())
dot=[tuple(map(int,input().split())) for i in range(N)]
dot.append(dot[0])
M=int(input())
move=[tuple(map(int,input().split())) for i in range(M)]
line=[]
for i in range(N):
maxi=-INF
a=0
b=0
for u,v in move:
x1=dot[i][0]+u
y1=dot[i][1]+v
x2=dot[i+1][0]+u
y2=dot[i+1][1]+v
a=(y2-y1)
b=-(x2-x1)
c=y2*(x2-x1)-x2*(y2-y1)
maxi=max(maxi,c)
line.append((a,b,maxi))
Q=int(input())
for i in range(Q):
a,b=map(int,input().split())
ans="Yes"
for A,B,C in line:
if A*a+B*b+C>0:
ans="No"
break
print(ans)
|
ConDefects/ConDefects/Code/abc251_g/Python/46368168
|
condefects-python_data_555
|
INF = 10 ** 18
N = int(input())
P = [tuple(map(int, input().split())) for _ in range(N)]
M = int(input())
move = [tuple(map(int, input().split())) for _ in range(M)]
lines = []
def intercept(dx, dy, x, y):
if dx == 0: return x
return dx * y - x * dy
for i in range(N):
x1, y1 = P[i]
x2, y2 = P[(i + 1) % N]
dx = x2 - x1
dy = y2 - y1
if intercept(dx, dy, x1, y1) < intercept(dx, dy, *P[(i - 1) % N]): d = 1
else: d = -1
inter = d * -INF
for x, y in move:
tmpinter = intercept(dx, dy, x1 + x, y1 + y)
if inter * d < tmpinter * d: inter = tmpinter
lines.append((dx, dy, d, inter))
Q = int(input())
for _ in range(Q):
x, y = map(int, input().split())
for i in range(N):
dx, dy, d, inter = lines[i]
if inter > d * intercept(dx, dy, x, y):
print('No')
break
else: print('Yes')
INF = 10 ** 18
N = int(input())
P = [tuple(map(int, input().split())) for _ in range(N)]
M = int(input())
move = [tuple(map(int, input().split())) for _ in range(M)]
lines = []
def intercept(dx, dy, x, y):
if dx == 0: return x
return dx * y - x * dy
for i in range(N):
x1, y1 = P[i]
x2, y2 = P[(i + 1) % N]
dx = x2 - x1
dy = y2 - y1
if intercept(dx, dy, x1, y1) < intercept(dx, dy, *P[(i - 1) % N]): d = 1
else: d = -1
inter = d * -INF
for x, y in move:
tmpinter = intercept(dx, dy, x1 + x, y1 + y)
if inter * d < tmpinter * d: inter = tmpinter
lines.append((dx, dy, d, inter))
Q = int(input())
for _ in range(Q):
x, y = map(int, input().split())
for i in range(N):
dx, dy, d, inter = lines[i]
if inter * d > intercept(dx, dy, x, y) * d:
print('No')
break
else: print('Yes')
|
ConDefects/ConDefects/Code/abc251_g/Python/31752648
|
condefects-python_data_556
|
def g_intersection_of_polygons(INF=float('inf')):
N = int(input())
Points = [[int(col) for col in input().split()] for row in range(N)]
Points.append(Points[0])
M = int(input())
Moves = [[int(col) for col in input().split()] for row in range(M)]
Q = int(input())
Queries = [complex(*[int(col) for col in input().split()])
for row in range(Q)]
def cross(p, q, r, s):
return p * s - q * r
Q1, Q2, R = [0] * (N + 1), [0] * (N + 1), [-INF] * (N + 1)
for i in range(N):
delta_x = Points[i + 1][0] - Points[i][0]
delta_y = Points[i + 1][1] - Points[i][1]
Q1[i] = delta_x
Q2[i] = delta_y
for j in range(M):
moved_x = Points[i][0] + Moves[j][0]
moved_y = Points[i][1] + Moves[j][1]
R[i] = max(R[i], cross(delta_x, delta_y, moved_x, moved_y))
ans = []
for q in Queries:
a, b = q.real, q.imag
for i in range(N):
if cross(Q1[i], Q2[i], a, b) < R[i]:
ans.append('No')
break
else:
ans.append('Yes')
return '\n'.join(map(str, ans))
print(g_intersection_of_polygons())
def g_intersection_of_polygons(INF=float('inf')):
N = int(input())
Points = [[int(col) for col in input().split()] for row in range(N)]
Points.append(Points[0])
M = int(input())
Moves = [[int(col) for col in input().split()] for row in range(M)]
Q = int(input())
Queries = [complex(*[int(col) for col in input().split()])
for row in range(Q)]
def cross(p, q, r, s):
return p * s - q * r
Q1, Q2, R = [0] * (N + 1), [0] * (N + 1), [-INF] * (N + 1)
for i in range(N):
delta_x = Points[i + 1][0] - Points[i][0]
delta_y = Points[i + 1][1] - Points[i][1]
Q1[i] = delta_x
Q2[i] = delta_y
for j in range(M):
moved_x = Points[i][0] + Moves[j][0]
moved_y = Points[i][1] + Moves[j][1]
R[i] = max(R[i], cross(delta_x, delta_y, moved_x, moved_y))
ans = []
for q in Queries:
a, b = int(q.real), int(q.imag)
for i in range(N):
if cross(Q1[i], Q2[i], a, b) < R[i]:
ans.append('No')
break
else:
ans.append('Yes')
return '\n'.join(map(str, ans))
print(g_intersection_of_polygons())
|
ConDefects/ConDefects/Code/abc251_g/Python/40927285
|
condefects-python_data_557
|
from scipy.optimize import minimize
from math import sqrt
N = int(input())
segments = [tuple(map(int, input().split())) for i in range(N)]
def f(param):
x, y = param
ret = 0
for a, b, c, d in segments:
if (a - c) * (a - x) + (b - d) * (b - y) < 0:
ret = max(ret, sqrt((a - x) ** 2 + (b - y) ** 2))
elif (c - a) * (c - x) + (d - b) * (d - y) < 0:
ret = max(ret, sqrt((c - x) ** 2 + (d - y) ** 2))
else:
ret = max(ret, abs((a - c) * (b - y) - (b - d) * (a - x)) / sqrt((a - c) ** 2 + (b - d) ** 2))
return ret
print(minimize(f, (500, 500), args=(), method='trust-constr', options = {"maxiter": 5000, "gtol":1e-15, "xtol": 1e-15, "barrier_tol": 1e-12}).fun)
from scipy.optimize import minimize
from math import sqrt
N = int(input())
segments = [tuple(map(int, input().split())) for i in range(N)]
def f(param):
x, y = param
ret = 0
for a, b, c, d in segments:
if (a - c) * (a - x) + (b - d) * (b - y) < 0:
ret = max(ret, sqrt((a - x) ** 2 + (b - y) ** 2))
elif (c - a) * (c - x) + (d - b) * (d - y) < 0:
ret = max(ret, sqrt((c - x) ** 2 + (d - y) ** 2))
else:
ret = max(ret, abs((a - c) * (b - y) - (b - d) * (a - x)) / sqrt((a - c) ** 2 + (b - d) ** 2))
return ret
print(minimize(f, (500, 500), args=(), method='Nelder-Mead', options = {"maxiter": 5000, "xatol": 1e-10, "fatol":1e-10}).fun)
|
ConDefects/ConDefects/Code/abc314_h/Python/44593278
|
condefects-python_data_558
|
from collections import defaultdict
import math
import sys
sys.setrecursionlimit(790000)
class UnionFind:
def __init__(self, N):
self.par = list(range(N))
self.g = [[] for i in range(N)]
def root(self, x):
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return
self.par[rx] = ry
self.g[x].append(y)
def same(self, x, y):
return self.root(x) == self.root(y)
n, m = map(int, input().split())
union = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
union.unite(a, b)
edge_nums = defaultdict(int)
node_nums = defaultdict(int)
for i in range(n):
edge_nums[union.root(i)] += len(union.g[i])
node_nums[union.root(i)] += 1
result = 0
for i in range(n):
result += math.comb(node_nums[i], 2) - edge_nums[i]
print(result)
from collections import defaultdict
import math
import sys
sys.setrecursionlimit(790000)
class UnionFind:
def __init__(self, N):
self.par = list(range(N))
self.g = [[] for i in range(N)]
def root(self, x):
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self, x, y):
rx = self.root(x)
ry = self.root(y)
self.par[rx] = ry
self.g[x].append(y)
def same(self, x, y):
return self.root(x) == self.root(y)
n, m = map(int, input().split())
union = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
union.unite(a, b)
edge_nums = defaultdict(int)
node_nums = defaultdict(int)
for i in range(n):
edge_nums[union.root(i)] += len(union.g[i])
node_nums[union.root(i)] += 1
result = 0
for i in range(n):
result += math.comb(node_nums[i], 2) - edge_nums[i]
print(result)
|
ConDefects/ConDefects/Code/abc350_d/Python/54866820
|
condefects-python_data_559
|
N=int(input())
A=list(map(int,input().split()))
Ada=[]
for i in range(N):
Ada.append(A[i])
while True:
if len(Ada)==1:
break
if Ada[-1]!=Ada[-2]:
break
else:
d1=Ada.pop()
d2=Ada.pop()
Ada.append(d1+1)
print(Ada)
N=int(input())
A=list(map(int,input().split()))
Ada=[]
for i in range(N):
Ada.append(A[i])
while True:
if len(Ada)==1:
break
if Ada[-1]!=Ada[-2]:
break
else:
d1=Ada.pop()
d2=Ada.pop()
Ada.append(d1+1)
print(len(Ada))
|
ConDefects/ConDefects/Code/abc351_c/Python/54893576
|
condefects-python_data_560
|
n = int(input())
A = list(map(int, input().split()))
ans = []
for i in range(n):
tmp = A[i]
ans.append(tmp)
while True:
if len(ans) == 1:
break
elif ans[-1] != ans[-2]:
break
bai = ans.pop() + 1
ans.pop()
ans.append(bai)
print(ans)
print(len(ans))
n = int(input())
A = list(map(int, input().split()))
ans = []
for i in range(n):
tmp = A[i]
ans.append(tmp)
while True:
if len(ans) == 1:
break
elif ans[-1] != ans[-2]:
break
bai = ans.pop() + 1
ans.pop()
ans.append(bai)
# print(ans)
print(len(ans))
|
ConDefects/ConDefects/Code/abc351_c/Python/55122758
|
condefects-python_data_561
|
from collections import deque
def solve_C():
n = int(input())
a = list(map(int, input().split()))
global dq
dq = deque()
def add(n):
global dq
if len(dq) == 0:
dq.append(n)
return
most_left = dq.pop()
if n == most_left:
add(n+1)
else:
dq.append(most_left)
dq.append(n)
return
i = 0
while i < n-1:
if a[i] == a[i+1] + 1 and a[n-1] == a[n-2]:
i += 1
else:
break
if i == n-2:
print(1)
return
for num in a:
add(num)
print(len(dq))
solve_C()
from collections import deque
def solve_C():
n = int(input())
a = list(map(int, input().split()))
global dq
dq = deque()
def add(n):
global dq
if len(dq) == 0:
dq.append(n)
return
most_left = dq.pop()
if n == most_left:
add(n+1)
else:
dq.append(most_left)
dq.append(n)
return
i = 0
while i < n-1:
if a[i] == a[i+1] + 1 and a[n-1] == a[n-2]:
i += 1
else:
break
if i == n-2 and i != 0:
print(1)
return
for num in a:
add(num)
print(len(dq))
solve_C()
|
ConDefects/ConDefects/Code/abc351_c/Python/54968121
|
condefects-python_data_562
|
from collections import deque
n = int(input())
input_list = [int(x) for x in input().split(' ')]
tfe = deque()
temp = None
for x in input_list:
temp = x
if tfe and tfe[-1] == temp:
while tfe and tfe[-1] == temp:
temp += 1
tfe.pop()
else:
tfe.append(temp)
from collections import deque
n = int(input())
input_list = [int(x) for x in input().split(' ')]
tfe = deque()
temp = None
for x in input_list:
temp = x
if tfe and tfe[-1] == temp:
while tfe and tfe[-1] == temp:
temp += 1
tfe.pop()
tfe.append(temp)
else:
tfe.append(temp)
print(len(tfe))
|
ConDefects/ConDefects/Code/abc351_c/Python/54982997
|
condefects-python_data_563
|
def main() -> None:
n: int = int(input())
d: dict[int, int] = dict.fromkeys(range(2 * n + 1), 0)
a: list[int] = list(map(int, input().split()))
for i, ai in enumerate(a):
d[(i + 1) * 2] = d[ai] + 1
d[(i + 1) * 2 + 1] = d[ai] + 1
for i in d.values():
print(i)
main()
def main() -> None:
n: int = int(input())
d: dict[int, int] = dict.fromkeys(range(1, 2 * n + 1), 0)
a: list[int] = list(map(int, input().split()))
for i, ai in enumerate(a):
d[(i + 1) * 2] = d[ai] + 1
d[(i + 1) * 2 + 1] = d[ai] + 1
for i in d.values():
print(i)
main()
|
ConDefects/ConDefects/Code/abc274_c/Python/52979754
|
condefects-python_data_564
|
MOD=10**9+7
n = int(input())
s = input()
ans=1
cnt=0
for i in range(n):
cnt+=1
if i==n-1 or s[i]==s[i+1]:
ans*=cnt//2
ans%=MOD
cnt=0
print(ans%MOD)
MOD=10**9+7
n = int(input())
s = input()
ans=1
cnt=0
for i in range(n):
cnt+=1
if i==n-1 or s[i]==s[i+1]:
ans*=-(-cnt//2)
ans%=MOD
cnt=0
print(ans%MOD)
|
ConDefects/ConDefects/Code/arc180_a/Python/55032207
|
condefects-python_data_565
|
n = int(input())
s = list(input())
for i in range(n):
if i % 2 == 0:
if s[i] == 'A':
s[i] = 'B'
else:
s[i] = 'A'
print(s)
L = []
cur = s[0]
cnt = 0
for si in s:
if si == cur:
cnt += 1
else:
cur = si
L.append(cnt)
cnt = 1
L.append(cnt)
print(L)
ans = 1
for l in L:
a = (l + 1) // 2
ans *= a
ans %= (10 ** 9) + 7
print(ans)
n = int(input())
s = list(input())
for i in range(n):
if i % 2 == 0:
if s[i] == 'A':
s[i] = 'B'
else:
s[i] = 'A'
L = []
cur = s[0]
cnt = 0
for si in s:
if si == cur:
cnt += 1
else:
cur = si
L.append(cnt)
cnt = 1
L.append(cnt)
ans = 1
for l in L:
a = (l + 1) // 2
ans *= a
ans %= (10 ** 9) + 7
print(ans)
|
ConDefects/ConDefects/Code/arc180_a/Python/55032077
|
condefects-python_data_566
|
from itertools import groupby
N = int(input())
S = list(input())
mod = 998244353
for i in range(0, N, 2):
if S[i] == "A":
S[i] = "B"
else:
S[i] = "A"
RLE = [(k, len(list(v))) for k, v in groupby(S)]
ans = 1
for s, cnt in RLE:
ans *= (cnt+1)//2
ans %= mod
print(ans)
from itertools import groupby
N = int(input())
S = list(input())
mod = 10**9 + 7
for i in range(0, N, 2):
if S[i] == "A":
S[i] = "B"
else:
S[i] = "A"
RLE = [(k, len(list(v))) for k, v in groupby(S)]
ans = 1
for s, cnt in RLE:
ans *= (cnt+1)//2
ans %= mod
print(ans)
|
ConDefects/ConDefects/Code/arc180_a/Python/55121294
|
condefects-python_data_567
|
n,m,k=list(map(int,input().split()))
nums1=[]
nums2=[]
for i in range(n):
nums1.append(list(map(int,input().split())))
for i in range(m):
nums2.append(list(map(int,input().split())))
l=0
r=1
while True:
mid=(l+r)/2
temp1=[]
temp2=[]
for i in range(n):
temp1.append(nums1[i][0]-(nums1[i][0]+nums1[i][1])*mid)
for i in range(m):
temp2.append(nums2[i][0]-(nums2[i][0]+nums2[i][1])*mid)
count=0
for i in range(n):
s=0
t=m
ng=s-1
ok=t
while (ok-ng)>1:
mid2=(ng+ok)//2
if temp2[mid2]+temp1[i]>=0:
ok=mid2
else:
ng=mid2
count+=m-ok
if count>=k:
l=mid
else:
r=mid
if abs(l-r)<1e-12:
print(l*100)
exit()
n,m,k=list(map(int,input().split()))
nums1=[]
nums2=[]
for i in range(n):
nums1.append(list(map(int,input().split())))
for i in range(m):
nums2.append(list(map(int,input().split())))
l=0
r=1
while True:
mid=(l+r)/2
temp1=[]
temp2=[]
for i in range(n):
temp1.append(nums1[i][0]-(nums1[i][0]+nums1[i][1])*mid)
for i in range(m):
temp2.append(nums2[i][0]-(nums2[i][0]+nums2[i][1])*mid)
temp1.sort()
temp2.sort()
count=0
for i in range(n):
s=0
t=m
ng=s-1
ok=t
while (ok-ng)>1:
mid2=(ng+ok)//2
if temp2[mid2]+temp1[i]>=0:
ok=mid2
else:
ng=mid2
count+=m-ok
if count>=k:
l=mid
else:
r=mid
if abs(l-r)<1e-12:
print(l*100)
exit()
|
ConDefects/ConDefects/Code/abc294_f/Python/46857187
|
condefects-python_data_568
|
N,M,K=map(int,input().split())
Tak=[list(map(int,input().split())) for i in range(N)]
Ao=[list(map(int,input().split())) for i in range(M)]
from bisect import *
def is_ok(x):
X=x/100
Ao2=[-Ao[i][0]+X*(Ao[i][0]+Ao[i][1]) for i in range(M)]
Ao2.sort()
count=0
for i in range(N):
now=Tak[i][0]-X*(Tak[i][0]+Tak[i][1])
ind=bisect_right(Ao2,now)
count+=ind
if count>=K:
return True
else:
return False
ok=0
ng=100
while ng-ok>10**(-6):
mid=(ng+ok)/2
if is_ok(mid):
ok=mid
else:
ng=mid
print(ok)
N,M,K=map(int,input().split())
Tak=[list(map(int,input().split())) for i in range(N)]
Ao=[list(map(int,input().split())) for i in range(M)]
from bisect import *
def is_ok(x):
X=x/100
Ao2=[-Ao[i][0]+X*(Ao[i][0]+Ao[i][1]) for i in range(M)]
Ao2.sort()
count=0
for i in range(N):
now=Tak[i][0]-X*(Tak[i][0]+Tak[i][1])
ind=bisect_right(Ao2,now)
count+=ind
if count>=K:
return True
else:
return False
ok=0
ng=100
while ng-ok>10**(-10):
mid=(ng+ok)/2
if is_ok(mid):
ok=mid
else:
ng=mid
print(ok)
|
ConDefects/ConDefects/Code/abc294_f/Python/47413656
|
condefects-python_data_569
|
def main():
from fractions import Fraction
from bisect import bisect_left, bisect_right, insort
N, M, K = map(int, input().split())
AB = [tuple(map(int, input().split())) for _ in range(N)]
CD = [tuple(map(int, input().split())) for _ in range(M)]
def is_ok(X: Fraction):
p, q = X.as_integer_ratio()
r = q-p
Dab = [p*b - r*a for a, b in AB]
Dcd = [r*c - p*d for c, d in CD]
Dcd.sort()
cnt = 0
for dab in Dab:
cnt += M - bisect_left(Dcd, dab)
return cnt >= K
def bin_search(ok: Fraction, ng: Fraction):
while abs(ok-ng) > 1e-10:
mid = (ok+ng)/2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
ans = bin_search(Fraction(0), Fraction(1))
print(float(ans*100))
main()
def main():
from fractions import Fraction
from bisect import bisect_left, bisect_right, insort
N, M, K = map(int, input().split())
AB = [tuple(map(int, input().split())) for _ in range(N)]
CD = [tuple(map(int, input().split())) for _ in range(M)]
def is_ok(X: Fraction):
p, q = X.as_integer_ratio()
r = q-p
Dab = [p*b - r*a for a, b in AB]
Dcd = [r*c - p*d for c, d in CD]
Dcd.sort()
cnt = 0
for dab in Dab:
cnt += M - bisect_left(Dcd, dab)
return cnt >= K
def bin_search(ok: Fraction, ng: Fraction):
while abs(ok-ng) > 1e-12:
mid = (ok+ng)/2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
ans = bin_search(Fraction(0), Fraction(1))
print(float(ans*100))
main()
|
ConDefects/ConDefects/Code/abc294_f/Python/53961424
|
condefects-python_data_570
|
from random import randint, shuffle
from math import gcd, log2, log, sqrt
from fractions import Fraction
from bisect import bisect_left, bisect_right
from itertools import accumulate, permutations, combinations, product, chain
from sortedcontainers import SortedList
from collections import Counter, deque, defaultdict as ddict
from heapq import heappush as push, heappop as pop
from functools import reduce, lru_cache
import sys
input = sys.stdin.readline
inf = 10**18
def read(dtype=int):
return list(map(dtype, input().split()))
n, m, k = read()
a = [read() for _ in range(n)]
b = [read() for _ in range(m)]
l = 0
r = 10 ** 6
def check(mid):
A = [x - (x+y) * mid for x, y in a]
B = [x - (x+y) * mid for x, y in b]
A.sort()
B.sort()
ptr = m-1
res = 0
for i in A:
while ptr >= 0 and i + B[ptr] >= 0:
ptr -= 1
res += m - ptr - 1
return res >= k
while r - l > 1e-10:
mid = (l+r) / 2
if check(mid):
l = mid
else:
r = mid
print(l * 100)
from random import randint, shuffle
from math import gcd, log2, log, sqrt
from fractions import Fraction
from bisect import bisect_left, bisect_right
from itertools import accumulate, permutations, combinations, product, chain
from sortedcontainers import SortedList
from collections import Counter, deque, defaultdict as ddict
from heapq import heappush as push, heappop as pop
from functools import reduce, lru_cache
import sys
input = sys.stdin.readline
inf = 10**18
def read(dtype=int):
return list(map(dtype, input().split()))
n, m, k = read()
a = [read() for _ in range(n)]
b = [read() for _ in range(m)]
l = 0
r = 10 ** 6
def check(mid):
A = [x - (x+y) * mid for x, y in a]
B = [x - (x+y) * mid for x, y in b]
A.sort()
B.sort()
ptr = m-1
res = 0
for i in A:
while ptr >= 0 and i + B[ptr] >= 0:
ptr -= 1
res += m - ptr - 1
return res >= k
while r - l > 1e-11:
mid = (l+r) / 2
if check(mid):
l = mid
else:
r = mid
print(l * 100)
|
ConDefects/ConDefects/Code/abc294_f/Python/49343974
|
condefects-python_data_571
|
N = int(input())
A = list(map(int, input().split()))
B = list(set(A))
A.sort()
B.sort()
for i in range(4*N-1):
if A[i] != B[i//4]:
print(A[i])
exit()
print(A[-1])
N = int(input())
A = list(map(int, input().split()))
B = list(set(A))
A.sort()
B.sort()
for i in range(4*N-1):
if A[i] != B[i//4]:
print(A[i]-1)
exit()
print(A[-1])
|
ConDefects/ConDefects/Code/abc236_b/Python/45474387
|
condefects-python_data_572
|
from collections import Counter
n = int(input())
A = input().replace(' ', '')
c = Counter(A)
print(c.most_common()[-1][0])
from collections import Counter
n = int(input())
A = list(map(int, input().split()))
c = Counter(A)
print(c.most_common()[-1][0])
|
ConDefects/ConDefects/Code/abc236_b/Python/46220986
|
condefects-python_data_573
|
import bisect
n, m = map(int,input().split())
A = sorted(map(int,input().split()))
print(A)
ans = 0
for i in range(n):
ans = max(ans, bisect.bisect_left(A, A[i] + m) - i)
print(bisect.bisect_left(A, A[i] + m) - i)
print(ans)
import bisect
n, m = map(int,input().split())
A = sorted(map(int,input().split()))
ans = 0
for i in range(n):
ans = max(ans, bisect.bisect_left(A, A[i] + m) - i)
print(ans)
|
ConDefects/ConDefects/Code/abc326_c/Python/54400118
|
condefects-python_data_574
|
N, M = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
res = 0
r = 0
for l in range(0, N):
while True:
if r < N - 1 and A[r + 1] - A[l] < M : r += 1
else : break
res = max(res, r - l)
print(res)
N, M = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
res = 0
r = 0
for l in range(0, N):
while True:
if r < N - 1 and A[r + 1] - A[l] < M : r += 1
else : break
res = max(res, r - l + 1)
print(res)
|
ConDefects/ConDefects/Code/abc326_c/Python/54412817
|
condefects-python_data_575
|
def main():
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
B=[]
for n in range(N-1):
B.append(A[n+1]-A[n])
kyori=0
kazu=1
i=0
ans=0
for b in B:
kyori+=b
kazu+=1
if kyori>=M:
while kyori>=M:
kyori-=B[i]
i+=1
kazu-=1
ans=max(ans,kazu)
print(ans)
if __name__=="__main__":
main()
def main():
N,M=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
B=[]
for n in range(N-1):
B.append(A[n+1]-A[n])
kyori=0
kazu=1
i=0
ans=1
for b in B:
kyori+=b
kazu+=1
if kyori>=M:
while kyori>=M:
kyori-=B[i]
i+=1
kazu-=1
ans=max(ans,kazu)
print(ans)
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/abc326_c/Python/54454360
|
condefects-python_data_576
|
import bisect
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(n):
ans=max(ans,bisect.bisect_left(a,a[i]+m)-1)
print(ans)
import bisect
n,m=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
ans=0
for i in range(n):
ans=max(ans,bisect.bisect_left(a,a[i]+m)-i)
print(ans)
|
ConDefects/ConDefects/Code/abc326_c/Python/54306688
|
condefects-python_data_577
|
n,m = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
j = 0
ans = 0
for i in range(n-1):
x = A[i] + m
while j < n and A[j] < x:
ans = max(ans,j-i+1)
j += 1
print(ans)
n,m = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
j = 0
ans = 0
for i in range(n):
x = A[i] + m
while j < n and A[j] < x:
ans = max(ans,j-i+1)
j += 1
print(ans)
|
ConDefects/ConDefects/Code/abc326_c/Python/54687593
|
condefects-python_data_578
|
N = int(input())
# N = 8
# M = (N - 1).bitlength()
# i番目(0-indexed)の人はiビット目が立つ番号のジュースのみ飲む
# i番目の人がお腹を壊した = 腐ったワインの番号のiビット目は立っている
# 0: 1, 3, 5, 7
# 1: 2, 3, 6, 7
# 2: 4, 5, 6, 7
M = (N - 1).bit_length()
Q = [[] for _ in range(M)]
for bit in range(1, N + 1):
for i in range(M):
if (bit >> i) & 1:
Q[i].append(bit)
print(M)
for i in range(M):
print(i + 1, *Q[i])
S = input()
ans = 0
for i in range(M):
if S[i] == "1":
ans ^= (1 << i)
print(N if ans == 0 else ans)
N = int(input())
# N = 8
# M = (N - 1).bitlength()
# i番目(0-indexed)の人はiビット目が立つ番号のジュースのみ飲む
# i番目の人がお腹を壊した = 腐ったワインの番号のiビット目は立っている
# 0: 1, 3, 5, 7
# 1: 2, 3, 6, 7
# 2: 4, 5, 6, 7
M = (N - 1).bit_length()
Q = [[] for _ in range(M)]
for bit in range(1, N + 1):
for i in range(M):
if (bit >> i) & 1:
Q[i].append(bit)
print(M)
for i in range(M):
print(len(Q[i]), *Q[i])
S = input()
ans = 0
for i in range(M):
if S[i] == "1":
ans ^= (1 << i)
print(N if ans == 0 else ans)
|
ConDefects/ConDefects/Code/abc337_e/Python/53945275
|
condefects-python_data_579
|
from collections import defaultdict, deque, Counter
from sortedcontainers import SortedSet, SortedList, SortedDict
from heapq import heappush, heappop
from atcoder.dsu import DSU
from atcoder.segtree import SegTree
# st = SegTree(lambda dt1,dt2: データ参照, 単位元, 元データ)
from atcoder.lazysegtree import LazySegTree
# lst = LazySegTree(lambda dt1,dt2: データ参照, 恒等写像, lambda lz,dt: データ更新, lambda lz1,lz2: 遅延伝播, 単位元, 元データ)
from bisect import bisect_left, bisect_right
from itertools import product, groupby, permutations, combinations
import math
from copy import copy, deepcopy
import sys
sys.setrecursionlimit(10000000)
# PyPy再帰高速化
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
# 切り上げ除算
# 絶対値の切り下げ/切り上げを反転する
def div_ceil(num, div):
return -(-num//div)
# ユークリッドの互除法 O(logN)
# 最大公約数(gcd)を求める
"""
gcdはaとbの約数の積集合
"""
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a%b != 0:
a, b = b, a%b
return b
# ユークリッドの互除法と約数集合 O(logN)
# 最小公倍数(lcm)を求める
"""
lcmはaとbの約数の和集合
ただし, lcm(3, 9) = 9のようになるので,
約数集合において1つ目の3と2つ目の3は別として扱うように,
同じ値でも何個目かによって区別する。
割り算は約数の引き算
1.aとbの約数集合を重ねる
2.ダブルカウントされた共通部分GCDを除く
補足: GCDで必ず割り切れるので先に割る
"""
def lcm(a, b):
GCD = gcd(a, b)
return a//GCD*b
# エラトステネスの篩 O(NloglogN)
# N未満の素数列挙
"""
素数の倍数の削除について, N/2+N/3+N/5... = N(1/2+1/3+1/5...)
N未満の素数の逆数和はloglogNになるらしいので, O(NloglogN)
O(NloglogN)がTLEするほど大きな結果をコードに埋め込むことはできない。
TLEしない10^6以下の素数列挙でもテキストのサイズが600kBほどになってしまうため。
"""
def eratosthenes_sieve(lim):
primes = set(range(3, lim, 2))
primes.add(2)
# iが素数か判定(奇数だけ見ていく)
for i in range(3, lim, 2):
if i in primes:
# 素数iの倍数を削除
for j in range(i*2, lim, i):
primes.discard(j)
return primes
# 試し割り法 O(√N)
# Nを素因数分解
"""
N = 10^16でO(10^8)でも424msなので, 実際はみかけより早い
N = 10^18でO(10^9)だと3009ms
N = 10^17だと1048msなので, この辺が限界
"""
def prime_factors(src):
# pf = {素因数p : 指数e}
pf = defaultdict(int)
now = src
i = 2
# src = i*j のときjがiより大きいなら既出なので√srcまで確認
while i*i <= src:
# 割り切れるなら割れるだけ割る
while now%i == 0:
now //= i
pf[i] += 1
i += 1
# それ以上分解できない残ったものを素因数に加える
if now > 1:
pf[now] += 1
return pf
# 累積和 O(N)
# imos法で使う場合は[l, r)のlに+v, rに-vして累積和で復元
# 区間和の取得をO(1)で行える
def pre_sum(src):
n = len(src)+1
pre_sum = [0]*n
for i in range(1, n):
pre_sum[i] = pre_sum[i-1]+src[i-1]
return pre_sum
# しゃくとり法 O(N)
"""
# l], (r
r = N-1
for l in range(N):
# 右の追い越し防止
while r > l and "ここにrを進める条件":
r -= 1
# 左の追い越し修正
if l > r:
r = l
# ここにメインの処理
"""
# 座標圧縮 O(N)
# 10 10 12 24 -> 0 0 1 2 (rankだと0 0 2 3)
def dense_rank(src):
# srcの重複を除いてソートして値と順位の対応を得る
d = {v:i for i, v in enumerate(sorted(set(src)))}
ret = [d[si] for si in src]
return ret
# ランレングス圧縮 O(N)
def rle(src):
return [(k, len(list(v))) for k, v in groupby(src)]
# 二分探索 O(logN)
"""
sより小さい最大値の位置を返す(挿入位置ではない)
sは必ず探索範囲内に存在するものとする
同じ値が存在する場合は最も右の値の位置を返す
"""
def binary_search(s):
# 半開区間[l, r)
l, r = 0, N
m = (l+r)//2
while r-l > 1:
if A[m] < s:
l = m
else:
r = m
m = (l+r)//2
print(m, l, r)
return m
# bitDP O(4^N) (種類をNとすると(2^N)^2 = 2^(N*2) = 4^N)
"""
選ぶ/選ばないの組合せを表すビットを状態にとる動的計画法
全ての選択肢に対してありうる全ての状態からの遷移を求める
下記のNは組合せのビット数なので注意
"""
def bit_dp(src):
# 元データの数を状態の数に圧縮する
src = Counter(src)
N = 2**len(src)
dp = [0]*N
# どれも選ばない場合が1通り
dp[0] = 1
for src_bits, cnt in src:
# 逆順に更新すれば1次元配列でも二重に更新されない
for frm_bits in range(N-1, -1, -1):
# srcから1つ以上選ぶ遷移, 爆発しないようにMODをとる
dp[frm_bits|src_bits] += (dp[frm_bits]*(2**cnt-1))%MOD
dp[frm_bits|src_bits] %= MOD
return dp
# 4隣接の取得
# "#"判定は呼び出し側
def get_4adjacent(i, j):
ret = []
# 時計回り
if 0 <= i-1 < H:
ret.append((i-1, j))
if 0 <= j+1 < W:
ret.append((i, j+1))
if 0 <= i+1 < H:
ret.append((i+1, j))
if 0 <= j-1 < W:
ret.append((i, j-1))
return ret
# 9隣接の取得
# "#"判定は呼び出し側
def get_9adjacent(frm):
ret = []
i, j = frm[0], frm[1]
d = (-1, 0, 1)
for di in d:
ii = i+di
for dj in d:
jj = j+dj
if ii == i and jj == j:
continue
if 0 <= ii < H and 0 <= jj < W:
ret.append((ii, jj))
return ret
# 3*3のグリッド(要素数9の配列)の縦横斜めがそろっているか判定(oxゲーム)
def judge_line(ox):
ret = "_"
for i in range(3):
# 横一列
if ox[i*3] == "o" and ox[i*3+1] == "o" and ox[i*3+2] == "o":
ret = "o"
break
if ox[i*3] == "x" and ox[i*3+1] == "x" and ox[i*3+2] == "x":
ret = "x"
break
# 縦一列
if ox[i] == "o" and ox[i+3] == "o" and ox[i+6] == "o":
ret = "o"
break
if ox[i] == "x" and ox[i+3] == "x" and ox[i+6] == "x":
ret = "x"
break
# 斜め(\, /)
if ox[0] == "o" and ox[4] == "o" and ox[8] == "o":
ret = "o"
if ox[0] == "x" and ox[4] == "x" and ox[8] == "x":
ret = "x"
if ox[2] == "o" and ox[4] == "o" and ox[6] == "o":
ret = "o"
if ox[2] == "x" and ox[4] == "x" and ox[6] == "x":
ret = "x"
return ret
"""
# 深さ優先探索(再帰) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(frm):
for to in G[frm]:
if dist[to] < INF:
continue
dist[to] = dist[frm]+1
dfs(to)
"""
# 深さ優先探索(行きがけのみ/スタック) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(start):
st = [start]
while st:
frm = st.pop()
for to in G[frm]:
if dist[to] < INF:
continue
# 行きがけ処理
dist[to] = dist[frm]+1
st.append(to)
# 深さ優先探索(行きがけ帰りがけ両対応/スタック) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(start):
# 帰りがけ用頂点と行きがけ用頂点を用意する
st = [~start, start]
while st:
frm = st.pop()
if frm >= 0:
# 行きがけ処理
for to in G[frm]:
if dist[to] < INF:
continue
dist[to] = dist[frm]+1
st.append(~to)
st.append(to)
else:
# 帰りがけ処理
frm = ~frm
# ここに具体的な帰りがけ処理(再帰の戻り値でやるようなやつ)
# 自身を含む自身以下の部分木のコスト総和を求める
def subtree_cost_sum(start):
st = [~start, start]
while st:
frm = st.pop()
if frm >= 0:
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
st.append(~to)
st.append(to)
else:
frm = ~frm
# 帰りがけ順に処理されるので自身と直下の子のみ足せばよい
C_sum[frm] = C[frm]+sum([C_sum[to] for to in G[frm]])
# 木の重心を求める
"""
直線とウニとその間の木で考えても重心での距離総和が最小で,
重心で木を分解したときの部分木の頂点数の最大値の最小値はN//2以下。
複数N//2より大きいtoが存在すると考えると頂点数がNを超えて矛盾するためtoはfrmに対して1つ。
頂点数でなくコストでも同様のことが成り立つ。
"""
def centroid(start):
st = [start]
while st:
frm = st.pop()
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
if C_sum[to] > C_sum[0]//2:
st.append(to)
return frm
# 幅優先探索 O(V+E)
# BFSごとにリセットする場合: in_visited = defaultdict(bool)
def bfs(start):
q = deque([start])
while q:
frm = q.popleft()
visited[frm] = True
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
q.append(to)
# ダイクストラ法 O((V+E)logV)
"""
単一始点最短経路(1つの頂点からすべての頂点までの最短経路)を求める。
ダイクストラ法のベースは幅優先探索。
最短距離が未確定の頂点のうち,
暫定最短距離が最短の頂点はその時点で距離が確定する。
その頂点は回り道したら必ず距離が暫定最短距離より大きくなるため。
負のコストが存在すると回り道した方がコストが小さくなる可能性があるため,
ダイクストラ法が使えない。
"""
def dijkstra(start):
# 各頂点の始点からの距離
dist = [INF]*N
dist[0] = 0
# 経路復元用の各頂点の最短経路における前の要素
prev = [-1]*N
# visited[i]: 最短距離確定済みか
visited = [False]*N
# (距離, 頂点)の優先度付きキュー
pq = [start]
while pq:
# 暫定距離最短の頂点の距離を確定してたどる
frm = heappop(pq)[1]
if visited[frm]:
continue
visited[frm] = True
for frm_to_dist, to in G[frm]:
# 暫定最短距離と前の頂点の更新
if dist[frm]+frm_to_dist < dist[to]:
dist[to] = dist[frm]+frm_to_dist
prev[to] = frm
heappush(pq, (dist[to], to))
# 最短経路を終点から遡って復元
# デフォルトの終点: N-1
path = [N-1]
frm = prev[path[0]]
while frm > -1:
path.append(frm)
frm = prev[frm]
# frm->to方向に直す
path = path[::-1]
# 始点から終点までの最短経路, 始点からの最短距離
# print(*path)
return dist
# ベルマンフォード法 O(VE)
"""
負の閉路がなければ再訪問は起きないので,
最短経路の経由頂点数の最大値はV-1個となる。
最短経路の部分経路が最短経路でなければ置き換えて短縮可能になってしまうので,
最短経路の部分経路は経由頂点数が自身未満の最短経路である。
それを利用して経由頂点数が0..V-1までの最短経路で動的計画法をするイメージのようだ。
負の閉路から到達可能かの判定については,
最初の1回で-INFとなる始点を求めて, 残りV-1回で影響を拾う。
"""
def bellman_ford(start):
dist = [INF]*N
dist[start] = 0
# 最短経路を求める
for _ in range(N-1):
for dist_frm_to, frm, to in E:
if dist[frm] < INF:
dist[to] = min(dist[to], dist[frm]+dist_frm_to)
# 負の閉路(の始点となる-INF)発見
for dist_frm_to, frm, to in E:
if dist[frm] < INF and dist[frm]+dist_frm_to < dist[to]:
dist[to] = -INF
# 負の閉路から到達可能か
for _ in range(N-1):
for dist_frm_to, frm, to in E:
if dist[frm] == -INF:
dist[to] = -INF
return dist
# ワーシャル-フロイド法 O(V^3)
"""
全点対最短経路(すべての頂点からすべての頂点までの最短経路)を求める。
基本的に隣接行列でやるものとしている。
経由する頂点の候補を増やしていくDP。
これは回り道がどうとか考えないので, 負のコストが存在しても動作する。
"""
def warshall_floyd():
for via in range(N):
for frm in range(N):
for to in range(N):
G[frm][to] = min(G[frm][to], G[frm][via]+G[via][to])
# クラスカル法 O(ElogE)
"""
MST(最小全域木)のコスト総和を求める。
辺をコストの昇順にソートして貪欲にとる。
MSTは最小コストで全頂点を連結にすればよいので, すでに連結ならとらない。
"""
def kruskal():
UF = DSU(N)
ret = 0
for c, u, v in sorted(E):
if not UF.same(u, v):
UF.merge(u, v)
ret += c
# MSTが作れない場合
if UF.size(0) < N:
ret = INF
return ret
# プリム法 O(ElogE)
"""
MST(最小全域木)のコスト総和を求める。
ダイクストラ法のように訪問済みの頂点に隣接する辺のうち,
コストが最小の辺からとって, その先の頂点を訪問済みにしていく。
どの頂点からスタートしてもok.
"""
def prim():
ret = 0
visited = {0}
pq = []
for c, to in G[0]:
heappush(pq, (c, to))
while len(visited) < N and len(pq) > 0:
c, frm = heappop(pq)
if frm in visited:
continue
ret += c
visited.add(frm)
for c, to in G[frm]:
if to in visited:
continue
heappush(pq, (c, to))
# MSTが作れない場合
if len(visited) < N:
ret = INF
return ret
INF = 1<<60
ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
abc = "abcdefghijklmnopqrstuvwxyz"
MOD = 998244353
# 固有部分
N = int(input())
# 呼ぶ友人の数(ビット数)
for M in range(1, 9):
if 1<<M >= N:
break
print(M)
# ジュースの与え方
A = [[] for _ in range(M)]
for i in range(N):
for j in range(M):
m = 1<<j
if i&m > 0:
A[j].append(i+1)
for i in range(M):
K = len(A[i])
print(K, *A[i])
# 結果ビットの解釈
S = input()
X = int(S, 2)+1
print(X)
from collections import defaultdict, deque, Counter
from sortedcontainers import SortedSet, SortedList, SortedDict
from heapq import heappush, heappop
from atcoder.dsu import DSU
from atcoder.segtree import SegTree
# st = SegTree(lambda dt1,dt2: データ参照, 単位元, 元データ)
from atcoder.lazysegtree import LazySegTree
# lst = LazySegTree(lambda dt1,dt2: データ参照, 恒等写像, lambda lz,dt: データ更新, lambda lz1,lz2: 遅延伝播, 単位元, 元データ)
from bisect import bisect_left, bisect_right
from itertools import product, groupby, permutations, combinations
import math
from copy import copy, deepcopy
import sys
sys.setrecursionlimit(10000000)
# PyPy再帰高速化
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
# 切り上げ除算
# 絶対値の切り下げ/切り上げを反転する
def div_ceil(num, div):
return -(-num//div)
# ユークリッドの互除法 O(logN)
# 最大公約数(gcd)を求める
"""
gcdはaとbの約数の積集合
"""
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a%b != 0:
a, b = b, a%b
return b
# ユークリッドの互除法と約数集合 O(logN)
# 最小公倍数(lcm)を求める
"""
lcmはaとbの約数の和集合
ただし, lcm(3, 9) = 9のようになるので,
約数集合において1つ目の3と2つ目の3は別として扱うように,
同じ値でも何個目かによって区別する。
割り算は約数の引き算
1.aとbの約数集合を重ねる
2.ダブルカウントされた共通部分GCDを除く
補足: GCDで必ず割り切れるので先に割る
"""
def lcm(a, b):
GCD = gcd(a, b)
return a//GCD*b
# エラトステネスの篩 O(NloglogN)
# N未満の素数列挙
"""
素数の倍数の削除について, N/2+N/3+N/5... = N(1/2+1/3+1/5...)
N未満の素数の逆数和はloglogNになるらしいので, O(NloglogN)
O(NloglogN)がTLEするほど大きな結果をコードに埋め込むことはできない。
TLEしない10^6以下の素数列挙でもテキストのサイズが600kBほどになってしまうため。
"""
def eratosthenes_sieve(lim):
primes = set(range(3, lim, 2))
primes.add(2)
# iが素数か判定(奇数だけ見ていく)
for i in range(3, lim, 2):
if i in primes:
# 素数iの倍数を削除
for j in range(i*2, lim, i):
primes.discard(j)
return primes
# 試し割り法 O(√N)
# Nを素因数分解
"""
N = 10^16でO(10^8)でも424msなので, 実際はみかけより早い
N = 10^18でO(10^9)だと3009ms
N = 10^17だと1048msなので, この辺が限界
"""
def prime_factors(src):
# pf = {素因数p : 指数e}
pf = defaultdict(int)
now = src
i = 2
# src = i*j のときjがiより大きいなら既出なので√srcまで確認
while i*i <= src:
# 割り切れるなら割れるだけ割る
while now%i == 0:
now //= i
pf[i] += 1
i += 1
# それ以上分解できない残ったものを素因数に加える
if now > 1:
pf[now] += 1
return pf
# 累積和 O(N)
# imos法で使う場合は[l, r)のlに+v, rに-vして累積和で復元
# 区間和の取得をO(1)で行える
def pre_sum(src):
n = len(src)+1
pre_sum = [0]*n
for i in range(1, n):
pre_sum[i] = pre_sum[i-1]+src[i-1]
return pre_sum
# しゃくとり法 O(N)
"""
# l], (r
r = N-1
for l in range(N):
# 右の追い越し防止
while r > l and "ここにrを進める条件":
r -= 1
# 左の追い越し修正
if l > r:
r = l
# ここにメインの処理
"""
# 座標圧縮 O(N)
# 10 10 12 24 -> 0 0 1 2 (rankだと0 0 2 3)
def dense_rank(src):
# srcの重複を除いてソートして値と順位の対応を得る
d = {v:i for i, v in enumerate(sorted(set(src)))}
ret = [d[si] for si in src]
return ret
# ランレングス圧縮 O(N)
def rle(src):
return [(k, len(list(v))) for k, v in groupby(src)]
# 二分探索 O(logN)
"""
sより小さい最大値の位置を返す(挿入位置ではない)
sは必ず探索範囲内に存在するものとする
同じ値が存在する場合は最も右の値の位置を返す
"""
def binary_search(s):
# 半開区間[l, r)
l, r = 0, N
m = (l+r)//2
while r-l > 1:
if A[m] < s:
l = m
else:
r = m
m = (l+r)//2
print(m, l, r)
return m
# bitDP O(4^N) (種類をNとすると(2^N)^2 = 2^(N*2) = 4^N)
"""
選ぶ/選ばないの組合せを表すビットを状態にとる動的計画法
全ての選択肢に対してありうる全ての状態からの遷移を求める
下記のNは組合せのビット数なので注意
"""
def bit_dp(src):
# 元データの数を状態の数に圧縮する
src = Counter(src)
N = 2**len(src)
dp = [0]*N
# どれも選ばない場合が1通り
dp[0] = 1
for src_bits, cnt in src:
# 逆順に更新すれば1次元配列でも二重に更新されない
for frm_bits in range(N-1, -1, -1):
# srcから1つ以上選ぶ遷移, 爆発しないようにMODをとる
dp[frm_bits|src_bits] += (dp[frm_bits]*(2**cnt-1))%MOD
dp[frm_bits|src_bits] %= MOD
return dp
# 4隣接の取得
# "#"判定は呼び出し側
def get_4adjacent(i, j):
ret = []
# 時計回り
if 0 <= i-1 < H:
ret.append((i-1, j))
if 0 <= j+1 < W:
ret.append((i, j+1))
if 0 <= i+1 < H:
ret.append((i+1, j))
if 0 <= j-1 < W:
ret.append((i, j-1))
return ret
# 9隣接の取得
# "#"判定は呼び出し側
def get_9adjacent(frm):
ret = []
i, j = frm[0], frm[1]
d = (-1, 0, 1)
for di in d:
ii = i+di
for dj in d:
jj = j+dj
if ii == i and jj == j:
continue
if 0 <= ii < H and 0 <= jj < W:
ret.append((ii, jj))
return ret
# 3*3のグリッド(要素数9の配列)の縦横斜めがそろっているか判定(oxゲーム)
def judge_line(ox):
ret = "_"
for i in range(3):
# 横一列
if ox[i*3] == "o" and ox[i*3+1] == "o" and ox[i*3+2] == "o":
ret = "o"
break
if ox[i*3] == "x" and ox[i*3+1] == "x" and ox[i*3+2] == "x":
ret = "x"
break
# 縦一列
if ox[i] == "o" and ox[i+3] == "o" and ox[i+6] == "o":
ret = "o"
break
if ox[i] == "x" and ox[i+3] == "x" and ox[i+6] == "x":
ret = "x"
break
# 斜め(\, /)
if ox[0] == "o" and ox[4] == "o" and ox[8] == "o":
ret = "o"
if ox[0] == "x" and ox[4] == "x" and ox[8] == "x":
ret = "x"
if ox[2] == "o" and ox[4] == "o" and ox[6] == "o":
ret = "o"
if ox[2] == "x" and ox[4] == "x" and ox[6] == "x":
ret = "x"
return ret
"""
# 深さ優先探索(再帰) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(frm):
for to in G[frm]:
if dist[to] < INF:
continue
dist[to] = dist[frm]+1
dfs(to)
"""
# 深さ優先探索(行きがけのみ/スタック) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(start):
st = [start]
while st:
frm = st.pop()
for to in G[frm]:
if dist[to] < INF:
continue
# 行きがけ処理
dist[to] = dist[frm]+1
st.append(to)
# 深さ優先探索(行きがけ帰りがけ両対応/スタック) O(V+E)
# 根からの距離を求める
# 呼び出し側でdist = [INF]*N, dist[root] = 0
def dfs(start):
# 帰りがけ用頂点と行きがけ用頂点を用意する
st = [~start, start]
while st:
frm = st.pop()
if frm >= 0:
# 行きがけ処理
for to in G[frm]:
if dist[to] < INF:
continue
dist[to] = dist[frm]+1
st.append(~to)
st.append(to)
else:
# 帰りがけ処理
frm = ~frm
# ここに具体的な帰りがけ処理(再帰の戻り値でやるようなやつ)
# 自身を含む自身以下の部分木のコスト総和を求める
def subtree_cost_sum(start):
st = [~start, start]
while st:
frm = st.pop()
if frm >= 0:
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
st.append(~to)
st.append(to)
else:
frm = ~frm
# 帰りがけ順に処理されるので自身と直下の子のみ足せばよい
C_sum[frm] = C[frm]+sum([C_sum[to] for to in G[frm]])
# 木の重心を求める
"""
直線とウニとその間の木で考えても重心での距離総和が最小で,
重心で木を分解したときの部分木の頂点数の最大値の最小値はN//2以下。
複数N//2より大きいtoが存在すると考えると頂点数がNを超えて矛盾するためtoはfrmに対して1つ。
頂点数でなくコストでも同様のことが成り立つ。
"""
def centroid(start):
st = [start]
while st:
frm = st.pop()
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
if C_sum[to] > C_sum[0]//2:
st.append(to)
return frm
# 幅優先探索 O(V+E)
# BFSごとにリセットする場合: in_visited = defaultdict(bool)
def bfs(start):
q = deque([start])
while q:
frm = q.popleft()
visited[frm] = True
for to in G[frm]:
if visited[to]:
continue
visited[to] = True
q.append(to)
# ダイクストラ法 O((V+E)logV)
"""
単一始点最短経路(1つの頂点からすべての頂点までの最短経路)を求める。
ダイクストラ法のベースは幅優先探索。
最短距離が未確定の頂点のうち,
暫定最短距離が最短の頂点はその時点で距離が確定する。
その頂点は回り道したら必ず距離が暫定最短距離より大きくなるため。
負のコストが存在すると回り道した方がコストが小さくなる可能性があるため,
ダイクストラ法が使えない。
"""
def dijkstra(start):
# 各頂点の始点からの距離
dist = [INF]*N
dist[0] = 0
# 経路復元用の各頂点の最短経路における前の要素
prev = [-1]*N
# visited[i]: 最短距離確定済みか
visited = [False]*N
# (距離, 頂点)の優先度付きキュー
pq = [start]
while pq:
# 暫定距離最短の頂点の距離を確定してたどる
frm = heappop(pq)[1]
if visited[frm]:
continue
visited[frm] = True
for frm_to_dist, to in G[frm]:
# 暫定最短距離と前の頂点の更新
if dist[frm]+frm_to_dist < dist[to]:
dist[to] = dist[frm]+frm_to_dist
prev[to] = frm
heappush(pq, (dist[to], to))
# 最短経路を終点から遡って復元
# デフォルトの終点: N-1
path = [N-1]
frm = prev[path[0]]
while frm > -1:
path.append(frm)
frm = prev[frm]
# frm->to方向に直す
path = path[::-1]
# 始点から終点までの最短経路, 始点からの最短距離
# print(*path)
return dist
# ベルマンフォード法 O(VE)
"""
負の閉路がなければ再訪問は起きないので,
最短経路の経由頂点数の最大値はV-1個となる。
最短経路の部分経路が最短経路でなければ置き換えて短縮可能になってしまうので,
最短経路の部分経路は経由頂点数が自身未満の最短経路である。
それを利用して経由頂点数が0..V-1までの最短経路で動的計画法をするイメージのようだ。
負の閉路から到達可能かの判定については,
最初の1回で-INFとなる始点を求めて, 残りV-1回で影響を拾う。
"""
def bellman_ford(start):
dist = [INF]*N
dist[start] = 0
# 最短経路を求める
for _ in range(N-1):
for dist_frm_to, frm, to in E:
if dist[frm] < INF:
dist[to] = min(dist[to], dist[frm]+dist_frm_to)
# 負の閉路(の始点となる-INF)発見
for dist_frm_to, frm, to in E:
if dist[frm] < INF and dist[frm]+dist_frm_to < dist[to]:
dist[to] = -INF
# 負の閉路から到達可能か
for _ in range(N-1):
for dist_frm_to, frm, to in E:
if dist[frm] == -INF:
dist[to] = -INF
return dist
# ワーシャル-フロイド法 O(V^3)
"""
全点対最短経路(すべての頂点からすべての頂点までの最短経路)を求める。
基本的に隣接行列でやるものとしている。
経由する頂点の候補を増やしていくDP。
これは回り道がどうとか考えないので, 負のコストが存在しても動作する。
"""
def warshall_floyd():
for via in range(N):
for frm in range(N):
for to in range(N):
G[frm][to] = min(G[frm][to], G[frm][via]+G[via][to])
# クラスカル法 O(ElogE)
"""
MST(最小全域木)のコスト総和を求める。
辺をコストの昇順にソートして貪欲にとる。
MSTは最小コストで全頂点を連結にすればよいので, すでに連結ならとらない。
"""
def kruskal():
UF = DSU(N)
ret = 0
for c, u, v in sorted(E):
if not UF.same(u, v):
UF.merge(u, v)
ret += c
# MSTが作れない場合
if UF.size(0) < N:
ret = INF
return ret
# プリム法 O(ElogE)
"""
MST(最小全域木)のコスト総和を求める。
ダイクストラ法のように訪問済みの頂点に隣接する辺のうち,
コストが最小の辺からとって, その先の頂点を訪問済みにしていく。
どの頂点からスタートしてもok.
"""
def prim():
ret = 0
visited = {0}
pq = []
for c, to in G[0]:
heappush(pq, (c, to))
while len(visited) < N and len(pq) > 0:
c, frm = heappop(pq)
if frm in visited:
continue
ret += c
visited.add(frm)
for c, to in G[frm]:
if to in visited:
continue
heappush(pq, (c, to))
# MSTが作れない場合
if len(visited) < N:
ret = INF
return ret
INF = 1<<60
ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
abc = "abcdefghijklmnopqrstuvwxyz"
MOD = 998244353
# 固有部分
N = int(input())
# 呼ぶ友人の数(ビット数)
for M in range(1, 9):
if 1<<M >= N:
break
print(M)
# ジュースの与え方
A = [[] for _ in range(M)]
for i in range(N):
for j in range(M):
m = 1<<j
if i&m > 0:
A[j].append(i+1)
for i in range(M):
K = len(A[i])
print(K, *A[i])
# 結果ビットの解釈
S = input()[::-1]
X = int(S, 2)+1
print(X)
|
ConDefects/ConDefects/Code/abc337_e/Python/53462087
|
condefects-python_data_580
|
N = int(input())
n = 1
while n**2<N:n+=1
out = [[i+1 for i in range(N) if (1<<b)&i] for b in range(n)]
print(len(out),flush=True)
for q in out:
print(len(q),*q,flush=True)
ret = [*map(int,input())]
ans = 1
for n in range(len(ret)):
if ret[n]==1 : ans += 1<<n
print(ans,flush=True)
N = int(input())
n = 1
while 2**n<N:n+=1
out = [[i+1 for i in range(N) if (1<<b)&i] for b in range(n)]
print(len(out),flush=True)
for q in out:
print(len(q),*q,flush=True)
ret = [*map(int,input())]
ans = 1
for n in range(len(ret)):
if ret[n]==1 : ans += 1<<n
print(ans,flush=True)
|
ConDefects/ConDefects/Code/abc337_e/Python/54032860
|
condefects-python_data_581
|
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
hash_mod = 2147483647
dpos4 = ((1, 0), (0, 1), (-1, 0), (0, -1))
dpos8 = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
def main():
N = ii()
M = (N-1).bit_length()
print(M,flush=True)
for i in range(M):
a = []
for j in range(N):
if (j >> i) & 1:
a.append(j+1)
print(len(a),*a,flush=True)
S = input()
ans = int(S,2)
print(ans,flush=True)
if __name__ == '__main__':
main()
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
hash_mod = 2147483647
dpos4 = ((1, 0), (0, 1), (-1, 0), (0, -1))
dpos8 = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
def main():
N = ii()
M = (N-1).bit_length()
print(M,flush=True)
for i in range(M):
a = []
for j in range(N):
if (j >> i) & 1:
a.append(j+1)
print(len(a),*a,flush=True)
S = input()
ans = int(S[::-1],2) + 1
print(ans,flush=True)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc337_e/Python/53016983
|
condefects-python_data_582
|
import sys
from array import array
input = lambda: sys.stdin.buffer.readline().decode().rstrip()
inp = lambda dtype: [dtype(x) for x in input().split()]
debug = lambda *x: print(*x, file=sys.stderr)
sum_n = lambda n: (n * (n + 1)) // 2
get_bit = lambda x, i: (x >> i) & 1
get_col = lambda arr, i: [row[i] for row in arr]
ceil_ = lambda a, b: a // b if (a >= 0) ^ (b > 0) else (abs(a) + abs(b) - 1) // abs(b)
Mint, Mlong, out = 2 ** 30 - 1, 2 ** 62 - 1, []
dx = array('b', [0, 1, 0, -1, 1, -1, 1, -1])
dy = array('b', [1, 0, -1, 0, 1, -1, -1, 1])
for _ in range(1):
# interactive
def ask(q) -> int:
sys.stdout.write(q)
sys.stdout.write('\n')
sys.stdout.flush()
ret = int(input())
if ret == -1: exit()
return ret
def answer(q):
sys.stdout.write(q)
sys.stdout.write('\n')
sys.stdout.flush()
n = int(input())
lg = len(bin(n - 1)[2:])
answer(f'{lg}')
for i in range(lg):
tem = []
for j in range(n):
if get_bit(j, i): tem.append(j + 1)
answer(' '.join(map(str, [len(tem)] + tem)))
s = input()[::-1]
answer(str(int(s, 2)))
# print('\n'.join(map(str, out)))
import sys
from array import array
input = lambda: sys.stdin.buffer.readline().decode().rstrip()
inp = lambda dtype: [dtype(x) for x in input().split()]
debug = lambda *x: print(*x, file=sys.stderr)
sum_n = lambda n: (n * (n + 1)) // 2
get_bit = lambda x, i: (x >> i) & 1
get_col = lambda arr, i: [row[i] for row in arr]
ceil_ = lambda a, b: a // b if (a >= 0) ^ (b > 0) else (abs(a) + abs(b) - 1) // abs(b)
Mint, Mlong, out = 2 ** 30 - 1, 2 ** 62 - 1, []
dx = array('b', [0, 1, 0, -1, 1, -1, 1, -1])
dy = array('b', [1, 0, -1, 0, 1, -1, -1, 1])
for _ in range(1):
# interactive
def ask(q) -> int:
sys.stdout.write(q)
sys.stdout.write('\n')
sys.stdout.flush()
ret = int(input())
if ret == -1: exit()
return ret
def answer(q):
sys.stdout.write(q)
sys.stdout.write('\n')
sys.stdout.flush()
n = int(input())
lg = len(bin(n - 1)[2:])
answer(f'{lg}')
for i in range(lg):
tem = []
for j in range(n):
if get_bit(j, i): tem.append(j + 1)
answer(' '.join(map(str, [len(tem)] + tem)))
s = input()[::-1]
answer(str(int(s, 2) + 1))
# print('\n'.join(map(str, out)))
|
ConDefects/ConDefects/Code/abc337_e/Python/55158609
|
condefects-python_data_583
|
n = int(input())
print("Yes" if n > 2 else "No")
n = int(input())
print("No" if 2 <= n <= 4 else "Yes")
|
ConDefects/ConDefects/Code/abc238_a/Python/46161245
|
condefects-python_data_584
|
import math
n=int(input())
if n>5:
print("Yes")
else:
print("No")
import math
n=int(input())
if n>4 or n==1:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc238_a/Python/44611745
|
condefects-python_data_585
|
n = int(input())
if n**2 > 2**n:
print("Yes")
else:
print("No")
n = int(input())
if 2**n > n**2:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc238_a/Python/45742753
|
condefects-python_data_586
|
n = int(input())
if n == 2 or n == 3:
print("No")
else:
print("Yes")
n = int(input())
if n == 2 or n == 3 or n == 4:
print("No")
else:
print("Yes")
|
ConDefects/ConDefects/Code/abc238_a/Python/45663153
|
condefects-python_data_587
|
N = int(input())
if 2**N>N:
print("Yes")
else:
print("No")
N = int(input())
if 2**N>N**2:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc238_a/Python/45742740
|
condefects-python_data_588
|
N = int(input())
if N > 4:
print("Yes")
else:
print("No")
N = int(input())
if N > 4 or N == 1:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc238_a/Python/45807737
|
condefects-python_data_589
|
n = int(input())
if n >= 5:
print("Yes")
else:
print("No")
n = int(input())
if n >= 5 or n == 1:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc238_a/Python/45016565
|
condefects-python_data_590
|
# 278a
n, k = map(int, input().split())
li = list(map(int, input().split()))
for i in range(k):
li.pop(0)
li.append(0)
print(li)
# 278a
n, k = map(int, input().split())
li = list(map(int, input().split()))
for i in range(k):
li.pop(0)
li.append(0)
print(*li)
|
ConDefects/ConDefects/Code/abc278_a/Python/45019575
|
condefects-python_data_591
|
# coding: utf-8
from functools import partial
try:
dummy = src
rl = partial(src.pop, 0)
except NameError:
rl = input
def ints():
return list(map(int, rl().strip().split()))
def int1():
return int(rl().strip())
#@psecs
def main():
n, k = ints()
aa = ints()
print(locals())
if n > k:
bb = aa[k:] + [0] * k
else:
bb = [0] * n
print(*bb)
if __name__ == '__main__':
main()
# coding: utf-8
from functools import partial
try:
dummy = src
rl = partial(src.pop, 0)
except NameError:
rl = input
def ints():
return list(map(int, rl().strip().split()))
def int1():
return int(rl().strip())
#@psecs
def main():
n, k = ints()
aa = ints()
# print(locals())
if n > k:
bb = aa[k:] + [0] * k
else:
bb = [0] * n
print(*bb)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc278_a/Python/45577064
|
condefects-python_data_592
|
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
if N <= K:
print(*([0] * N))
else:
print(*(A[K:] + [0] * (N - K + 1)))
if __name__ == "__main__":
main()
def main():
N, K = map(int, input().split())
A = list(map(int, input().split()))
if N <= K:
print(*([0] * N))
else:
print(*(A[K:] + [0] * K))
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc278_a/Python/46183354
|
condefects-python_data_593
|
a, b = map(int, input().split())
while a > 0 and b > 0:
if (a % 10) + (b % 10) >= 10:
print("Hard")
break
a //= 10
b //= 10
print("Easy")
a, b = map(int, input().split())
while a > 0 and b > 0:
if (a % 10) + (b % 10) >= 10:
print("Hard")
exit()
a //= 10
b //= 10
print("Easy")
|
ConDefects/ConDefects/Code/abc229_b/Python/45280624
|
condefects-python_data_594
|
import sys
a, b = input().split()
n = min(len(a), len(b))
for i in range(1, n):
if int(a[-i])+int(b[-i]) > 9:
print("Hard")
sys.exit()
print("Easy")
import sys
a, b = input().split()
n = min(len(a), len(b))
for i in range(1, n+1):
if int(a[-i])+int(b[-i]) > 9:
print("Hard")
sys.exit()
print("Easy")
|
ConDefects/ConDefects/Code/abc229_b/Python/44815699
|
condefects-python_data_595
|
import heapq
n,k = map(int, input().split())
P = list(map(int, input().split()))
q = P[:k]
heapq.heapify(q)
print(q)
a = heapq.heappop(q)
prev = a
print(a)
for i in range(k,n):
heapq.heappush(q, P[i])
a = heapq.heappop(q)
if prev < a:
prev = a
print(a)
else:
print(prev)
import heapq
n,k = map(int, input().split())
P = list(map(int, input().split()))
q = P[:k]
heapq.heapify(q)
# print(q)
a = heapq.heappop(q)
prev = a
print(a)
for i in range(k,n):
heapq.heappush(q, P[i])
a = heapq.heappop(q)
if prev < a:
prev = a
print(a)
else:
print(prev)
|
ConDefects/ConDefects/Code/abc234_d/Python/54691667
|
condefects-python_data_596
|
num = 3*10**6 + 1
frac = [1] * num
inv_frac = [1] * num
MOD = 998244353
for i in range(2, num):
frac[i] = (frac[i-1] * i) % MOD
inv_frac[-1] = pow(frac[-1], MOD-2, MOD)
for i in range(num-1, 0, -1):
inv_frac[i-1] = (inv_frac[i] * i) % MOD
def comb(n, r):
if r < 0 or r > n:
return 0
return (frac[n] * (inv_frac[n-r] * inv_frac[r])%MOD) % MOD
R, G, B, K = map(int, input().split())
R -= K
G -= K
ans = 1
ans *= comb(R+B+K, B)
ans *= comb(R+B, K)
ans %= MOD
ans *= comb(B+K+1+G-1, G)
ans %= MOD
print(ans)
num = 3*10**6 + 1
frac = [1] * num
inv_frac = [1] * num
MOD = 998244353
for i in range(2, num):
frac[i] = (frac[i-1] * i) % MOD
inv_frac[-1] = pow(frac[-1], MOD-2, MOD)
for i in range(num-1, 0, -1):
inv_frac[i-1] = (inv_frac[i] * i) % MOD
def comb(n, r):
if r < 0 or r > n:
return 0
return (frac[n] * (inv_frac[n-r] * inv_frac[r])%MOD) % MOD
R, G, B, K = map(int, input().split())
R -= K
G -= K
ans = 1
ans *= comb(R+B+K, B)
ans *= comb(R+K, K)
ans %= MOD
ans *= comb(B+K+1+G-1, G)
ans %= MOD
print(ans)
|
ConDefects/ConDefects/Code/abc266_g/Python/44683031
|
condefects-python_data_597
|
n=int(input())
a=list(map(int,input().split()))
t=[]
for i in a:
if len(t)==0 or t[-1][0]!=i:
t.append([i,1])
else:
t[-1][1]+=1
mx0=0
mx1=0
c0=0
c1=1
ind0=0
ind1=0
for i in range(n):
c0=max(c0,0)
c1=max(c1,0)
if a[i]==0:
c0+=1
c1-=1
else:
c1+=1
c0-=1
mx0=max(mx0,c0)
mx1=max(mx1,c1)
print(mx0+mx1+1)
n=int(input())
a=list(map(int,input().split()))
t=[]
for i in a:
if len(t)==0 or t[-1][0]!=i:
t.append([i,1])
else:
t[-1][1]+=1
mx0=0
mx1=0
c0=0
c1=0
ind0=0
ind1=0
for i in range(n):
c0=max(c0,0)
c1=max(c1,0)
if a[i]==0:
c0+=1
c1-=1
else:
c1+=1
c0-=1
mx0=max(mx0,c0)
mx1=max(mx1,c1)
print(mx0+mx1+1)
|
ConDefects/ConDefects/Code/arc137_b/Python/44650081
|
condefects-python_data_598
|
import math
C = 12800000
h = int(input())
print(math.sqrt(h + (h + C)))
import math
C = 12800000
h = int(input())
print(math.sqrt(h * (h + C)))
|
ConDefects/ConDefects/Code/abc239_a/Python/46183850
|
condefects-python_data_599
|
h=int(input())
a=(h*(12800000+h))**(1//2)
print(a)
h=int(input())
a=(h*(12800000+h))**(0.5)
print(a)
|
ConDefects/ConDefects/Code/abc239_a/Python/45076480
|
condefects-python_data_600
|
H = int(input())
print((H*(12800000+H))*0.5)
H = int(input())
print((H*(12800000+H))**0.5)
|
ConDefects/ConDefects/Code/abc239_a/Python/45807134
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.