id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_201 | from heapq import heappop,heappush
import sys
read = sys.stdin.buffer.read
N,M,*DATA = map(int,read().split())
ST = DATA[:2*M]
it = iter(DATA[2*M:])
LR = [[0,0]]
for l,r in zip(it,it):
LR.append([l,r])
links = [[] for _ in range(N+1)]
links_rev = [[] for _ in range(N+1)]
it = iter(ST)
for s,t in zip(it,it):
links[s].append(t)
links_rev[t].append(s)
# DAG判定 & L修正
deg = [len(x) for x in links_rev]
stack = []
for i in range(1,N+1):
if deg[i] == 0:
stack.append(i)
while stack:
i = stack.pop()
for j in links[i]:
deg[j] -= 1
if deg[j] == 0:
stack.append(j)
ls = []
for k in links_rev[j]:
ls.append(LR[k][0])
ls.sort()
for idx in range(len(ls)-1):
if ls[idx+1] <= ls[idx]:
ls[idx+1] = ls[idx] + 1
LR[j][0] = ls[-1]+1
if sum(deg) != 0:
print('No')
exit()
# 上から決めていく
deg = [len(x) for x in links]
stack_r = [[] for _ in range(N+1)]
for i in range(1,N+1):
if deg[i] == 0:
li,ri = LR[i]
if li > ri:
print('No')
exit()
stack_r[ri].append(i)
hq = []
ans = [0] * (N+1)
base = (1<<20) - 1
for x in range(N,0,-1):
while stack_r[x]:
i = stack_r[x].pop()
li = LR[i][0]
num = (li << 20) + i
num *= -1
heappush(hq, num)
if len(hq) == 0:
print('No')
exit()
num = heappop(hq) * -1
li = num >> 20
i = num & base
if li > x:
print('No')
exit()
ans[i] = x
for j in links_rev[i]:
deg[j] -= 1
if deg[j] == 0:
lj,rj = LR[j]
if lj > rj:
print('No')
exit()
if rj >= x:
num = (lj << 20) + j
num *= -1
heappush(hq, num)
else:
stack_r[rj].append(j)
# check
for i in range(1,N+1):
li,ri = LR[i]
if li <= ans[i] <= ri:
continue
print('No')
exit()
print('Yes')
print(*ans[1:])
from heapq import heappop,heappush
import sys
read = sys.stdin.buffer.read
N,M,*DATA = map(int,read().split())
ST = DATA[:2*M]
it = iter(DATA[2*M:])
LR = [[0,0]]
for l,r in zip(it,it):
LR.append([l,r])
links = [[] for _ in range(N+1)]
links_rev = [[] for _ in range(N+1)]
it = iter(ST)
for s,t in zip(it,it):
links[s].append(t)
links_rev[t].append(s)
# DAG判定 & L修正
deg = [len(x) for x in links_rev]
stack = []
for i in range(1,N+1):
if deg[i] == 0:
stack.append(i)
while stack:
i = stack.pop()
for j in links[i]:
deg[j] -= 1
if deg[j] == 0:
stack.append(j)
ls = []
for k in links_rev[j]:
ls.append(LR[k][0])
ls.sort()
for idx in range(len(ls)-1):
if ls[idx+1] <= ls[idx]:
ls[idx+1] = ls[idx] + 1
LR[j][0] = max(LR[j][0], ls[-1]+1)
if sum(deg) != 0:
print('No')
exit()
# 上から決めていく
deg = [len(x) for x in links]
stack_r = [[] for _ in range(N+1)]
for i in range(1,N+1):
if deg[i] == 0:
li,ri = LR[i]
if li > ri:
print('No')
exit()
stack_r[ri].append(i)
hq = []
ans = [0] * (N+1)
base = (1<<20) - 1
for x in range(N,0,-1):
while stack_r[x]:
i = stack_r[x].pop()
li = LR[i][0]
num = (li << 20) + i
num *= -1
heappush(hq, num)
if len(hq) == 0:
print('No')
exit()
num = heappop(hq) * -1
li = num >> 20
i = num & base
if li > x:
print('No')
exit()
ans[i] = x
for j in links_rev[i]:
deg[j] -= 1
if deg[j] == 0:
lj,rj = LR[j]
if lj > rj:
print('No')
exit()
if rj >= x:
num = (lj << 20) + j
num *= -1
heappush(hq, num)
else:
stack_r[rj].append(j)
# check
for i in range(1,N+1):
li,ri = LR[i]
if li <= ans[i] <= ri:
continue
print('No')
exit()
print('Yes')
print(*ans[1:]) | ConDefects/ConDefects/Code/abc304_h/Python/42019155 |
condefects-python_data_202 | import os,sys
from io import BytesIO, IOBase
sys.setrecursionlimit(10**6)
from typing import *
# only use pypyjit when needed, it usese more memory, but speeds up recursion in pypy
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# sys.stdout = open('output.txt', 'w')
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import deque
from heapq import heappush, heappop
def main():
n, m = map(int, input().split())
indegrees = [0] * (n + 1)
outdegrees = [0] * (n + 1)
adj_list = [[] for _ in range(n + 1)]
rev_adj_list = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = map(int, input().split())
adj_list[u].append(v)
rev_adj_list[v].append(u)
indegrees[v] += 1
outdegrees[u] += 1
print('indegrees', indegrees)
lranges, rranges = [0] * (n + 1), [0] * (n + 1)
for i in range(1, n + 1):
left, right = map(int, input().split())
lranges[i], rranges[i] = left, right
# reverse topological sort
queue = deque()
for i in range(1, n + 1):
if outdegrees[i] == 0:
queue.append(i)
while queue:
node = queue.popleft()
for nei in rev_adj_list[node]:
outdegrees[nei] -= 1
rranges[nei] = min(rranges[nei], rranges[node] - 1)
if outdegrees[nei] == 0:
queue.append(nei)
# topological sort
res = [0] * (n + 1)
p = 1
ready, not_ready = [], []
for i in range(1, n + 1):
if indegrees[i] == 0:
if lranges[i] > p: heappush(not_ready, (lranges[i], i))
else: heappush(ready, (rranges[i], i))
while ready:
# print('ready', ready, 'not_ready', not_ready)
right, node = heappop(ready)
if p > right:
print("No")
return
res[node] = p
# print('node', node, 'p', p)
p += 1
while not_ready and not_ready[0][0] <= p:
_, n1 = heappop(not_ready)
heappush(ready, (rranges[n1], n1))
for nei in adj_list[node]:
indegrees[nei] -= 1
if indegrees[nei] == 0:
if lranges[nei] > p: heappush(not_ready, (lranges[nei], nei))
else: heappush(ready, (rranges[nei], nei))
if p <= n:
print("No")
return
print("Yes")
print(*res[1:])
if __name__ == '__main__':
main()
import os,sys
from io import BytesIO, IOBase
sys.setrecursionlimit(10**6)
from typing import *
# only use pypyjit when needed, it usese more memory, but speeds up recursion in pypy
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# sys.stdout = open('output.txt', 'w')
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import deque
from heapq import heappush, heappop
def main():
n, m = map(int, input().split())
indegrees = [0] * (n + 1)
outdegrees = [0] * (n + 1)
adj_list = [[] for _ in range(n + 1)]
rev_adj_list = [[] for _ in range(n + 1)]
for _ in range(m):
u, v = map(int, input().split())
adj_list[u].append(v)
rev_adj_list[v].append(u)
indegrees[v] += 1
outdegrees[u] += 1
# print('indegrees', indegrees)
lranges, rranges = [0] * (n + 1), [0] * (n + 1)
for i in range(1, n + 1):
left, right = map(int, input().split())
lranges[i], rranges[i] = left, right
# reverse topological sort
queue = deque()
for i in range(1, n + 1):
if outdegrees[i] == 0:
queue.append(i)
while queue:
node = queue.popleft()
for nei in rev_adj_list[node]:
outdegrees[nei] -= 1
rranges[nei] = min(rranges[nei], rranges[node] - 1)
if outdegrees[nei] == 0:
queue.append(nei)
# topological sort
res = [0] * (n + 1)
p = 1
ready, not_ready = [], []
for i in range(1, n + 1):
if indegrees[i] == 0:
if lranges[i] > p: heappush(not_ready, (lranges[i], i))
else: heappush(ready, (rranges[i], i))
while ready:
# print('ready', ready, 'not_ready', not_ready)
right, node = heappop(ready)
if p > right:
print("No")
return
res[node] = p
# print('node', node, 'p', p)
p += 1
while not_ready and not_ready[0][0] <= p:
_, n1 = heappop(not_ready)
heappush(ready, (rranges[n1], n1))
for nei in adj_list[node]:
indegrees[nei] -= 1
if indegrees[nei] == 0:
if lranges[nei] > p: heappush(not_ready, (lranges[nei], nei))
else: heappush(ready, (rranges[nei], nei))
if p <= n:
print("No")
return
print("Yes")
print(*res[1:])
if __name__ == '__main__':
main() | ConDefects/ConDefects/Code/abc304_h/Python/42210009 |
condefects-python_data_203 | n, k = map(int,input().split())
A = list(map(int,input().split()))
seen = [-1]*n
now_pos = 0
candy = [0]
cnt = 0
while seen[now_pos] == -1:
seen[now_pos] = cnt
candy.append(candy[-1] + A[now_pos])
cnt += 1
if cnt == k:
print(candy[-1])
exit()
now_pos = candy[-1] % n
start_loop = seen[now_pos]
loop_len = cnt - seen[now_pos]
start_candy = candy[start_loop]
loop_candy = candy[cnt] - start_candy
#print(seen, candy)
#print(start_loop, start_candy, loop_len, loop_candy)
ans = start_candy + (k-start_loop)//loop_len*loop_candy
rem = (k-start_loop)%loop_len
now = start_loop
for _ in range(rem):
ans += A[now]
now = ans % n
print(ans)
n, k = map(int,input().split())
A = list(map(int,input().split()))
seen = [-1]*n
now_pos = 0
candy = [0]
cnt = 0
while seen[now_pos] == -1:
seen[now_pos] = cnt
candy.append(candy[-1] + A[now_pos])
cnt += 1
if cnt == k:
print(candy[-1])
exit()
now_pos = candy[-1] % n
start_loop = seen[now_pos]
loop_len = cnt - seen[now_pos]
start_candy = candy[start_loop]
loop_candy = candy[cnt] - start_candy
#print(seen, candy)
#print(start_loop, start_candy, loop_len, loop_candy)
ans = start_candy + (k-start_loop)//loop_len*loop_candy
rem = (k-start_loop)%loop_len
now = candy[start_loop]%n
for _ in range(rem):
ans += A[now]
now = ans % n
print(ans) | ConDefects/ConDefects/Code/abc241_e/Python/45018675 |
condefects-python_data_204 | """
Author ankisho
Created 2023/09/10 22:47JST
"""
N,K = map(int,input().split())
A = list(map(int,input().split()))
nset = set()#すでに出現したあまり
ls = []
ncandy = 0
while True:
idx = ncandy%N
if idx in nset:
cycle_st = idx
break
else:
ls.append(idx)
nset.add(idx)
ncandy += A[idx]
#lsを周期前後で分ける
for i in range(len(ls)):
if ls[i] == cycle_st:
befcycle = ls[:i]
aftcycle = ls[i:]
#周期前の飴の個数の累積和
befS = [0]*(len(befcycle)+1)
for i in range(len(befcycle)): befS[i+1]=befS[i]+A[befcycle[i]]
#周期入った後の飴の個数の累積和
aftS = [0]*(len(aftcycle)+1)
for i in range(len(aftcycle)): aftS[i+1]=aftS[i]+A[aftcycle[i]]
#print(befcycle,befS)
#print(aftcycle,aftS)
#答えの出力
ans = 0
ans +=befS[min(len(befcycle),K)]
ans +=aftS[len(aftcycle)]*((K-len(befcycle))//len(aftcycle))
ans +=aftS[max(K-len(befcycle),0)%len(aftcycle)]
print(ans)
"""
Author ankisho
Created 2023/09/10 22:47JST
"""
N,K = map(int,input().split())
A = list(map(int,input().split()))
nset = set()#すでに出現したあまり
ls = []
ncandy = 0
while True:
idx = ncandy%N
if idx in nset:
cycle_st = idx
break
else:
ls.append(idx)
nset.add(idx)
ncandy += A[idx]
#lsを周期前後で分ける
for i in range(len(ls)):
if ls[i] == cycle_st:
befcycle = ls[:i]
aftcycle = ls[i:]
#周期前の飴の個数の累積和
befS = [0]*(len(befcycle)+1)
for i in range(len(befcycle)): befS[i+1]=befS[i]+A[befcycle[i]]
#周期入った後の飴の個数の累積和
aftS = [0]*(len(aftcycle)+1)
for i in range(len(aftcycle)): aftS[i+1]=aftS[i]+A[aftcycle[i]]
#print(befcycle,befS)
#print(aftcycle,aftS)
#答えの出力
ans = 0
ans +=befS[min(len(befcycle),K)]
ans +=aftS[len(aftcycle)]*(max(K-len(befcycle),0)//len(aftcycle))
ans +=aftS[max(K-len(befcycle),0)%len(aftcycle)]
print(ans)
| ConDefects/ConDefects/Code/abc241_e/Python/45450212 |
condefects-python_data_205 | def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC241 E 1248 - Putting Candies
# 長さ N の数列 A = (A0,A1,…,A_{N-1}) が与えられます。
# 最初の時点では空の皿があり、高橋君は次の操作を K 回繰り返します。
# ・皿の中のアメの個数を X とする。皿に A_(X mod N) 個のアメを追加する。
# K 回の操作の後で、皿の中には何個のアメがあるか求めてください。
# ・2 ≤ N ≤ 2×10^5
# ・1 ≤ K ≤ 10^12
# ・1 ≤ Ai ≤ 10^6
N, K = mp()
A = lmp()
X = 0
fst = [-1] * N
# first[x]: xに始めてなる操作回数
fst[0] = 0
for i in range(1, N+1):
X += A[X % N]
K -= 1
if fst[X % N] == -1:
fst[X % N] = i
else:
loop = i - fst[X % N]
# 2回目のとき loop を定義する
break
if K == 0:
exit(print(X))
while K % loop != 0:
# Kがloopで割り切れるまで操作を繰り返す
K -= 1
X += A[X % N]
if K == 0:
exit(print(0))
loop_sum = 0
for _ in range(loop):
# loop 1回分を計算する
K -= 1
loop_sum += A[X % N]
X += A[X % N]
X += loop_sum * (K // loop)
# 繰り返しの分を加える
print(X)
def ip():return int(input())
def mp():return map(int, input().split())
def lmp():return list(map(int, input().split()))
# ABC241 E 1248 - Putting Candies
# 長さ N の数列 A = (A0,A1,…,A_{N-1}) が与えられます。
# 最初の時点では空の皿があり、高橋君は次の操作を K 回繰り返します。
# ・皿の中のアメの個数を X とする。皿に A_(X mod N) 個のアメを追加する。
# K 回の操作の後で、皿の中には何個のアメがあるか求めてください。
# ・2 ≤ N ≤ 2×10^5
# ・1 ≤ K ≤ 10^12
# ・1 ≤ Ai ≤ 10^6
N, K = mp()
A = lmp()
X = 0
fst = [-1] * N
# first[x]: xに始めてなる操作回数
fst[0] = 0
for i in range(1, N+1):
X += A[X % N]
K -= 1
if fst[X % N] == -1:
fst[X % N] = i
else:
loop = i - fst[X % N]
# 2回目のとき loop を定義する
break
if K == 0:
exit(print(X))
while K % loop != 0:
# Kがloopで割り切れるまで操作を繰り返す
K -= 1
X += A[X % N]
if K == 0:
exit(print(X))
loop_sum = 0
for _ in range(loop):
# loop 1回分を計算する
K -= 1
loop_sum += A[X % N]
X += A[X % N]
X += loop_sum * (K // loop)
# 繰り返しの分を加える
print(X)
| ConDefects/ConDefects/Code/abc241_e/Python/46162583 |
condefects-python_data_206 | import math
MOD = 998244353
def main():
n = int(input())
k = math.floor(math.log10(n)) + 1
y = pow(10**k - 1, MOD - 2, MOD)
ans = ((n % MOD) * (pow(10, n * k, MOD) - 1) * y) % MOD
print(ans)
if __name__ == "__main__":
main()
import math
MOD = 998244353
def main():
n = int(input())
k = len(str(n))
y = pow(10**k - 1, MOD - 2, MOD)
ans = ((n % MOD) * (pow(10, n * k, MOD) - 1) * y) % MOD
print(ans)
if __name__ == "__main__":
main()
| ConDefects/ConDefects/Code/abc357_d/Python/54944133 |
condefects-python_data_207 | def Arithmetic_Sequence_Sum(N,first_term,common_ratio,mod):
return first_term*(Matrix(matrix=[[common_ratio,1],[0,1]],mod=mod)@N)[0][1]%mod
class Matrix:
def __init__(self,H=0,W=0,matrix=False,eps=0,mod=0,identity=0):
if identity:
if H:
self.H=H
self.W=H
else:
self.H=W
self.W=W
self.matrix=[[0]*self.W for i in range(self.H)]
for i in range(self.H):
self.matrix[i][i]=identity
elif matrix:
self.matrix=matrix
self.H=len(self.matrix)
self.W=len(self.matrix[0]) if self.matrix else 0
else:
self.H=H
self.W=W
self.matrix=[[0]*self.W for i in range(self.H)]
self.mod=mod
self.eps=eps
def __eq__(self,other):
if type(other)!=Matrix:
return False
if self.H!=other.H:
return False
if self.mod:
for i in range(self.H):
for j in range(self.W):
if self.matrix[i][j]%self.mod!=other.matrix[i][j]%self.mod:
return False
else:
for i in range(self.H):
for j in range(self.W):
if self.eps<abs(self.matrix[i][j]-other.matrix[i][j]):
return False
return True
def __ne__(self,other):
if type(other)!=Matrix:
return True
if self.H!=other.H:
return True
if self.mod:
for i in range(self.H):
for j in range(self.W):
if self.matrix[i][j]%self.mod!=other.matrix[i][j]%self.mod:
return True
else:
for i in range(self.H):
for j in range(self.W):
if self.eps<abs(self.matrix[i][j]-other.matrix[i][j]):
return True
return False
def __add__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
summ=Matrix(matrix=[[(self.matrix[i][j]+other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
summ=Matrix(matrix=[[self.matrix[i][j]+other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
summ=Matrix(matrix=[[(self.matrix[i][j]+other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
summ=Matrix(matrix=[[self.matrix[i][j]+other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return summ
def __sub__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
diff=Matrix(matrix=[[(self.matrix[i][j]-other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
diff=Matrix(matrix=[[self.matrix[i][j]-other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
diff=Matrix(matrix=[[(self.matrix[i][j]-other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
diff=Matrix(matrix=[[self.matrix[i][j]-other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return diff
def __mul__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
prod=Matrix(matrix=[[(self.matrix[i][j]*other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(matrix=[[self.matrix[i][j]*other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
prod=Matrix(matrix=[[(self.matrix[i][j]*other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(matrix=[[self.matrix[i][j]*other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return prod
def __matmul__(self,other):
if type(other)==Matrix:
assert self.W==other.H
prod=Matrix(H=self.H,W=other.W,eps=self.eps,mod=self.mod)
for i in range(self.H):
for j in range(other.W):
for k in range(self.W):
prod.matrix[i][j]+=self.matrix[i][k]*other.matrix[k][j]
if self.mod:
prod.matrix[i][j]%=self.mod
elif type(other)==int:
assert self.H==self.W
if other==0:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
elif other==1:
prod=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
doub=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
while other>=2:
if other&1:
prod@=doub
doub@=doub
other>>=1
prod@=doub
return prod
def __truediv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
quot=Matrix(matrix=[[(self.matrix[i][j]*MOD(self.mod).Pow(other.matrix[i][j],-1))%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]/other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
quot=Matrix(matrix=[[(self.matrix[i][j]*inve)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]/other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return quot
def __floordiv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
quot=Matrix(matrix=[[self.matrix[i][j]//other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]//other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return quot
def __mod__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
rema=Matrix(matrix=[[self.matrix[i][j]%other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
rema=Matrix(matrix=[[self.matrix[i][j]%other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return rema
def __pow__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other.matrix[i][j],self.mod) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other.matrix[i][j]) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other,self.mod) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return powe
def __lshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
lshi=Matrix(matrix=[[self.matrix[i][j]<<other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
lshi=Matrix(matrix=[[self.matrix[i][j]<<other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return lshi
def __rshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
rshi=Matrix(matrix=[[self.matrix[i][j]>>other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
rshi=Matrix(matrix=[[self.matrix[i][j]>>other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return rshi
def __and__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
conj=Matrix(matrix=[[self.matrix[i][j]&other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
conj=Matrix(matrix=[[self.matrix[i][j]&other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return conj
def __or__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
disj=Matrix(matrix=[[self.matrix[i][j]|other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
disj=Matrix(matrix=[[self.matrix[i][j]|other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return disj
def __xor__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
excl=Matrix(matrix=[[self.matrix[i][j]^other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
excl=Matrix(matrix=[[self.matrix[i][j]^other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return excl
def __iadd__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]+=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]+=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __isub__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]-=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]-=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __imul__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]*=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]*=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __imatmul__(self,other):
if type(other)==Matrix:
assert self.W==other.H
prod=Matrix(H=self.H,W=other.W,eps=self.eps,mod=self.mod)
for i in range(self.H):
for j in range(other.W):
for k in range(self.W):
prod.matrix[i][j]+=self.matrix[i][k]*other.matrix[k][j]
if self.mod:
prod.matrix[i][j]%=self.mod
elif type(other)==int:
assert self.H==self.W
if other==0:
return Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
elif other==1:
prod=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
doub=self
while other>=2:
if other&1:
prod@=doub
doub@=doub
other>>=1
prod@=doub
return prod
def __itruediv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=self.matrix[i][j]*MOD(self.mod).Pow(other.matrix[i][j],-1)%self.mod
else:
self.matrix[i][j]/=other.matrix[i][j]
else:
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=self.matrix[i][j]*inve%self.mod
else:
self.matrix[i][j]/=other
return self
def __ifloordiv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]//=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]//=other
return self
def __imod__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]%=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]%=other
return self
def __ipow__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=pow(self.matrix[i][j],other.matrix[i][j],self.mod)
else:
self.matrix[i][j]=pow(self.matrix[i][j],other.matrix[i][j])
else:
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=pow(self.matrix[i][j],other,self.mod)
else:
self.matrix[i][j]=pow(self.matrix[i][j],other)
return self
def __ilshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]<<=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]<<=other
return self
def __irshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]>>=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]>>=other
return self
def __iand__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]&=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]&=other
return self
def __ior__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]|=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]|=other
return self
def __ixor__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]^=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]^=other
return self
def __neg__(self):
if self.mod:
nega=Matrix(matrix=[[(-self.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
nega=Matrix(matrix=[[-self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return nega
def __pos__(self):
posi=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return posi
def __invert__(self):
inve=Matrix(matrix=[[~self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return inve
def __abs__(self):
abso=Matrix(matrix=[[abs(self.matrix[i][j]) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return abso
def __getitem__(self,i):
if type(i)==int:
return self.matrix[i]
elif type(i)==tuple:
i,j=i
if type(i)==int:
i=slice(i,i+1)
if type(j)==int:
j=slice(j,j+1)
return Matrix(matrix=[lst[j] for lst in self.matrix[i]],eps=self.eps,mod=self.mod)
def __contains__(self,x):
for i in range(self.H):
if x in self.matrix[i]:
return True
return False
def __str__(self):
digit=[max(len(str(self.matrix[i][j])) for i in range(self.H)) for j in range(self.W)]
return "\n".join([(" [" if i else "[[")+", ".join([str(self.matrix[i][j]).rjust(digit[j]," ") for j in range(self.W)])+"]" for i in range(self.H)])+"]"
def __bool__(self):
return True
def Transpose(self):
return Matrix(matrix=[[self.matrix[i][j] for i in range(self.H)] for j in range(self.W)])
def Trace(self):
assert self.H==self.W
trace=sum(self.matrix[i][i] for i in range(self.H))
if self.mod:
trace%=self.mod
return trace
def Elem_Raw_Operate_1(self,i0,i1):
self.matrix[i0],self.matrix[i1]=self.matrix[i1],self.matrix[i0]
def Elem_Raw_Operate_2(self,i,c):
if self.mod:
self.matrix[i]=[self.matrix[i][j]*c%self.mod for j in range(self.W)]
else:
self.matrix[i]=[self.matrix[i][j]*c for j in range(self.W)]
def Elem_Raw_Operate_3(self,i0,i1,c):
if self.mod:
self.matrix[i0]=[(self.matrix[i0][j]+c*self.matrix[i1][j])%self.mod for j in range(self.W)]
else:
self.matrix[i0]=[self.matrix[i0][j]+c*self.matrix[i1][j] for j in range(self.W)]
def Elimination(self,determinant=False,inverse_matrix=False,linear_equation=False,rank=False,upper_triangular=False):
h=0
ut=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
if determinant or inverse_matrix:
assert self.H==self.W
det=1
if inverse_matrix:
assert self.H==self.W
im=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
if linear_equation:
assert self.H==linear_equation.H
le=Matrix(matrix=[[linear_equation.matrix[i][j] for j in range(linear_equation.W)] for i in range(linear_equation.H)],eps=self.eps,mod=self.mod)
for j in range(ut.W):
for i in range(h,ut.H):
if abs(ut.matrix[i][j])>ut.eps:
if determinant or inverse_matrix:
det*=ut.matrix[i][j]
if self.mod:
det%=self.mod
if self.mod:
inve=MOD(self.mod).Pow(ut.matrix[i][j],-1)
else:
inve=1/ut.matrix[i][j]
ut.Elem_Raw_Operate_1(i,h)
if determinant and i!=h and self.mod:
det=(-det)%self.mod
if inverse_matrix:
im.Elem_Raw_Operate_1(i,h)
if linear_equation:
le.Elem_Raw_Operate_1(i,h)
ut.Elem_Raw_Operate_2(h,inve)
if inverse_matrix:
im.Elem_Raw_Operate_2(h,inve)
if linear_equation:
le.Elem_Raw_Operate_2(h,inve)
for ii in range(ut.H):
if ii==h:
continue
x=-ut.matrix[ii][j]
ut.Elem_Raw_Operate_3(ii,h,x)
if inverse_matrix:
im.Elem_Raw_Operate_3(ii,h,x)
if linear_equation:
le.Elem_Raw_Operate_3(ii,h,x)
h+=1
break
else:
det=0
if linear_equation and any(le[i][0] for i in range(h,self.H)):
le=None
tpl=()
if determinant:
tpl+=(det,)
if inverse_matrix:
if det==0:
im=None
tpl+=(im,)
if linear_equation:
tpl+=(le,)
if rank:
tpl+=(h,)
if upper_triangular:
tpl+=(ut,)
if len(tpl)==1:
tpl=tpl[0]
return tpl
N=int(input())
mod=998244353
ans=N*Arithmetic_Sequence_Sum(N,1,10,mod)%mod
print(ans)
def Arithmetic_Sequence_Sum(N,first_term,common_ratio,mod):
return first_term*(Matrix(matrix=[[common_ratio,1],[0,1]],mod=mod)@N)[0][1]%mod
class Matrix:
def __init__(self,H=0,W=0,matrix=False,eps=0,mod=0,identity=0):
if identity:
if H:
self.H=H
self.W=H
else:
self.H=W
self.W=W
self.matrix=[[0]*self.W for i in range(self.H)]
for i in range(self.H):
self.matrix[i][i]=identity
elif matrix:
self.matrix=matrix
self.H=len(self.matrix)
self.W=len(self.matrix[0]) if self.matrix else 0
else:
self.H=H
self.W=W
self.matrix=[[0]*self.W for i in range(self.H)]
self.mod=mod
self.eps=eps
def __eq__(self,other):
if type(other)!=Matrix:
return False
if self.H!=other.H:
return False
if self.mod:
for i in range(self.H):
for j in range(self.W):
if self.matrix[i][j]%self.mod!=other.matrix[i][j]%self.mod:
return False
else:
for i in range(self.H):
for j in range(self.W):
if self.eps<abs(self.matrix[i][j]-other.matrix[i][j]):
return False
return True
def __ne__(self,other):
if type(other)!=Matrix:
return True
if self.H!=other.H:
return True
if self.mod:
for i in range(self.H):
for j in range(self.W):
if self.matrix[i][j]%self.mod!=other.matrix[i][j]%self.mod:
return True
else:
for i in range(self.H):
for j in range(self.W):
if self.eps<abs(self.matrix[i][j]-other.matrix[i][j]):
return True
return False
def __add__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
summ=Matrix(matrix=[[(self.matrix[i][j]+other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
summ=Matrix(matrix=[[self.matrix[i][j]+other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
summ=Matrix(matrix=[[(self.matrix[i][j]+other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
summ=Matrix(matrix=[[self.matrix[i][j]+other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return summ
def __sub__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
diff=Matrix(matrix=[[(self.matrix[i][j]-other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
diff=Matrix(matrix=[[self.matrix[i][j]-other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
diff=Matrix(matrix=[[(self.matrix[i][j]-other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
diff=Matrix(matrix=[[self.matrix[i][j]-other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return diff
def __mul__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
prod=Matrix(matrix=[[(self.matrix[i][j]*other.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(matrix=[[self.matrix[i][j]*other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
prod=Matrix(matrix=[[(self.matrix[i][j]*other)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(matrix=[[self.matrix[i][j]*other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return prod
def __matmul__(self,other):
if type(other)==Matrix:
assert self.W==other.H
prod=Matrix(H=self.H,W=other.W,eps=self.eps,mod=self.mod)
for i in range(self.H):
for j in range(other.W):
for k in range(self.W):
prod.matrix[i][j]+=self.matrix[i][k]*other.matrix[k][j]
if self.mod:
prod.matrix[i][j]%=self.mod
elif type(other)==int:
assert self.H==self.W
if other==0:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
elif other==1:
prod=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
doub=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
while other>=2:
if other&1:
prod@=doub
doub@=doub
other>>=1
prod@=doub
return prod
def __truediv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
quot=Matrix(matrix=[[(self.matrix[i][j]*MOD(self.mod).Pow(other.matrix[i][j],-1))%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]/other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
quot=Matrix(matrix=[[(self.matrix[i][j]*inve)%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]/other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return quot
def __floordiv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
quot=Matrix(matrix=[[self.matrix[i][j]//other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
quot=Matrix(matrix=[[self.matrix[i][j]//other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return quot
def __mod__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
rema=Matrix(matrix=[[self.matrix[i][j]%other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
rema=Matrix(matrix=[[self.matrix[i][j]%other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return rema
def __pow__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
if self.mod:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other.matrix[i][j],self.mod) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other.matrix[i][j]) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
if self.mod:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other,self.mod) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
powe=Matrix(matrix=[[pow(self.matrix[i][j],other) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return powe
def __lshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
lshi=Matrix(matrix=[[self.matrix[i][j]<<other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
lshi=Matrix(matrix=[[self.matrix[i][j]<<other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return lshi
def __rshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
rshi=Matrix(matrix=[[self.matrix[i][j]>>other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
rshi=Matrix(matrix=[[self.matrix[i][j]>>other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return rshi
def __and__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
conj=Matrix(matrix=[[self.matrix[i][j]&other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
conj=Matrix(matrix=[[self.matrix[i][j]&other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return conj
def __or__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
disj=Matrix(matrix=[[self.matrix[i][j]|other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
disj=Matrix(matrix=[[self.matrix[i][j]|other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return disj
def __xor__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
excl=Matrix(matrix=[[self.matrix[i][j]^other.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
excl=Matrix(matrix=[[self.matrix[i][j]^other for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return excl
def __iadd__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]+=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]+=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __isub__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]-=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]-=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __imul__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]*=other.matrix[i][j]
if self.mod:
self.matrix[i][j]%=self.mod
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]*=other
if self.mod:
self.matrix[i][j]%=self.mod
return self
def __imatmul__(self,other):
if type(other)==Matrix:
assert self.W==other.H
prod=Matrix(H=self.H,W=other.W,eps=self.eps,mod=self.mod)
for i in range(self.H):
for j in range(other.W):
for k in range(self.W):
prod.matrix[i][j]+=self.matrix[i][k]*other.matrix[k][j]
if self.mod:
prod.matrix[i][j]%=self.mod
elif type(other)==int:
assert self.H==self.W
if other==0:
return Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
elif other==1:
prod=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
prod=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
doub=self
while other>=2:
if other&1:
prod@=doub
doub@=doub
other>>=1
prod@=doub
return prod
def __itruediv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=self.matrix[i][j]*MOD(self.mod).Pow(other.matrix[i][j],-1)%self.mod
else:
self.matrix[i][j]/=other.matrix[i][j]
else:
if self.mod:
inve=MOD(self.mod).Pow(other,-1)
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=self.matrix[i][j]*inve%self.mod
else:
self.matrix[i][j]/=other
return self
def __ifloordiv__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]//=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]//=other
return self
def __imod__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]%=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]%=other
return self
def __ipow__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=pow(self.matrix[i][j],other.matrix[i][j],self.mod)
else:
self.matrix[i][j]=pow(self.matrix[i][j],other.matrix[i][j])
else:
for i in range(self.H):
for j in range(self.W):
if self.mod:
self.matrix[i][j]=pow(self.matrix[i][j],other,self.mod)
else:
self.matrix[i][j]=pow(self.matrix[i][j],other)
return self
def __ilshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]<<=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]<<=other
return self
def __irshift__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]>>=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]>>=other
return self
def __iand__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]&=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]&=other
return self
def __ior__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]|=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]|=other
return self
def __ixor__(self,other):
if type(other)==Matrix:
assert self.H==other.H
assert self.W==other.W
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]^=other.matrix[i][j]
else:
for i in range(self.H):
for j in range(self.W):
self.matrix[i][j]^=other
return self
def __neg__(self):
if self.mod:
nega=Matrix(matrix=[[(-self.matrix[i][j])%self.mod for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
else:
nega=Matrix(matrix=[[-self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return nega
def __pos__(self):
posi=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return posi
def __invert__(self):
inve=Matrix(matrix=[[~self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return inve
def __abs__(self):
abso=Matrix(matrix=[[abs(self.matrix[i][j]) for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
return abso
def __getitem__(self,i):
if type(i)==int:
return self.matrix[i]
elif type(i)==tuple:
i,j=i
if type(i)==int:
i=slice(i,i+1)
if type(j)==int:
j=slice(j,j+1)
return Matrix(matrix=[lst[j] for lst in self.matrix[i]],eps=self.eps,mod=self.mod)
def __contains__(self,x):
for i in range(self.H):
if x in self.matrix[i]:
return True
return False
def __str__(self):
digit=[max(len(str(self.matrix[i][j])) for i in range(self.H)) for j in range(self.W)]
return "\n".join([(" [" if i else "[[")+", ".join([str(self.matrix[i][j]).rjust(digit[j]," ") for j in range(self.W)])+"]" for i in range(self.H)])+"]"
def __bool__(self):
return True
def Transpose(self):
return Matrix(matrix=[[self.matrix[i][j] for i in range(self.H)] for j in range(self.W)])
def Trace(self):
assert self.H==self.W
trace=sum(self.matrix[i][i] for i in range(self.H))
if self.mod:
trace%=self.mod
return trace
def Elem_Raw_Operate_1(self,i0,i1):
self.matrix[i0],self.matrix[i1]=self.matrix[i1],self.matrix[i0]
def Elem_Raw_Operate_2(self,i,c):
if self.mod:
self.matrix[i]=[self.matrix[i][j]*c%self.mod for j in range(self.W)]
else:
self.matrix[i]=[self.matrix[i][j]*c for j in range(self.W)]
def Elem_Raw_Operate_3(self,i0,i1,c):
if self.mod:
self.matrix[i0]=[(self.matrix[i0][j]+c*self.matrix[i1][j])%self.mod for j in range(self.W)]
else:
self.matrix[i0]=[self.matrix[i0][j]+c*self.matrix[i1][j] for j in range(self.W)]
def Elimination(self,determinant=False,inverse_matrix=False,linear_equation=False,rank=False,upper_triangular=False):
h=0
ut=Matrix(matrix=[[self.matrix[i][j] for j in range(self.W)] for i in range(self.H)],eps=self.eps,mod=self.mod)
if determinant or inverse_matrix:
assert self.H==self.W
det=1
if inverse_matrix:
assert self.H==self.W
im=Matrix(H=self.H,eps=self.eps,mod=self.mod,identity=1)
if linear_equation:
assert self.H==linear_equation.H
le=Matrix(matrix=[[linear_equation.matrix[i][j] for j in range(linear_equation.W)] for i in range(linear_equation.H)],eps=self.eps,mod=self.mod)
for j in range(ut.W):
for i in range(h,ut.H):
if abs(ut.matrix[i][j])>ut.eps:
if determinant or inverse_matrix:
det*=ut.matrix[i][j]
if self.mod:
det%=self.mod
if self.mod:
inve=MOD(self.mod).Pow(ut.matrix[i][j],-1)
else:
inve=1/ut.matrix[i][j]
ut.Elem_Raw_Operate_1(i,h)
if determinant and i!=h and self.mod:
det=(-det)%self.mod
if inverse_matrix:
im.Elem_Raw_Operate_1(i,h)
if linear_equation:
le.Elem_Raw_Operate_1(i,h)
ut.Elem_Raw_Operate_2(h,inve)
if inverse_matrix:
im.Elem_Raw_Operate_2(h,inve)
if linear_equation:
le.Elem_Raw_Operate_2(h,inve)
for ii in range(ut.H):
if ii==h:
continue
x=-ut.matrix[ii][j]
ut.Elem_Raw_Operate_3(ii,h,x)
if inverse_matrix:
im.Elem_Raw_Operate_3(ii,h,x)
if linear_equation:
le.Elem_Raw_Operate_3(ii,h,x)
h+=1
break
else:
det=0
if linear_equation and any(le[i][0] for i in range(h,self.H)):
le=None
tpl=()
if determinant:
tpl+=(det,)
if inverse_matrix:
if det==0:
im=None
tpl+=(im,)
if linear_equation:
tpl+=(le,)
if rank:
tpl+=(h,)
if upper_triangular:
tpl+=(ut,)
if len(tpl)==1:
tpl=tpl[0]
return tpl
N=int(input())
mod=998244353
ans=N*Arithmetic_Sequence_Sum(N,1,10**len(str(N)),mod)%mod
print(ans) | ConDefects/ConDefects/Code/abc357_d/Python/54746473 |
condefects-python_data_208 | def extgcd(a, b):
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b) * x
return d, x, y
return a, 1, 0
def remainder(V):
x = 0; d = 1
for X, Y in V:
g, a, b = extgcd(d, Y)
x, d = (Y*b*x + d*a*X) // g, d*(Y // g)
x %= d
return x, d
lis = [4, 9, 5, 7, 11, 13, 17, 19, 23]
now = 0
a = []
check = []
for num in lis:
now+=1
check.append(now)
a.append(now+num-1)
for i in range(num-1):
a.append(now)
now+=1
print(len(a))
print(*a)
b = list(map(int, input().split()))
V = []
for i in range(len(check)):
amari = b.index(check[i]) - check[i] + 1
m = check[i]
V.append((amari,m))
x,d = remainder(V)
print(x)
def extgcd(a, b):
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b) * x
return d, x, y
return a, 1, 0
def remainder(V):
x = 0; d = 1
for X, Y in V:
g, a, b = extgcd(d, Y)
x, d = (Y*b*x + d*a*X) // g, d*(Y // g)
x %= d
return x, d
lis = [4, 9, 5, 7, 11, 13, 17, 19, 23]
now = 0
a = []
check = []
for num in lis:
now+=1
check.append(now)
a.append(now+num-1)
for i in range(num-1):
a.append(now)
now+=1
print(len(a))
print(*a)
b = list(map(int, input().split()))
V = []
for i in range(len(check)):
amari = b.index(check[i]) - check[i] + 1
m = lis[i]
V.append((amari,m))
x,d = remainder(V)
print(x) | ConDefects/ConDefects/Code/abc286_f/Python/45090669 |
condefects-python_data_209 | n, k = map(int, input().split())
a = list(map(int, input().split()))
seat_count = k
dep_count = 0
for i in range(n):
if seat_count > a[i]:
seat_count -= a[i]
elif seat_count < a[i]:
dep_count += 1
seat_count = k
seat_count -= a[i]
if seat_count == 0:
dep_count += 1
seat_count = k
elif seat_count == a[i]:
dep_count += 1
seat_count = k
if seat_count != 0:
dep_count += 1
print(dep_count)
n, k = map(int, input().split())
a = list(map(int, input().split()))
seat_count = k
dep_count = 0
for i in range(n):
if seat_count > a[i]:
seat_count -= a[i]
elif seat_count < a[i]:
dep_count += 1
seat_count = k
seat_count -= a[i]
if seat_count == 0:
dep_count += 1
seat_count = k
elif seat_count == a[i]:
dep_count += 1
seat_count = k
if seat_count != 0 and seat_count != k:
dep_count += 1
print(dep_count) | ConDefects/ConDefects/Code/abc353_b/Python/54945668 |
condefects-python_data_210 | N,K=map(int,input().split())
A=list(map(int,input().split()))
i,num=0,0
for x in range(N):
if A[x]+i<=K:
i=i+A[x]
print(i,"now1")
elif A[x]+i>K:
num+=1
i=0
i=i+A[x]
print(i,"now2")
print(num+1)
N,K=map(int,input().split())
A=list(map(int,input().split()))
i,num=0,0
for x in range(N):
if A[x]+i<=K:
i=i+A[x]
elif A[x]+i>K:
num+=1
i=0
i=i+A[x]
print(num+1) | ConDefects/ConDefects/Code/abc353_b/Python/55018999 |
condefects-python_data_211 | n, m, *a = map(int, open(0).read().split())
a.sort()
ans = sum(i*i for i in a)
pairs = n - m
for i in range(pairs):
ans += 2 * a[i] * a[i+pairs]
print(ans)
n, m, *a = map(int, open(0).read().split())
a.sort()
ans = sum(i*i for i in a)
pairs = n - m
for i in range(pairs):
ans += 2 * a[i] * a[pairs+pairs-1-i]
print(ans)
| ConDefects/ConDefects/Code/arc167_a/Python/52183660 |
condefects-python_data_212 | n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
single_sz = n - (n-m)*2
print(single_sz)
ans = 0
for i in range(single_sz):
ans += a[i]**2
for i in range(n-m):
i1 = single_sz+i
i2 = n-1-i
ans += (a[i1]+a[i2])**2
print(ans)
n, m = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
single_sz = n - (n-m)*2
#print(single_sz)
ans = 0
for i in range(single_sz):
ans += a[i]**2
for i in range(n-m):
i1 = single_sz+i
i2 = n-1-i
ans += (a[i1]+a[i2])**2
print(ans)
| ConDefects/ConDefects/Code/arc167_a/Python/51403165 |
condefects-python_data_213 | from string import ascii_uppercase
N, X = map(int, input().split())
print(ascii_uppercase[X // N - 1])
from string import ascii_uppercase
N, X = map(int, input().split())
print(ascii_uppercase[(X - 1) // N])
| ConDefects/ConDefects/Code/abc257_a/Python/46189766 |
condefects-python_data_214 | import sys
sys.setrecursionlimit(500*500)
# if 'pypyjit' in sys.builtin_module_names:
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
input = sys.stdin.readline
from math import gcd
from functools import reduce
# product('ABCD', repeat=2) => AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
from itertools import product
# permutations('ABCD', 2) => AB AC AD BA BC BD CA CB CD DA DB DC
from itertools import permutations
# combinations('ABCD', 2) => AB AC AD BC BD CD
from itertools import combinations
from itertools import accumulate # 累積和作るやつ
from collections import deque
from collections import defaultdict
from heapq import heappop, heappush
from bisect import bisect_left
# 0埋めされた二進数表現
f'{9:05b}'
alpha2num = lambda c: ord(c) - ord('a')
num2alpha = lambda c: chr(c+ord('A'))
popcnt = lambda x: bin(x).count("1")
# 数値判定
"1".isdigit()
dh = [-1, 0, 1, 0]
dw = [0, -1, 0, 1]
dh8 = [-1, -1, -1, 0, 0, 1, 1, 1]
dw8 = [-1, 0, 1, -1, 1, -1, 0, 1]
def resolve():
inf = 10**18+1
N, X = map(int, input()[:-1].split(" "))
c = num2alpha((X//N)-1)
print(c)
resolve()
import sys
sys.setrecursionlimit(500*500)
# if 'pypyjit' in sys.builtin_module_names:
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
input = sys.stdin.readline
from math import gcd
from functools import reduce
# product('ABCD', repeat=2) => AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
from itertools import product
# permutations('ABCD', 2) => AB AC AD BA BC BD CA CB CD DA DB DC
from itertools import permutations
# combinations('ABCD', 2) => AB AC AD BC BD CD
from itertools import combinations
from itertools import accumulate # 累積和作るやつ
from collections import deque
from collections import defaultdict
from heapq import heappop, heappush
from bisect import bisect_left
# 0埋めされた二進数表現
f'{9:05b}'
alpha2num = lambda c: ord(c) - ord('a')
num2alpha = lambda c: chr(c+ord('A'))
popcnt = lambda x: bin(x).count("1")
# 数値判定
"1".isdigit()
dh = [-1, 0, 1, 0]
dw = [0, -1, 0, 1]
dh8 = [-1, -1, -1, 0, 0, 1, 1, 1]
dw8 = [-1, 0, 1, -1, 1, -1, 0, 1]
def resolve():
inf = 10**18+1
N, X = map(int, input()[:-1].split(" "))
c = num2alpha(((X-N-1)//N)+1)
print(c)
resolve()
| ConDefects/ConDefects/Code/abc257_a/Python/45289055 |
condefects-python_data_215 | n,x=map(int,input().split())
print(chr(64+x//n))
n,x=map(int,input().split())
print(chr(64-(-x//n))) | ConDefects/ConDefects/Code/abc257_a/Python/45802027 |
condefects-python_data_216 | n=int(input())
s=input()
dango=0
lv=0
x=0
for i in range(n):
if s[i]=="-":
lv=0
dango=1
else:
if dango==1:
lv+=1
if lv>x:
x=lv
dango=0
lv=0
y=0
for i in range(n):
if s[n-1-i]=="-":
lv=0
dango=1
else:
if dango==1:
lv+=1
if lv>y:
y=lv
if x!=0 and y!=0:
print(max(x,y))
else:
print(-1)
n=int(input())
s=input()
dango=0
lv=0
x=0
for i in range(n):
if s[i]=="-":
lv=0
dango=1
else:
if dango==1:
lv+=1
if lv>x:
x=lv
dango=0
lv=0
y=0
for i in range(n):
if s[n-1-i]=="-":
lv=0
dango=1
else:
if dango==1:
lv+=1
if lv>y:
y=lv
if x!=0 or y!=0:
print(max(x,y))
else:
print(-1) | ConDefects/ConDefects/Code/abc299_c/Python/45695018 |
condefects-python_data_217 | N=input()
S=input()
sec = 0
ans = 0
for i in S:
if i == "o":
sec += 1
else:
if sec > ans:
ans = sec
sec = 0
if ans == 0:
print(-1)
else:
print(ans)
N=input()
S=input()
sec = 0
ans = 0
if "-" in S:
S += "-"
for i in S:
if i == "o":
sec += 1
else:
if sec > ans:
ans = sec
sec = 0
if ans == 0:
print(-1)
else:
print(ans) | ConDefects/ConDefects/Code/abc299_c/Python/45929496 |
condefects-python_data_218 | n = int(input())
s = input()
ans = -1
cnt = 0
for i in range(n):
if s[i] == "o":
cnt += 1
else:
if s != "o"*n and cnt != 0:
ans = max(ans,cnt)
cnt = 0
print(ans)
n = int(input())
s = input()
ans = -1
cnt = 0
for i in range(n):
if s[i] == "o":
cnt += 1
if s[i] == "-" or i == n-1:
if s != "o"*n and cnt != 0:
ans = max(ans,cnt)
cnt = 0
print(ans) | ConDefects/ConDefects/Code/abc299_c/Python/46056786 |
condefects-python_data_219 | import io
import sys
import math
import collections
import itertools
from operator import mul
from functools import reduce, wraps
from collections import defaultdict, deque
import bisect
import time
import heapq
from copy import deepcopy
import sys
sys.setrecursionlimit(1000000000)
# input
# --------------------------------------------------------------------
def N(): return int(input())
def NM(): return map(int, input().split()) # multi
def NMFAST(): return map(int, sys.stdin.readline().split())
def NL(): return list(map(int, input().split())) # list
def NR(N): return [list(map(int, sys.stdin.readline().split())) # row
for _ in range(N)]
def NR1(N): return [int(input()) # row
for _ in range(N)]
def S(): return input()
def SM(): return input().split() # multi
def SL(): return list(map(str, input().split())) # list
def SR(N): return [list(map(str, sys.stdin.readline().split())) # row
for _ in range(N)]
def SR1(N): return [input() for i in range(N)]
def SPR(N): return [list(input()) for i in range(N)] # 1文字ずつ分割
def F(): return float(input())
def FM(): return map(float, input().split()) # multi
def FL(): return list(map(float, input().split())) # list
def FR(N): return [list(map(float, sys.stdin.readline().split())) # row
for _ in range(N)]
def FR1(N): return [float(input()) # row
for _ in range(N)]
# --------------------------------------------------------------------
# output
# --------------------------------------------------------------------
def P(arg): print(arg)
def Yes(): print("Yes")
def No(): print("No")
def E(): exit()
def PE(arg):
print(arg)
exit()
def YE():
print("Yes")
exit()
def NE():
print("No")
exit()
# --------------------------------------------------------------------
def stop_watch(func):
@wraps(func)
def wrapper(*args, **kargs):
start = time.time()
result = func(*args, **kargs)
process_time = time.time() - start
print(f"{func.__name__}は{process_time}秒かかりました")
return result
return wrapper
INF = float('inf')
MOD = 10**9 + 7
MOD2 = 998244353
''' ------------------------debug--------------------------------- '''
# --------------------------------------------------------------------
_INPUT = """\
"""
# sys.stdin = io.StringIO(_INPUT)
''' ------------------------終 debug--------------------------------- '''
'''-----------------------------main-------------------------------'''
# --------------------------------------------------------------------
def main():
n = N()
s = S()
s_set = list(set(s))
if len(s_set) == 1 and s_set[0] == '-':
print(-1)
exit()
ans = 0
count = 0
for i in range(n):
if s[i] == '-':
count = 0
else:
count += 1
ans = max(ans, count)
print(ans)
if __name__ == '__main__':
main()
import io
import sys
import math
import collections
import itertools
from operator import mul
from functools import reduce, wraps
from collections import defaultdict, deque
import bisect
import time
import heapq
from copy import deepcopy
import sys
sys.setrecursionlimit(1000000000)
# input
# --------------------------------------------------------------------
def N(): return int(input())
def NM(): return map(int, input().split()) # multi
def NMFAST(): return map(int, sys.stdin.readline().split())
def NL(): return list(map(int, input().split())) # list
def NR(N): return [list(map(int, sys.stdin.readline().split())) # row
for _ in range(N)]
def NR1(N): return [int(input()) # row
for _ in range(N)]
def S(): return input()
def SM(): return input().split() # multi
def SL(): return list(map(str, input().split())) # list
def SR(N): return [list(map(str, sys.stdin.readline().split())) # row
for _ in range(N)]
def SR1(N): return [input() for i in range(N)]
def SPR(N): return [list(input()) for i in range(N)] # 1文字ずつ分割
def F(): return float(input())
def FM(): return map(float, input().split()) # multi
def FL(): return list(map(float, input().split())) # list
def FR(N): return [list(map(float, sys.stdin.readline().split())) # row
for _ in range(N)]
def FR1(N): return [float(input()) # row
for _ in range(N)]
# --------------------------------------------------------------------
# output
# --------------------------------------------------------------------
def P(arg): print(arg)
def Yes(): print("Yes")
def No(): print("No")
def E(): exit()
def PE(arg):
print(arg)
exit()
def YE():
print("Yes")
exit()
def NE():
print("No")
exit()
# --------------------------------------------------------------------
def stop_watch(func):
@wraps(func)
def wrapper(*args, **kargs):
start = time.time()
result = func(*args, **kargs)
process_time = time.time() - start
print(f"{func.__name__}は{process_time}秒かかりました")
return result
return wrapper
INF = float('inf')
MOD = 10**9 + 7
MOD2 = 998244353
''' ------------------------debug--------------------------------- '''
# --------------------------------------------------------------------
_INPUT = """\
"""
# sys.stdin = io.StringIO(_INPUT)
''' ------------------------終 debug--------------------------------- '''
'''-----------------------------main-------------------------------'''
# --------------------------------------------------------------------
def main():
n = N()
s = S()
s_set = list(set(s))
if len(s_set) == 1:
print(-1)
exit()
ans = 0
count = 0
for i in range(n):
if s[i] == '-':
count = 0
else:
count += 1
ans = max(ans, count)
print(ans)
if __name__ == '__main__':
main()
| ConDefects/ConDefects/Code/abc299_c/Python/46165545 |
condefects-python_data_220 | def main():
n = int(input())
s = list(input())
if n == 1:
print(-1)
return
dango = 0
max_dango = -1
stick = False
for i in range(n):
if s[i] == "o":
dango += 1
else:
stick = True
if dango > max_dango:
max_dango = dango
dango = 0
if dango > max_dango:
max_dango = dango
if stick == True:
print(max_dango)
else:
print(-1)
if __name__ == "__main__":
main()
def main():
n = int(input())
s = list(input())
if n == 1:
print(-1)
return
dango = 0
max_dango = -1
stick = False
for i in range(n):
if s[i] == "o":
dango += 1
else:
stick = True
if dango > max_dango:
max_dango = dango
dango = 0
if dango > max_dango:
max_dango = dango
if stick == True and max_dango != 0:
print(max_dango)
else:
print(-1)
if __name__ == "__main__":
main() | ConDefects/ConDefects/Code/abc299_c/Python/45999829 |
condefects-python_data_221 | n = int(input())
s = input()
sr=''.join(reversed(s))
ans=0
cnt=0
flag=0
for i in range(n):
if s[i]=="-":
if flag == 0:
flag = 1
else:
ans=max(ans,cnt)
cnt=0
else:
if flag == 1:
cnt+=1
flag=0
cnt=0
for i in range(n):
if sr[i]=="-":
if flag == 0:
flag = 1
else:
ans=max(ans,cnt)
cnt=0
else:
if flag == 1:
cnt+=1
if ans == 0:
print(-1)
else:
print(ans)
n = int(input())
s = input()
sr=''.join(reversed(s))
ans=0
cnt=0
flag=0
for i in range(n):
if s[i]=="-":
if flag == 0:
flag = 1
else:
ans=max(ans,cnt)
cnt=0
else:
if flag == 1:
cnt+=1
ans=max(ans,cnt)
flag=0
cnt=0
for i in range(n):
if sr[i]=="-":
if flag == 0:
flag = 1
else:
ans=max(ans,cnt)
cnt=0
else:
if flag == 1:
cnt+=1
ans=max(ans,cnt)
if ans == 0:
print(-1)
else:
print(ans) | ConDefects/ConDefects/Code/abc299_c/Python/46050962 |
condefects-python_data_222 | N=int(input())
S=input()
ans=0
flg=False
tmp=0
for i in range(N):
if flg:
if S[i]=="o":
tmp+=1
else:
ans=max(ans,tmp)
tmp=0
else:
if S[i]=="-":
flg=True
flg=False
tmp=0
for i in range(N-1,-1,-1):
if flg:
if S[i]=="o":
tmp+=1
else:
ans=max(ans,tmp)
tmp=0
else:
if S[i]=="-":
flg=True
if ans==0:
print(-1)
else:
print(ans)
N=int(input())
S=input()
ans=0
flg=False
tmp=0
for i in range(N):
if flg:
if S[i]=="o":
tmp+=1
else:
ans=max(ans,tmp)
tmp=0
else:
if S[i]=="-":
flg=True
ans=max(ans,tmp)
flg=False
tmp=0
for i in range(N-1,-1,-1):
if flg:
if S[i]=="o":
tmp+=1
else:
ans=max(ans,tmp)
tmp=0
else:
if S[i]=="-":
flg=True
ans=max(ans,tmp)
if ans==0:
print(-1)
else:
print(ans) | ConDefects/ConDefects/Code/abc299_c/Python/45797933 |
condefects-python_data_223 | n=int(input())
s=input()
ok=False
cnt=0
ans=0
for i in range(n):
if s[i]=="o":
cnt+=1
else:
ok=True
ans=max(ans,cnt)
print(cnt)
cnt=0
if ok:
ans=max(ans,cnt)
print(cnt)
print(ans if ans>0 else -1)
n=int(input())
s=input()
ok=False
cnt=0
ans=0
for i in range(n):
if s[i]=="o":
cnt+=1
else:
ok=True
ans=max(ans,cnt)
cnt=0
if ok:
ans=max(ans,cnt)
print(ans if ans>0 else -1) | ConDefects/ConDefects/Code/abc299_c/Python/45334014 |
condefects-python_data_224 | N = int(input())
S = input()
ox = 0
ans = -1
cnt = -1
for s in S:
if s=="-":
ox |= 0b01
ans = max(ans, cnt)
cnt = 0
elif s=="o":
ox |= 0b10
cnt += 1
if ox ==0b11:
ans = max(ans, cnt)
else:
ans = -1
print(ans)
N = int(input())
S = input()
ox = 0
ans = -1
cnt = 0
for s in S:
if s=="-":
ox |= 0b01
ans = max(ans, cnt)
cnt = 0
elif s=="o":
ox |= 0b10
cnt += 1
if ox ==0b11:
ans = max(ans, cnt)
else:
ans = -1
print(ans)
| ConDefects/ConDefects/Code/abc299_c/Python/45524936 |
condefects-python_data_225 | n=int(input())
s=input()
right,now,ans=0,0,0
for left in range(n):
while(right<n and s[right]=='o'):
now+=1
right+=1
ans=max(ans,right-left)
if right==left:right+=1
else:now-=1 if s[left]=="o" else 0
print(ans if ans!=0 else -1)
n=int(input())
s=input()
right,now,ans=0,0,0
for left in range(n):
while(right<n and s[right]=='o'):
now+=1
right+=1
ans=max(ans,right-left)
if right==left:right+=1
else:now-=1 if s[left]=="o" else 0
print(ans if ans!=0 and "-" in s else -1)
| ConDefects/ConDefects/Code/abc299_c/Python/45513147 |
condefects-python_data_226 | # Copyright (c) 2023, Le Duc Phuc Long
# If you don't think twice, you have to code twice.
# Import session
import sys
#input = sys.stdin.readline
from collections import defaultdict
############ ---- Input Functions ---- ############
def inp():
return int(input())
def inlt():
return list(map(int, input().split()))
def instr():
return list(input().strip())
def invr():
return map(int, input().split())
############ ---- Other Functions ---- ############
# Precompute
# IO
#input = sys.stdin.readline
#sys.stdin = open('in.txt', 'r')
#sys.stdout = open('out.txt', 'w')
# Main function
n = inp()
s = input().strip()
cur, ans = 0, -1
for c in s:
if c == '-':
if cur == 0:
continue
ans = max(cur, ans)
cur = 0
else:
cur += 1
if '-' in s:
ans = max(cur, ans)
print(ans)
# Copyright (c) 2023, Le Duc Phuc Long
# If you don't think twice, you have to code twice.
# Import session
import sys
#input = sys.stdin.readline
from collections import defaultdict
############ ---- Input Functions ---- ############
def inp():
return int(input())
def inlt():
return list(map(int, input().split()))
def instr():
return list(input().strip())
def invr():
return map(int, input().split())
############ ---- Other Functions ---- ############
# Precompute
# IO
#input = sys.stdin.readline
#sys.stdin = open('in.txt', 'r')
#sys.stdout = open('out.txt', 'w')
# Main function
n = inp()
s = input().strip()
cur, ans = 0, -1
for c in s:
if c == '-':
if cur == 0:
continue
ans = max(cur, ans)
cur = 0
else:
cur += 1
if '-' in s and cur != 0:
ans = max(cur, ans)
print(ans)
| ConDefects/ConDefects/Code/abc299_c/Python/45750635 |
condefects-python_data_227 | N=int(input())
S=input()
left=0 if S[0]=="o" else -1
max_L=-1
for right in range(1,N):
if S[right-1]=="-" and S[right]=="o":
left = right
elif S[right-1]=="o" and S[right]=="-":
#print(left, right, right-left)
if 0<=left-1 and S[left-1]=="-" or right+1<N and S[right+1]=="-":
max_L = max(max_L, right-left)
if S[-1]=="o" and 0<=left-1 and S[left-1]=="-":
#print(left, N, N-left)
max_L = max(max_L, N-left)
print(max_L)
N=int(input())
S=input()
left=0 if S[0]=="o" else -1
max_L=-1
for right in range(1,N):
if S[right-1]=="-" and S[right]=="o":
left = right
elif S[right-1]=="o" and S[right]=="-":
#print(left, right, right-left)
if 0<=left-1 and S[left-1]=="-" or right<N and S[right]=="-":
max_L = max(max_L, right-left)
if S[-1]=="o" and 0<=left-1 and S[left-1]=="-":
#print(left, N, N-left)
max_L = max(max_L, N-left)
print(max_L) | ConDefects/ConDefects/Code/abc299_c/Python/46032299 |
condefects-python_data_228 | N = int(input())
S = input()
max = 0
count = 0
for i in range(N):
if S[i] == "o":
count += 1
if count > max:
max = count
else:
count = 0
if max == len(S) and S[0] == "-" and S[len(S) - 1] == "-":
print(-1)
elif max == 0:
print(-1)
else:
print(max)
N = int(input())
S = input()
max = 0
count = 0
for i in range(N):
if S[i] == "o":
count += 1
if count > max:
max = count
else:
count = 0
if max == len(S) and S[0] != "-" and S[len(S) - 1] != "-":
print(-1)
elif max == 0:
print(-1)
else:
print(max)
| ConDefects/ConDefects/Code/abc299_c/Python/45333505 |
condefects-python_data_229 | import sys
f = sys.stdin
N = int(f.readline().rstrip())
S = f.readline().rstrip()
d, td = 0, 0
s = 0
for i in range(N):
if S[i] == 'o':
td += 1
else:
s = 1
d = max(d, td)
td = 0
print(d if (0 < d and s == 1) else -1)
import sys
f = sys.stdin
N = int(f.readline().rstrip())
S = f.readline().rstrip()
d, td = 0, 0
s = 0
for i in range(N):
if S[i] == 'o':
td += 1
d = max(d, td)
else:
s = 1
td = 0
print(d if (0 < d and s == 1) else -1)
| ConDefects/ConDefects/Code/abc299_c/Python/45221667 |
condefects-python_data_230 | n=int(input())+2
s='-'+input()+'-'
m=0
x=0
for i in range(n):
if s[i]=='-':
m=max(m,x)
x=0
else: x+=1
if m==n-2:
print(-1)
else: print(m)
n=int(input())+2
s='-'+input()+'-'
m=0
x=0
for i in range(n):
if s[i]=='-':
m=max(m,x)
x=0
else: x+=1
if m==n-2 or m==0:
print(-1)
else: print(m) | ConDefects/ConDefects/Code/abc299_c/Python/45439049 |
condefects-python_data_231 | n = int(input())
a_s = list(map(int, input().split()))
m = int(input())
b_s = list(map(int, input().split()))
l = int(input())
c_n = list(map(int, input().split()))
q = int(input())
x_s = list(map(int, input().split()))
comb_sum = []
for a in a_s:
for b in b_s:
for c in c_n:
comb_sum.append(a + b + c)
sorted_comb_sum = sorted(comb_sum)
for x in x_s:
flag = False
left, right = 0, len(sorted_comb_sum) - 1
while left <= right:
mid = (left + right) // 2
if sorted_comb_sum[mid] == x:
print("YES")
flag = True
break
if sorted_comb_sum[mid] < x:
left = mid + 1
else:
right = mid - 1
if not flag:
print("No")
n = int(input())
a_s = list(map(int, input().split()))
m = int(input())
b_s = list(map(int, input().split()))
l = int(input())
c_n = list(map(int, input().split()))
q = int(input())
x_s = list(map(int, input().split()))
comb_sum = []
for a in a_s:
for b in b_s:
for c in c_n:
comb_sum.append(a + b + c)
sorted_comb_sum = sorted(comb_sum)
for x in x_s:
flag = False
left, right = 0, len(sorted_comb_sum) - 1
while left <= right:
mid = (left + right) // 2
if sorted_comb_sum[mid] == x:
print("Yes")
flag = True
break
if sorted_comb_sum[mid] < x:
left = mid + 1
else:
right = mid - 1
if not flag:
print("No")
| ConDefects/ConDefects/Code/abc344_c/Python/54709044 |
condefects-python_data_232 | # https://atcoder.jp/contests/arc158/tasks/arc158_c
n = int(input())
a = list(map(int,input().split()))
ans = 0
# 思考按数位进行枚举？进位再进位何解？
# 单独去掉进位的部分
for i in a:
while i:
ans += i%10 *2*n
i //= 10
import bisect
for i in range(1,14):
b = sorted([x%(10**i) for x in a])
for x in b:
ans -= 9*(n - bisect.bisect_left(b,10**i - x))
print(ans)
# https://atcoder.jp/contests/arc158/tasks/arc158_c
n = int(input())
a = list(map(int,input().split()))
ans = 0
# 思考按数位进行枚举？进位再进位何解？
# 单独去掉进位的部分
for i in a:
while i:
ans += i%10 *2*n
i //= 10
import bisect
for i in range(1,16):
b = sorted([x%(10**i) for x in a])
for x in b:
ans -= 9*(n - bisect.bisect_left(b,10**i - x))
print(ans) | ConDefects/ConDefects/Code/arc158_c/Python/40365558 |
condefects-python_data_233 | from bisect import bisect_left as bl
N,P,Q,R = list(map(int,input().split()))
A = list(map(int,input().split()))
asum = [0]
for n in range(N):
asum.append(asum[-1]+A[n])
for x in range(N):
a = asum[x]
y = bl(asum,P+a)
if y>=N or asum[y]-a!=P : continue
a = asum[y]
z = bl(asum,Q+a)
if z>=N or asum[z]-a!=Q : continue
a = asum[z]
w = bl(asum,R+a)
if w>=N or asum[w]-a!=R : continue
print("Yes")
break
else:
print("No")
from bisect import bisect_left as bl
N,P,Q,R = list(map(int,input().split()))
A = list(map(int,input().split()))
asum = [0]
for n in range(N):
asum.append(asum[-1]+A[n])
for x in range(N):
a = asum[x]
y = bl(asum,P+a)
if y>=N or asum[y]-a!=P : continue
a = asum[y]
z = bl(asum,Q+a)
if z>=N or asum[z]-a!=Q : continue
a = asum[z]
w = bl(asum,R+a)
if w>N or asum[w]-a!=R : continue
print("Yes")
break
else:
print("No") | ConDefects/ConDefects/Code/abc265_d/Python/45075464 |
condefects-python_data_234 | import sys
sys.setrecursionlimit(500*500)
# if 'pypyjit' in sys.builtin_module_names:
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
input = sys.stdin.readline
from math import gcd
from functools import reduce
# product('ABCD', repeat=2) => AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
from itertools import product
# permutations('ABCD', 2) => AB AC AD BA BC BD CA CB CD DA DB DC
from itertools import permutations
# combinations('ABCD', 2) => AB AC AD BC BD CD
from itertools import combinations
from itertools import accumulate # 累積和作るやつ
from collections import deque
from collections import defaultdict
from heapq import heappop, heappush
from bisect import bisect_left
# 0埋めされた二進数表現
f'{9:05b}'
alpha2num = lambda c: ord(c) - ord('a')
num2alpha = lambda c: chr(c+97)
popcnt = lambda x: bin(x).count("1")
# 数値判定
"1".isdigit()
dh = [-1, 0, 1, 0]
dw = [0, -1, 0, 1]
dh8 = [-1, -1, -1, 0, 0, 1, 1, 1]
dw8 = [-1, 0, 1, -1, 1, -1, 0, 1]
def resolve():
inf = 10**18+1
N, P, Q, R = map(int, input()[:-1].split(" "))
A = [int(x) for x in input()[:-1].split(" ")]
acc = [0] + list(accumulate(A))
setAcc = set(acc)
for x in range(N-3):
base = acc[x]
if base + P not in setAcc: continue
if base + P + Q not in setAcc: continue
if base + P + Q + R not in setAcc: continue
print("Yes")
return
print("No")
resolve()
import sys
sys.setrecursionlimit(500*500)
# if 'pypyjit' in sys.builtin_module_names:
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
input = sys.stdin.readline
from math import gcd
from functools import reduce
# product('ABCD', repeat=2) => AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
from itertools import product
# permutations('ABCD', 2) => AB AC AD BA BC BD CA CB CD DA DB DC
from itertools import permutations
# combinations('ABCD', 2) => AB AC AD BC BD CD
from itertools import combinations
from itertools import accumulate # 累積和作るやつ
from collections import deque
from collections import defaultdict
from heapq import heappop, heappush
from bisect import bisect_left
# 0埋めされた二進数表現
f'{9:05b}'
alpha2num = lambda c: ord(c) - ord('a')
num2alpha = lambda c: chr(c+97)
popcnt = lambda x: bin(x).count("1")
# 数値判定
"1".isdigit()
dh = [-1, 0, 1, 0]
dw = [0, -1, 0, 1]
dh8 = [-1, -1, -1, 0, 0, 1, 1, 1]
dw8 = [-1, 0, 1, -1, 1, -1, 0, 1]
def resolve():
inf = 10**18+1
N, P, Q, R = map(int, input()[:-1].split(" "))
A = [int(x) for x in input()[:-1].split(" ")]
acc = [0] + list(accumulate(A))
setAcc = set(acc)
for x in range(N):
base = acc[x]
if base + P not in setAcc: continue
if base + P + Q not in setAcc: continue
if base + P + Q + R not in setAcc: continue
print("Yes")
return
print("No")
resolve()
| ConDefects/ConDefects/Code/abc265_d/Python/45966660 |
condefects-python_data_235 | # Python3/Pypy3テンプレート集
#ライブラリ-------------------------------------------------------------------
from bisect import *
import heapq
import collections
from collections import deque
from queue import Queue
from itertools import groupby
import itertools
import math
import array
import string
import copy
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from functools import reduce
from operator import and_, or_, xor
#便利スクリプト---------------------------------------------------------------
INF = 10**20
mod = 998244353
MOD = 10**9+7
bigmod = 8128812800000059
def YesNo(b): print("Yes") if b else print("No")
def YESNO(b): print("YES") if b else print("NO")
#標準入力---------------------------------------------------------------------
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
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(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().strip('\n')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def LMS(rows_number): return [MS() for _ in range(rows_number)]
#関数------------------------------------------------------------------------
###標準ライブラリ###
def ceil(a,b): #切り捨て
return (a+b-1)//b
def inv(a,p): #aのpを法とする逆元(aとpは互いに素)
return pow(a,p-2,p)%p
def transpose(A): #二次元配列の転置
A_t = []
for i in range(len(A[0])) :
tmp = []
for v in A :
tmp.append(v[i])
A_t.append(tmp)
return A_t
def rotate_matrix(A): #グリッドを時計回りに90度回転
return transpose(A[::-1])
def removeDuplicates_2D(A): #二次元配列の重複削除
return list(map(list, set(map(tuple, A))))
def convert(S,c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
s = set()
h = len(S)
w = len(S[0])
for i in range(h):
for j in range(w):
if S[i][j] == c:
s.add((i, j))
return s
def normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
mi = min(i for (i, j) in s)
mj = min(j for (i, j) in s)
return set((i - mi, j - mj) for (i, j) in s)
def cumulativeSum_1D(A): #配列Aの累積和
return list(itertools.accumulate(A))
def cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
h = len(S)
w = len(S[0])
CS = [[0 for _ in range(w)]for _ in range(h)]
CCS = [[0 for _ in range(w)]for _ in range(h)]
for i in range(h):
for j in range(w):
if(j==0):
CS[i][0] = S[i][0]
else:
CS[i][j] = CS[i][j-1] + S[i][j]
for i in range(h):
for j in range(w):
if(i==0):
CCS[0][j] = CS[0][j]
else:
CCS[i][j] = CCS[i-1][j] + CS[i][j]
return CCS
def string_to_runLength(S: str): #文字列/リストからラングレス圧縮
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
def runLength_to_string(L: "list[tuple]"): #ラングレス圧縮から文字列 => 文字だけ
res = ""
for c, n in L:
res += c * int(n)
return res
def bfs(i,G): # i:始点
n = len(G)
dist = [-1] * n
pre = [-1] * n
que = deque()
dist[i] = 0
que.append(i)
while not len(que)==0:
v = que.popleft()
for next_v in G[v]:
if dist[next_v] != -1:
continue
dist[next_v] = dist[v] + 1
pre[next_v] = v
que.append(next_v)
return dist,pre
def bfs01(s, G): # i:始点 => dist
N = len(G)
dist = [INF] * N
S = deque([s])
T = deque()
dist[s] = 0
d = 0
while S:
while S:
v = S.popleft()
for c, w in G[v]:
if d+c < dist[w]:
dist[w] = d+c
if c:
T.append(w)
else:
S.append(w)
S, T = T, S
d += 1
return dist
def dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
n = len(G)
hq = [(0, s)]
heapq.heapify(hq)
cost = [INF]*n
cost[s]= 0
pre = [-1] * n
while hq:
c,v = heapq.heappop(hq)
if c > cost[v]:
continue
for d,u in G[v]:
tmp = d+cost[v]
if tmp < cost[u]:
cost[u] = tmp
pre[u] = v
heapq.heappush(hq,(tmp,u))
return cost, pre
def coordinates(A): # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
B = sorted(set(A))
C = { v: i for i, v in enumerate(B) }
D = { i: v for i, v in enumerate(B) }
E = list(map(lambda v: C[v], A))
return C, D, E
def eng_L(): return list(string.ascii_lowercase)
def ENG_L(): return list(string.ascii_uppercase)
def bit_len(n): #bit長
return n.bit_length()
def bit_cnt(n): # bitにしたときの1の数
cnt = 0
for i in range(bit_len(n)+1):
cnt += n>>i & 1
return cnt
def idx_le(A, x): # x 以下の最大の要素位置 / なければ "No"
return bisect_right(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_lt(A, x): # x 未満の最大の要素位置 / なければ "No"
return bisect_left(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_ge(A, x): # x 以上の最小の要素位置 / なければ "No"
return bisect_left(A, x) if bisect_left(A, x) != len(A) else "No"
def idx_gt(A, x): # x 超過の最小の要素位置 / なければ "No"
return bisect_right(A, x) if bisect_right(A, x) != len(A) else "No"
def cnt_le(A, x): # x 以下の要素の個数
if(idx_le(A, x) == "No"): return 0
return idx_le(A, x) + 1
def cnt_lt(A, x): # x 未満の要素の個数
if(idx_lt(A, x) == "No"): return 0
return idx_lt(A, x) + 1
def cnt_ge(A, x): # x 以上の要素の個数
return len(A) - cnt_lt(A, x)
def cnt_gt(A, x): # x 超過の要素の個数
return len(A) - cnt_le(A, x)
###数学ライブラリ###
def allAND(A): # 配列Aの総AND
return reduce(and_, A)
def allOR(A): # 配列Aの総OR
return reduce(or_, A)
def allXOR(A): # 配列Aの総XOR
return reduce(xor, A)
def allGCD(A): # 配列Aの総GCD
if(len(A)==1):
return A[0]
g = math.gcd(A[0],A[1])
for i in range(1,len(A)):
g = math.gcd(g, A[i])
return g
def mex(A): #配列Aのmexを求める
B = set()
for a in A:
if(a>=0):
B.add(a)
B = list(B)
B.sort()
if(len(B)==0):
return 0
if(B[0]!=0):
return 0
m = 0
for i in range(1,len(B)):
if(B[i]==B[i-1]+1):
m +=1
else:
break
return m +1
def gcd(a,b): #aとbの最大公約数を求める
return math.gcd(a,b)
def lcm(a,b): #aとbの最小公倍数を求める
return a*b//gcd(a,b)
def extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b)*x
return d, x, y
return a, 1, 0
def fact_L(n,mod): # [0!, 1! ..., n!] を返す
fact = [1]
p = 1
for i in range(1,n+1):
p *= i
p %= mod
fact.append(p)
return fact
def bitCount_L(n): # n以下のそれぞれのbitカウントを返す
bitcount = [0] * (n+1)
for i in range(1,n+1):
bitcount[i] = bitcount[i//2] + i%2
return bitcount
def factorial(n, m=0): #nの階乗 | m:mod(デフォなし)
if(n<0):
return -1
elif(n==0):
return 1
P = 1
for i in range(1,n+1):
P *= i
if(m==0):
continue
P %= m
return P
def nPr(n, r, m=0): #順列nPr
if(n<=0 or r<0 or n<r):
return -1
if(r==0):
return 1
P = 1
for i in range(n,n-r,-1):
P *= i
if(m==0):
continue
P %= m
return P
def nCr(n, r, m=0): #組み合わせnCr
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
N = 1
for i in range(r):
N *= n-i
if(m==0):
continue
N %= m
R = factorial(r)
return N//R
def nCrm(n,r,m=mod): #逆元を用いた組み合わせnCr%mod
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
over=1
for i in range(n-r+1,n+1):
over *= i
over %= m
under=1
for i in range(1,r+1):
under *= i
under %= m
return over*pow(under,m-2,m)%m
def is_prime(n): #素数判定 => True/False
if n == 2:
return 1
if n == 1 or n%2 == 0:
return 0
m = n - 1
lsb = m & -m
s = lsb.bit_length()-1
d = m // lsb
test_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in test_numbers:
if a == n:
continue
x = pow(a,d,n)
r = 0
if x == 1:
continue
while x != m:
x = pow(x,2,n)
r += 1
if x == 1 or r == s:
return 0
return 1
def prime_L(n): #n以下の素数のリスト
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
def find_prime_factor(n):
if n%2 == 0:
return 2
m = int(n**0.125)+1
for c in range(1,n):
f = lambda a: (pow(a,2,n)+c)%n
y = 0
g = q = r = 1
k = 0
while g == 1:
x = y
while k < 3*r//4:
y = f(y)
k += 1
while k < r and g == 1:
ys = y
for _ in range(min(m, r-k)):
y = f(y)
q = q*abs(x-y)%n
g = math.gcd(q,n)
k += m
k = r
r *= 2
if g == n:
g = 1
y = ys
while g == 1:
y = f(y)
g = math.gcd(abs(x-y),n)
if g == n:
continue
if is_prime(g):
return g
elif is_prime(n//g):
return n//g
else:
return find_prime_factor(g)
def primeFactorization_2L(n): #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
if(n<=10**6):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
else:
res = {}
while not is_prime(n) and n > 1:
p = find_prime_factor(n)
s = 0
while n%p == 0:
n //= p
s += 1
res[p] = s
if n > 1:
res[n] = 1
R = []
for r in res:
R.append([r,res[r]])
R.sort()
return R
def divisor_L(n): #nまでの約数のリスト
if(n==1):
return [1]
if(n<=10**6):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
else:
L = primeFactorization_2L(n)
E = [[]for i in range(len(L))]
for i in range(len(L)):
for j in range(L[i][1]+1):
E[i].append(L[i][0]**j)
D = []
for p in list(itertools.product(*E)):
s = 1
for v in p:
s *= v
D.append(s)
D.sort()
return D
def floorsqrt(n): # N => ⌊√N⌋
# only for n <= 10 ** 18
ok = 10 ** 9 + 10
ng = 0
while ok - ng > 1:
t = (ok + ng) // 2
if t * t > n: ok = t
else: ng = t
return ng
def decimal_to_nAry(num_10,n): #10進数からn進数へ変換する(n<=36) |int型 => str型
str_n = []
while num_10:
if num_10%n >= 10:
str_n.append(chr(num_10%n+55))
else:
str_n.append(str(num_10%n))
num_10 //= n
return "".join(str_n[::-1])
def nAry_to_decimal(X,n): #n進数から10進数へ変換する(n<=36) | str型 => int型
num = 0
X = X.upper()
X = list(X)
for i in range(len(X)):
if(("0"<=X[i]<="9")==False):
X[i] = str(ord(X[i]) - 55)
for i in range(1,len(X)+1):
num += int(X[-i]) * pow(n, (i-1))
return num
def roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
return float(Decimal(x).quantize(Decimal(f"1E{d}"), rounding=ROUND_HALF_UP))
###幾何ライブラリ###
def dsin(d): #度数法でsinを計算する
return math.sin(math.radians(d))
def dcos(d): #度数法でcosを計算する
return math.cos(math.radians(d))
def rotate(x,y,d,cx=0,cy=0): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転 => [x,y]
nx = (x-cx)*dcos(d)-(y-cy)*dsin(d)
ny = (x-cx)*dsin(d)+(y-cy)*dcos(d)
return [nx+cx,ny+cy]
def findAngle(O,A,B): #∠AOBを求める(弧度法)
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
u = s[0]*t[0]+s[1]*t[1]
l = (s[0]**2+s[1]**2)**(1/2) * (t[0]**2+t[1]**2)**(1/2)
v = u/l
t = math.degrees(math.acos(v))
return t
def outerProduct(Av,Bv): #二次元ベクトルの外積(=符号付面積)を求める(a×b)
return Av[0]*Bv[1] - Bv[0]*Av[1]
def CCW(O,A,B): #Oを中心として、Aから見たAとBの位置関係を求める。
# -1: 時計回り, 0: 一直線上, 1: 反時計回り
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
op = outerProduct(s,t)
if(op > 0): return 1
if(op < 0): return -1
if(op == 0): return 0
def matrixMultiplication_2D(a,b,m): #行列の掛け算(a×b) m:mod
I,J,K,L = len(a),len(b[0]),len(b),len(a[0])
if(L!=K):
return -1
c = [[0] * J for _ in range(I)]
for i in range(I) :
for j in range(J) :
for k in range(K) :
c[i][j] += a[i][k] * b[k][j]
c[i][j] %= m
return c
def matrixExponentiation_2D(x,n,m): #行列の累乗 (x^n) m:mod
y = [[0] * len(x) for _ in range(len(x))]
for i in range(len(x)):
y[i][i] = 1
while n > 0:
if n & 1:
y = matrixMultiplication_2D(x,y,m)
x = matrixMultiplication_2D(x,x,m)
n >>= 1
return y
def twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
# 1 : 一方の円が他方の円を完全に含み、2 つの円は接していない
# 2 : 一方の円が他方の円を完全に含み、2 つの円は接している
# 3 : 2 つの円が互いに交差する
# 4 : 2 つの円の内部に共通部分は存在しないが、2 つの円は接している
# 5 : 2 つの円の内部に共通部分は存在せず、2 つの円は接していない
x1 = A[0]
x2 = B[0]
y1 = A[1]
y2 = B[1]
r1 = A[2]
r2 = B[2]
d = abs((x1-x2)+1j*(y1-y2))
if(abs(r2-r1)>d):
return 1
elif(abs(r2-r1)==d):
return 2
elif(r1+r2>d):
return 3
elif(r1+r2==d):
return 4
elif(r1+r2<d):
return 5
###デバッグ用ライブラリ###
def TS(_str): #変数/リストに格納されている値を確認
print('{}: {}'.format(_str, eval(_str)))
def T2d(A): #二次元配列の確認用
for a in A:
print(*a)
def T3d(A): #三次元配列の確認用
for a in A:
T2d(a)
BR()
def BR(): #横線で区切りを入れる
print("---")
#クラス----------------------------------------------------------------------
#カンニングペーパー-----------------------------------------------------------
'''
###標準ライブラリ###
ceil(a,b): #切り捨て
inv(a,p): #xのpを法とする逆元 | pは素数
transpose(A): #二次元配列の転置
rotate_matrix(A): #グリッドを時計回りに90度回転
removeDuplicates_2D(A): #二次元配列の重複削除
convert(S, c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
例)normalize(convert(h,w,A))
cumulativeSum_1D(A) #配列Aの累積和
cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
string_to_runLength(S: str) #文字列/リストからラングレス圧縮 => [(文字,個数), ...]の二次元リスト
runLength_to_string(L: "list[tuple]") #ラングレス圧縮 => 文字列
bfs(i,G) # i:始点 => dist,pre
bfs01(i,G) # i:始点 => dist
dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
coordinates(A) # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
eng_L() #英小文字のリスト
ENG_L() #英大文字のリスト
bit_len(n): #bit長
bit_cnt(n): # bitにしたときの1の数
idx_le(A, x) # x 以下の最大の要素位置 / なければ "No"
idx_lt(A, x) # x 未満の最大の要素位置 / なければ "No"
idx_ge(A, x) # x 以上の最小の要素位置 / なければ "No"
idx_gt(A, x) # x 超過の最小の要素位置 / なければ "No"
cnt_le(A, x) # x 以下の要素の個数
cnt_lt(A, x) # x 未満の要素の個数
cnt_ge(A, x) # x 以上の要素の個数
cnt_gt(A, x) # x 超過の要素の個数
###数学ライブラリ###
allAND(A): # 配列Aの総AND
allOR(A): # 配列Aの総OR
allXOR(A): # 配列Aの総XOR
allGCD(A): # 配列Aの総GCD
mex(A) #配列Aのmexを求める
gcd(a,b) #aとbの最大公約数を求める
lcm(a,b) #aとbの最小公倍数を求める
extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
fact_L(n,mod): # [0!, 1! ..., n!] を返す
bitCount_L(n): # n以下のそれぞれのbitカウントを返す
factorial(n,m) #nの階乗 | m:mod(デフォなし)
nPr(n,r,m) #順列nPr | m:mod(デフォなし)
nCr(n,r,m) #組み合わせ,nCr | m:mod(デフォなし)
nCrm(n,r,m) #逆元を用いた組み合わせnCr%mod
divisor_L(n) #nの約数のリスト
is_prime(n) #素数判定 => True/False
prime_L(n) #nまでの素数のリスト
primeFactorization_2L(n) #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
floorsqrt(n): # N => ⌊√N⌋
decimal_to_nAry(num_10,n) #10進数からn進数へ変換する(n<=36) |int型 => str型
nAry_to_decimal(num_n,n) #n進数から10進数へ変換する(n<=36) | str型 => int型
roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
###幾何ライブラリ###
dsin(d): #度数法でsinを計算する
dcos(d): #度数法でcosを計算する
rotate(x,y,d,cx,cy): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転(デフォ原点) => [x,y]
findAngle(O,A,B) #∠AOBを求める(弧度法) | 引数はそれぞれ[x,y(=座標)]
outerProduct(Av,Bv) #二次元ベクトルの外積(=符号付面積)を求める(a×b) | 引数はそれぞれ[x,y(=座標)]
CCW(O,A,B) #Oを中心として、Aから見たAとBの位置関係
=> -1:時計回り, 0:一直線上, 1:反時計回り | 引数はそれぞれ[x,y(=座標)]
matrixMultiplication_2D(a,b,m) #行列の掛け算(a×b) m:mod | 引数は二次元リスト
matrixExponentiation_2D(x,n m)#行列の累乗 (x^n) m:mod | 引数は二次元リスト
twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
=> 1, 2, 3, 4, 5 各数字に対応する位置関係の説明は上記参照
###デバッグ用ライブラリ###
TS(_str) # 変数/リストに格納されている値を確認 => 〇〇:××
T2d(A): # 二次元配列の確認用
T3d(A): # 三次元配列の確認用
BR() # 横線で区切りを入れる
###文法チートシート###
|S|<x => "0"*(x-|S|) + S : str(n).zfill(x)
全部大文字に変換：str.upper()
全部小文字に変換：str.lower()
先頭のみ大文字に変換：str.capitalize()
各単語の先頭のみ大文字に変換（タイトルケース）:str.title()
大文字と小文字を入れ替える：str.swapcase()
文字 → ASCIIコード ord(s)
ASCIIコード → 文字 chr(x)
ASCII表
65:A ~ 90:Z
97:a ~ 122:z
'''
#PyPyで再帰関数を用いる場合はコメントを外す----------------------------------
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
#----------------------------------------------------------------------------
n,p,q,r = MI()
A = LI()
CA = [0] + cumulativeSum_1D(A)
sCA = set(CA)
for i in range(len(CA)):
if(p-CA[i] in sCA and p+q-CA[i] in sCA and p+q+r-CA[i] in sCA):
print("Yes")
exit()
print("No")
# Python3/Pypy3テンプレート集
#ライブラリ-------------------------------------------------------------------
from bisect import *
import heapq
import collections
from collections import deque
from queue import Queue
from itertools import groupby
import itertools
import math
import array
import string
import copy
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from functools import reduce
from operator import and_, or_, xor
#便利スクリプト---------------------------------------------------------------
INF = 10**20
mod = 998244353
MOD = 10**9+7
bigmod = 8128812800000059
def YesNo(b): print("Yes") if b else print("No")
def YESNO(b): print("YES") if b else print("NO")
#標準入力---------------------------------------------------------------------
import sys
sys.setrecursionlimit(10 ** 5 + 10000)
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(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return input().strip('\n')
def MS(): return input().split()
def LS(): return list(input().strip('\n'))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def LMS(rows_number): return [MS() for _ in range(rows_number)]
#関数------------------------------------------------------------------------
###標準ライブラリ###
def ceil(a,b): #切り捨て
return (a+b-1)//b
def inv(a,p): #aのpを法とする逆元(aとpは互いに素)
return pow(a,p-2,p)%p
def transpose(A): #二次元配列の転置
A_t = []
for i in range(len(A[0])) :
tmp = []
for v in A :
tmp.append(v[i])
A_t.append(tmp)
return A_t
def rotate_matrix(A): #グリッドを時計回りに90度回転
return transpose(A[::-1])
def removeDuplicates_2D(A): #二次元配列の重複削除
return list(map(list, set(map(tuple, A))))
def convert(S,c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
s = set()
h = len(S)
w = len(S[0])
for i in range(h):
for j in range(w):
if S[i][j] == c:
s.add((i, j))
return s
def normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
mi = min(i for (i, j) in s)
mj = min(j for (i, j) in s)
return set((i - mi, j - mj) for (i, j) in s)
def cumulativeSum_1D(A): #配列Aの累積和
return list(itertools.accumulate(A))
def cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
h = len(S)
w = len(S[0])
CS = [[0 for _ in range(w)]for _ in range(h)]
CCS = [[0 for _ in range(w)]for _ in range(h)]
for i in range(h):
for j in range(w):
if(j==0):
CS[i][0] = S[i][0]
else:
CS[i][j] = CS[i][j-1] + S[i][j]
for i in range(h):
for j in range(w):
if(i==0):
CCS[0][j] = CS[0][j]
else:
CCS[i][j] = CCS[i-1][j] + CS[i][j]
return CCS
def string_to_runLength(S: str): #文字列/リストからラングレス圧縮
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, int(len(list(v)))))
return res
def runLength_to_string(L: "list[tuple]"): #ラングレス圧縮から文字列 => 文字だけ
res = ""
for c, n in L:
res += c * int(n)
return res
def bfs(i,G): # i:始点
n = len(G)
dist = [-1] * n
pre = [-1] * n
que = deque()
dist[i] = 0
que.append(i)
while not len(que)==0:
v = que.popleft()
for next_v in G[v]:
if dist[next_v] != -1:
continue
dist[next_v] = dist[v] + 1
pre[next_v] = v
que.append(next_v)
return dist,pre
def bfs01(s, G): # i:始点 => dist
N = len(G)
dist = [INF] * N
S = deque([s])
T = deque()
dist[s] = 0
d = 0
while S:
while S:
v = S.popleft()
for c, w in G[v]:
if d+c < dist[w]:
dist[w] = d+c
if c:
T.append(w)
else:
S.append(w)
S, T = T, S
d += 1
return dist
def dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
n = len(G)
hq = [(0, s)]
heapq.heapify(hq)
cost = [INF]*n
cost[s]= 0
pre = [-1] * n
while hq:
c,v = heapq.heappop(hq)
if c > cost[v]:
continue
for d,u in G[v]:
tmp = d+cost[v]
if tmp < cost[u]:
cost[u] = tmp
pre[u] = v
heapq.heappush(hq,(tmp,u))
return cost, pre
def coordinates(A): # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
B = sorted(set(A))
C = { v: i for i, v in enumerate(B) }
D = { i: v for i, v in enumerate(B) }
E = list(map(lambda v: C[v], A))
return C, D, E
def eng_L(): return list(string.ascii_lowercase)
def ENG_L(): return list(string.ascii_uppercase)
def bit_len(n): #bit長
return n.bit_length()
def bit_cnt(n): # bitにしたときの1の数
cnt = 0
for i in range(bit_len(n)+1):
cnt += n>>i & 1
return cnt
def idx_le(A, x): # x 以下の最大の要素位置 / なければ "No"
return bisect_right(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_lt(A, x): # x 未満の最大の要素位置 / なければ "No"
return bisect_left(A, x)-1 if bisect_right(A, x)-1 != -1 else "No"
def idx_ge(A, x): # x 以上の最小の要素位置 / なければ "No"
return bisect_left(A, x) if bisect_left(A, x) != len(A) else "No"
def idx_gt(A, x): # x 超過の最小の要素位置 / なければ "No"
return bisect_right(A, x) if bisect_right(A, x) != len(A) else "No"
def cnt_le(A, x): # x 以下の要素の個数
if(idx_le(A, x) == "No"): return 0
return idx_le(A, x) + 1
def cnt_lt(A, x): # x 未満の要素の個数
if(idx_lt(A, x) == "No"): return 0
return idx_lt(A, x) + 1
def cnt_ge(A, x): # x 以上の要素の個数
return len(A) - cnt_lt(A, x)
def cnt_gt(A, x): # x 超過の要素の個数
return len(A) - cnt_le(A, x)
###数学ライブラリ###
def allAND(A): # 配列Aの総AND
return reduce(and_, A)
def allOR(A): # 配列Aの総OR
return reduce(or_, A)
def allXOR(A): # 配列Aの総XOR
return reduce(xor, A)
def allGCD(A): # 配列Aの総GCD
if(len(A)==1):
return A[0]
g = math.gcd(A[0],A[1])
for i in range(1,len(A)):
g = math.gcd(g, A[i])
return g
def mex(A): #配列Aのmexを求める
B = set()
for a in A:
if(a>=0):
B.add(a)
B = list(B)
B.sort()
if(len(B)==0):
return 0
if(B[0]!=0):
return 0
m = 0
for i in range(1,len(B)):
if(B[i]==B[i-1]+1):
m +=1
else:
break
return m +1
def gcd(a,b): #aとbの最大公約数を求める
return math.gcd(a,b)
def lcm(a,b): #aとbの最小公倍数を求める
return a*b//gcd(a,b)
def extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
if b:
d, y, x = extgcd(b, a % b)
y -= (a // b)*x
return d, x, y
return a, 1, 0
def fact_L(n,mod): # [0!, 1! ..., n!] を返す
fact = [1]
p = 1
for i in range(1,n+1):
p *= i
p %= mod
fact.append(p)
return fact
def bitCount_L(n): # n以下のそれぞれのbitカウントを返す
bitcount = [0] * (n+1)
for i in range(1,n+1):
bitcount[i] = bitcount[i//2] + i%2
return bitcount
def factorial(n, m=0): #nの階乗 | m:mod(デフォなし)
if(n<0):
return -1
elif(n==0):
return 1
P = 1
for i in range(1,n+1):
P *= i
if(m==0):
continue
P %= m
return P
def nPr(n, r, m=0): #順列nPr
if(n<=0 or r<0 or n<r):
return -1
if(r==0):
return 1
P = 1
for i in range(n,n-r,-1):
P *= i
if(m==0):
continue
P %= m
return P
def nCr(n, r, m=0): #組み合わせnCr
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
N = 1
for i in range(r):
N *= n-i
if(m==0):
continue
N %= m
R = factorial(r)
return N//R
def nCrm(n,r,m=mod): #逆元を用いた組み合わせnCr%mod
if(n<r):
return 0
if(n==r):
return 1
if(n<=0 or r<0 or n<r):
return -1
over=1
for i in range(n-r+1,n+1):
over *= i
over %= m
under=1
for i in range(1,r+1):
under *= i
under %= m
return over*pow(under,m-2,m)%m
def is_prime(n): #素数判定 => True/False
if n == 2:
return 1
if n == 1 or n%2 == 0:
return 0
m = n - 1
lsb = m & -m
s = lsb.bit_length()-1
d = m // lsb
test_numbers = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
for a in test_numbers:
if a == n:
continue
x = pow(a,d,n)
r = 0
if x == 1:
continue
while x != m:
x = pow(x,2,n)
r += 1
if x == 1 or r == s:
return 0
return 1
def prime_L(n): #n以下の素数のリスト
is_prime = [True] * (n + 1)
is_prime[0] = False
is_prime[1] = False
for i in range(2, int(n**0.5) + 1):
if not is_prime[i]:
continue
for j in range(i * 2, n + 1, i):
is_prime[j] = False
return [i for i in range(n + 1) if is_prime[i]]
def find_prime_factor(n):
if n%2 == 0:
return 2
m = int(n**0.125)+1
for c in range(1,n):
f = lambda a: (pow(a,2,n)+c)%n
y = 0
g = q = r = 1
k = 0
while g == 1:
x = y
while k < 3*r//4:
y = f(y)
k += 1
while k < r and g == 1:
ys = y
for _ in range(min(m, r-k)):
y = f(y)
q = q*abs(x-y)%n
g = math.gcd(q,n)
k += m
k = r
r *= 2
if g == n:
g = 1
y = ys
while g == 1:
y = f(y)
g = math.gcd(abs(x-y),n)
if g == n:
continue
if is_prime(g):
return g
elif is_prime(n//g):
return n//g
else:
return find_prime_factor(g)
def primeFactorization_2L(n): #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
if(n<=10**6):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
else:
res = {}
while not is_prime(n) and n > 1:
p = find_prime_factor(n)
s = 0
while n%p == 0:
n //= p
s += 1
res[p] = s
if n > 1:
res[n] = 1
R = []
for r in res:
R.append([r,res[r]])
R.sort()
return R
def divisor_L(n): #nまでの約数のリスト
if(n==1):
return [1]
if(n<=10**6):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
else:
L = primeFactorization_2L(n)
E = [[]for i in range(len(L))]
for i in range(len(L)):
for j in range(L[i][1]+1):
E[i].append(L[i][0]**j)
D = []
for p in list(itertools.product(*E)):
s = 1
for v in p:
s *= v
D.append(s)
D.sort()
return D
def floorsqrt(n): # N => ⌊√N⌋
# only for n <= 10 ** 18
ok = 10 ** 9 + 10
ng = 0
while ok - ng > 1:
t = (ok + ng) // 2
if t * t > n: ok = t
else: ng = t
return ng
def decimal_to_nAry(num_10,n): #10進数からn進数へ変換する(n<=36) |int型 => str型
str_n = []
while num_10:
if num_10%n >= 10:
str_n.append(chr(num_10%n+55))
else:
str_n.append(str(num_10%n))
num_10 //= n
return "".join(str_n[::-1])
def nAry_to_decimal(X,n): #n進数から10進数へ変換する(n<=36) | str型 => int型
num = 0
X = X.upper()
X = list(X)
for i in range(len(X)):
if(("0"<=X[i]<="9")==False):
X[i] = str(ord(X[i]) - 55)
for i in range(1,len(X)+1):
num += int(X[-i]) * pow(n, (i-1))
return num
def roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
return float(Decimal(x).quantize(Decimal(f"1E{d}"), rounding=ROUND_HALF_UP))
###幾何ライブラリ###
def dsin(d): #度数法でsinを計算する
return math.sin(math.radians(d))
def dcos(d): #度数法でcosを計算する
return math.cos(math.radians(d))
def rotate(x,y,d,cx=0,cy=0): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転 => [x,y]
nx = (x-cx)*dcos(d)-(y-cy)*dsin(d)
ny = (x-cx)*dsin(d)+(y-cy)*dcos(d)
return [nx+cx,ny+cy]
def findAngle(O,A,B): #∠AOBを求める(弧度法)
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
u = s[0]*t[0]+s[1]*t[1]
l = (s[0]**2+s[1]**2)**(1/2) * (t[0]**2+t[1]**2)**(1/2)
v = u/l
t = math.degrees(math.acos(v))
return t
def outerProduct(Av,Bv): #二次元ベクトルの外積(=符号付面積)を求める(a×b)
return Av[0]*Bv[1] - Bv[0]*Av[1]
def CCW(O,A,B): #Oを中心として、Aから見たAとBの位置関係を求める。
# -1: 時計回り, 0: 一直線上, 1: 反時計回り
s = [A[0]-O[0],A[1]-O[1]]
t = [B[0]-O[0],B[1]-O[1]]
op = outerProduct(s,t)
if(op > 0): return 1
if(op < 0): return -1
if(op == 0): return 0
def matrixMultiplication_2D(a,b,m): #行列の掛け算(a×b) m:mod
I,J,K,L = len(a),len(b[0]),len(b),len(a[0])
if(L!=K):
return -1
c = [[0] * J for _ in range(I)]
for i in range(I) :
for j in range(J) :
for k in range(K) :
c[i][j] += a[i][k] * b[k][j]
c[i][j] %= m
return c
def matrixExponentiation_2D(x,n,m): #行列の累乗 (x^n) m:mod
y = [[0] * len(x) for _ in range(len(x))]
for i in range(len(x)):
y[i][i] = 1
while n > 0:
if n & 1:
y = matrixMultiplication_2D(x,y,m)
x = matrixMultiplication_2D(x,x,m)
n >>= 1
return y
def twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
# 1 : 一方の円が他方の円を完全に含み、2 つの円は接していない
# 2 : 一方の円が他方の円を完全に含み、2 つの円は接している
# 3 : 2 つの円が互いに交差する
# 4 : 2 つの円の内部に共通部分は存在しないが、2 つの円は接している
# 5 : 2 つの円の内部に共通部分は存在せず、2 つの円は接していない
x1 = A[0]
x2 = B[0]
y1 = A[1]
y2 = B[1]
r1 = A[2]
r2 = B[2]
d = abs((x1-x2)+1j*(y1-y2))
if(abs(r2-r1)>d):
return 1
elif(abs(r2-r1)==d):
return 2
elif(r1+r2>d):
return 3
elif(r1+r2==d):
return 4
elif(r1+r2<d):
return 5
###デバッグ用ライブラリ###
def TS(_str): #変数/リストに格納されている値を確認
print('{}: {}'.format(_str, eval(_str)))
def T2d(A): #二次元配列の確認用
for a in A:
print(*a)
def T3d(A): #三次元配列の確認用
for a in A:
T2d(a)
BR()
def BR(): #横線で区切りを入れる
print("---")
#クラス----------------------------------------------------------------------
#カンニングペーパー-----------------------------------------------------------
'''
###標準ライブラリ###
ceil(a,b): #切り捨て
inv(a,p): #xのpを法とする逆元 | pは素数
transpose(A): #二次元配列の転置
rotate_matrix(A): #グリッドを時計回りに90度回転
removeDuplicates_2D(A): #二次元配列の重複削除
convert(S, c): # グリッドをの 黒 マスの点集合に変換する | S: グリッド c:黒マスがなにか(ex #,1)
normalize(s): # グリッドの # マスの点集合を与えると最小の x 座標と最小の y 座標がともに 0 となるように平行移動して返す
例)normalize(convert(h,w,A))
cumulativeSum_1D(A) #配列Aの累積和
cumulativeSum_2D(S): #二次元配列Sの累積和 => 二次元リスト
string_to_runLength(S: str) #文字列/リストからラングレス圧縮 => [(文字,個数), ...]の二次元リスト
runLength_to_string(L: "list[tuple]") #ラングレス圧縮 => 文字列
bfs(i,G) # i:始点 => dist,pre
bfs01(i,G) # i:始点 => dist
dijkstra(s,G): #s:始点 => cost,pre | G:タプルの中身(コスト,行先)
coordinates(A) # 変換表(元の値 : 座標圧縮の値),変換表2(座標圧縮の値: 元の値), 圧縮後配列
eng_L() #英小文字のリスト
ENG_L() #英大文字のリスト
bit_len(n): #bit長
bit_cnt(n): # bitにしたときの1の数
idx_le(A, x) # x 以下の最大の要素位置 / なければ "No"
idx_lt(A, x) # x 未満の最大の要素位置 / なければ "No"
idx_ge(A, x) # x 以上の最小の要素位置 / なければ "No"
idx_gt(A, x) # x 超過の最小の要素位置 / なければ "No"
cnt_le(A, x) # x 以下の要素の個数
cnt_lt(A, x) # x 未満の要素の個数
cnt_ge(A, x) # x 以上の要素の個数
cnt_gt(A, x) # x 超過の要素の個数
###数学ライブラリ###
allAND(A): # 配列Aの総AND
allOR(A): # 配列Aの総OR
allXOR(A): # 配列Aの総XOR
allGCD(A): # 配列Aの総GCD
mex(A) #配列Aのmexを求める
gcd(a,b) #aとbの最大公約数を求める
lcm(a,b) #aとbの最小公倍数を求める
extgcd(a, b): # a,b =>ax+by=gcd(a,b)を満たす(g,x,y) a,bが互いに素のとき、xはaのbを法とする逆元
fact_L(n,mod): # [0!, 1! ..., n!] を返す
bitCount_L(n): # n以下のそれぞれのbitカウントを返す
factorial(n,m) #nの階乗 | m:mod(デフォなし)
nPr(n,r,m) #順列nPr | m:mod(デフォなし)
nCr(n,r,m) #組み合わせ,nCr | m:mod(デフォなし)
nCrm(n,r,m) #逆元を用いた組み合わせnCr%mod
divisor_L(n) #nの約数のリスト
is_prime(n) #素数判定 => True/False
prime_L(n) #nまでの素数のリスト
primeFactorization_2L(n) #2以上の整数n => [[素因数, 指数], ...]の2次元リスト
floorsqrt(n): # N => ⌊√N⌋
decimal_to_nAry(num_10,n) #10進数からn進数へ変換する(n<=36) |int型 => str型
nAry_to_decimal(num_n,n) #n進数から10進数へ変換する(n<=36) | str型 => int型
roundOff(x,d): #四捨五入する x:対象の数字, d:四捨五入する位(正|負) => float型の数値
###幾何ライブラリ###
dsin(d): #度数法でsinを計算する
dcos(d): #度数法でcosを計算する
rotate(x,y,d,cx,cy): #P(x,y)をA(cx,cy)を中心としてに反時計回りにd°回転(デフォ原点) => [x,y]
findAngle(O,A,B) #∠AOBを求める(弧度法) | 引数はそれぞれ[x,y(=座標)]
outerProduct(Av,Bv) #二次元ベクトルの外積(=符号付面積)を求める(a×b) | 引数はそれぞれ[x,y(=座標)]
CCW(O,A,B) #Oを中心として、Aから見たAとBの位置関係
=> -1:時計回り, 0:一直線上, 1:反時計回り | 引数はそれぞれ[x,y(=座標)]
matrixMultiplication_2D(a,b,m) #行列の掛け算(a×b) m:mod | 引数は二次元リスト
matrixExponentiation_2D(x,n m)#行列の累乗 (x^n) m:mod | 引数は二次元リスト
twoCircles(A,B): #二つの円の半径の位置関係 | 引数はそれぞれ[x,y(=座標),r(=半径)]
=> 1, 2, 3, 4, 5 各数字に対応する位置関係の説明は上記参照
###デバッグ用ライブラリ###
TS(_str) # 変数/リストに格納されている値を確認 => 〇〇:××
T2d(A): # 二次元配列の確認用
T3d(A): # 三次元配列の確認用
BR() # 横線で区切りを入れる
###文法チートシート###
|S|<x => "0"*(x-|S|) + S : str(n).zfill(x)
全部大文字に変換：str.upper()
全部小文字に変換：str.lower()
先頭のみ大文字に変換：str.capitalize()
各単語の先頭のみ大文字に変換（タイトルケース）:str.title()
大文字と小文字を入れ替える：str.swapcase()
文字 → ASCIIコード ord(s)
ASCIIコード → 文字 chr(x)
ASCII表
65:A ~ 90:Z
97:a ~ 122:z
'''
#PyPyで再帰関数を用いる場合はコメントを外す----------------------------------
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
#----------------------------------------------------------------------------
n,p,q,r = MI()
A = LI()
CA = [0] + cumulativeSum_1D(A)
sCA = set(CA)
for i in range(len(CA)):
if(CA[i]+p in sCA and CA[i]+p+q in sCA and CA[i]+p+q+r in sCA):
print("Yes")
exit()
print("No")
| ConDefects/ConDefects/Code/abc265_d/Python/45502599 |
condefects-python_data_236 | # Aの累積和を出すと、Ax がわかれば、あとは SA[x] + P SA[x] + P + Q, SA[x] + P + Q + Z
# の数字が累積和中に出現するか調べればよい ただそのまま配列を走査すると、O(N)かかり
# X の走査と併せて O(N**2) となってしまうので、累積和の値をset または dict に突っ込んで
# 存在判定するとよい
import numpy
N, P, Q, R = map(int, input().split())
A = list(map(int, input().split()))
SA = numpy.cumsum(A)
sa_set = set()
for sa in SA:
sa_set.add(sa)
for sa in SA:
if sa + P in sa_set and sa + P + Q in sa_set and sa + P + Q + R in sa_set:
print("Yes")
exit()
print("No")
# Aの累積和を出すと、Ax がわかれば、あとは SA[x] + P SA[x] + P + Q, SA[x] + P + Q + Z
# の数字が累積和中に出現するか調べればよい ただそのまま配列を走査すると、O(N)かかり
# X の走査と併せて O(N**2) となってしまうので、累積和の値をset または dict に突っ込んで
# 存在判定するとよい
import numpy
N, P, Q, R = map(int, input().split())
A = list(map(int, input().split()))
SA = numpy.cumsum([0] + A)
sa_set = set()
for sa in SA:
sa_set.add(sa)
for sa in SA:
if sa + P in sa_set and sa + P + Q in sa_set and sa + P + Q + R in sa_set:
print("Yes")
exit()
print("No")
| ConDefects/ConDefects/Code/abc265_d/Python/46180053 |
condefects-python_data_237 | N,M=map(int, input().split())
ans=1<<60
for i in range(1, int(M**(1/2))+1):
if i>N: break
b=(M+i-1)//i
if b>N: continue
ans=min(ans, i*b)
if ans==1<<60: ans=-1
print(ans)
N,M=map(int, input().split())
ans=1<<60
for i in range(1, int(M**(1/2))+2):
if i>N: break
b=(M+i-1)//i
if b>N: continue
ans=min(ans, i*b)
if ans==1<<60: ans=-1
print(ans) | ConDefects/ConDefects/Code/abc296_d/Python/45931532 |
condefects-python_data_238 | # D - M<=ab
import math
def main():
N, M = map(int, input().split())
n = int(math.sqrt(M*10))
ans = []
for a in range(1, n+1):
b = ceil(M, a)
if b <= N:
ans.append(a*b)
if len(ans) == 0:
print(-1)
else:
print(min(ans))
def ceil(dividend, divisor):
q = dividend // divisor
if dividend % divisor > 0:
q += 1
return q
if __name__ == '__main__':
main()
# D - M<=ab
import math
def main():
N, M = map(int, input().split())
n = int(math.sqrt(M*10))
ans = []
for a in range(1, min(n, N)+1):
b = ceil(M, a)
if b <= N:
ans.append(a*b)
if len(ans) == 0:
print(-1)
else:
print(min(ans))
def ceil(dividend, divisor):
q = dividend // divisor
if dividend % divisor > 0:
q += 1
return q
if __name__ == '__main__':
main() | ConDefects/ConDefects/Code/abc296_d/Python/45933759 |
condefects-python_data_239 | import math
n,m=map(int,input().split(' '))
ans=-1
for i in range(1, min(n,int(math.sqrt(m)))+1):
k = (m+i-1)//i
if(k>=1 and k<=n):
if(ans==-1):
ans=k*i
else:
ans=min(ans, k*i)
print(ans)
import math
n,m=map(int,input().split(' '))
ans=-1
for i in range(1, min(n,int(math.sqrt(m))+1)+1):
k = (m+i-1)//i
if(k>=1 and k<=n):
if(ans==-1):
ans=k*i
else:
ans=min(ans, k*i)
print(ans) | ConDefects/ConDefects/Code/abc296_d/Python/45553301 |
condefects-python_data_240 | import math
from math import ceil
n, m = map(int, input().split())
ans = n ** 2 + 2
if m > n ** 2:
print(-1)
exit()
for i in range(1, 10 ** 6 + 1):
p = ceil(m / i)
if 1 <= p <= n and m <= i * p <= n ** 2:
ans = min(ans, i * p)
if ans == n ** 2 + 2:
print(-1)
else:
print(ans)
import math
from math import ceil
n, m = map(int, input().split())
ans = n ** 2 + 2
if m > n ** 2:
print(-1)
exit()
for i in range(1, 10 ** 6 + 1):
p = ceil(m / i)
if 1 <= p <= n and m <= i * p <= n ** 2 and 1 <= i <= n:
ans = min(ans, i * p)
if ans == n ** 2 + 2:
print(-1)
else:
print(ans) | ConDefects/ConDefects/Code/abc296_d/Python/45799143 |
condefects-python_data_241 | n, m = map(int, input().split())
if n**2 < m:
print(-1)
exit()
sq = int(m**0.5)
ans = 10**12 + 1
for i in range(1, sq + 1):
j = m // i + 1
if i * j >= m and 1 <= i <= n and 1 <= j <= n:
ans = min(ans, i * j)
j = m // i
if i * j >= m and 1 <= i <= n and 1 <= j <= n:
ans = min(ans, i * j)
if ans == 10**12 + 1:
print(-1)
else:
print(ans)
n, m = map(int, input().split())
if n**2 < m:
print(-1)
exit()
sq = int(m**0.5)
ans = 10**12 + 1
for i in range(1, sq + 5):
j = m // i + 1
if i * j >= m and 1 <= i <= n and 1 <= j <= n:
ans = min(ans, i * j)
j = m // i
if i * j >= m and 1 <= i <= n and 1 <= j <= n:
ans = min(ans, i * j)
if ans == 10**12 + 1:
print(-1)
else:
print(ans)
| ConDefects/ConDefects/Code/abc296_d/Python/45976166 |
condefects-python_data_242 | N,M = map(int,input().split())
if N**2 < M:
print(-1)
exit()
ans = 10**100
for i in range(1,int(M**0.5)+10):
if M%i == 0 and M//i <= N and i<=N:
ans = min(ans,M)
continue
elif i * (M//i+1) >= M and i<=N and M//i+1:
ans = min(ans,i*(M//i+1))
continue
if ans == 10**100:
print(-1)
else:
print(ans)
N,M = map(int,input().split())
if N**2 < M:
print(-1)
exit()
ans = 10**100
for i in range(1,int(M**0.5)+10):
if M%i == 0 and M//i <= N and i<=N:
ans = min(ans,M)
continue
elif i * (M//i+1) >= M and i<=N and (M//i+1)<=N:
ans = min(ans,i*(M//i+1))
continue
if ans == 10**100:
print(-1)
else:
print(ans)
| ConDefects/ConDefects/Code/abc296_d/Python/45768294 |
condefects-python_data_243 | n,m=map(int,input().split())
ans=float('inf')
for a in range(1,int(m**0.5)+1):
b=-(-m//a)
if a<=n and b<=n:
ans=min(ans,a*b)
if ans==float('inf'):
print(-1)
else:
print(ans)
n,m=map(int,input().split())
ans=float('inf')
for a in range(1,int(m**0.5)+2):
b=-(-m//a)
if a<=n and b<=n:
ans=min(ans,a*b)
if ans==float('inf'):
print(-1)
else:
print(ans)
| ConDefects/ConDefects/Code/abc296_d/Python/45742817 |
condefects-python_data_244 | x,k = list(map(int,input().split(" ")))
for i in range(k):
x = round(x+0.0001,-(i+1))
print(int(x))
x,k = list(map(int,input().split(" ")))
for i in range(k):
x = round(x+0.9,-(i+1))
print(int(x)) | ConDefects/ConDefects/Code/abc273_b/Python/45324083 |
condefects-python_data_245 | def change(i,rnk):
s=str(i)
if len(s)>rnk+1:
if int(s[-rnk-1])>=5:
return str(int(s[:-rnk-1])+1)+"0"*(rnk+1)
else:
return s[:-rnk-1]+"0"*(rnk+1)
elif len(s)==rnk+1:
if int(s[0])>=5:
return "1"+"0"*len(s)
else:
return "0"*len(s)
else:
return "0"
x,k=map(int,input().split())
for i in range(k):
x=change(x,i)
print(x)
def change(i,rnk):
s=str(i)
if len(s)>rnk+1:
if int(s[-rnk-1])>=5:
return str(int(s[:-rnk-1])+1)+"0"*(rnk+1)
else:
return s[:-rnk-1]+"0"*(rnk+1)
elif len(s)==rnk+1:
if int(s[0])>=5:
return "1"+"0"*len(s)
else:
return "0"
else:
return "0"
x,k=map(int,input().split())
for i in range(k):
x=change(x,i)
print(x) | ConDefects/ConDefects/Code/abc273_b/Python/45948106 |
condefects-python_data_246 | x,k=map(int,input().split())
for i in range(k):
if x%10**i<5*10**i:
x=x//10**(1+i)*10**(1+i)
else:
x=(x//10**(1+i)+1)*10**(1+i)
print(x)
x,k=map(int,input().split())
for i in range(k):
if x%10**(1+i)<5*10**i:
x=x//10**(1+i)*10**(1+i)
else:
x=(x//10**(1+i)+1)*10**(1+i)
print(x) | ConDefects/ConDefects/Code/abc273_b/Python/46029599 |
condefects-python_data_247 | x, k = map(int,input().split())
p = 1
for i in range(k):
x /= p
m = x % 10
if m <= 4:
x -= m
else:
x += 10 - m
x *= p
p *= 10
print(x)
x, k = map(int,input().split())
p = 1
for i in range(k):
x /= p
m = x % 10
if m <= 4:
x -= m
else:
x += 10 - m
x *= p
p *= 10
print(int(x))
| ConDefects/ConDefects/Code/abc273_b/Python/46013086 |
condefects-python_data_248 | x, k = map(int, input().split())
for i in range(k):
p, q = divmod(x, 10**(i+1))
if q >= 5:
p += 1
x = p*10**(i+1)
print(x)
x, k = map(int, input().split())
for i in range(k):
p, q = divmod(x, 10**(i+1))
if q//10**i >= 5:
p += 1
x = p*10**(i+1)
print(x)
| ConDefects/ConDefects/Code/abc273_b/Python/45010464 |
condefects-python_data_249 | N = int(input())
S = input()
d = S.split("C")
d = ["A" * p.count("A") + "B" * p.count("B") for p in d]
print("C".join(d))
N = int(input())
S = input()
d = S.split("C")
d = ["A" * (p.count("A") + p.count("B") // 2) + "B" * (p.count("B") % 2) for p in d]
print("C".join(d)) | ConDefects/ConDefects/Code/arc136_a/Python/43450838 |
condefects-python_data_250 | n=int(input())
s=input()
L=[]
for i in range(n):
if s[i]=="A":
L.append("B")
L.append("B")
else:
L.append(s[i])
now=0
while now<len(L):
if now==len(L)-1:
print(L[i])
now+=1
elif L[now]=="B" and L[now+1]=="B":
print("A",end="")
now+=2
else:
print(L[now],end="")
now+=1
n=int(input())
s=input()
L=[]
for i in range(n):
if s[i]=="A":
L.append("B")
L.append("B")
else:
L.append(s[i])
now=0
while now<len(L):
if now==len(L)-1:
print(L[now])
now+=1
elif L[now]=="B" and L[now+1]=="B":
print("A",end="")
now+=2
else:
print(L[now],end="")
now+=1 | ConDefects/ConDefects/Code/arc136_a/Python/44851620 |
condefects-python_data_251 | N = int(input())
S = input()
while "A" in S:
S = S.replace("A", "B")
while "BB" in S:
S = S.replace("BB", "A")
print(S)
N = int(input())
S = input()
while "A" in S:
S = S.replace("A", "BB")
while "BB" in S:
S = S.replace("BB", "A")
print(S)
| ConDefects/ConDefects/Code/arc136_a/Python/45786138 |
condefects-python_data_252 | # LUOGU_RID: 117445639
print(input().replace('A','BB').replace('BB','A'))
input()
print(input().replace('A','BB').replace('BB','A')) | ConDefects/ConDefects/Code/arc136_a/Python/43956932 |
condefects-python_data_253 | def main():
# write code here.
N,H = MI()
time2coord = LM()
coord2idx = DD(int)
idx2coord = [-1]*N
for idx,coord in enumerate(sorted(time2coord)):
coord2idx[coord] = idx
idx2coord[idx] = coord
time2idx = [coord2idx[time2coord[idx]] for idx in range(N)]
idx2island_ID = [0]*N
crr_id = 0
prev = idx2coord[0]
for idx in range(1,N):
crr_coord = idx2coord[idx]
if crr_coord - prev > H:
crr_id += 1
idx2island_ID[idx] = crr_id
prev = crr_coord
island_size = idx2island_ID[-1]+1
from atcoder.segtree import SegTree
def prob_mul(x,y):
return (x[0]*y[0]%MOD, x[1]+y[1])
def prob_add(x,y):
if x[1]<y[1]:
x,y=y,x
assert x[1]>=y[1]
numerator = x[0]+y[0]*pow(2,x[1]-y[1],MOD)
numerator %= MOD
return (numerator, x[1])
e0 = (1,0)
island_fin_prob = SegTree(prob_mul, e0, [(0,0)]*island_size)
ans = [0]*N
right_req = [0]*N
left_req = [0]*N
ss_of_idx = SortedSet()
for time in range(N):
now = 0
idx = time2idx[time]
island_id = idx2island_ID[idx]
ss_of_idx.add(idx)
adj_right = ss_of_idx.gt(idx)
if adj_right is not None and island_id == idx2island_ID[adj_right]:
right_req[idx] = right_req[adj_right] + 1
adj_left = ss_of_idx.lt(idx)
if adj_left is not None and island_id == idx2island_ID[adj_left]:
left_req[idx] = left_req[adj_left] + 1
DB(time=time)
DB(idx, adj_right, adj_left)
DB(right_req[idx], left_req[idx])
DB(island_id)
other_fin_prob = prob_mul(island_fin_prob.prod(0,island_id), island_fin_prob.prod(island_id+1,island_size))
crr_prob = (0,0)
#右が全部倒れていて左に倒れるパターン.
if idx==N-1 or island_id != idx2island_ID[idx+1] or adj_right == idx+1:
crr_prob = prob_add(crr_prob, (1,1+left_req[idx]+right_req[idx]))
prob = prob_mul((1,1+left_req[idx]+right_req[idx]), other_fin_prob)
now += prob[0] * pow(2, N-prob[1], MOD)
now %= MOD
#左が全部倒れていて右に倒れるパターン.
if idx==0 or island_id != idx2island_ID[idx-1] or adj_left == idx-1:
crr_prob = prob_add(crr_prob, (1,1+left_req[idx]+right_req[idx]))
prob = prob_mul((1,1+left_req[idx]+right_req[idx]), other_fin_prob)
now += prob[0] * pow(2, N-prob[1], MOD)
now %= MOD
ans[time] = now
prev_prob = island_fin_prob.get(island_id)
island_fin_prob.set(island_id, prob_add(prev_prob, crr_prob))
print(*ans)
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(coeff1, coeff0, bound_included1, bound_included2, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
if MOD:
# MODが素数でない場合にも対応するように、和公式を適応後に剰余を計算している.
return ((coeff0%MOD*((right-left+1)%MOD)%MOD) + (coeff1%MOD*((left+right)*(right-left+1)//2%MOD)%MOD))%MOD
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mul_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mul_matrix(res, mat, mod)
mat = mul_matrix(mat, mat, mod)
exp //= 2
return res
def popcount64(n):
# 63桁まで高速に動く.64桁まで正常に動く.
c=(n&0x5555555555555555)+((n>>1)&0x5555555555555555)
c=(c&0x3333333333333333)+((c>>2)&0x3333333333333333)
c=(c&0x0f0f0f0f0f0f0f0f)+((c>>4)&0x0f0f0f0f0f0f0f0f)
c=(c&0x00ff00ff00ff00ff)+((c>>8)&0x00ff00ff00ff00ff)
c=(c&0x0000ffff0000ffff)+((c>>16)&0x0000ffff0000ffff)
c=(c&0x00000000ffffffff)+((c>>32)&0x00000000ffffffff)
return c
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
def multi_add(self, x, y):
if not self.exist(x):
self.add((x,y))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+y))
def multi_sub(self, x, y):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt <= y:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-y))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# wotsushiさん作成 : https://qiita.com/wotsushi/items/c936838df992b706084c
# global MOD を定義.
# ModIntとintの結果はModInt.
# a**b , a/b といった演算も可能.
# 配列などの添え字には利用できない. intに変換はできない.
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def island(self, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
H, W = self.H, self.W
self.island_id = [[-1]*W for _ in range(H)]
self.island_size = [[-1]*W for _ in range(W)]
crr_id = 0
id2size = dict()
for sh in range(H):
for sw in range(W):
if self.table[sh][sw] in self.wall:
continue
if self.island_id[sh][sw] != -1:
continue
deq = deque()
deq.append((sh,sw))
crr_size = 1
self.island_id[sh][sw] = crr_id
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh, nw = h+dh, w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if self.table[nh][nw] in self.wall:
continue
if self.island_id[nh][nw] == -1:
self.island_id[nh][nw] = crr_id
deq.append((nh, nw))
crr_size += 1
id2size[crr_id] = crr_size
crr_id += 1
for h in range(H):
for w in range(W):
if self.table[h][w] in self.wall:
continue
self.island_size[h][w] = id2size[self.island_id[h][w]]
return self.island_id, self.island_size
def distance(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main()
def main():
# write code here.
N,H = MI()
time2coord = LM()
coord2idx = DD(int)
idx2coord = [-1]*N
for idx,coord in enumerate(sorted(time2coord)):
coord2idx[coord] = idx
idx2coord[idx] = coord
time2idx = [coord2idx[time2coord[idx]] for idx in range(N)]
idx2island_ID = [0]*N
crr_id = 0
prev = idx2coord[0]
for idx in range(1,N):
crr_coord = idx2coord[idx]
if crr_coord - prev > H:
crr_id += 1
idx2island_ID[idx] = crr_id
prev = crr_coord
island_size = idx2island_ID[-1]+1
from atcoder.segtree import SegTree
def prob_mul(x,y):
return (x[0]*y[0]%MOD, x[1]+y[1])
def prob_add(x,y):
if x[1]<y[1]:
x,y=y,x
assert x[1]>=y[1]
numerator = x[0]+y[0]*pow(2,x[1]-y[1],MOD)
numerator %= MOD
return (numerator, x[1])
e0 = (1,0)
island_fin_prob = SegTree(prob_mul, e0, [(0,0)]*island_size)
ans = [0]*N
right_req = [0]*N
left_req = [0]*N
ss_of_idx = SortedSet()
for time in range(N):
now = 0
idx = time2idx[time]
island_id = idx2island_ID[idx]
ss_of_idx.add(idx)
adj_right = ss_of_idx.gt(idx)
if adj_right is not None and island_id == idx2island_ID[adj_right]:
right_req[idx] = right_req[adj_right] + 1
adj_left = ss_of_idx.lt(idx)
if adj_left is not None and island_id == idx2island_ID[adj_left]:
left_req[idx] = left_req[adj_left] + 1
DB(time=time)
DB(idx, adj_right, adj_left)
DB(right_req[idx], left_req[idx])
DB(island_id)
other_fin_prob = prob_mul(island_fin_prob.prod(0,island_id), island_fin_prob.prod(island_id+1,island_size))
crr_prob = (0,0)
#右が全部倒れていて左に倒れるパターン.
if idx==N-1 or island_id != idx2island_ID[idx+1] or adj_right == idx+1:
crr_prob = prob_add(crr_prob, (1,1+left_req[idx]+right_req[idx]))
prob = prob_mul((1,1+left_req[idx]+right_req[idx]), other_fin_prob)
now += prob[0] * pow(2, N-prob[1], MOD)
now %= MOD
#左が全部倒れていて右に倒れるパターン.
if idx==0 or island_id != idx2island_ID[idx-1] or adj_left == idx-1:
crr_prob = prob_add(crr_prob, (1,1+left_req[idx]+right_req[idx]))
prob = prob_mul((1,1+left_req[idx]+right_req[idx]), other_fin_prob)
now += prob[0] * pow(2, N-prob[1], MOD)
now %= MOD
ans[time] = now
prev_prob = island_fin_prob.get(island_id)
island_fin_prob.set(island_id, prob_add(prev_prob, crr_prob))
print(*ans)
# user config
############
DEBUG_MODE=0
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(coeff1, coeff0, bound_included1, bound_included2, MOD=None):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
if MOD:
# MODが素数でない場合にも対応するように、和公式を適応後に剰余を計算している.
return ((coeff0%MOD*((right-left+1)%MOD)%MOD) + (coeff1%MOD*((left+right)*(right-left+1)//2%MOD)%MOD))%MOD
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mul_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mul_matrix(res, mat, mod)
mat = mul_matrix(mat, mat, mod)
exp //= 2
return res
def popcount64(n):
# 63桁まで高速に動く.64桁まで正常に動く.
c=(n&0x5555555555555555)+((n>>1)&0x5555555555555555)
c=(c&0x3333333333333333)+((c>>2)&0x3333333333333333)
c=(c&0x0f0f0f0f0f0f0f0f)+((c>>4)&0x0f0f0f0f0f0f0f0f)
c=(c&0x00ff00ff00ff00ff)+((c>>8)&0x00ff00ff00ff00ff)
c=(c&0x0000ffff0000ffff)+((c>>16)&0x0000ffff0000ffff)
c=(c&0x00000000ffffffff)+((c>>32)&0x00000000ffffffff)
return c
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
def multi_add(self, x, y):
if not self.exist(x):
self.add((x,y))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+y))
def multi_sub(self, x, y):
if not self.exist(x):
return
num, cnt = self.gt((x,0))
if cnt <= y:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-y))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# wotsushiさん作成 : https://qiita.com/wotsushi/items/c936838df992b706084c
# global MOD を定義.
# ModIntとintの結果はModInt.
# a**b , a/b といった演算も可能.
# 配列などの添え字には利用できない. intに変換はできない.
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
__repr__ = __str__
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(self.x, other, MOD))
)
__radd__ = __add__
def __rsub__(self, other):
return (
ModInt(other.x - self.x) if isinstance(other, ModInt) else
ModInt(other - self.x)
)
__rmul__ = __mul__
def __rtruediv__(self, other):
return (
ModInt(
other.x * pow(self.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(other * pow(self.x, MOD - 2, MOD))
)
def __rpow__(self, other):
return (
ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
ModInt(pow(other, self.x, MOD))
)
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def island(self, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
H, W = self.H, self.W
self.island_id = [[-1]*W for _ in range(H)]
self.island_size = [[-1]*W for _ in range(W)]
crr_id = 0
id2size = dict()
for sh in range(H):
for sw in range(W):
if self.table[sh][sw] in self.wall:
continue
if self.island_id[sh][sw] != -1:
continue
deq = deque()
deq.append((sh,sw))
crr_size = 1
self.island_id[sh][sw] = crr_id
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh, nw = h+dh, w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if self.table[nh][nw] in self.wall:
continue
if self.island_id[nh][nw] == -1:
self.island_id[nh][nw] = crr_id
deq.append((nh, nw))
crr_size += 1
id2size[crr_id] = crr_size
crr_id += 1
for h in range(H):
for w in range(W):
if self.table[h][w] in self.wall:
continue
self.island_size[h][w] = id2size[self.island_id[h][w]]
return self.island_id, self.island_size
def distance(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main() | ConDefects/ConDefects/Code/arc177_d/Python/53453584 |
condefects-python_data_254 | from collections import defaultdict
import sys
class segtree():
n=1
size=1
log=2
d=[0]
op=None
e=10**15
def __init__(self,V,OP,E):
self.n=len(V)
self.op=OP
self.e=E
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
return self.d[p+self.size]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if (l&1):
sml=self.op(sml,self.d[l])
l+=1
if (r&1):
smr=self.op(self.d[r-1],smr)
r-=1
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def max_right(self,l,f):
assert 0<=l and l<=self.n
assert f(self.e)
if l==self.n:
return self.n
l+=self.size
sm=self.e
while(1):
while(l%2==0):
l>>=1
if not(f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if f(self.op(sm,self.d[l])):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:
break
return self.n
def min_left(self,r,f):
assert 0<=r and r<self.n
assert f(self.e)
if r==0:
return 0
r+=self.size
sm=self.e
while(1):
r-=1
while(r>1 & (r%2)):
r>>=1
if not(f(self.op(self.d[r],sm))):
while(r<self.size):
r=(2*r+1)
if f(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r& -r)==r:
break
return 0
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
MOD = 998244353
sys.setrecursionlimit(10**9)
N,H = map(int,input().split())
X = list(map(int,input().split()))
position_index = list(zip(X,range(N)))
position_index.sort()
V = []
for _,i in position_index:
V.append(i)
R = [None] * N
for i in range(N):
R[V[i]] = i
components = []
positions = [None] * N
st = segtree(V, min, N)
l = -10**18
for p,i in position_index:
if l+H < p:
components.append([i])
else:
components[-1].append(i)
l = p
for i in range(len(components)):
comp = components[i]
for j in range(len(comp)):
positions[comp[j]] = (i,j)
def calc(turn, depth, l, r):
if l >= r:
dc = defaultdict(int)
dc[turn] = pow(2,-depth,MOD)
return dc
t = 10**6
t = st.prod(l,r)
j = R[t]
dc = defaultdict(int)
left = calc(t, depth+1, l, j)
right = calc(t, depth+1, j+1, r)
if len(left) < len(right):
for k in left:
right[k] += left[k]
right[k] %= MOD
return right
else:
for k in right:
left[k] += right[k]
left[k] %= MOD
return left
ans = []
temp = 0
for comp in components:
x = len(comp)
ans.append(calc(0,0, temp, temp+x))
temp += x
components_prob = [0] * len(components)
ans_lst = [None] * N
zeros = len(components)
prob = 0
prod = 0
for i in range(N):
j,_ = positions[i]
if components_prob[j] == 0:
if ans[j][i] > 0:
components_prob[j] = ans[j][i]
if zeros == 1:
prod = 1
for num in components_prob:
prod *= num
prod %= MOD
zeros -= 1
else:
prod = prod * pow(components_prob[j], -1, MOD) * (components_prob[j] + ans[j][i])
prod %= MOD
components_prob[j] += ans[j][i]
components_prob[j] %= MOD
ans_lst[i] = prod - prob
prob = prod
coef = pow(2,N,MOD)
ans_lst = list(map(lambda x: (x*coef)%MOD,ans_lst))
print(*ans_lst)
from collections import defaultdict
import sys
class segtree():
n=1
size=1
log=2
d=[0]
op=None
e=10**15
def __init__(self,V,OP,E):
self.n=len(V)
self.op=OP
self.e=E
self.log=(self.n-1).bit_length()
self.size=1<<self.log
self.d=[E for i in range(2*self.size)]
for i in range(self.n):
self.d[self.size+i]=V[i]
for i in range(self.size-1,0,-1):
self.update(i)
def set(self,p,x):
assert 0<=p and p<self.n
p+=self.size
self.d[p]=x
for i in range(1,self.log+1):
self.update(p>>i)
def get(self,p):
assert 0<=p and p<self.n
return self.d[p+self.size]
def prod(self,l,r):
assert 0<=l and l<=r and r<=self.n
sml=self.e
smr=self.e
l+=self.size
r+=self.size
while(l<r):
if (l&1):
sml=self.op(sml,self.d[l])
l+=1
if (r&1):
smr=self.op(self.d[r-1],smr)
r-=1
l>>=1
r>>=1
return self.op(sml,smr)
def all_prod(self):
return self.d[1]
def max_right(self,l,f):
assert 0<=l and l<=self.n
assert f(self.e)
if l==self.n:
return self.n
l+=self.size
sm=self.e
while(1):
while(l%2==0):
l>>=1
if not(f(self.op(sm,self.d[l]))):
while(l<self.size):
l=2*l
if f(self.op(sm,self.d[l])):
sm=self.op(sm,self.d[l])
l+=1
return l-self.size
sm=self.op(sm,self.d[l])
l+=1
if (l&-l)==l:
break
return self.n
def min_left(self,r,f):
assert 0<=r and r<self.n
assert f(self.e)
if r==0:
return 0
r+=self.size
sm=self.e
while(1):
r-=1
while(r>1 & (r%2)):
r>>=1
if not(f(self.op(self.d[r],sm))):
while(r<self.size):
r=(2*r+1)
if f(self.op(self.d[r],sm)):
sm=self.op(self.d[r],sm)
r-=1
return r+1-self.size
sm=self.op(self.d[r],sm)
if (r& -r)==r:
break
return 0
def update(self,k):
self.d[k]=self.op(self.d[2*k],self.d[2*k+1])
def __str__(self):
return str([self.get(i) for i in range(self.n)])
MOD = 998244353
sys.setrecursionlimit(10**9)
N,H = map(int,input().split())
X = list(map(int,input().split()))
position_index = list(zip(X,range(N)))
position_index.sort()
V = []
for _,i in position_index:
V.append(i)
R = [None] * N
for i in range(N):
R[V[i]] = i
components = []
positions = [None] * N
st = segtree(V, min, N)
l = -10**18
for p,i in position_index:
if l+H < p:
components.append([i])
else:
components[-1].append(i)
l = p
for i in range(len(components)):
comp = components[i]
for j in range(len(comp)):
positions[comp[j]] = (i,j)
def calc(turn, depth, l, r):
if l >= r:
dc = defaultdict(int)
dc[turn] = pow(2,-depth,MOD)
return dc
t = 10**6
t = st.prod(l,r)
j = R[t]
dc = defaultdict(int)
left = calc(t, depth+1, l, j)
right = calc(t, depth+1, j+1, r)
if len(left) < len(right):
for k in left:
right[k] += left[k]
right[k] %= MOD
return right
else:
for k in right:
left[k] += right[k]
left[k] %= MOD
return left
ans = []
temp = 0
for comp in components:
x = len(comp)
ans.append(calc(0,0, temp, temp+x))
temp += x
components_prob = [0] * len(components)
ans_lst = [None] * N
zeros = len(components)
prob = 0
prod = 0
for i in range(N):
j,_ = positions[i]
if components_prob[j] == 0:
if ans[j][i] > 0:
components_prob[j] = ans[j][i]
if zeros == 1:
prod = 1
for num in components_prob:
prod *= num
prod %= MOD
zeros -= 1
else:
prod = prod * pow(components_prob[j], -1, MOD) * (components_prob[j] + ans[j][i])
prod %= MOD
components_prob[j] += ans[j][i]
components_prob[j] %= MOD
if components_prob[j] == 0:
zeros += 1
ans_lst[i] = prod - prob
prob = prod
coef = pow(2,N,MOD)
ans_lst = list(map(lambda x: (x*coef)%MOD,ans_lst))
print(*ans_lst)
| ConDefects/ConDefects/Code/arc177_d/Python/53430198 |
condefects-python_data_255 | import sys
# input = sys.stdin.readline
# input = lambda :sys.stdin.readline().rstrip()
readline = sys.stdin.readline
input = lambda :readline().rstrip()
sys.setrecursionlimit(6*10**5)
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
from heapq import heappush,heappop,heapify
from collections import defaultdict,deque,Counter
from bisect import bisect_left,bisect_right
from itertools import combinations,permutations,product
from math import gcd,sin,cos,atan2,degrees,pi,floor,ceil,radians,factorial
from decimal import Decimal
from string import ascii_lowercase
# import copy
# 整数の計算か小数の計算かでINFを変える。
# INF = float('inf')
INF = 8*10**18
mi = lambda:map(int,input().split())
li = lambda:list(mi())
ti = lambda:tuple(mi())
ii = lambda:int(input())
MOD = 998244353
# MOD = 10**9+7
# 大きい数のべき乗はpow関数を使う。
# dijkstraではなくbfsやdpで解けないか。
# 再帰がPypyでTLEする場合はPythonで提出する。もしくは再帰をDPにする。
# defaultdictでTLEした場合はlistにしてみる。
# listの足し算は遅い。e.g. l = [0]+l
n,k,d = mi()
a = ti()
dp = [[-INF for _ in range(d)] for _ in range(k+1)]
dp[0][0] = 0
for ai in a:
for i in range(k-1,-1,-1):
for j in range(d):
nj = (j+ai)%d
dp[i+1][nj] = max(dp[i][j]+ai,dp[i+1][nj])
print(dp[k][0] if dp[k][0] > 0 else -1)
import sys
# input = sys.stdin.readline
# input = lambda :sys.stdin.readline().rstrip()
readline = sys.stdin.readline
input = lambda :readline().rstrip()
sys.setrecursionlimit(6*10**5)
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
from heapq import heappush,heappop,heapify
from collections import defaultdict,deque,Counter
from bisect import bisect_left,bisect_right
from itertools import combinations,permutations,product
from math import gcd,sin,cos,atan2,degrees,pi,floor,ceil,radians,factorial
from decimal import Decimal
from string import ascii_lowercase
# import copy
# 整数の計算か小数の計算かでINFを変える。
# INF = float('inf')
INF = 8*10**18
mi = lambda:map(int,input().split())
li = lambda:list(mi())
ti = lambda:tuple(mi())
ii = lambda:int(input())
MOD = 998244353
# MOD = 10**9+7
# 大きい数のべき乗はpow関数を使う。
# dijkstraではなくbfsやdpで解けないか。
# 再帰がPypyでTLEする場合はPythonで提出する。もしくは再帰をDPにする。
# defaultdictでTLEした場合はlistにしてみる。
# listの足し算は遅い。e.g. l = [0]+l
n,k,d = mi()
a = ti()
dp = [[-INF for _ in range(d)] for _ in range(k+1)]
dp[0][0] = 0
for ai in a:
for i in range(k-1,-1,-1):
for j in range(d):
nj = (j+ai)%d
dp[i+1][nj] = max(dp[i][j]+ai,dp[i+1][nj])
print(dp[k][0] if dp[k][0] >= 0 else -1) | ConDefects/ConDefects/Code/abc281_d/Python/45096639 |
condefects-python_data_256 | n,K,D,*a=map(int,open(0).read().split())
dp=[[[-1]*D for _ in range(K+1)]for _ in range(n+1)]
dp[0][0][0]=0
for i in range(1,n+1):
for j in range(K+1):
for k in range(D):
dp[i][j][k]=dp[i-1][j][k]
if j and dp[i-1][j-1][k]!=-1:
nk=(k+a[i-1])%D
dp[i][j][nk]=max(dp[i][j][nk],dp[i-1][j-1][k]+a[i-1])
print(dp[n][K][0])
n,K,D,*a=map(int,open(0).read().split())
dp=[[[-1]*D for _ in range(K+1)]for _ in range(n+1)]
dp[0][0][0]=0
for i in range(1,n+1):
for j in range(K+1):
for k in range(D):
dp[i][j][k]=max(dp[i][j][k],dp[i-1][j][k])
if j and dp[i-1][j-1][k]!=-1:
nk=(k+a[i-1])%D
dp[i][j][nk]=max(dp[i][j][nk],dp[i-1][j-1][k]+a[i-1])
print(dp[n][K][0]) | ConDefects/ConDefects/Code/abc281_d/Python/45944263 |
condefects-python_data_257 | n, k, d = map(int, input().split())
a = list(map(int, input().split()))
dp = [[[-1]* d for _ in range(k+1)] for i in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
for j in range(k):
for l in range(d):
if dp[i][j][l] == -1:
continue
dp[i+1][j][l] = max(dp[i+1][j][l], dp[i][j][l])
if j+1 <= k:
dp[i+1][j+1][(l+a[i])%d] = max(dp[i+1][j+1][(l+a[i])%d], dp[i][j][l] + a[i])
print(dp[n][k][0])
n, k, d = map(int, input().split())
a = list(map(int, input().split()))
dp = [[[-1]* d for _ in range(k+1)] for i in range(n+1)]
dp[0][0][0] = 0
for i in range(n):
for j in range(k+1):
for l in range(d):
if dp[i][j][l] == -1:
continue
dp[i+1][j][l] = max(dp[i+1][j][l], dp[i][j][l])
if j+1 <= k:
dp[i+1][j+1][(l+a[i])%d] = max(dp[i+1][j+1][(l+a[i])%d], dp[i][j][l] + a[i])
print(dp[n][k][0]) | ConDefects/ConDefects/Code/abc281_d/Python/45212447 |
condefects-python_data_258 | n, k, d = map(int, input().split())
aa = list(map(int, input().split()))
inf = 2**63 - 1
dp = [[-inf] * d for _ in range(k + 1)]
dp[0][0] = 0
nx = [x[:] for x in dp]
for a in aa:
for i in range(k):
for j in range(d):
nxj = (j + a) % d
nx[i + 1][nxj] = max(nx[i + 1][nxj], dp[i][j] + a)
dp = [x[:] for x in nx]
ans = dp[k][0]
print(ans if 0 < ans else -1)
n, k, d = map(int, input().split())
aa = list(map(int, input().split()))
inf = 2**63 - 1
dp = [[-inf] * d for _ in range(k + 1)]
dp[0][0] = 0
nx = [x[:] for x in dp]
for a in aa:
for i in range(k):
for j in range(d):
nxj = (j + a) % d
nx[i + 1][nxj] = max(nx[i + 1][nxj], dp[i][j] + a)
dp = [x[:] for x in nx]
ans = dp[k][0]
print(ans if 0 <= ans else -1)
| ConDefects/ConDefects/Code/abc281_d/Python/44892775 |
condefects-python_data_259 | import sys
from collections import *
input = sys.stdin.readline
from math import *
def mrd(): return [int(x) for x in input().split()]
def rd(): return int(input())
MAXN = 2 * 10**5 + 5
INF = 10**16 * 2
mod = 10**9 + 7
#----------------------------------------------------------------------------------#
'''
https://atcoder.jp/contests/arc148/tasks/arc148_c
输入 n(2≤n≤2e5) q(≤2e5)，然后输入 p2,p3,...,pn 表示一棵根为 1 的树，pi 表示点 i 的父节点。
然后输入 q 个询问，每个询问先输入 m，然后输入 m 个互不相同的特殊节点 v1,v2,...,vm。所有询问的 m 之和不超过 2e5。
每个节点都有一盏灯，其中特殊节点的灯打开，其余节点的灯关闭。
每次操作，你可以选择一棵子树，切换子树内所有灯的开/闭状态。
对每个询问，回答：要使所有灯关闭，至少需要多少次操作。
try1:
似乎自上而下模拟就好了
看错题了，这是多次询问，cao
try2:
找联通块，答案就是和其相邻的子节点格式+1
'''
class UnionFind:
def __init__(self, n):
self.p = list(range(n))
self.size = [1] * n
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, a, b):
pa, pb = self.find(a), self.find(b)
if pa != pb:
if self.size[pa] > self.size[pb]:
self.p[pb] = pa
self.size[pa] += self.size[pb]
else:
self.p[pa] = pb
self.size[pb] += self.size[pa]
def reset(self, x):
self.p[x] = x
self.size[x] = 1
def solve():
n, m = mrd()
p = [i - 1 for i in mrd()]
son = [0] * n
for i in range(n - 1):
#i+1 p[i]
son[p[i]] += 1
uf = UnionFind(n)
for _ in range(m):
t = mrd()
t = [t[0]] + [t[i] - 1 for i in range(1, t[0] + 1)]
s = set([t[i] for i in range(1, t[0] + 1)])
ans = 0
for i in range(1, t[0] + 1):
ans += son[t[i]]
if p[t[i] - 1] in s:
uf.union(p[t[i] - 1], t[i])
roots = set()
for i in range(1, t[0] + 1):
u = t[i]
roots.add(uf.find(u))
if p[u - 1] in s and u:
ans -= 1
print(ans + len(roots))
for i in range(1, t[0] + 1):
uf.reset(t[i])
uf.reset(p[t[i] - 1])
if __name__ == "__main__":
solve()
import sys
from collections import *
input = sys.stdin.readline
from math import *
def mrd(): return [int(x) for x in input().split()]
def rd(): return int(input())
MAXN = 2 * 10**5 + 5
INF = 10**16 * 2
mod = 10**9 + 7
#----------------------------------------------------------------------------------#
'''
https://atcoder.jp/contests/arc148/tasks/arc148_c
输入 n(2≤n≤2e5) q(≤2e5)，然后输入 p2,p3,...,pn 表示一棵根为 1 的树，pi 表示点 i 的父节点。
然后输入 q 个询问，每个询问先输入 m，然后输入 m 个互不相同的特殊节点 v1,v2,...,vm。所有询问的 m 之和不超过 2e5。
每个节点都有一盏灯，其中特殊节点的灯打开，其余节点的灯关闭。
每次操作，你可以选择一棵子树，切换子树内所有灯的开/闭状态。
对每个询问，回答：要使所有灯关闭，至少需要多少次操作。
try1:
似乎自上而下模拟就好了
看错题了，这是多次询问，cao
try2:
找联通块，答案就是和其相邻的子节点格式+1
'''
class UnionFind:
def __init__(self, n):
self.p = list(range(n))
self.size = [1] * n
def find(self, x):
if self.p[x] != x:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, a, b):
pa, pb = self.find(a), self.find(b)
if pa != pb:
if self.size[pa] > self.size[pb]:
self.p[pb] = pa
self.size[pa] += self.size[pb]
else:
self.p[pa] = pb
self.size[pb] += self.size[pa]
def reset(self, x):
self.p[x] = x
self.size[x] = 1
def solve():
n, m = mrd()
p = [i - 1 for i in mrd()]
son = [0] * n
for i in range(n - 1):
#i+1 p[i]
son[p[i]] += 1
uf = UnionFind(n)
for _ in range(m):
t = mrd()
t = [t[0]] + [t[i] - 1 for i in range(1, t[0] + 1)]
s = set([t[i] for i in range(1, t[0] + 1)])
ans = 0
for i in range(1, t[0] + 1):
ans += son[t[i]]
if p[t[i] - 1] in s and t[i]:
uf.union(p[t[i] - 1], t[i])
roots = set()
for i in range(1, t[0] + 1):
u = t[i]
roots.add(uf.find(u))
if p[u - 1] in s and u:
ans -= 1
print(ans + len(roots))
for i in range(1, t[0] + 1):
uf.reset(t[i])
uf.reset(p[t[i] - 1])
if __name__ == "__main__":
solve() | ConDefects/ConDefects/Code/arc148_c/Python/38559514 |
condefects-python_data_260 | from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N,Q=map(int,input().split())
P=list(map(int,input().split()))
con=[0 for _ in range(N+1)]
for i in range(N-1):
con[P[i]]+=1
con[i+2]+=1
for _ in range(Q):
q=list(map(int,input().split()))
uf=UnionFind(q[0])
dic={}
ans=0
for i in range(1,q[0]+1):
dic.setdefault(q[i],i)
ans+=con[q[i]]
for i in range(1,q[0]+1):
if dic.get(P[q[i]-2])!=None:
uf.unite(dic[P[q[i]-2]],i)
add=0
if 1 in q[1:]:
add=1
print(ans-(q[0]-len(uf.roots())+1)*2+add)
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N,Q=map(int,input().split())
P=list(map(int,input().split()))
con=[0 for _ in range(N+1)]
for i in range(N-1):
con[P[i]]+=1
con[i+2]+=1
for _ in range(Q):
q=list(map(int,input().split()))
uf=UnionFind(q[0])
dic={}
ans=0
for i in range(1,q[0]+1):
dic.setdefault(q[i],i)
ans+=con[q[i]]
for i in range(1,q[0]+1):
if q[i]==1:
continue
if dic.get(P[q[i]-2])!=None:
uf.unite(dic[P[q[i]-2]],i)
add=0
if 1 in q[1:]:
add=1
print(ans-(q[0]-len(uf.roots())+1)*2+add)
| ConDefects/ConDefects/Code/arc148_c/Python/39976054 |
condefects-python_data_261 | def main():
H, W = map(int, input().split())
C = []
for i in range(H):
C.append(list(input()))
for i in range(H):
for j in range(W):
if C[i][j] != ".": continue
d = set(["1","2","3","4","5"])
if i > 0: d.discard(C[i-1][j])
if j > 0: d.discard(C[i][j-1])
if i < H-1: d.discard(C[i+1][j])
if j > W-1: d.discard(C[i][j+1])
C[i][j] = d.pop()
for i in range(H):
print("".join(C[i]))
if __name__ == '__main__':
main()
def main():
H, W = map(int, input().split())
C = []
for i in range(H):
C.append(list(input()))
for i in range(H):
for j in range(W):
if C[i][j] != ".": continue
d = set(["1","2","3","4","5"])
if i > 0: d.discard(C[i-1][j])
if j > 0: d.discard(C[i][j-1])
if i < H-1: d.discard(C[i+1][j])
if j < W-1: d.discard(C[i][j+1])
C[i][j] = d.pop()
for i in range(H):
print("".join(C[i]))
if __name__ == '__main__':
main() | ConDefects/ConDefects/Code/arc131_b/Python/38447849 |
condefects-python_data_262 | from sortedcontainers import SortedSet, SortedList, SortedDict
from collections import defaultdict
N, K = map(int,input().split())
P = list(map(int,input().split()))
INF = 10 ** 20
ans = [-1] * N
dic = defaultdict(list)
S = SortedSet([-INF, INF])
for i, value in enumerate(P):
key = S[S.bisect_left(value)]
if key == INF:
print(0)
if key is not INF and key is not - INF:
dic[value] = dic.pop(key)
S.discard(value)
S.discard(key)
dic[value].append(value)
S.add(value)
if len(dic[value]) == K:
for y in dic.pop(value):
ans[y - 1] = i + 1
S.discard(value)
print(*ans)
from sortedcontainers import SortedSet, SortedList, SortedDict
from collections import defaultdict
N, K = map(int,input().split())
P = list(map(int,input().split()))
INF = 10 ** 20
ans = [-1] * N
dic = defaultdict(list)
S = SortedSet([-INF, INF])
for i, value in enumerate(P):
key = S[S.bisect_left(value)]
if key is not INF and key is not - INF:
dic[value] = dic.pop(key)
S.discard(value)
S.discard(key)
dic[value].append(value)
S.add(value)
if len(dic[value]) == K:
for y in dic.pop(value):
ans[y - 1] = i + 1
S.discard(value)
print(*ans)
| ConDefects/ConDefects/Code/abc260_d/Python/53288501 |
condefects-python_data_263 | from atcoder.dsu import DSU
from atcoder.segtree import SegTree
N, K = map(int, input().split())
P = list(map(int, input().split()))
ans = [-1] * (N + 1)
if K == 1:
for i,p in enumerate(P,start= 1):
ans[p] = i
print(*ans)
exit()
dsu = DSU(N + 1)
st = SegTree(max, 0, [0] * (N + 1))
dic = {}
for i, p in enumerate(P, start=1):
x = st.max_right(p, lambda v: v == 0)
if x > N or x < p:
st.set(p, 1)
elif x > p:
st.set(x, 0)
dsu.merge(x, p)
if dsu.size(x) == K:
dic[dsu.leader(x)] = i
else:
st.set(p, 1)
for i in range(N + 1):
x = dsu.leader(i)
if x in dic:
ans[i] = dic[x]
print(*ans[1:])
from atcoder.dsu import DSU
from atcoder.segtree import SegTree
N, K = map(int, input().split())
P = list(map(int, input().split()))
ans = [-1] * (N + 1)
if K == 1:
for i,p in enumerate(P,start= 1):
ans[p] = i
print(*ans[1:])
exit()
dsu = DSU(N + 1)
st = SegTree(max, 0, [0] * (N + 1))
dic = {}
for i, p in enumerate(P, start=1):
x = st.max_right(p, lambda v: v == 0)
if x > N or x < p:
st.set(p, 1)
elif x > p:
st.set(x, 0)
dsu.merge(x, p)
if dsu.size(x) == K:
dic[dsu.leader(x)] = i
else:
st.set(p, 1)
for i in range(N + 1):
x = dsu.leader(i)
if x in dic:
ans[i] = dic[x]
print(*ans[1:])
| ConDefects/ConDefects/Code/abc260_d/Python/51017696 |
condefects-python_data_264 | n,k=map(int,input().split())
a=list(map(int,input().split()))
asort=sorted(a)
ak=[[] for _ in range(k)]
for i in range(n):
ak[i%k].append(a[i])
aksort=[0]*k
for i in range(k):
aksort[i] = sorted(ak[i])
print(aksort)
print(asort)
for i in range(n):
if asort[i] != aksort[i%k][i//k]:
print("No")
exit()
print('Yes')
n,k=map(int,input().split())
a=list(map(int,input().split()))
asort=sorted(a)
ak=[[] for _ in range(k)]
for i in range(n):
ak[i%k].append(a[i])
aksort=[0]*k
for i in range(k):
aksort[i] = sorted(ak[i])
for i in range(n):
if asort[i] != aksort[i%k][i//k]:
print("No")
exit()
print('Yes') | ConDefects/ConDefects/Code/abc254_c/Python/44995126 |
condefects-python_data_265 | n = int(input())
s = input()
t = input()
p = 0
for i in range(n):
if s[i] == "1" or s[i] == "l":
if t[i] == "1" or t[i] == "l":
p += 1
elif s[i] == "0" or t[i] == "o":
if t[i] == "0" or t[i] == "o":
p += 1
elif s[i] == t[i]:
p += 1
if p == n:
print("Yes")
else:
print("No")
n = int(input())
s = input()
t = input()
p = 0
for i in range(n):
if s[i] == "1" or s[i] == "l":
if t[i] == "1" or t[i] == "l":
p += 1
elif s[i] == "0" or s[i] == "o":
if t[i] == "0" or t[i] == "o":
p += 1
elif s[i] == t[i]:
p += 1
if p == n:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/abc303_a/Python/46127283 |
condefects-python_data_266 | #!/usr/bin/env python3
n, m = map(int, input().split())
S = input()
muji_t = m
logo_t = 0
ans = 0
for s in S:
if s == '2':
if logo_t == 0:
ans += 1
else:
logo_t -= 1
elif s == '1':
if muji_t == 0 and logo_t == 0:
ans += 1
elif muji_t == 0:
logo_t -= 1
else:
muji_t == 0
else:
logo_t = ans
muji_t = m
print(ans)
#!/usr/bin/env python3
n, m = map(int, input().split())
S = input()
muji_t = m
logo_t = 0
ans = 0
for s in S:
if s == '2':
if logo_t == 0:
ans += 1
else:
logo_t -= 1
elif s == '1':
if muji_t == 0 and logo_t == 0:
ans += 1
elif muji_t == 0:
logo_t -= 1
else:
muji_t -= 1
else:
logo_t = ans
muji_t = m
print(ans) | ConDefects/ConDefects/Code/abc332_c/Python/54711529 |
condefects-python_data_267 | n,m = map(int,input().split())
s = input()
used_m = 0
used_r = 0
muji = m
rogo = 0
buy_t = 0
for i in s:
if i == "1":
if muji > 0:
muji -= 1
used_m += 1
elif rogo > 0:
rogo -= 1
used_r += 1
else:
buy_t += 1
used_r += 1
elif i == "2":
if rogo > 0:
rogo -= 1
used_r += 1
else:
buy_t += 1
used_r += 1
else:
muji += used_m
rogo += used_r
print(buy_t)
n,m = map(int,input().split())
s = input()
used_m = 0
used_r = 0
muji = m
rogo = 0
buy_t = 0
for i in s:
if i == "1":
if muji > 0:
muji -= 1
used_m += 1
elif rogo > 0:
rogo -= 1
used_r += 1
else:
buy_t += 1
used_r += 1
elif i == "2":
if rogo > 0:
rogo -= 1
used_r += 1
else:
buy_t += 1
used_r += 1
else:
muji += used_m
rogo += used_r
used_m = 0
used_r = 0
print(buy_t) | ConDefects/ConDefects/Code/abc332_c/Python/54021349 |
condefects-python_data_268 | n, m = map(int, input().split())
s = list(input())
ans = 0
cnt = 0
muji = 0
for c in s:
match c:
case "0":
cnt =0
muji = m
case "1":
if muji == 0:
cnt += 1
else:
muji -= 1
case "2":
cnt += 1
ans = max(cnt, ans)
print(ans)
n, m = map(int, input().split())
s = list(input())
ans = 0
cnt = 0
muji = m
for c in s:
match c:
case "0":
cnt =0
muji = m
case "1":
if muji == 0:
cnt += 1
else:
muji -= 1
case "2":
cnt += 1
ans = max(cnt, ans)
print(ans) | ConDefects/ConDefects/Code/abc332_c/Python/54029466 |
condefects-python_data_269 | n, m = map(int, input().split())
s = str(input())
m_real = m
logo_T = 0
logo_T_real = 0
for i in range (n):
if s[i] == "0":
m_real = m
logo_T_real = logo_T
if s[i] == "1":
if m_real > 0:
m_real -= 1
else:
logo_T += 1
if s[i] == "2":
if logo_T_real > 0:
logo_T_real -= 1
else:
logo_T += 1
print(logo_T)
n, m = map(int, input().split())
s = str(input())
m_real = m
logo_T = 0
logo_T_real = 0
for i in range (n):
if s[i] == "0":
m_real = m
logo_T_real = logo_T
if s[i] == "1":
if m_real > 0:
m_real -= 1
elif logo_T_real > 0:
logo_T_real -= 1
else:
logo_T += 1
if s[i] == "2":
if logo_T_real > 0:
logo_T_real -= 1
else:
logo_T += 1
print(logo_T) | ConDefects/ConDefects/Code/abc332_c/Python/54228100 |
condefects-python_data_270 |
def rint(): return list(map(int, input().split()))
N, M = rint()
S = input()
shirts = M
buy = 0
logo = 0
for i in range(N):
if S[i] == '1':
if shirts == 0:
buy += 1
else:
shirts -= 1
elif S[i] == '2':
if logo == 0:
buy += 1
else:
shirts -= 1
logo -= 1
else:
logo = buy
shirts = buy+M
print(buy)
def rint(): return list(map(int, input().split()))
N, M = rint()
S = input()
shirts = M
buy = 0
logo = 0
for i in range(N):
if S[i] == '1':
if shirts == 0:
buy += 1
else:
if shirts == logo:
logo -= 1
shirts -= 1
elif S[i] == '2':
if logo == 0:
buy += 1
else:
shirts -= 1
logo -= 1
else:
logo = buy
shirts = buy+M
print(buy) | ConDefects/ConDefects/Code/abc332_c/Python/54741421 |
condefects-python_data_271 | def solve_C():
n, m = map(int, input().split())
s = [int(day) for day in list(input())]
logo = 0
plain = m
buy = 0
for day in s:
if day == 1:
if plain > 0:
plain -= 1
else:
buy += 1
if day == 2:
buy += 1
if day == 0:
logo = max(logo, buy)
buy = 0
plain = m
print(buy)
solve_C()
def solve_C():
n, m = map(int, input().split())
s = [int(day) for day in list(input())]
logo = 0
plain = m
buy = 0
for day in s:
if day == 1:
if plain > 0:
plain -= 1
else:
buy += 1
if day == 2:
buy += 1
if day == 0:
logo = max(logo, buy)
buy = 0
plain = m
print(max(logo, buy))
solve_C()
| ConDefects/ConDefects/Code/abc332_c/Python/54522217 |
condefects-python_data_272 | from collections import Counter
N=int(input())
S=[input() for _ in range(N)]
win_result=[]
for i in range(N):
counter=Counter(S[i])
win_result.append(counter["o"])
c=N-1
rank=[]
for i in range(N):
for j in range(N):
if win_result[j]==c:
rank.append(j+1)
c-=1
print(rank)
from collections import Counter
N=int(input())
S=[input() for _ in range(N)]
win_result=[]
for i in range(N):
counter=Counter(S[i])
win_result.append(counter["o"])
c=N-1
rank=[]
for i in range(N):
for j in range(N):
if win_result[j]==c:
rank.append(j+1)
c-=1
print(*rank, sep=" ") | ConDefects/ConDefects/Code/abc323_b/Python/54780741 |
condefects-python_data_273 | n = int(input())
s = [str(input()) for _ in range(n)]
dic = {}
for i in range(n):
dic[i] = 0
for i in range(n):
for k in range(n):
if i > k and s[i][k] == "o":
dic[i] += 1
dic = sorted(dic.items(), key=lambda x:x[1], reverse=True)
for i in dic:
print(i[0]+1, end=" ")
n = int(input())
s = [str(input()) for _ in range(n)]
dic = {}
for i in range(n):
dic[i] = 0
for i in range(n):
for k in range(n):
if i > k and s[i][k] == "o":
dic[i] += 1
elif i > k and s[i][k] == "x":
dic[k] += 1
dic = sorted(dic.items(), key=lambda x:x[1], reverse=True)
for i in dic:
print(i[0]+1, end=" ")
| ConDefects/ConDefects/Code/abc323_b/Python/54226184 |
condefects-python_data_274 | N = int(input())
S = [""] * N
for i in range(N):
S[i] = input()
C = 0
A = [0] * N
for i in range(N):
for j in range(N):
if S[i][j] == "o":
C += 1
A[i] = [C, i+1]
C = 0
print(A)
Y = 0
for i in range(N):
Y = max(Y, A[i][0])
for i in range(N):
A[i][0] = Y - A[i][0]
A.sort(key=lambda d:(d[0], d[1]))
D = [0]*N
for k in range(N):
D[k] = A[k][1]
print(A)
print(*D)
N = int(input())
S = [""] * N
for i in range(N):
S[i] = input()
C = 0
A = [0] * N
for i in range(N):
for j in range(N):
if S[i][j] == "o":
C += 1
A[i] = [C, i+1]
C = 0
Y = 0
for i in range(N):
Y = max(Y, A[i][0])
for i in range(N):
A[i][0] = Y - A[i][0]
A.sort(key=lambda d:(d[0], d[1]))
D = [0]*N
for k in range(N):
D[k] = A[k][1]
print(*D)
| ConDefects/ConDefects/Code/abc323_b/Python/54238360 |
condefects-python_data_275 | Sx,Sy = map(int,input().split())
Tx,Ty = map(int,input().split())
if (Sx + Sy)%2 != 0:
posS = "right"
Sx -= 1
if (Tx + Ty)%2 != 0:
Tx -= 1
if abs(Tx-Sx) > abs(Ty-Sy):
print(abs(Tx-Sx))
else:
print(abs(Ty-Sy))
Sx,Sy = map(int,input().split())
Tx,Ty = map(int,input().split())
if (Sx + Sy)%2 != 0:
posS = "right"
Sx -= 1
if (Tx + Ty)%2 != 0:
Tx -= 1
if abs(Tx-Sx) > abs(Ty-Sy):
print(abs(Ty-Sy) + (abs(Tx-Sx)-abs(Ty-Sy))//2)
else:
print(abs(Ty-Sy)) | ConDefects/ConDefects/Code/abc359_c/Python/55038783 |
condefects-python_data_276 | Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
Sx -= (Sy - Sx) % 2
Tx -= (Ty - Tx) % 2
Tx -= Sx
Ty -= Sy
Tx = abs(Tx)
Ty = abs(Ty)
print(Ty + max(0, Tx - Ty) / 2)
Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
Sx -= (Sy - Sx) % 2
Tx -= (Ty - Tx) % 2
Tx -= Sx
Ty -= Sy
Tx = abs(Tx)
Ty = abs(Ty)
print(Ty + max(0, Tx - Ty) // 2)
| ConDefects/ConDefects/Code/abc359_c/Python/55129367 |
condefects-python_data_277 | Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
# S, T ともに左側基準に
if (Sx + Sy) % 2 == 1:
Sx -= 1
if (Tx + Ty) % 2 == 1:
Tx -= 1
# (Sx, Sy) = (0, 0) と考えたとき、(Tx, Ty)を第一第一象限に移動させる
Tx -= Sx
Ty -= Sy
Tx = abs(Tx)
Ty = abs(Ty)
Tx = max(Tx - Ty, 0)
print(Tx+Ty)
Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
# S, T ともに左側基準に
if (Sx + Sy) % 2 == 1:
Sx -= 1
if (Tx + Ty) % 2 == 1:
Tx -= 1
# (Sx, Sy) = (0, 0) と考えたとき、(Tx, Ty)を第一第一象限に移動させる
Tx -= Sx
Ty -= Sy
Tx = abs(Tx)
Ty = abs(Ty)
Tx = max(Tx - Ty, 0) // 2
print(Tx+Ty)
| ConDefects/ConDefects/Code/abc359_c/Python/55101823 |
condefects-python_data_278 |
Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
if (Sx + Sy) % 2 == 1:
Sx -= 1
if (Tx + Ty) % 2 == 1:
Tx -= 1
x = abs(Sx - Tx)
y = abs(Sy - Ty)
if y >= x:
print(y)
else:
print(y + x // 2)
Sx, Sy = map(int, input().split())
Tx, Ty = map(int, input().split())
if (Sx + Sy) % 2 == 1:
Sx -= 1
if (Tx + Ty) % 2 == 1:
Tx -= 1
x = abs(Sx - Tx)
y = abs(Sy - Ty)
if y >= x:
print(y)
else:
print(y + (x-y) // 2)
| ConDefects/ConDefects/Code/abc359_c/Python/55043442 |
condefects-python_data_279 | t=int(input())
for おはよう in range(t):
n,a,b=map(int,input().split())
if n<a:
print("No")
continue
if n%2==1:
N=n
else:
N=n+1
if min(n-a,(N+1)//2)*(n-a)>=b:
print("Yes")
else:
print("No")
t=int(input())
for おはよう in range(t):
n,a,b=map(int,input().split())
if n<a:
print("No")
continue
if n%2==1:
N=n
else:
N=n
if min(n-a,(N+1)//2)*(n-a)>=b:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/arc171_a/Python/54909908 |
condefects-python_data_280 | T = int(input())
for _ in range(T):
N, A, B = map(int,input().split())
if N < A:
print("No")
continue
if N//2 >= A:
tate = (N - 2*A + 1)//2 + A
yoko = N - A
if tate*yoko >= B:
print("Yes")
else:
print("No")
else:
yoko = N - A
A -= N // 2
tate = N // 2 - A
if tate*yoko >= B:
print("Yes")
else:
print("No")
T = int(input())
for _ in range(T):
N, A, B = map(int,input().split())
if N < A:
print("No")
continue
if N//2 >= A:
tate = (N - 2*A + 1)//2 + A
yoko = N - A
if tate*yoko >= B:
print("Yes")
else:
print("No")
else:
yoko = N - A
A -= N // 2
tate = N - N//2 - A
if tate*yoko >= B:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/arc171_a/Python/51436402 |
condefects-python_data_281 | #ルークとポーンを互いに取れない状態で設置が可能かを判断
# ルークは斜めに設置していけば取られることはない→斜めに設置
# ポーンは隣接しなければよい
# ルークは詰めておいてもいい？→正方形を小さくするだけ？
T = int(input())
for _ in range(T):
N,A,B = map(int, input().split())
#残りにおけるマス数
b = N-A
c = min((N+1)//2,b)
print("yes" if N-A >= 0 and c * (N-A) >= B else "no")
#ルークとポーンを互いに取れない状態で設置が可能かを判断
# ルークは斜めに設置していけば取られることはない→斜めに設置
# ポーンは隣接しなければよい
# ルークは詰めておいてもいい？→正方形を小さくするだけ？
T = int(input())
for _ in range(T):
N,A,B = map(int, input().split())
#残りにおけるマス数
b = N-A
c = min((N+1)//2,b)
print("Yes" if N-A >= 0 and c * (N-A) >= B else "No") | ConDefects/ConDefects/Code/arc171_a/Python/52986573 |
condefects-python_data_282 | T=int(input())
for i in range(T):
Nx,A,B=map(int,input().split())
Ny=Nx
Ny2=Ny/2
Nx-=A
if(Ny2<A):
Ny-=(A-Ny2)
Ny-=Ny2
if(Nx<0 or Ny*Nx<B):
print("No")
else:
print("Yes")
T=int(input())
for i in range(T):
Nx,A,B=map(int,input().split())
Ny=Nx
Ny2=int(Ny/2)
Nx-=A
if(Ny2<A):
Ny-=(A-Ny2)
Ny-=Ny2
if(Nx<0 or Ny*Nx<B):
print("No")
else:
print("Yes")
| ConDefects/ConDefects/Code/arc171_a/Python/52479572 |
condefects-python_data_283 | T = int(input())
for _ in range(T):
N, A, B = map(int, input().split())
if A > N:
print('No')
continue
if A == 0:
h = (N + 1) // 2
elif N % 2 == 0:
if A <= N // 2:
h = N // 2
else:
h = N - A
else:
if A <= N // 2 + 1:
h = N // 2 + 1
else:
h = N - A
w = N - A
if A > N or B > h * w:
print('No')
continue
print('Yes')
T = int(input())
for _ in range(T):
N, A, B = map(int, input().split())
if A > N:
print('No')
continue
if A == 0:
h = (N + 1) // 2
elif N % 2 == 0:
if A <= N // 2:
h = N // 2
else:
h = N - A
else:
if A <= N // 2:
h = N // 2 + 1
else:
h = N - A
w = N - A
if A > N or B > h * w:
print('No')
continue
print('Yes') | ConDefects/ConDefects/Code/arc171_a/Python/55000897 |
condefects-python_data_284 | #!/usr/bin/env python3
T = int(input())
def solve(n, a, b):
if a >= n + 1:
return 0
if a == n:
if b == 0:
return 1
else:
return 0
c = (b + n - a - 1) // (n - a)
if a + c <= n:
return 1
return 0
for _ in range(T):
n, a, b = map(int, input().split())
if solve(n, a, b):
print('Yes')
else:
print('No')
#!/usr/bin/env python3
T = int(input())
def solve(n, a, b):
if a >= n + 1:
return 0
if a == n:
if b == 0:
return 1
else:
return 0
c = (b + n - a - 1) // (n - a)
if c > (n + 1) // 2:
return 0
if a + c <= n:
return 1
return 0
for _ in range(T):
n, a, b = map(int, input().split())
if solve(n, a, b):
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/arc171_a/Python/54529613 |
condefects-python_data_285 | for _ in range(int(input())):
N, A, B = map(int, input().split())
if A <= N // 2:
print("Yes" if B <= ((N + 1) // 2) * (N - A) else "No")
elif A < N:
print("Yes" if B <= (N - A) ** 2 else "No")
else:
print("No")
for _ in range(int(input())):
N, A, B = map(int, input().split())
if A <= N // 2:
print("Yes" if B <= ((N + 1) // 2) * (N - A) else "No")
elif A <= N:
print("Yes" if B <= (N - A) ** 2 else "No")
else:
print("No") | ConDefects/ConDefects/Code/arc171_a/Python/53564647 |
condefects-python_data_286 | n, q = map(int, input().split())
p = [0] * n
for _ in range(q):
t, x = map(int, input().split())
x -= 1
if t == 1:
p[x] += 1
elif t == 2:
p[x] += 2
else:
if p[x] == 2:
print("Yes")
else:
print("No")
n, q = map(int, input().split())
p = [0] * n
for _ in range(q):
t, x = map(int, input().split())
x -= 1
if t == 1:
p[x] += 1
elif t == 2:
p[x] += 2
else:
if p[x] >= 2:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc292_b/Python/45575109 |
condefects-python_data_287 | # B - Yellow and Red Card
def main():
N, Q = map(int, input().split())
cards = [0] * (N+1)
for _ in range(Q):
c, x = map(int, input().split())
if c == 1:
cards[x] += 1
elif c == 2:
cards[x] += 2
else:
if cards[x] == 2:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
# B - Yellow and Red Card
def main():
N, Q = map(int, input().split())
cards = [0] * (N+1)
for _ in range(Q):
c, x = map(int, input().split())
if c == 1:
cards[x] += 1
elif c == 2:
cards[x] += 2
else:
if cards[x] >= 2:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main() | ConDefects/ConDefects/Code/abc292_b/Python/44986856 |
condefects-python_data_288 | n, q = map(int, input().split())
player = [0] * n
for i in range(q):
c, x = map(int,input().split())
if c == 1:
player[x - 1] += 1
elif c == 2:
player[x - 1] += 2
else:
if player[x - 1] == 2:
print("Yes")
else:
print("No")
n, q = map(int, input().split())
player = [0] * n
for i in range(q):
c, x = map(int,input().split())
if c == 1:
player[x - 1] += 1
elif c == 2:
player[x - 1] += 2
else:
if player[x - 1] >= 2:
print("Yes")
else:
print("No")
| ConDefects/ConDefects/Code/abc292_b/Python/45695205 |
condefects-python_data_289 | n, m = map(int, input().split())
cnts = [0]*n
for i in range(m):
s = list(map(int, input().split()))
player = s[1]-1
if s[0] == 1:
cnts[player] += 1
elif s[0] == 2:
cnts[player] += 2
elif s[0] == 3:
if cnts[player] == 2:
print("Yes")
else:
print("No")
n, m = map(int, input().split())
cnts = [0]*n
for i in range(m):
s = list(map(int, input().split()))
player = s[1]-1
if s[0] == 1:
cnts[player] += 1
elif s[0] == 2:
cnts[player] += 2
elif s[0] == 3:
if cnts[player] >= 2:
print("Yes")
else:
print("No") | ConDefects/ConDefects/Code/abc292_b/Python/45300323 |
condefects-python_data_290 | N, Q = map(int, input().split())
T = [2] * N
for i in range(Q):
c, x = map(int, input().split())
if c == 1:
T[x-1] -= 1
elif c == 2:
T[x-1] -= 2
else:
if (T[x-1] == 0):
print('Yes')
else:
print('No')
N, Q = map(int, input().split())
T = [2] * N
for i in range(Q):
c, x = map(int, input().split())
if c == 1:
T[x-1] -= 1
elif c == 2:
T[x-1] -= 2
else:
if (T[x-1] <= 0):
print('Yes')
else:
print('No') | ConDefects/ConDefects/Code/abc292_b/Python/45444129 |
condefects-python_data_291 | n=int(input())
f=[[0]*101 for i in range(101)]
for i in range(n):
a,b,c,d=map(int,input().split())
for x in range(a,b):
for y in range(c,d):
# print(x,y)
f[x][y]=1
ans=0
for i in range(10):
ans+=sum(f[i])
print(ans)
n=int(input())
f=[[0]*101 for i in range(101)]
for i in range(n):
a,b,c,d=map(int,input().split())
for x in range(a,b):
for y in range(c,d):
# print(x,y)
f[x][y]=1
ans=0
for i in range(101):
ans+=sum(f[i])
print(ans) | ConDefects/ConDefects/Code/abc318_b/Python/54678489 |
condefects-python_data_292 | from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
xor_sum = 0
cnt = defaultdict(lambda: 0)
for elem in a:
xor_sum = xor_sum ^ elem
cnt[elem] += 1
if xor_sum > 0:
print(-1)
exit(0)
elem_and_cnt = list(cnt.items())
elem_and_cnt.sort(key=lambda elem: elem[0], reverse=True)
for elem, cnt in elem_and_cnt:
if cnt % 2 == 1:
print(cnt - 1)
exit(0)
print(0)
from collections import defaultdict
n = int(input())
a = list(map(int, input().split()))
xor_sum = 0
cnt = defaultdict(lambda: 0)
for elem in a:
xor_sum = xor_sum ^ elem
cnt[elem] += 1
if xor_sum > 0:
print(-1)
exit(0)
elem_and_cnt = list(cnt.items())
elem_and_cnt.sort(key=lambda elem: elem[0], reverse=True)
for elem, cnt in elem_and_cnt:
if cnt % 2 == 1:
print(elem - 1)
exit(0)
print(0) | ConDefects/ConDefects/Code/arc168_b/Python/47858758 |
condefects-python_data_293 | from collections import*
n = int(input())
a = list(map(int, input().split()))
dic = defaultdict(int)
cnt = 0
for ai in a:
dic[ai] += 1
cnt ^= ai
if cnt:
print(-1)
exit()
cnt = 0
for k in dic.keys():
if dic[k]%2: cnt = k
if cnt:
print(cnt-1)
else:
print(0)
from collections import*
n = int(input())
a = list(map(int, input().split()))
dic = defaultdict(int)
cnt = 0
for ai in a:
dic[ai] += 1
cnt ^= ai
if cnt:
print(-1)
exit()
cnt = 0
for k in dic.keys():
if dic[k]%2: cnt = max(cnt, k)
if cnt:
print(cnt-1)
else:
print(0)
| ConDefects/ConDefects/Code/arc168_b/Python/50455727 |
condefects-python_data_294 | # ABC263D - Left Right Operation
#####segfunc#####
def segfunc(x, y):
return min(x, y)
#################
#####ide_ele#####
ide_ele = 10**18
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
# code
N, L, R = map(int, input().split())
An = list(map(int, input().split()))
AnCS = [0]
now = 0
for n in range(N):
now += An[n]
AnCS.append(now)
Antemp = []
count = N
for n in range(N+1):
Antemp.append(AnCS[n] + R * (count))
count -= 1
ans = 10 ** 20
seg = SegTree(Antemp, segfunc, ide_ele)
for n in range(N+1):
ans = min(L * n + seg.query(n+1, N+1) - AnCS[n], ans)
print(ans)
# ABC263D - Left Right Operation
#####segfunc#####
def segfunc(x, y):
return min(x, y)
#################
#####ide_ele#####
ide_ele = 10**18
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
# code
N, L, R = map(int, input().split())
An = list(map(int, input().split()))
AnCS = [0]
now = 0
for n in range(N):
now += An[n]
AnCS.append(now)
Antemp = []
count = N
for n in range(N+1):
Antemp.append(AnCS[n] + R * (count))
count -= 1
ans = 10 ** 20
seg = SegTree(Antemp, segfunc, ide_ele)
for n in range(N+1):
ans = min(L * n + seg.query(n, N+1) - AnCS[n], ans)
print(ans) | ConDefects/ConDefects/Code/abc263_d/Python/45558657 |
condefects-python_data_295 | N,L,R=map(int,input().split())
A=list(map(int,input().split()))
A=[0]+A
f=[0]*(N+1)
for i in range(1,N+1):
f[i]=min(f[i-1]+A[i],L*i)
A=A[::-1]
A=[0]+A
g=[0]*(N+1)
for i in range(1,N+1):
g[i]=min(g[i-1]+A[i],R*i)
ans=10*15
for i in range(N+1):
ans=min(ans,f[i]+g[N-i])
print(ans)
N,L,R=map(int,input().split())
A=list(map(int,input().split()))
A=[0]+A
f=[0]*(N+1)
for i in range(1,N+1):
f[i]=min(f[i-1]+A[i],L*i)
A=A[::-1]
A=[0]+A
g=[0]*(N+1)
for i in range(1,N+1):
g[i]=min(g[i-1]+A[i],R*i)
ans=10**15
for i in range(N+1):
ans=min(ans,f[i]+g[N-i])
print(ans) | ConDefects/ConDefects/Code/abc263_d/Python/45092562 |
condefects-python_data_296 | class Input_kyopro:
def II(self): return int(input())
def MI(self): return map( int,input().split())
def MS(self): return map(str,input().split())
def LMI(self): return list(self.MI())
def LMS(self): return list(self.MS())
def LLI(self,N): return [self.LMI() for _ in range(N)]
def LLS(self,N): return [self.LMS() for _ in range(N)]
def LS(self,N): return [input() for _ in range(N)]
def LSL(self,N): return [list(input()) for _ in range(N)]
def LI(self,N): return [self.II() for _ in range(N)]
I=Input_kyopro()
#入力
N,L,R=I.MI()
A=I.LMI()
ruiseki_l=[0]*(N+1)
s=sum(A)
for i in range(N):
ruiseki_l[i+1]=ruiseki_l[i]+L-A[i]
for i in range(N):
ruiseki_l[i+1]=min(ruiseki_l[i+1],ruiseki_l[i])
ruiseki_r=[0]*(N+1)
for i in range(N):
ruiseki_r[i+1]=ruiseki_r[i]+R-A[-i-1]
for i in range(N):
ruiseki_r[i+1]=min(ruiseki_r[i+1],ruiseki_r[i])
ans=float('inf')
for i in range(N):
ans=min(ans,ruiseki_l[i]+ruiseki_r[-i-1]+s)
print(ans)
class Input_kyopro:
def II(self): return int(input())
def MI(self): return map( int,input().split())
def MS(self): return map(str,input().split())
def LMI(self): return list(self.MI())
def LMS(self): return list(self.MS())
def LLI(self,N): return [self.LMI() for _ in range(N)]
def LLS(self,N): return [self.LMS() for _ in range(N)]
def LS(self,N): return [input() for _ in range(N)]
def LSL(self,N): return [list(input()) for _ in range(N)]
def LI(self,N): return [self.II() for _ in range(N)]
I=Input_kyopro()
#入力
N,L,R=I.MI()
A=I.LMI()
ruiseki_l=[0]*(N+1)
s=sum(A)
for i in range(N):
ruiseki_l[i+1]=ruiseki_l[i]+L-A[i]
for i in range(N):
ruiseki_l[i+1]=min(ruiseki_l[i+1],ruiseki_l[i])
ruiseki_r=[0]*(N+1)
for i in range(N):
ruiseki_r[i+1]=ruiseki_r[i]+R-A[-i-1]
for i in range(N):
ruiseki_r[i+1]=min(ruiseki_r[i+1],ruiseki_r[i])
ans=float('inf')
for i in range(N+1):
ans=min(ans,ruiseki_l[i]+ruiseki_r[-i-1]+s)
print(ans)
| ConDefects/ConDefects/Code/abc263_d/Python/46128003 |
condefects-python_data_297 | n, l, r = map(int, input().split())
a = list(map(int, input().split()))
sma = 0
smb = 0
mx = 0
ans = float("INF")
for i in range(n):
sma += a[i]
smb += a[i] - l
mx = max(mx, smb)
ans = min(ans, sma + (n - i - 1) * r - mx)
print(ans)
n, l, r = map(int, input().split())
a = list(map(int, input().split()))
sma = 0
smb = 0
mx = 0
ans = r * n
for i in range(n):
sma += a[i]
smb += a[i] - l
mx = max(mx, smb)
ans = min(ans, sma + (n - i - 1) * r - mx)
print(ans)
| ConDefects/ConDefects/Code/abc263_d/Python/45700792 |
condefects-python_data_298 | N,L,R=map(int,input().split())
A=list(map(int,input().split()))
result=sum(A)
result=min(result,L*N,R*N)
v=[0]*N
for i in range(N):
x=v[i-1]+A[i]
if x>(i+1)*L:
v[i]=(i+1)*L
else:
v[i]=x
for i in range(N-1,0,-1):
p=v[i]+(N-1-i)*R
result=min(result,p)
print(result)
N,L,R=map(int,input().split())
A=list(map(int,input().split()))
result=sum(A)
result=min(result,L*N,R*N)
v=[0]*N
for i in range(N):
x=v[i-1]+A[i]
if x>(i+1)*L:
v[i]=(i+1)*L
else:
v[i]=x
for i in range(N-1,-1,-1):
p=v[i]+(N-1-i)*R
result=min(result,p)
print(result) | ConDefects/ConDefects/Code/abc263_d/Python/46033883 |
condefects-python_data_299 | N,L,R = map(int,input().split())
A = list(map(int,input().split()))
dpL=[0]*(N+1)
dpR=[0]*(N+1)
for i in range(N):
dpL[i+1] = min(dpL[i]+A[i],L*(i+1))
for j in range(N-1,-1,-1):
dpR[j]= min(dpR[j+1]+A[j],R*(N-j))
ans=10**18
for i in range(N):
ans = min(ans,dpL[i]+dpR[i])
print(ans)
N,L,R = map(int,input().split())
A = list(map(int,input().split()))
dpL=[0]*(N+1)
dpR=[0]*(N+1)
for i in range(N):
dpL[i+1] = min(dpL[i]+A[i],L*(i+1))
for j in range(N-1,-1,-1):
dpR[j]= min(dpR[j+1]+A[j],R*(N-j))
ans=10**18
for i in range(N+1):
ans = min(ans,dpL[i]+dpR[i])
print(ans) | ConDefects/ConDefects/Code/abc263_d/Python/45504816 |
condefects-python_data_300 | from heapq import heappush, heappop, heapify
from collections import defaultdict, deque, Counter
from itertools import permutations, combinations, accumulate
from math import gcd, sqrt, factorial, ceil
from bisect import bisect_left, bisect_right
import sys
from decimal import Decimal, ROUND_HALF_UP, getcontext
sys.setrecursionlimit(10**6)
getcontext().rounding = ROUND_HALF_UP
import sys
input = sys.stdin.readline
#X=Decimal(str(X)).quantize(Decimal('1e'+str(i)))で使える。'1e'+str(i)は桁数を指定
#X = Decimal(str(X)).quantize(Decimal('1.' + '0' * i))これは小数点以下ででiは桁数
# ROUND_HALF_UPで四捨五入
# ROUND_HALF_EVENは、丸め込み
#pypy用
#from pypyjit import set_param
#set_param('max_unroll_recursion=0')
#import numpy as np
#from math import isqrt, prod
#from functools import cache
#@cache
N,L,R=map(int,input().split())
A=list(map(int,input().split()))
ldp=[0]*(N+1)
rdp=[0]*(N+1)
for i in range(N):ldp[i+1]=min(ldp[i]+A[i],L*(i+1))
A.reverse()
for i in range(N):rdp[i+1]=min(rdp[i]+A[i],R*(i+1))
rdp.reverse()
ans=float('inf')
for i in range(1,N+1):ans=min(ans,ldp[i]+rdp[i])
print(ans)
from heapq import heappush, heappop, heapify
from collections import defaultdict, deque, Counter
from itertools import permutations, combinations, accumulate
from math import gcd, sqrt, factorial, ceil
from bisect import bisect_left, bisect_right
import sys
from decimal import Decimal, ROUND_HALF_UP, getcontext
sys.setrecursionlimit(10**6)
getcontext().rounding = ROUND_HALF_UP
import sys
input = sys.stdin.readline
#X=Decimal(str(X)).quantize(Decimal('1e'+str(i)))で使える。'1e'+str(i)は桁数を指定
#X = Decimal(str(X)).quantize(Decimal('1.' + '0' * i))これは小数点以下ででiは桁数
# ROUND_HALF_UPで四捨五入
# ROUND_HALF_EVENは、丸め込み
#pypy用
#from pypyjit import set_param
#set_param('max_unroll_recursion=0')
#import numpy as np
#from math import isqrt, prod
#from functools import cache
#@cache
N,L,R=map(int,input().split())
A=list(map(int,input().split()))
ldp=[0]*(N+1)
rdp=[0]*(N+1)
for i in range(N):ldp[i+1]=min(ldp[i]+A[i],L*(i+1))
A.reverse()
for i in range(N):rdp[i+1]=min(rdp[i]+A[i],R*(i+1))
rdp.reverse()
ans=float('inf')
for i in range(N+1):ans=min(ans,ldp[i]+rdp[i])
print(ans)
| ConDefects/ConDefects/Code/abc263_d/Python/44705646 |