id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_801
|
def solve():
n,x,k = list(map(int, input().split(' ')))
# print(n,x,k)
n += 1
k = min(100,k)
ans = 0
depth = k
prev = -1
while x and depth >= 0:
# print(f'{x=} {depth=} {prev=}')
if prev == -1:
L = x*(1<<depth)
R = L + (1<<depth)
else:
if depth == 0:
L = x
R = x+1
else:
another_way = prev^1
# print(f'{another_way=}')
L = another_way*(1<<(depth-1))
R = L + (1<<(depth-1))
# print(L,R)
intersection = max(0,min(R,n)-max(0,L))
# print(f'{intersection=}')
ans += intersection
prev = x
x //= 2
depth -= 1
# print(f'{ans=}')
return ans
t = int(input())
for _ in range(t):
print(solve())
def solve():
n,x,k = list(map(int, input().split(' ')))
# print(n,x,k)
n += 1
k = min(200,k)
ans = 0
depth = k
prev = -1
while x and depth >= 0:
# print(f'{x=} {depth=} {prev=}')
if prev == -1:
L = x*(1<<depth)
R = L + (1<<depth)
else:
if depth == 0:
L = x
R = x+1
else:
another_way = prev^1
# print(f'{another_way=}')
L = another_way*(1<<(depth-1))
R = L + (1<<(depth-1))
# print(L,R)
intersection = max(0,min(R,n)-max(0,L))
# print(f'{intersection=}')
ans += intersection
prev = x
x //= 2
depth -= 1
# print(f'{ans=}')
return ans
t = int(input())
for _ in range(t):
print(solve())
|
ConDefects/ConDefects/Code/abc321_e/Python/54658110
|
condefects-python_data_802
|
import sys
input = sys.stdin.readline
n = int(input())
dp = [0] * (n + 1)
for i in range(1, n + 1):
tmp = 0
for j in range(1, 7):
if j < dp[i - 1]:
tmp += dp[i - 1] / 6
else:
tmp += j / 6
dp[i] = tmp
print(dp)
import sys
input = sys.stdin.readline
n = int(input())
dp = [0] * (n + 1)
for i in range(1, n + 1):
tmp = 0
for j in range(1, 7):
if j < dp[i - 1]:
tmp += dp[i - 1] / 6
else:
tmp += j / 6
dp[i] = tmp
print(dp[n])
|
ConDefects/ConDefects/Code/abc266_e/Python/44641284
|
condefects-python_data_803
|
n,a,b,c = map(int, input().split())
al = list(map(int, input().split()))
def gcm(a,b):
if b == 0:
return a
else:
return gcm(b,a%b)
def calc(x,y):
if x%y == 0:
return x
else:
return y * (x//y + 1)
ab_gcm = gcm(a,b)
ab = a*b//ab_gcm
ac_gcm = gcm(a,c)
ac = a*c//ac_gcm
bc_gcm = gcm(b,c)
bc = b*c//bc_gcm
abc_gcm = gcm(ab,c)
abc = ab*c//abc_gcm
dl = [[0] * 8 for i in range(n)]
for i,l in enumerate(al):
dl[i][int('001',2)] = calc(l,a) - l
dl[i][int('010',2)] = calc(l,b) - l
dl[i][int('100',2)] = calc(l,c) - l
dl[i][int('011',2)] = calc(l,ab) - l
dl[i][int('101',2)] = calc(l,ac) - l
dl[i][int('110',2)] = calc(l,bc) - l
dl[i][int('111',2)] = calc(l,abc) - l
dp=[[1000000000000000000] * 9 for i in range(n+1)]
for i,d in enumerate(dl):
dp[i+1][int('001',2)] = min(dp[i][int('001',2)],d[int('001',2)])
dp[i+1][int('010',2)] = min(dp[i][int('010',2)],d[int('010',2)])
dp[i+1][int('100',2)] = min(dp[i][int('100',2)],d[int('100',2)])
dp[i+1][int('011',2)] = min(dp[i][int('011',2)],d[int('011',2)],dp[i][int('001',2)]+d[int('010',2)],dp[i][int('010',2)]+d[int('001',2)])
dp[i+1][int('101',2)] = min(dp[i][int('101',2)],d[int('101',2)],dp[i][int('001',2)]+d[int('100',2)],dp[i][int('100',2)]+d[int('001',2)])
dp[i+1][int('011',2)] = min(dp[i][int('110',2)],d[int('110',2)],dp[i][int('010',2)]+d[int('100',2)],dp[i][int('100',2)]+d[int('010',2)])
dp[i+1][int('111',2)] = min(dp[i][int('111',2)], d[int('111',2)]\
,dp[i][int('011',2)]+d[int('100',2)],dp[i][int('101',2)]+d[int('010',2)],dp[i][int('110',2)]+d[int('001',2)]\
,dp[i][int('001',2)]+d[int('110',2)],dp[i][int('010',2)]+d[int('101',2)],dp[i][int('100',2)]+d[int('011',2)])
print(dp[n][7])
n,a,b,c = map(int, input().split())
al = list(map(int, input().split()))
def gcm(a,b):
if b == 0:
return a
else:
return gcm(b,a%b)
def calc(x,y):
if x%y == 0:
return x
else:
return y * (x//y + 1)
ab_gcm = gcm(a,b)
ab = a*b//ab_gcm
ac_gcm = gcm(a,c)
ac = a*c//ac_gcm
bc_gcm = gcm(b,c)
bc = b*c//bc_gcm
abc_gcm = gcm(ab,c)
abc = ab*c//abc_gcm
dl = [[0] * 8 for i in range(n)]
for i,l in enumerate(al):
dl[i][int('001',2)] = calc(l,a) - l
dl[i][int('010',2)] = calc(l,b) - l
dl[i][int('100',2)] = calc(l,c) - l
dl[i][int('011',2)] = calc(l,ab) - l
dl[i][int('101',2)] = calc(l,ac) - l
dl[i][int('110',2)] = calc(l,bc) - l
dl[i][int('111',2)] = calc(l,abc) - l
dp=[[1000000000000000000] * 9 for i in range(n+1)]
for i,d in enumerate(dl):
dp[i+1][int('001',2)] = min(dp[i][int('001',2)],d[int('001',2)])
dp[i+1][int('010',2)] = min(dp[i][int('010',2)],d[int('010',2)])
dp[i+1][int('100',2)] = min(dp[i][int('100',2)],d[int('100',2)])
dp[i+1][int('011',2)] = min(dp[i][int('011',2)],d[int('011',2)],dp[i][int('001',2)]+d[int('010',2)],dp[i][int('010',2)]+d[int('001',2)])
dp[i+1][int('101',2)] = min(dp[i][int('101',2)],d[int('101',2)],dp[i][int('001',2)]+d[int('100',2)],dp[i][int('100',2)]+d[int('001',2)])
dp[i+1][int('110',2)] = min(dp[i][int('110',2)],d[int('110',2)],dp[i][int('010',2)]+d[int('100',2)],dp[i][int('100',2)]+d[int('010',2)])
dp[i+1][int('111',2)] = min(dp[i][int('111',2)], d[int('111',2)]\
,dp[i][int('011',2)]+d[int('100',2)],dp[i][int('101',2)]+d[int('010',2)],dp[i][int('110',2)]+d[int('001',2)]\
,dp[i][int('001',2)]+d[int('110',2)],dp[i][int('010',2)]+d[int('101',2)],dp[i][int('100',2)]+d[int('011',2)])
print(dp[n][7])
|
ConDefects/ConDefects/Code/arc166_b/Python/49426497
|
condefects-python_data_804
|
## https://atcoder.jp/contests/arc166/tasks/arc166_b
def calc_gcd(A, B):
"""
正の整数A, Bの最大公約数を計算する
"""
a = max(A, B)
b = min(A, B)
while a % b > 0:
c = a % b
a = b
b = c
return b
def main():
N, a, b, c = map(int, input().split())
A = list(map(int, input().split()))
ab = calc_gcd(a, b)
ab = (a // ab) * b
ac = calc_gcd(a, c)
ac = (a // ac) * c
bc = calc_gcd(b, c)
bc = (b // bc) * c
abc = calc_gcd(ab, c)
abc = (ab // abc) * c
array = [[0] * 9 for _ in range(N)]
for i in range(N):
array[i][0] = (-A[i] % a)
array[i][1] = (-A[i] % b)
array[i][2] = (-A[i] % c)
array[i][3] = (-A[i] % ab)
array[i][4] = (-A[i] % ac)
array[i][5] = (-A[i] % bc)
array[i][6] = (-A[i] % abc)
array[i][7] = i
answer = float("inf")
# a, b, cそれぞれ1つずつある状態に持っていく場合
# aにすると一番近いベスト3を選ぶ
array_a = []
array_b = []
array_c = []
array.sort(key=lambda x: x[0])
for j in range(min(len(array), 3)):
array_a.append((array[j][0], array[j][7]))
array.sort(key=lambda x: x[1])
for j in range(min(len(array), 3)):
array_b.append((array[j][1], array[j][7]))
array.sort(key=lambda x: x[2])
for j in range(min(len(array), 3)):
array_c.append((array[j][2], array[j][7]))
if N >= 3:
for i in range(3):
for j in range(3):
for k in range(3):
if array_a[i][1] != array_b[j][1] and array_b[j][1] != array_c[k][1] and array_a[i][1] != array_c[k][1]:
answer = min(answer, array_a[i][0] + array_b[j][0] + array_c[k][0])
# ab, cそれぞれ1つずつある状態に持っていく場合
if N >= 2:
array_ab = []
array.sort(key=lambda x: x[3])
for j in range(2):
array_ab.append((array[j][3], array[j][7]))
array_ac = []
array.sort(key=lambda x: x[4])
for j in range(2):
array_ac.append((array[j][4], array[j][7]))
array_bc = []
array.sort(key=lambda x: x[5])
for j in range(2):
array_bc.append((array[j][5], array[j][7]))
# ab, c
for i in range(2):
for j in range(2):
if array_ab[i][1] != array_c[j][1]:
answer = min(answer, array_ab[i][0] + array_ac[j][0])
# ac, b
for i in range(2):
for j in range(2):
if array_ac[i][1] != array_b[j][1]:
answer = min(answer, array_ac[i][0] + array_b[j][0])
# bc, a
for i in range(2):
for j in range(2):
if array_bc[i][1] != array_a[j][1]:
answer = min(answer, array_bc[i][0] + array_a[j][0])
#abcの場合
for j in range(N):
if array[j][6] < answer:
answer = array[j][6]
print(answer)
if __name__ == "__main__":
main()
## https://atcoder.jp/contests/arc166/tasks/arc166_b
def calc_gcd(A, B):
"""
正の整数A, Bの最大公約数を計算する
"""
a = max(A, B)
b = min(A, B)
while a % b > 0:
c = a % b
a = b
b = c
return b
def main():
N, a, b, c = map(int, input().split())
A = list(map(int, input().split()))
ab = calc_gcd(a, b)
ab = (a // ab) * b
ac = calc_gcd(a, c)
ac = (a // ac) * c
bc = calc_gcd(b, c)
bc = (b // bc) * c
abc = calc_gcd(ab, c)
abc = (ab // abc) * c
array = [[0] * 9 for _ in range(N)]
for i in range(N):
array[i][0] = (-A[i] % a)
array[i][1] = (-A[i] % b)
array[i][2] = (-A[i] % c)
array[i][3] = (-A[i] % ab)
array[i][4] = (-A[i] % ac)
array[i][5] = (-A[i] % bc)
array[i][6] = (-A[i] % abc)
array[i][7] = i
answer = float("inf")
# a, b, cそれぞれ1つずつある状態に持っていく場合
# aにすると一番近いベスト3を選ぶ
array_a = []
array_b = []
array_c = []
array.sort(key=lambda x: x[0])
for j in range(min(len(array), 3)):
array_a.append((array[j][0], array[j][7]))
array.sort(key=lambda x: x[1])
for j in range(min(len(array), 3)):
array_b.append((array[j][1], array[j][7]))
array.sort(key=lambda x: x[2])
for j in range(min(len(array), 3)):
array_c.append((array[j][2], array[j][7]))
if N >= 3:
for i in range(3):
for j in range(3):
for k in range(3):
if array_a[i][1] != array_b[j][1] and array_b[j][1] != array_c[k][1] and array_a[i][1] != array_c[k][1]:
answer = min(answer, array_a[i][0] + array_b[j][0] + array_c[k][0])
# ab, cそれぞれ1つずつある状態に持っていく場合
if N >= 2:
array_ab = []
array.sort(key=lambda x: x[3])
for j in range(2):
array_ab.append((array[j][3], array[j][7]))
array_ac = []
array.sort(key=lambda x: x[4])
for j in range(2):
array_ac.append((array[j][4], array[j][7]))
array_bc = []
array.sort(key=lambda x: x[5])
for j in range(2):
array_bc.append((array[j][5], array[j][7]))
# ab, c
for i in range(2):
for j in range(2):
if array_ab[i][1] != array_c[j][1]:
answer = min(answer, array_ab[i][0] + array_c[j][0])
# ac, b
for i in range(2):
for j in range(2):
if array_ac[i][1] != array_b[j][1]:
answer = min(answer, array_ac[i][0] + array_b[j][0])
# bc, a
for i in range(2):
for j in range(2):
if array_bc[i][1] != array_a[j][1]:
answer = min(answer, array_bc[i][0] + array_a[j][0])
#abcの場合
for j in range(N):
if array[j][6] < answer:
answer = array[j][6]
print(answer)
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/arc166_b/Python/51949905
|
condefects-python_data_805
|
n,m = map(int,input().split())
q = True
if n > m:
n,m = m,n
q = False
t = m - n
ans = []
for i in range(2 + t):
ans.append([1,i + 1])
if t == 0:
for i in range(2):
ans.append([2,2 + t - i])
else:
for i in range(3):
ans.append([2,2 + t - i])
for i in range(n - 2):
ans.append([2 + i,t + 2 + i + 1])
ans.append([2 + i + 1,t + 2 + i + 1])
ans.append([2 + i + 1,t + 2 + i])
ans.append([2 + i + 1,t + 2 + i - 1])
if n == 1:
print(m)
if q:
for i in range(m):
print(1,i + 1)
else:
for i in range(m):
print(i + 1,1)
elif n == m and n % 2 == 1:
print(4 * m - 3)
for i in range(3):
for j in range(3):
print(i + 1,j + 1)
t = (m - 3) // 2
for i in range(t):
for j in range(3):
for k in range(3):
if j != 0 or k != 0:
print(2 * (i + 1) + j,2 * (i + 1) + k)
else:
print(len(ans))
if q:
for i in ans:
print(i[0],i[1])
else:
for i in ans:
print(i[1],i[0])
n,m = map(int,input().split())
q = True
if n > m:
n,m = m,n
q = False
t = m - n
ans = []
for i in range(2 + t):
ans.append([1,i + 1])
if t == 0:
for i in range(2):
ans.append([2,2 + t - i])
else:
for i in range(3):
ans.append([2,2 + t - i])
for i in range(n - 2):
ans.append([2 + i,t + 2 + i + 1])
ans.append([2 + i + 1,t + 2 + i + 1])
ans.append([2 + i + 1,t + 2 + i])
ans.append([2 + i + 1,t + 2 + i - 1])
if n == 1:
print(m)
if q:
for i in range(m):
print(1,i + 1)
else:
for i in range(m):
print(i + 1,1)
elif n == m and n % 2 == 1:
print(4 * m - 3)
for i in range(3):
for j in range(3):
print(i + 1,j + 1)
t = (m - 3) // 2
for i in range(t):
for j in range(3):
for k in range(3):
if j != 0 or k != 0:
print(2 * (i + 1) + j + 1,2 * (i + 1) + k + 1)
else:
print(len(ans))
if q:
for i in ans:
print(i[0],i[1])
else:
for i in ans:
print(i[1],i[0])
|
ConDefects/ConDefects/Code/arc139_c/Python/31247940
|
condefects-python_data_806
|
n,m=map(int,input().split())
ans=set()
use=set()
use2=set()
for i in range(10**5):
for dx in range(1,4):
for dy in range(1,4):
x=2*i+dx
y=2*i+dy
if 1<=x<=n and 1<=y<=m:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
if m<=n:
for y in range(1,m+1):
x=n
if 3*x+y not in use and x+3*y not in use2:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
else:
for x in range(1,n+1):
y=m
if 3*x+y not in use and x+3*y not in use2:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
print(len(ans))
for x,y in ans:
print(x,y)
n,m=map(int,input().split())
ans=set()
use=set()
use2=set()
for i in range(10**5):
for dx in range(1,4):
for dy in range(1,4):
x=2*i+dx
y=2*i+dy
if 1<=x<=n and 1<=y<=m:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
if n<=m:
for y in range(1,m+1):
x=n
if 3*x+y not in use and x+3*y not in use2:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
else:
for x in range(1,n+1):
y=m
if 3*x+y not in use and x+3*y not in use2:
ans.add((x,y))
use.add(3*x+y)
use2.add(x+3*y)
print(len(ans))
for x,y in ans:
print(x,y)
|
ConDefects/ConDefects/Code/arc139_c/Python/31248584
|
condefects-python_data_807
|
import functools
import math
import decimal
import collections
import itertools
import sys
import random
import bisect
import typing
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
# Union-Find
class UnionFind():
def __init__(self, n: int) -> None:
self.n = n
self.par = list(range(self.n))
self.rank = [1] * self.n
self.count = self.n
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x: int, y: int) -> None:
p = self.find(x)
q = self.find(y)
if p == q:
return None
if p > q:
p, q = q, p
self.rank[p] += self.rank[q]
self.par[q] = p
self.count -= 1
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return self.rank[x]
def count(self) -> int:
return self.count
# 素数列挙
def prime_numbers(x: int) -> list:
if x < 2:
return []
prime_numbers = [i for i in range(x)]
prime_numbers[1] = 0
for prime_number in prime_numbers:
if prime_number ** 2 > x:
break
if prime_number == 0:
continue
for composite_number in range(2 * prime_number, x, prime_number):
prime_numbers[composite_number] = 0
return [prime_number for prime_number in prime_numbers if prime_number != 0]
# 素数判定
def is_prime(x: int) -> bool:
if x < 2: return False
if x == 2 or x == 3 or x == 5: return True
if x % 2 == 0 or x % 3 == 0 or x % 5 == 0: return False
prime_number = 7
difference = 4
while prime_number ** 2 <= x:
if x % prime_number == 0: return False
prime_number += difference
difference = 6 - difference
return True
# 素因数分解
def prime_factorize(n: int) -> list:
res = []
while n % 2 == 0:
res.append(2)
n //= 2
f = 3
while f ** 2 <= n:
if n % f == 0:
res.append(f)
n //= f
else:
f += 2
if n != 1:
res.append(n)
return res
# nCrなど
mod = 10 ** 9 + 7
class Combinatorics:
def __init__(self, n: int, mod: int) -> None:
self.n = n
self.mod = mod
self.fa = [1] * (self.n + 1)
self.fi = [1] * (self.n + 1)
for i in range(1, self.n + 1):
self.fa[i] = self.fa[i - 1] * i % self.mod
self.fi[-1] = pow(self.fa[-1], self.mod - 2, self.mod)
for i in range(self.n, 0, -1):
self.fi[i - 1] = self.fi[i] * i % self.mod
def comb(self, n: int, r: int) -> int:
if n < r:return 0
if n < 0 or r < 0:return 0
return self.fa[n] * self.fi[r] % self.mod * self.fi[n - r] % self.mod
def perm(self, n: int, r: int) -> int:
if n < r:return 0
if n < 0 or r < 0:return 0
return self.fa[n] * self.fi[n - r] % self.mod
def combr(self, n: int, r: int) -> int:
if n == r == 0:return 1
return self.comb(n + r - 1, r)
# BIT
class BinaryIndexedTree():
def __init__(self, n: int) -> None:
self.n = 1 << (n.bit_length())
self.BIT = [0] * (self.n + 1)
def build(self, init_lis: list) -> None:
for i, v in enumerate(init_lis):
self.add(i, v)
def add(self, i: int, x: int) -> None:
i += 1
while i <= self.n:
self.BIT[i] += x
i += i & -i
def sum(self, l: int, r: int) -> int:
return self._sum(r) - self._sum(l)
def _sum(self, i: int) -> int:
res = 0
while i > 0:
res += self.BIT[i]
i -= i & -i
return res
def binary_search(self, x: int) -> int:
i = self.n
while True:
if i & 1:
if x > self.BIT[i]:
i += 1
break
if x > self.BIT[i]:
x -= self.BIT[i]
i += (i & -i) >> 1
else:
i -= (i & -i) >> 1
return i
# Floor-Sum
def floor_sum(n: int, m: int, a: int, b: int) -> int:
res = 0
if a >= m:
res += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
res += n * (b // m)
b %= m
y_max = (a * n + b) // m
x_max = y_max * m - b
if y_max == 0:
return res
res += y_max * (n + (-x_max // a))
res += floor_sum(y_max, a, m, (a - x_max % a) % a)
return res
# Z-Algorithm
def z_algorithm(s: str) -> list:
str_len = len(s)
res = [0] * str_len
res[str_len - 1] = str_len
i, j = 1, 0
while i < str_len:
while i + j < str_len and s[i + j] == s[j]:
j += 1
res[i] = j
if j == 0:
i += 1
continue
k = 1
while i + k < str_len and j > res[k] + k:
res[i + k] = res[k]
k += 1
i += k
j -= k
return res
# Manacher's Algorithm
class Manacher():
def __init__(self, s: str) -> None:
self.s = s
def coustruct(self) -> list:
i, j = 0, 0
res = [0] * len(self.s)
while i < len(self.s):
while i - j >= 0 and i + j < len(self.s) and self.s[i - j] == self.s[i + j]:
j += 1
res[i] = j
k = 1
while i - k >= 0 and i + k < len(self.s) and k + res[i - k] < j:
res[i + k] = res[i - k]
k += 1
i += k
j -= k
return res
# mod-sqrt
def mod_sqrt(a: int, p: int) -> int:
if a == 0: return 0
if p == 2: return 1
k = (p - 1) // 2
if pow(a, k, p) != 1: return -1
while True:
n = random.randint(2, p - 1)
r = (n ** 2 - a) % p
if r == 0: return n
if pow(r, k, p) == p - 1: break
k += 1
w, x, y, z = n, 1, 1, 0
while k:
if k % 2:
y, z = w * y + r * x * z, x * y + w * z
w, x = w * w + r * x * x, 2 * w * x
w %= p; x %= p; y %= p; z %= p
k >>= 1
return y
import typing
import typing
# Segment Tree
class SegmentTree:
def __init__(
self,
lis: list,
ele: typing.Any,
op: typing.Callable[[typing.Any, typing.Any], typing.Any]) -> None:
self.n = len(lis)
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.op = op
self.ele = ele
self.tree = self._build(lis)
def _build(self, lis: list) -> list:
res_tree = [self.ele] * (2 * self.size)
for i, a in enumerate(lis):
res_tree[self.size + i] = a
for i in range(1, self.size)[::-1]:
res_tree[i] = self.op(res_tree[2 * i], res_tree[2 * i + 1])
return res_tree
def __getitem__(self, i: int) -> None:
return self.tree[self.size + i]
def __setitem__(self, p: int, x: int) -> None:
p += self.size
self.tree[p] = x
for i in range(1, self.log + 1):
self.tree[p >> i] = self.op(self.tree[2 * (p >> i)], self.tree[2 * (p >> i) + 1])
def prod(self, l: int, r: int) -> typing.Any:
l += self.size
r += self.size
L = R = self.ele
while l < r:
if l & 1:
L = self.op(L, self.tree[l])
l += 1
if r & 1:
r -= 1
R = self.op(self.tree[r], R)
l >>= 1
r >>= 1
return self.op(L, R)
def all_prod(self) -> typing.Any:
return self.tree[1]
def max_right(self, l: int, f: typing.Callable[[typing.Any], typing.Any]) -> int:
if l == self.n:
return self.n
l += self.size
sm = self.ele
while True:
while l % 2 == 0:
l >>= 1
if not f(self.op(sm, self.tree[l])):
while l < self.size:
l *= 2
if f(self.op(sm, self.tree[l])):
sm = self.op(sm, self.tree[l])
l += 1
return l - self.size
sm = self.op(sm, self.tree[l])
l += 1
if (l & -l) == l:
return self.n
def min_left(self, r: int, f: typing.Callable[[typing.Any], typing.Any]) -> int:
if r == 0:
return 0
r += self.size
sm = self.ele
while True:
r -= 1
while r > 1 and (r % 2):
r >>= 1
if not f(self.op(self.tree[r], sm)):
while r < self.size:
r = 2 * r + 1
if f(self.op(self.tree[r], sm)):
sm = self.op(self.tree[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r:
return 0
# 1次元座標圧縮
def one_d_coordinate_compression(l: list) -> list:
n = len(l)
sorted_list = sorted(set(l))
d = {sorted_list[i]: i for i in range(len(sorted_list))}
return [d[i] for i in l]
# 重み付きUnion-Find
class WeightedUnionFind:
def __init__(self, n: int) -> None:
self.n = n
self.par = list(range(n))
self.rank = [0] * n
self.weight = [0] * n
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
y = self.find(self.par[x])
self.weight[x] += self.weight[self.par[x]]
self.par[x] = y
return y
def unite(self, x: int, y: int, w: int) -> None:
p, q = self.find(x), self.find(y)
if self.rank[p] < self.rank[q]:
self.par[p] = q
self.weight[p] = w - self.weight[x] + self.weight[y]
else:
self.par[q] = p
self.weight[q] = -w - self.weight[y] + self.weight[x]
if self.rank[p] == self.rank[q]:
self.rank[p] += 1
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def diff(self, x: int, y: int) -> int:
return self.weight[x] - self.weight[y]
# Trie
class TrieNode:
def __init__(self):
self.child = collections.defaultdict(TrieNode)
self.is_word = False
class Trie:
def __init__(self):
self.root = TrieNode()
def insert(self, word: str) -> None:
cur = self.root
for letter in word:
cur = cur.child[letter]
cur.is_word = True
def search(self, word: str) -> bool:
cur = self.root
for letter in word:
cur = cur.child.get(letter)
if cur == None:
return False
return cur.is_word
def starts_with(self, prefix: str) -> bool:
cur = self.root
for letter in prefix:
cur = cur.child.get(letter)
if cur == None:
return False
return True
import bisect
# 部分永続Union-Find
class PartiallyPersistentUnionFind:
def __init__(self, n: int) -> None:
self.par = list(range(n))
self.size = [1] * n
self.h = [1] * n
self.s = [[(0, 1)] for i in range(n)]
self.t = [10 ** 18] * n
def find(self, x: int, t: int) -> int:
while self.t[x] <= t:
x = self.par[x]
return x
def unite(self, x: int, y: int, t: int) -> None:
p = self.find(x, t)
q = self.find(y, t)
if p == q:
return None
if self.h[q] < self.h[p]:
self.par[q] = p
self.t[q] = t
self.size[p] += self.size[q]
self.s[p].append((t, self.size[p]))
else:
self.par[p] = q
self.t[p] = t
self.size[q] += self.size[p]
self.s[q].append((t, self.size[q]))
self.h[q] = max(self.h[q], self.h[p] + 1)
def getsize(self, x: int, t: int = 10 ** 9) -> int:
p = self.find(x, t)
ind = bisect.bisect(self.s[p], (t, 10 ** 18)) - 1
return self.s[p][ind][1]
def same(self, x: int, y: int, t: int = 10 ** 9) -> int:
return self.find(x, t) == self.find(y, t)
def binary_search(self, x: int, y: int) -> int:
if not self.same(x, y):
return -1
l, r = 0, 10 ** 9
ans = 10 ** 18
while l < r:
m = (l + r) // 2
if self.same(x, y, m):
ans = min(ans, m)
r = m
else:
l = m
return ans + 1
# 遅延セグ木
class LazySegmentTree:
def __init__(
self,
lis: list,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
ele: typing.Any,
mapp: typing.Callable[[typing.Any, typing.Any], typing.Any],
comp: typing.Callable[[typing.Any, typing.Any], typing.Any],
id: typing.Any) -> None:
self.lis = lis
self.n = len(lis)
self.op = op
self.ele = ele
self.mapp = mapp
self.comp = comp
self.id = id
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.data = [ele] * (2 * self.size)
self.lazy = [id] * self.size
self._build(lis)
def update(self, k: int) -> None:
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def _build(self, lis: list) -> None:
for i, l in enumerate(lis, self.size):
self.data[i] = l
for i in range(1, self.size)[::-1]:
self.update(i)
def __setitem__(self, p: int, x: int) -> None:
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def __getitem__(self, p: int) -> typing.Any:
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def apply(self, p: int, f: typing.Optional[typing.Any]) -> None:
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapp(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l: int, r: int, f: typing.Optional[typing.Any]) -> None:
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push((r - 1) >> i)
l2, r2 = l, r
while l2 < r2:
if l2 & 1:
self.all_apply(l2, f)
l2 += 1
if r2 & 1:
r2 -= 1
self.all_apply(r2, f)
l2 >>= 1
r2 >>= 1
for i in range(1, self.log + 1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r - 1) >> i)
def all_apply(self, k: int, f: typing.Optional[typing.Any]) -> None:
self.data[k] = self.mapp(f, self.data[k])
if k < self.size:
self.lazy[k] = self.comp(f, self.lazy[k])
def push(self, k: int) -> None:
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def prod(self, l: int, r: int) -> typing.Any:
if l == r: return self.ele
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push(r >> i)
sml = smr = self.ele
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self) -> typing.Any:
return self.data[1]
def max_right(self, l: int, g: typing.Callable[[typing.Any], bool]) -> int:
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.ele
while True:
while l % 2 == 0:
l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l <<= 1
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r: int, g: typing.Callable[[typing.Any], bool]) -> int:
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.ele
while True:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
# SCC
def strongly_connected_components(G: list) -> list:
n = len(G)
G_rev = [[] for i in range(n)]
for i in range(n):
for v in G[i]:
G_rev[v].append(i)
vs = []
visited = [False] * n
def dfs(v):
visited[v] = True
for u in G[v]:
if not visited[u]:
dfs(u)
vs.append(v)
for i in range(n):
if not visited[i]:
dfs(i)
rev_visited = [False] * n
def rev_dfs(v):
p.append(v)
rev_visited[v] = True
for u in G_rev[v]:
if not rev_visited[u]:
rev_dfs(u)
res = []
for v in vs[::-1]:
if not rev_visited[v]:
p = []
rev_dfs(v)
res.append(p)
return res
class TwoSat:
def __init__(self, n) -> None:
self.n = n
self.res = [0] * self.n
self.G = [[] for i in range(2 * self.n)]
def add_clause(self, i, f, j, g) -> None:
self.G[2 * i + (not f)].append(2 * j + g)
self.G[2 * j + g].append(2 * i + (not f))
self.G[2 * j + (not g)].append(2 * i + f)
self.G[2 * i + f].append(2 * j + (not g))
def satisfiabe(self) -> bool:
scc = strongly_connected_components(self.G)
l = [0] * (2 * self.n)
for i in range(2 * self.n):
for j in scc[i]:
l[j] = i
for i in range(self.n):
if l[2 * i] == l[2 * i + 1]: return False
self.res[i] = (l[2 * i] < l[2 * i + 1])
return True
def result(self):
return self.res
# SkewHeap(遅延伝播)
class SHNode:
def __init__(self, val: int) -> None:
self.left = None
self.right = None
self.val = val
self.add = 0
def lazy(self) -> None:
if self.left != None: self.left.add += self.add
if self.right != None: self.right.add += self.add
self.val += self.add
self.add = 0
class SkewHeap:
def __init__(self) -> None:
self.root = None
def heapmeld(self, h1: SHNode, h2: SHNode) -> SHNode:
if h1 == None: return h2
if h2 == None: return h1
if h1.val + h1.add > h2.val + h2.add:
h1, h2 = h2, h1
h1.lazy()
h1.right = self.heapmeld(h2, h1.right)
h1.left, h1.right = h1.right, h1.left
return h1
def heappop(self) -> int:
res = self.root
res.lazy()
self.root = self.heapmeld(res.left, res.right)
return res.val
def heappush(self, x: int) -> None:
nh = SHNode(x)
self.root = self.heapmeld(self.root, nh)
def heaptop(self) -> typing.Union[int, None]:
if self.root == None: return None
return self.root.val
def heapadd(self, val: int) -> None:
self.root.add += val
# 最小全域有向木
def directed_minimum_spanning_tree(n: int, m: int, edges: list, root: int) -> typing.Tuple[int, list]:
froms = [0] * n
from_cost = [0] * n
from_heap = [SkewHeap() for i in range(n)]
UF = UnionFind(n)
par = [-1] * m
stem = [-1] * n
used = [0] * n
used[root] = 2
inds = []
for i, (u, v, c) in enumerate(edges):
from_heap[v].heappush(c * m + i)
res = 0
for v in range(n):
if used[v] != 0: continue
proc = []
chi = []
cycle = 0
while used[v] != 2:
used[v] = 1
proc.append(v)
if from_heap[v].root == None: return -1, [-1] * n
from_cost[v], ind = divmod(from_heap[v].heappop(), m)
froms[v] = UF.find(edges[ind][0])
if stem[v] == -1: stem[v] = ind
if froms[v] == v: continue
res += from_cost[v]
inds.append(ind)
while cycle:
par[chi.pop()] = ind
cycle -= 1
chi.append(ind)
if used[froms[v]] == 1:
p = v
while True:
if not from_heap[p].root == None:
from_heap[p].heapadd(-from_cost[p] * m)
if p != v:
UF.unite(v, p)
from_heap[v].root = from_heap[v].heapmeld(from_heap[v].root, from_heap[p].root)
p = UF.find(froms[p])
new_v = UF.find(v)
from_heap[new_v] = from_heap[v]
v = new_v
cycle += 1
if p == v: break
else:
v = froms[v]
for v in proc:
used[v] = 2
visited = [0] * m
tree = [-1] * n
for i in inds[::-1]:
if visited[i]: continue
u, v, c = edges[i]
tree[v] = u
x = stem[v]
while x != i:
visited[x] = 1
x = par[x]
return res, tree
# 永続配列
class PersistentArrayNode:
def __init__(self, log: int) -> None:
self.val = None
self.ch = [None] * (1 << log)
class PersistentArray:
def __init__(self, log: int = 4) -> None:
self.log = log
self.mask = (1 << log) - 1
def build(self, array: list) -> typing.Union[PersistentArrayNode, None]:
rt = None
for i, val in enumerate(array):
rt = self.init_set(i, val, rt)
return rt
def init_set(self, i: int, val: typing.Any, t: typing.Union[PersistentArrayNode, None]) -> PersistentArrayNode:
if t is None:
t = PersistentArrayNode(self.log)
if i == 0:
t.val = val
else:
t.ch[i & self.mask] = self.init_set(i >> self.log, val, t.ch[i & self.mask])
return t
def set(self, i: int, val: typing.Any, t: int) -> PersistentArrayNode:
res = PersistentArrayNode(self.log)
if t is not None:
res.ch = t.ch[:]
res.val = t.val
if i == 0:
res.val = val
else:
res.ch[i & self.mask] = self.set(i >> self.log, val, res.ch[i & self.mask])
return res
def get(self, i: int, t: int) -> typing.Any:
if i == 0:
return t.val
else:
return self.get(i >> self.log, t.ch[i & self.mask])
# 完全永続Union-Find
class PersistentUnionFind:
def __init__(self, n: int) -> None:
self.par = PersistentArray()
self.rt = self.par.build([-1] * n)
def find(self, x: int, t: int) -> None:
p = self.par.get(x, t)
if p < 0: return x
return self.find(p, t)
def unite(self, x: int, y: int, t: int) -> int:
p = self.find(x, t)
q = self.find(y, t)
if x == y: return t
px = self.par.get(p, t)
qy = self.par.get(q, t)
if px > qy:
p, q = q, p
tmp = self.par.set(q, p, t)
return self.par.set(p, px + qy, tmp)
# Li-Chao-Tree
class LiChaoTree:
def __init__(self, x_list: list, INF: int = 10 ** 18) -> None:
x_list = sorted(list(set(x_list)))
self.comp = {x : k for k, x in enumerate(x_list)}
self.log = (len(x_list) - 1).bit_length()
self.n = 1 << self.log
self.ele = (0, INF)
self.xs = x_list + [INF] * (self.n - len(x_list))
self.inf = INF
self.tree = [self.ele for _ in range(2 * self.n)]
def f(self, line: typing.Tuple[int, int], x: int) -> int:
a, b = line
return a * x + b
def _add_(self, line: typing.Tuple[int, int], ind: int, left: int, right: int) -> None:
while True:
mid = (left + right) // 2
lx = self.xs[left]
mx = self.xs[mid]
rx = self.xs[right - 1]
lu = self.f(line, lx) < self.f(self.tree[ind], lx)
mu = self.f(line, mx) < self.f(self.tree[ind], mx)
ru = self.f(line, rx) < self.f(self.tree[ind], rx)
if lu and ru:
self.tree[ind] = line
return
if not lu and not ru:
return
if mu:
self.tree[ind], line = line, self.tree[ind]
if lu != mu:
right = mid
ind = ind * 2
else:
left = mid
ind = ind * 2 + 1
def add_line(self, line: typing.Tuple[int, int]) -> None:
self._add_(line, 1, 0, self.n)
def add_segment(self, line: typing.Tuple[int, int], left: int, right: int) -> None:
lind, rind = self.comp[left] + self.n, self.comp[right] + self.n
left, right = self.comp[left], self.comp[right]
size = 1
while lind < rind:
if lind & 1:
self._add_(line, lind, left, left + size)
lind += 1
left += size
if rind & 1:
rind -= 1
right -= size
self._add_(line, rind, right, right + size)
lind >>= 1
rind >>= 1
size <<= 1
def get_min(self, x: int) -> int:
ind = self.comp[x] + self.n
res = self.inf
while ind:
res = min(res, self.f(self.tree[ind], x))
ind >>= 1
return res
# k 乗根の切り捨て/切り上げ
def root_floor(n: int, k: int) -> int:
l, r = 0, int(pow(n, 1 / k)) + 10000
while r - l > 1:
m = (l + r) // 2
if pow(m, k) > n:
r = m
else:
l = m
return l
def root_ceil(n: int, k: int) -> int:
l, r = 0, int(pow(n, 1 / k)) + 10000
while r - l > 1:
m = (l + r) // 2
if pow(m, k) < n:
l = m
else:
r = m
return r
# Baby-Step Giant-Step
def discrete_logarithm(x: int, y: int, m: int) -> int:
if m == 1: return 0
if y == 1: return 0
if x == 0:
if y == 0: return 1
else: return -1
sq = root_ceil(m, 2) + 1
d = dict()
z = 1
for i in range(sq):
if z % m == y: return i
d[y * z % m] = i
z *= x
z %= m
g = pow(x, sq, m)
z = g
for i in range(1, sq + 1):
if z in d:
num = d[z]
res = i * sq - num
return res if pow(x, res, m) == y else -1
z *= g
z %= m
return -1
# NTT
class NumberTheoreticTransform:
def primitive_root(self, m: int) -> int:
if m == 2: return 1
if m == 167772161: return 3
if m == 469762049: return 3
if m == 754974721: return 11
if m == 998244353: return 3
divs = [0] * 20
divs[0] = 2
cnt = 1
x = (m - 1) // 2
while x % 2 == 0: x //= 2
i = 3
while i ** 2 <= x:
if x % i == 0:
divs[cnt] = i
cnt += 1
while x % i == 0: x //= i
if x > 1:
divs[cnt] = x
cnt += 1
g = 2
while True:
f = True
for i in range(cnt):
if pow(g, (m - 1) // divs[i], m) == 1: break
else:
return g
g += 1
def bsf(self, x: int) -> int:
res = 0
while x % 2 == 0:
res += 1
x //= 2
return res
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
self.g = self.primitive_root(self.mod)
def butterfly(self, a: list) -> None:
n = len(a)
h = (n - 1).bit_length()
sum_e = [0] * 30
first = True
if first:
first = False
es = [0] * 30
ies = [0] * 30
cnt2 = self.bsf(self.mod - 1)
e = pow(self.g, (self.mod - 1) >> cnt2, self.mod)
ie = invmod(e, self.mod)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e ** 2 % self.mod
ie = ie ** 2 % self.mod
now = 1
for i in range(cnt2 - 2):
sum_e[i] = es[i] * now % self.mod
now = now * ies[i] % self.mod
for ph in range(1, h + 1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
now = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * now % self.mod
a[i + offset] = (l + r) % self.mod
a[i + offset + p] = (l - r) % self.mod
now = now * sum_e[(~s & -~s).bit_length() - 1] % self.mod
def butterfly_inv(self, a: list) -> None:
n = len(a)
h = (n - 1).bit_length()
sum_ie = [0] * 30
first = True
if first:
first = False
es = [0] * 30
ies = [0] * 30
cnt2 = self.bsf(self.mod - 1)
e = pow(self.g, (self.mod - 1) >> cnt2, self.mod)
ie = invmod(e, self.mod)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e ** 2 % self.mod
ie = ie ** 2 % self.mod
now = 1
for i in range(cnt2 - 2):
sum_ie[i] = ies[i] * now % self.mod
now = now * es[i] % self.mod
for ph in range(h, 0, -1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
inow = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % self.mod
a[i + offset + p] = (l - r) * inow % self.mod
inow = inow * sum_ie[(~s & -~s).bit_length() - 1] % self.mod
def convolution(self, a: list, b: list) -> list:
n = len(a)
m = len(b)
if not a or not b: return []
z = 1 << ((n + m - 2).bit_length())
a += [0] * (z - n)
b += [0] * (z - m)
self.butterfly(a)
self.butterfly(b)
c = [0] * z
for i in range(z):
c[i] = (a[i] * b[i]) % self.mod
self.butterfly_inv(c)
iz = invmod(z, self.mod)
for i in range(n + m - 1):
c[i] = c[i] * iz % self.mod
return c[:n + m - 1]
# 形式的冪級数（未完成）
class FormalPowerSeries:
def __init__(self, n: int, l: list = [], mod: int = 998244353) -> None:
self.n = n
self.l = l + [0] * (n - len(l))
self.mod = mod
def __add__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] + other.l[i]
res.l[i] %= self.mod
return res
def __sub__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] - other.l[i]
res.l[i] %= self.mod
return res
def __mul__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
NTT = NumberTheoreticTransform(self.mod)
cv = NTT.convolution(self.l, other.l)
for i in range(self.n):
res.l[i] = cv[i]
return res
def resize(self, n: int):
res = FormalPowerSeries(n, [], self.mod)
for i in range(min(n, self.n)):
res.l[i] = self.l[i]
return res
def times(self, k: int):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] * k % self.mod
return res
def inverse(self):
r = invmod(self.l[0], self.mod)
m = 1
res = FormalPowerSeries(m, [r], self.mod)
while m < self.n:
m *= 2
res = res.resize(m)
res = res.times(2).subtract(res.multiply(res.resize(m)).multiply(self.resize(m)))
res = res.resize(self.n)
return res
def divide(self, other) -> None:
self.multiply(self, other.inverse())
def differentiate(self):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(1, self.n):
res.l[i - 1] = self.l[i] * i % self.mod
return res
def integrate(self):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n - 1):
res.l[i + 1] = self.l[i] * invmod(i + 1, self.mod)
return res
# BitVector
class BitVector:
def __init__(self, size: int) -> None:
self.block = (size + 31) >> 5
self.bit = [0] * self.block
self.cnt = [0] * self.block
def set(self, i: int) -> None:
self.bit[i >> 5] |= 1 << (i & 31)
def build(self) -> None:
for i in range(self.block - 1):
self.cnt[i + 1] = self.cnt[i] + self.popcount(self.bit[i])
def popcount(self, x: int) -> int:
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def rank1(self, r: int) -> int:
msk = (1 << (r & 31)) - 1
return self.cnt[r >> 5] + self.popcount(self.bit[r >> 5] & msk)
def rank0(self, r: int) -> int:
return r - self.rank1(r)
# Wavelet Matrix
class WaveletMatrix:
def __init__(self, array: list, log: int = 32) -> None:
self.n = len(array)
self.mat = []
self.zs = []
self.log = log
for d in range(self.log)[::-1]:
ls, rs = [], []
BV = BitVector(self.n + 1)
for ind, val in enumerate(array):
if val & (1 << d):
rs.append(val)
BV.set(ind)
else:
ls.append(val)
BV.build()
self.mat.append(BV)
self.zs.append(len(ls))
array = ls + rs
def access(self, i: int) -> int:
res = 0
for d in range(self.log):
res <<= 1
if self.mat[d][i]:
res |= 1
i = self.mat[d].rank1(i) + self.zs[d]
else:
i = self.mat[d].rank0(i)
return res
def rank(self, val: int, l: int, r: int) -> int:
for d in range(self.log):
if val >> (self.log - d - 1) & 1:
l = self.mat[d].rank1(l) + self.zs[d]
r = self.mat[d].rank1(r) + self.zs[d]
else:
l = self.mat[d].rank0(l)
r = self.mat[d].rank0(r)
return r - l
def quantile(self, l: int, r: int, k: int) -> int:
res = 0
for d in range(self.log):
res <<= 1
cntl, cntr = self.mat[d].rank1(l), self.mat[d].rank1(r)
if cntr - cntl >= k:
l = cntl + self.zs[d]
r = cntr + self.zs[d]
res |= 1
else:
l -= cntl
r -= cntr
k -= cntr - cntl
return res
def kth_smallest(self, l: int, r: int, k: int) -> int:
return self.quantile(l, r, r - l - k)
class CompressedWaveletMatrix:
def __init__(self, array: list) -> None:
self.array = sorted(set(array))
self.comp = {val: ind for ind, val in enumerate(self.array)}
array = [self.comp[val] for val in array]
log = len(self.array).bit_length()
self.WM = WaveletMatrix(array, log)
def access(self, i: int) -> int:
return self.array[self.WM.access(i)]
def rank(self, l: int, r: int, val: int) -> int:
if val not in self.comp: return 0
return self.WM.rank(self.comp[val], l, r)
def kth_smallest(self, l: int, r: int, k: int) -> int:
return self.array[self.WM.kth_smallest(l, r, k)]
# 中国剰余定理
def invgcd(a: int, b: int) -> typing.Tuple[int, int]:
a %= b
if a == 0: return (b, 0)
s, t, m0, m1 = b, a, 0, 1
while t:
u = s // t
s %= t
m0 -= m1 * u
s, t = t, s
m0, m1 = m1, m0
if m0 < 0: m0 += b // s
return (s, m0)
def garner(r: list, m: list) -> typing.Tuple[int, int]:
n = len(r)
r0, m0 = 0, 1
for i in range(n):
r1, m1 = r[i] % m[i], m[i]
if m0 < m1:
r0, r1 = r1, r0
m0, m1 = m1, m0
if m0 % m1 == 0:
if r0 % m1 != r1: return (0, 0)
continue
g, im = invgcd(m0, m1)
u1 = m1 // g
if (r1 - r0) % g: return (0, 0)
x = (r1 - r0) // g % u1 * im % u1
r0 += x * m0
m0 *= u1
if r0 < 0: r0 += m0
return (r0, m0)
# Bitwise And Convolution
class BitwiseAndConvolution:
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
def fast_zeta_transform_and(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
a[j] += a[bit | j]
a[j] %= self.mod
return a
def fast_mobius_transform_and(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
a[j] -= a[bit | j]
a[j] %= self.mod
return a
def bitwise_and_convolution(self, a: list, b: list) -> list:
n = len(a)
A = self.fast_zeta_transform_and(a)
B = self.fast_zeta_transform_and(b)
C = [i * j % self.mod for i, j in zip(A, B)]
return self.fast_mobius_transform_and(C)
# Bitwise Or Convolution
class BitwiseOrConvolution:
def __init__(self, mod: int = 9888244353) -> None:
self.mod = mod
def fast_zeta_transform_or(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if bit & j:
a[j] += a[bit ^ j]
a[j] %= self.mod
return a
def fast_mobius_transform_or(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if bit & j:
a[j] -= a[bit ^ j]
a[j] %= self.mod
return a
def bitwise_or_convolution(self, a: list, b: list) -> list:
n = len(a)
A = self.fast_zeta_transform_or(a)
B = self.fast_zeta_transform_or(b)
C = [i * j % self.mod for i, j in zip(A, B)]
return self.fast_mobius_transform_or(C)
# Bitwise Xor Convolution
class BitwiseXorConvolution:
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
def fast_hadamard_transform(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
x, y = a[j], a[j | bit]
a[j] = (x + y) % self.mod
a[j | bit] = (x - y) % self.mod
return a
def inv_fast_hadamard_transform(self, a: list) -> list:
a = self.fast_hadamard_transform(a)
n = len(a)
inv = invmod(n, self.mod)
for i in range(n):
a[i] *= inv
a[i] %= self.mod
return a
def bitwise_xor_convolution(self, a: list, b: list) -> list:
A = self.fast_hadamard_transform(a)
B = self.fast_hadamard_transform(b)
n = len(a)
C = [i * j for i, j in zip(A, B)]
C = self.inv_fast_hadamard_transform(C)
return C
# HLD
class HeavyLightDecomposition:
def __init__(self, G: list) -> None:
self.G = G
self.n = len(G)
self.par = [-1] * self.n
self.size = [1] * self.n
self.head = [0] * self.n
self.preord = [0] * self.n
self.k = 0
for v in range(self.n):
if self.par[v] == -1:
self.dfs_sz(v)
self.dfs_hld(v)
def dfs_sz(self, v: int) -> None:
G = self.G
stack, order = [v], [v]
while stack:
p = stack.pop()
for u in G[p]:
if self.par[p] == u: continue
self.par[u] = p
stack.append(u)
order.append(u)
while order:
p = order.pop()
ch = G[p]
if len(ch) and ch[0] == self.par[p]:
ch[0], ch[-1] = ch[-1], ch[0]
for i, u in enumerate(ch):
if u == self.par[p]: continue
self.size[p] += self.size[u]
if self.size[u] > self.size[ch[0]]:
ch[i], ch[0] = ch[0], ch[i]
def dfs_hld(self, v: int) -> None:
G = self.G
stack = [v]
while stack:
p = stack.pop()
self.preord[p] = self.k
self.k += 1
top = self.G[p][0]
for u in G[p][::-1]:
if u == self.par[p]: continue
if u == top:
self.head[u] = self.head[p]
else:
self.head[u] = u
stack.append(u)
def enumerate_vertices(self, u: int, v: int) -> typing.Generator[typing.Tuple[int, int], None, None]:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
l = max(self.preord[self.head[v]], self.preord[u])
r = self.preord[v]
yield l, r
if self.head[u] != self.head[v]:
v = self.par[self.head[v]]
else:
return
def enumerate_edges(self, u: int, v: int) -> typing.Generator[typing.Tuple[int, int], None, None]:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
if self.head[u] != self.head[v]:
yield self.preord[self.head[v]], self.preord[v]
v = self.par[self.head[v]]
else:
if u != v:
yield self.preord[u] + 1, self.preord[v]
break
def subtree(self, v: int) -> typing.Tuple[int, int]:
l = self.preord[v]
r = self.preord[v] + self.size(v)
return l, r
def lowest_common_ancestor(self, u: int, v: int) -> int:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
if self.head[u] == self.head[v]: return u
v = self.par[self.head[v]]
# 行列ライブラリ(遅い)
class Matrix:
def __init__(self, n: int, m: int, mat: typing.Union[list, None] = None, mod: int = 998244353) -> None:
self.n = n
self.m = m
self.mat = [[0] * self.m for i in range(self.n)]
self.mod = mod
if mat:
for i in range(self.n):
self.mat[i] = mat[i]
def is_square(self) -> None:
return self.n == self.m
def __getitem__(self, key: int) -> int:
if isinstance(key, slice):
return self.mat[key]
else:
assert key >= 0
return self.mat[key]
@classmethod
def id(n: int) -> "Matrix":
res = Matrix(n, n)
for i in range(n):
res[i][i] = 1
return res
def __len__(self) -> int:
return len(self.mat)
def __str__(self) -> str:
return "\n".join(" ".join(map(str, self[i])) for i in range(self.n))
def times(self, k: int) -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = k * self[i][j] % self.mod
return Matrix(self.n, self.m, res)
def __pos__(self) -> "Matrix":
return self
def __neg__(self) -> "Matrix":
return self.times(-1)
def __add__(self, other: "Matrix") -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = (self[i][j] + other[i][j]) % self.mod
return Matrix(self.n, self.m, res)
def __sub__(self, other: "Matrix") -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = (self[i][j] - other[i][j]) % self.mod
return Matrix(self.n, self.m, res)
def __mul__(self, other: typing.Union["Matrix", int]) -> "Matrix":
if other.__class__ == Matrix:
res = [[0] * other.m for i in range(self.n)]
for i in range(self.n):
for k in range(self.m):
for j in range(other.m):
res[i][j] += self[i][k] * other[k][j]
res[i][j] %= self.mod
return Matrix(self.n, other.m, res)
else:
return self.times(other)
def __rmul__(self, other: typing.Union["Matrix", int]) -> "Matrix":
return self.times(other)
def __pow__(self, k: int) -> "Matrix":
tmp = Matrix(self.n, self.n, self.mat)
res = Matrix.id(self.n)
while k:
if k & 1:
res *= tmp
tmp *= tmp
k >>= 1
return res
def determinant(self) -> int:
res = 1
tmp = Matrix(self.n, self.n, self.mat)
for j in range(self.n):
if tmp[j][j] == 0:
for i in range(j + 1, self.n):
if tmp[i][j] != 0: break
else:
return 0
tmp.mat[j], tmp.mat[i] = tmp.mat[i], tmp.mat[j]
res *= -1
inv = invmod(tmp[j][j], self.mod)
for i in range(j + 1, self.n):
c = -inv * tmp[i][j] % self.mod
for k in range(self.n):
tmp[i][k] += c * tmp[j][k]
tmp[i][k] %= self.mod
for i in range(self.n):
res *= tmp[i][i]
res %= self.mod
return res
# 多項式補間
class PolynomialInterpolation:
def __init__(self, mod: int = 99824353) -> None:
self.mod = mod
# 多項式補間(普通の O(N^2))
def polynomial_interpolation(self, X: list, Y: list, t: int) -> int:
n = len(X) - 1
c = [0] * (n + 1)
for i, xi in enumerate(X):
f = 1
for j, xj in enumerate(X):
if i == j: continue
f *= (xi - xj)
f %= self.mod
c[i] = (Y[i] * invmod(f, self.mod)) % self.mod
res = 0
f = 1
for i, x in enumerate(X):
f *= (t - x)
f %= self.mod
for i, a in enumerate(c):
res += a * f * invmod(t - X[i], self.mod) % self.mod
res %= self.mod
return res
# 多項式補間(等差の O(N log N))
def polynomial_interpolation_arithmetic(self, a: int, d: int, Y: list, t: int) -> int:
n = len(Y) - 1
C = [0] * (n + 1)
f = 1
for i in range(1, n + 1):
f *= -d * i
f %= self.mod
C[0] = (Y[0] * invmod(f, self.mod)) % self.mod
for i in range(1, n + 1):
f *= invmod(-d * (n - i + 1), self.mod) * d * i
f %= self.mod
C[i] = (Y[i] * invmod(f, self.mod)) % self.mod
res = 0
f = 1
for i in range(n + 1):
f = f * (t - (a + d * i))
f %= self.mod
for i, c in enumerate(C):
res += c * f * invmod(t - (a + d * i), self.mod)
res %= self.mod
return res
# 拡張Euclidの互除法
def extgcd(a: int, b: int, d: int = 0) -> typing.Tuple[int, int, int]:
g = a
if b == 0:
x, y = 1, 0
else:
x, y, g = extgcd(b, a % b)
x, y = y, x - a // b * y
return x, y, g
# mod p における逆元
def invmod(a: int, p: int) -> int:
x, y, g = extgcd(a, p)
x %= p
return x
# モンモール数（長さ N の完全順列の数）を 1,2,...,N について求める
def montmort_number(n: int, mod: int = 998244353) -> list:
res = [0]
for i in range(2, n + 1): res.append((i * res[-1] + pow(-1, i)) % mod)
return res
# 偏角ソート
def sort_by_argument(points: list) -> list:
def compare(p1: tuple, p2: tuple) -> int:
x1, y1 = p1; x2, y2 = p2
tmp = x1 * y2 - y1 * x2
if tmp < 0: return 1
elif tmp > 0: return -1
else: return 0
quad = [[] for i in range(4)]
for x, y in points:
if x == y == 0: quad[2].append((x, y))
elif x <= 0 and y < 0: quad[0].append((x, y))
elif x > 0 and y <= 0: quad[1].append((x, y))
elif x >= 0 and y > 0: quad[2].append((x, y))
else: quad[3].append((x, y))
res = []
for i in range(4):
quad[i].sort(key=functools.cmp_to_key(compare))
for point in quad[i]: res.append(point)
return res
# SlidingWindowAggretgation
class SlidingWindowAggretgation:
def __init__(self, op: typing.Callable[[typing.Any, typing.Any], typing.Any]) -> None:
self.op = op
self.front_stack = []
self.back_stack = []
def __len__(self) -> int:
return len(self.front_stack) + len(self.back_stack)
def __bool__(self) -> bool:
return len(self) > 0
def __str__(self) -> str:
data = [x for x, _ in self.front_stack][::-1] + [x for x, _ in self.back_stack]
return str(data)
def append(self, x: int) -> None:
fx = x
if self.back_stack:
fx = self.op(self.back_stack[-1][1], x)
self.back_stack.append((x, fx))
def popleft(self) -> None:
if not self.front_stack:
x = fx = self.back_stack.pop()[0]
self.front_stack.append((x, fx))
while self.back_stack:
x = self.back_stack.pop()[0]
fx = self.op(x, fx)
self.front_stack.append((x, fx))
self.front_stack.pop()
def all_prod(self) -> int:
res = None
if self.front_stack:
res = self.front_stack[-1][1]
if self.back_stack:
if res is None:
res = self.back_stack[-1][1]
else:
res = self.op(res, self.back_stack[-1][1])
return res
# トポロジカルソート
def topological_sort(G: list, d: list) -> list:
n = len(G)
s = []
for i in range(n):
if d[i] == 0: s.append(i)
ans = []
while s:
u = s.pop()
ans.append(u)
for v in G[u]:
d[v] -= 1
if d[v] == 0: s.append(v)
if len(ans) != n: return -1
return ans
# maxflow (Ford-Fulkerson)
class FordFulkerson:
def __init__(self, n: int) -> None:
self.n = n
self.G = [[] for _ in range(n)]
self.inf = 10 ** 9
def add_edge(self, fr: int, to: int, cap: int) -> None:
fwd = [to, cap, None]
fwd[2] = bwd = [fr, 0, fwd]
self.G[fr].append(fwd)
self.G[to].append(bwd)
def add_multi_edge(self, v1, v2, cap1, cap2):
edge1 = [v2, cap1, None]
edge1[2] = edge2 = [v1, cap2, edge1]
self.G[v1].append(edge1)
self.G[v2].append(edge2)
def dfs(self, v: int, t: int, f: int) -> int:
if v == t: return f
self.visit[v] = 1
for e in self.G[v]:
w, cap, rev = e
if cap and not self.visit[w]:
d = self.dfs(w, t, min(f, cap))
if d:
e[1] -= d
rev[1] += d
return d
return 0
def max_flow(self, s: int, t: int) -> int:
flow = 0
f = self.inf
while f:
self.visit = [0] * self.n
f = self.dfs(s, t, self.inf)
flow += f
return flow
# maxflow (Dinic)
class Dinic:
def __init__(self, n: int) -> None:
self.n = n
self.G = [[] for _ in range(n)]
self.inf = 10 ** 9
def add_edge(self, fr: int, to: int, cap: int) -> None:
fwd = [to, cap, None]
fwd[2] = bwd = [fr, 0, fwd]
self.G[fr].append(fwd)
self.G[to].append(bwd)
def add_multi_edge(self, v1: int, v2: int, cap1: int, cap2: int) -> None:
edge1 = [v2, cap1, None]
edge1[2] = edge2 = [v1, cap2, edge1]
self.G[v1].append(edge1)
self.G[v2].append(edge2)
def bfs(self, s: int, t: int) -> bool:
self.level = [None] * self.n
Q = collections.deque([s])
self.level[s] = 0
while Q:
u = Q.popleft()
lv = self.level[u] + 1
for v, cap, _ in self.G[u]:
if cap and self.level[v] is None:
self.level[v] = lv
Q.append(v)
return self.level[t] is not None
def dfs(self, v: int, t: int, f: int) -> int:
if v == t: return f
for e in self.it[v]:
w, cap, rev = e
if cap and self.level[v] < self.level[w]:
d = self.dfs(w, t, min(f, cap))
if d:
e[1] -= d
rev[1] += d
return d
return 0
def max_flow(self, s: int, t: int) -> int:
flow = 0
while self.bfs(s, t):
*self.it, = map(iter, self.G)
f = self.inf
while f:
f = self.dfs(s, t, self.inf)
flow += f
return flow
n, m = map(int, input().split())
s = set()
cx, cy = 1, 1
for _ in range(min(2 * 10 ** 5, n * 100)):
for i in range(3):
for j in range(3):
if cx + i <= n and cy + j <= m: s.add((cx + i, cy + j))
cx = min(cx + 2, n); cy = min(cy + 2, m)
print(len(s))
for a, b in s: print(a, b)
import functools
import math
import decimal
import collections
import itertools
import sys
import random
import bisect
import typing
sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
# Union-Find
class UnionFind():
def __init__(self, n: int) -> None:
self.n = n
self.par = list(range(self.n))
self.rank = [1] * self.n
self.count = self.n
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x: int, y: int) -> None:
p = self.find(x)
q = self.find(y)
if p == q:
return None
if p > q:
p, q = q, p
self.rank[p] += self.rank[q]
self.par[q] = p
self.count -= 1
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def size(self, x: int) -> int:
return self.rank[x]
def count(self) -> int:
return self.count
# 素数列挙
def prime_numbers(x: int) -> list:
if x < 2:
return []
prime_numbers = [i for i in range(x)]
prime_numbers[1] = 0
for prime_number in prime_numbers:
if prime_number ** 2 > x:
break
if prime_number == 0:
continue
for composite_number in range(2 * prime_number, x, prime_number):
prime_numbers[composite_number] = 0
return [prime_number for prime_number in prime_numbers if prime_number != 0]
# 素数判定
def is_prime(x: int) -> bool:
if x < 2: return False
if x == 2 or x == 3 or x == 5: return True
if x % 2 == 0 or x % 3 == 0 or x % 5 == 0: return False
prime_number = 7
difference = 4
while prime_number ** 2 <= x:
if x % prime_number == 0: return False
prime_number += difference
difference = 6 - difference
return True
# 素因数分解
def prime_factorize(n: int) -> list:
res = []
while n % 2 == 0:
res.append(2)
n //= 2
f = 3
while f ** 2 <= n:
if n % f == 0:
res.append(f)
n //= f
else:
f += 2
if n != 1:
res.append(n)
return res
# nCrなど
mod = 10 ** 9 + 7
class Combinatorics:
def __init__(self, n: int, mod: int) -> None:
self.n = n
self.mod = mod
self.fa = [1] * (self.n + 1)
self.fi = [1] * (self.n + 1)
for i in range(1, self.n + 1):
self.fa[i] = self.fa[i - 1] * i % self.mod
self.fi[-1] = pow(self.fa[-1], self.mod - 2, self.mod)
for i in range(self.n, 0, -1):
self.fi[i - 1] = self.fi[i] * i % self.mod
def comb(self, n: int, r: int) -> int:
if n < r:return 0
if n < 0 or r < 0:return 0
return self.fa[n] * self.fi[r] % self.mod * self.fi[n - r] % self.mod
def perm(self, n: int, r: int) -> int:
if n < r:return 0
if n < 0 or r < 0:return 0
return self.fa[n] * self.fi[n - r] % self.mod
def combr(self, n: int, r: int) -> int:
if n == r == 0:return 1
return self.comb(n + r - 1, r)
# BIT
class BinaryIndexedTree():
def __init__(self, n: int) -> None:
self.n = 1 << (n.bit_length())
self.BIT = [0] * (self.n + 1)
def build(self, init_lis: list) -> None:
for i, v in enumerate(init_lis):
self.add(i, v)
def add(self, i: int, x: int) -> None:
i += 1
while i <= self.n:
self.BIT[i] += x
i += i & -i
def sum(self, l: int, r: int) -> int:
return self._sum(r) - self._sum(l)
def _sum(self, i: int) -> int:
res = 0
while i > 0:
res += self.BIT[i]
i -= i & -i
return res
def binary_search(self, x: int) -> int:
i = self.n
while True:
if i & 1:
if x > self.BIT[i]:
i += 1
break
if x > self.BIT[i]:
x -= self.BIT[i]
i += (i & -i) >> 1
else:
i -= (i & -i) >> 1
return i
# Floor-Sum
def floor_sum(n: int, m: int, a: int, b: int) -> int:
res = 0
if a >= m:
res += (n - 1) * n * (a // m) // 2
a %= m
if b >= m:
res += n * (b // m)
b %= m
y_max = (a * n + b) // m
x_max = y_max * m - b
if y_max == 0:
return res
res += y_max * (n + (-x_max // a))
res += floor_sum(y_max, a, m, (a - x_max % a) % a)
return res
# Z-Algorithm
def z_algorithm(s: str) -> list:
str_len = len(s)
res = [0] * str_len
res[str_len - 1] = str_len
i, j = 1, 0
while i < str_len:
while i + j < str_len and s[i + j] == s[j]:
j += 1
res[i] = j
if j == 0:
i += 1
continue
k = 1
while i + k < str_len and j > res[k] + k:
res[i + k] = res[k]
k += 1
i += k
j -= k
return res
# Manacher's Algorithm
class Manacher():
def __init__(self, s: str) -> None:
self.s = s
def coustruct(self) -> list:
i, j = 0, 0
res = [0] * len(self.s)
while i < len(self.s):
while i - j >= 0 and i + j < len(self.s) and self.s[i - j] == self.s[i + j]:
j += 1
res[i] = j
k = 1
while i - k >= 0 and i + k < len(self.s) and k + res[i - k] < j:
res[i + k] = res[i - k]
k += 1
i += k
j -= k
return res
# mod-sqrt
def mod_sqrt(a: int, p: int) -> int:
if a == 0: return 0
if p == 2: return 1
k = (p - 1) // 2
if pow(a, k, p) != 1: return -1
while True:
n = random.randint(2, p - 1)
r = (n ** 2 - a) % p
if r == 0: return n
if pow(r, k, p) == p - 1: break
k += 1
w, x, y, z = n, 1, 1, 0
while k:
if k % 2:
y, z = w * y + r * x * z, x * y + w * z
w, x = w * w + r * x * x, 2 * w * x
w %= p; x %= p; y %= p; z %= p
k >>= 1
return y
import typing
import typing
# Segment Tree
class SegmentTree:
def __init__(
self,
lis: list,
ele: typing.Any,
op: typing.Callable[[typing.Any, typing.Any], typing.Any]) -> None:
self.n = len(lis)
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.op = op
self.ele = ele
self.tree = self._build(lis)
def _build(self, lis: list) -> list:
res_tree = [self.ele] * (2 * self.size)
for i, a in enumerate(lis):
res_tree[self.size + i] = a
for i in range(1, self.size)[::-1]:
res_tree[i] = self.op(res_tree[2 * i], res_tree[2 * i + 1])
return res_tree
def __getitem__(self, i: int) -> None:
return self.tree[self.size + i]
def __setitem__(self, p: int, x: int) -> None:
p += self.size
self.tree[p] = x
for i in range(1, self.log + 1):
self.tree[p >> i] = self.op(self.tree[2 * (p >> i)], self.tree[2 * (p >> i) + 1])
def prod(self, l: int, r: int) -> typing.Any:
l += self.size
r += self.size
L = R = self.ele
while l < r:
if l & 1:
L = self.op(L, self.tree[l])
l += 1
if r & 1:
r -= 1
R = self.op(self.tree[r], R)
l >>= 1
r >>= 1
return self.op(L, R)
def all_prod(self) -> typing.Any:
return self.tree[1]
def max_right(self, l: int, f: typing.Callable[[typing.Any], typing.Any]) -> int:
if l == self.n:
return self.n
l += self.size
sm = self.ele
while True:
while l % 2 == 0:
l >>= 1
if not f(self.op(sm, self.tree[l])):
while l < self.size:
l *= 2
if f(self.op(sm, self.tree[l])):
sm = self.op(sm, self.tree[l])
l += 1
return l - self.size
sm = self.op(sm, self.tree[l])
l += 1
if (l & -l) == l:
return self.n
def min_left(self, r: int, f: typing.Callable[[typing.Any], typing.Any]) -> int:
if r == 0:
return 0
r += self.size
sm = self.ele
while True:
r -= 1
while r > 1 and (r % 2):
r >>= 1
if not f(self.op(self.tree[r], sm)):
while r < self.size:
r = 2 * r + 1
if f(self.op(self.tree[r], sm)):
sm = self.op(self.tree[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.d[r], sm)
if (r & -r) == r:
return 0
# 1次元座標圧縮
def one_d_coordinate_compression(l: list) -> list:
n = len(l)
sorted_list = sorted(set(l))
d = {sorted_list[i]: i for i in range(len(sorted_list))}
return [d[i] for i in l]
# 重み付きUnion-Find
class WeightedUnionFind:
def __init__(self, n: int) -> None:
self.n = n
self.par = list(range(n))
self.rank = [0] * n
self.weight = [0] * n
def find(self, x: int) -> int:
if self.par[x] == x:
return x
else:
y = self.find(self.par[x])
self.weight[x] += self.weight[self.par[x]]
self.par[x] = y
return y
def unite(self, x: int, y: int, w: int) -> None:
p, q = self.find(x), self.find(y)
if self.rank[p] < self.rank[q]:
self.par[p] = q
self.weight[p] = w - self.weight[x] + self.weight[y]
else:
self.par[q] = p
self.weight[q] = -w - self.weight[y] + self.weight[x]
if self.rank[p] == self.rank[q]:
self.rank[p] += 1
def same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def diff(self, x: int, y: int) -> int:
return self.weight[x] - self.weight[y]
# Trie
class TrieNode:
def __init__(self):
self.child = collections.defaultdict(TrieNode)
self.is_word = False
class Trie:
def __init__(self):
self.root = TrieNode()
def insert(self, word: str) -> None:
cur = self.root
for letter in word:
cur = cur.child[letter]
cur.is_word = True
def search(self, word: str) -> bool:
cur = self.root
for letter in word:
cur = cur.child.get(letter)
if cur == None:
return False
return cur.is_word
def starts_with(self, prefix: str) -> bool:
cur = self.root
for letter in prefix:
cur = cur.child.get(letter)
if cur == None:
return False
return True
import bisect
# 部分永続Union-Find
class PartiallyPersistentUnionFind:
def __init__(self, n: int) -> None:
self.par = list(range(n))
self.size = [1] * n
self.h = [1] * n
self.s = [[(0, 1)] for i in range(n)]
self.t = [10 ** 18] * n
def find(self, x: int, t: int) -> int:
while self.t[x] <= t:
x = self.par[x]
return x
def unite(self, x: int, y: int, t: int) -> None:
p = self.find(x, t)
q = self.find(y, t)
if p == q:
return None
if self.h[q] < self.h[p]:
self.par[q] = p
self.t[q] = t
self.size[p] += self.size[q]
self.s[p].append((t, self.size[p]))
else:
self.par[p] = q
self.t[p] = t
self.size[q] += self.size[p]
self.s[q].append((t, self.size[q]))
self.h[q] = max(self.h[q], self.h[p] + 1)
def getsize(self, x: int, t: int = 10 ** 9) -> int:
p = self.find(x, t)
ind = bisect.bisect(self.s[p], (t, 10 ** 18)) - 1
return self.s[p][ind][1]
def same(self, x: int, y: int, t: int = 10 ** 9) -> int:
return self.find(x, t) == self.find(y, t)
def binary_search(self, x: int, y: int) -> int:
if not self.same(x, y):
return -1
l, r = 0, 10 ** 9
ans = 10 ** 18
while l < r:
m = (l + r) // 2
if self.same(x, y, m):
ans = min(ans, m)
r = m
else:
l = m
return ans + 1
# 遅延セグ木
class LazySegmentTree:
def __init__(
self,
lis: list,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
ele: typing.Any,
mapp: typing.Callable[[typing.Any, typing.Any], typing.Any],
comp: typing.Callable[[typing.Any, typing.Any], typing.Any],
id: typing.Any) -> None:
self.lis = lis
self.n = len(lis)
self.op = op
self.ele = ele
self.mapp = mapp
self.comp = comp
self.id = id
self.log = (self.n - 1).bit_length()
self.size = 1 << self.log
self.data = [ele] * (2 * self.size)
self.lazy = [id] * self.size
self._build(lis)
def update(self, k: int) -> None:
self.data[k] = self.op(self.data[2 * k], self.data[2 * k + 1])
def _build(self, lis: list) -> None:
for i, l in enumerate(lis, self.size):
self.data[i] = l
for i in range(1, self.size)[::-1]:
self.update(i)
def __setitem__(self, p: int, x: int) -> None:
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = x
for i in range(1, self.log + 1):
self.update(p >> i)
def __getitem__(self, p: int) -> typing.Any:
p += self.size
for i in range(1, self.log + 1):
self.push(p >> i)
return self.data[p]
def apply(self, p: int, f: typing.Optional[typing.Any]) -> None:
p += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(p >> i)
self.data[p] = self.mapp(f, self.data[p])
for i in range(1, self.log + 1):
self.update(p >> i)
def range_apply(self, l: int, r: int, f: typing.Optional[typing.Any]) -> None:
if l == r: return
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push((r - 1) >> i)
l2, r2 = l, r
while l2 < r2:
if l2 & 1:
self.all_apply(l2, f)
l2 += 1
if r2 & 1:
r2 -= 1
self.all_apply(r2, f)
l2 >>= 1
r2 >>= 1
for i in range(1, self.log + 1):
if ((l >> i) << i) != l:
self.update(l >> i)
if ((r >> i) << i) != r:
self.update((r - 1) >> i)
def all_apply(self, k: int, f: typing.Optional[typing.Any]) -> None:
self.data[k] = self.mapp(f, self.data[k])
if k < self.size:
self.lazy[k] = self.comp(f, self.lazy[k])
def push(self, k: int) -> None:
self.all_apply(2 * k, self.lazy[k])
self.all_apply(2 * k + 1, self.lazy[k])
self.lazy[k] = self.id
def prod(self, l: int, r: int) -> typing.Any:
if l == r: return self.ele
l += self.size
r += self.size
for i in range(1, self.log + 1)[::-1]:
if ((l >> i) << i) != l:
self.push(l >> i)
if ((r >> i) << i) != r:
self.push(r >> i)
sml = smr = self.ele
while l < r:
if l & 1:
sml = self.op(sml, self.data[l])
l += 1
if r & 1:
r -= 1
smr = self.op(self.data[r], smr)
l >>= 1
r >>= 1
return self.op(sml, smr)
def all_prod(self) -> typing.Any:
return self.data[1]
def max_right(self, l: int, g: typing.Callable[[typing.Any], bool]) -> int:
if l == self.n: return self.n
l += self.size
for i in range(1, self.log + 1)[::-1]:
self.push(l >> i)
sm = self.ele
while True:
while l % 2 == 0:
l >>= 1
if not g(self.op(sm, self.data[l])):
while l < self.size:
self.push(l)
l <<= 1
if g(self.op(sm, self.data[l])):
sm = self.op(sm, self.data[l])
l += 1
return l - self.size
sm = self.op(sm, self.data[l])
l += 1
if (l & -l) == l: return self.n
def min_left(self, r: int, g: typing.Callable[[typing.Any], bool]) -> int:
if r == 0: return 0
r += self.size
for i in range(1, self.log + 1)[::-1]:
self.push((r - 1) >> i)
sm = self.ele
while True:
r -= 1
while r > 1 and r % 2:
r >>= 1
if not g(self.op(self.data[r], sm)):
while r < self.size:
self.push(r)
r = 2 * r + 1
if g(self.op(self.data[r], sm)):
sm = self.op(self.data[r], sm)
r -= 1
return r + 1 - self.size
sm = self.op(self.data[r], sm)
if (r & -r) == r: return 0
# SCC
def strongly_connected_components(G: list) -> list:
n = len(G)
G_rev = [[] for i in range(n)]
for i in range(n):
for v in G[i]:
G_rev[v].append(i)
vs = []
visited = [False] * n
def dfs(v):
visited[v] = True
for u in G[v]:
if not visited[u]:
dfs(u)
vs.append(v)
for i in range(n):
if not visited[i]:
dfs(i)
rev_visited = [False] * n
def rev_dfs(v):
p.append(v)
rev_visited[v] = True
for u in G_rev[v]:
if not rev_visited[u]:
rev_dfs(u)
res = []
for v in vs[::-1]:
if not rev_visited[v]:
p = []
rev_dfs(v)
res.append(p)
return res
class TwoSat:
def __init__(self, n) -> None:
self.n = n
self.res = [0] * self.n
self.G = [[] for i in range(2 * self.n)]
def add_clause(self, i, f, j, g) -> None:
self.G[2 * i + (not f)].append(2 * j + g)
self.G[2 * j + g].append(2 * i + (not f))
self.G[2 * j + (not g)].append(2 * i + f)
self.G[2 * i + f].append(2 * j + (not g))
def satisfiabe(self) -> bool:
scc = strongly_connected_components(self.G)
l = [0] * (2 * self.n)
for i in range(2 * self.n):
for j in scc[i]:
l[j] = i
for i in range(self.n):
if l[2 * i] == l[2 * i + 1]: return False
self.res[i] = (l[2 * i] < l[2 * i + 1])
return True
def result(self):
return self.res
# SkewHeap(遅延伝播)
class SHNode:
def __init__(self, val: int) -> None:
self.left = None
self.right = None
self.val = val
self.add = 0
def lazy(self) -> None:
if self.left != None: self.left.add += self.add
if self.right != None: self.right.add += self.add
self.val += self.add
self.add = 0
class SkewHeap:
def __init__(self) -> None:
self.root = None
def heapmeld(self, h1: SHNode, h2: SHNode) -> SHNode:
if h1 == None: return h2
if h2 == None: return h1
if h1.val + h1.add > h2.val + h2.add:
h1, h2 = h2, h1
h1.lazy()
h1.right = self.heapmeld(h2, h1.right)
h1.left, h1.right = h1.right, h1.left
return h1
def heappop(self) -> int:
res = self.root
res.lazy()
self.root = self.heapmeld(res.left, res.right)
return res.val
def heappush(self, x: int) -> None:
nh = SHNode(x)
self.root = self.heapmeld(self.root, nh)
def heaptop(self) -> typing.Union[int, None]:
if self.root == None: return None
return self.root.val
def heapadd(self, val: int) -> None:
self.root.add += val
# 最小全域有向木
def directed_minimum_spanning_tree(n: int, m: int, edges: list, root: int) -> typing.Tuple[int, list]:
froms = [0] * n
from_cost = [0] * n
from_heap = [SkewHeap() for i in range(n)]
UF = UnionFind(n)
par = [-1] * m
stem = [-1] * n
used = [0] * n
used[root] = 2
inds = []
for i, (u, v, c) in enumerate(edges):
from_heap[v].heappush(c * m + i)
res = 0
for v in range(n):
if used[v] != 0: continue
proc = []
chi = []
cycle = 0
while used[v] != 2:
used[v] = 1
proc.append(v)
if from_heap[v].root == None: return -1, [-1] * n
from_cost[v], ind = divmod(from_heap[v].heappop(), m)
froms[v] = UF.find(edges[ind][0])
if stem[v] == -1: stem[v] = ind
if froms[v] == v: continue
res += from_cost[v]
inds.append(ind)
while cycle:
par[chi.pop()] = ind
cycle -= 1
chi.append(ind)
if used[froms[v]] == 1:
p = v
while True:
if not from_heap[p].root == None:
from_heap[p].heapadd(-from_cost[p] * m)
if p != v:
UF.unite(v, p)
from_heap[v].root = from_heap[v].heapmeld(from_heap[v].root, from_heap[p].root)
p = UF.find(froms[p])
new_v = UF.find(v)
from_heap[new_v] = from_heap[v]
v = new_v
cycle += 1
if p == v: break
else:
v = froms[v]
for v in proc:
used[v] = 2
visited = [0] * m
tree = [-1] * n
for i in inds[::-1]:
if visited[i]: continue
u, v, c = edges[i]
tree[v] = u
x = stem[v]
while x != i:
visited[x] = 1
x = par[x]
return res, tree
# 永続配列
class PersistentArrayNode:
def __init__(self, log: int) -> None:
self.val = None
self.ch = [None] * (1 << log)
class PersistentArray:
def __init__(self, log: int = 4) -> None:
self.log = log
self.mask = (1 << log) - 1
def build(self, array: list) -> typing.Union[PersistentArrayNode, None]:
rt = None
for i, val in enumerate(array):
rt = self.init_set(i, val, rt)
return rt
def init_set(self, i: int, val: typing.Any, t: typing.Union[PersistentArrayNode, None]) -> PersistentArrayNode:
if t is None:
t = PersistentArrayNode(self.log)
if i == 0:
t.val = val
else:
t.ch[i & self.mask] = self.init_set(i >> self.log, val, t.ch[i & self.mask])
return t
def set(self, i: int, val: typing.Any, t: int) -> PersistentArrayNode:
res = PersistentArrayNode(self.log)
if t is not None:
res.ch = t.ch[:]
res.val = t.val
if i == 0:
res.val = val
else:
res.ch[i & self.mask] = self.set(i >> self.log, val, res.ch[i & self.mask])
return res
def get(self, i: int, t: int) -> typing.Any:
if i == 0:
return t.val
else:
return self.get(i >> self.log, t.ch[i & self.mask])
# 完全永続Union-Find
class PersistentUnionFind:
def __init__(self, n: int) -> None:
self.par = PersistentArray()
self.rt = self.par.build([-1] * n)
def find(self, x: int, t: int) -> None:
p = self.par.get(x, t)
if p < 0: return x
return self.find(p, t)
def unite(self, x: int, y: int, t: int) -> int:
p = self.find(x, t)
q = self.find(y, t)
if x == y: return t
px = self.par.get(p, t)
qy = self.par.get(q, t)
if px > qy:
p, q = q, p
tmp = self.par.set(q, p, t)
return self.par.set(p, px + qy, tmp)
# Li-Chao-Tree
class LiChaoTree:
def __init__(self, x_list: list, INF: int = 10 ** 18) -> None:
x_list = sorted(list(set(x_list)))
self.comp = {x : k for k, x in enumerate(x_list)}
self.log = (len(x_list) - 1).bit_length()
self.n = 1 << self.log
self.ele = (0, INF)
self.xs = x_list + [INF] * (self.n - len(x_list))
self.inf = INF
self.tree = [self.ele for _ in range(2 * self.n)]
def f(self, line: typing.Tuple[int, int], x: int) -> int:
a, b = line
return a * x + b
def _add_(self, line: typing.Tuple[int, int], ind: int, left: int, right: int) -> None:
while True:
mid = (left + right) // 2
lx = self.xs[left]
mx = self.xs[mid]
rx = self.xs[right - 1]
lu = self.f(line, lx) < self.f(self.tree[ind], lx)
mu = self.f(line, mx) < self.f(self.tree[ind], mx)
ru = self.f(line, rx) < self.f(self.tree[ind], rx)
if lu and ru:
self.tree[ind] = line
return
if not lu and not ru:
return
if mu:
self.tree[ind], line = line, self.tree[ind]
if lu != mu:
right = mid
ind = ind * 2
else:
left = mid
ind = ind * 2 + 1
def add_line(self, line: typing.Tuple[int, int]) -> None:
self._add_(line, 1, 0, self.n)
def add_segment(self, line: typing.Tuple[int, int], left: int, right: int) -> None:
lind, rind = self.comp[left] + self.n, self.comp[right] + self.n
left, right = self.comp[left], self.comp[right]
size = 1
while lind < rind:
if lind & 1:
self._add_(line, lind, left, left + size)
lind += 1
left += size
if rind & 1:
rind -= 1
right -= size
self._add_(line, rind, right, right + size)
lind >>= 1
rind >>= 1
size <<= 1
def get_min(self, x: int) -> int:
ind = self.comp[x] + self.n
res = self.inf
while ind:
res = min(res, self.f(self.tree[ind], x))
ind >>= 1
return res
# k 乗根の切り捨て/切り上げ
def root_floor(n: int, k: int) -> int:
l, r = 0, int(pow(n, 1 / k)) + 10000
while r - l > 1:
m = (l + r) // 2
if pow(m, k) > n:
r = m
else:
l = m
return l
def root_ceil(n: int, k: int) -> int:
l, r = 0, int(pow(n, 1 / k)) + 10000
while r - l > 1:
m = (l + r) // 2
if pow(m, k) < n:
l = m
else:
r = m
return r
# Baby-Step Giant-Step
def discrete_logarithm(x: int, y: int, m: int) -> int:
if m == 1: return 0
if y == 1: return 0
if x == 0:
if y == 0: return 1
else: return -1
sq = root_ceil(m, 2) + 1
d = dict()
z = 1
for i in range(sq):
if z % m == y: return i
d[y * z % m] = i
z *= x
z %= m
g = pow(x, sq, m)
z = g
for i in range(1, sq + 1):
if z in d:
num = d[z]
res = i * sq - num
return res if pow(x, res, m) == y else -1
z *= g
z %= m
return -1
# NTT
class NumberTheoreticTransform:
def primitive_root(self, m: int) -> int:
if m == 2: return 1
if m == 167772161: return 3
if m == 469762049: return 3
if m == 754974721: return 11
if m == 998244353: return 3
divs = [0] * 20
divs[0] = 2
cnt = 1
x = (m - 1) // 2
while x % 2 == 0: x //= 2
i = 3
while i ** 2 <= x:
if x % i == 0:
divs[cnt] = i
cnt += 1
while x % i == 0: x //= i
if x > 1:
divs[cnt] = x
cnt += 1
g = 2
while True:
f = True
for i in range(cnt):
if pow(g, (m - 1) // divs[i], m) == 1: break
else:
return g
g += 1
def bsf(self, x: int) -> int:
res = 0
while x % 2 == 0:
res += 1
x //= 2
return res
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
self.g = self.primitive_root(self.mod)
def butterfly(self, a: list) -> None:
n = len(a)
h = (n - 1).bit_length()
sum_e = [0] * 30
first = True
if first:
first = False
es = [0] * 30
ies = [0] * 30
cnt2 = self.bsf(self.mod - 1)
e = pow(self.g, (self.mod - 1) >> cnt2, self.mod)
ie = invmod(e, self.mod)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e ** 2 % self.mod
ie = ie ** 2 % self.mod
now = 1
for i in range(cnt2 - 2):
sum_e[i] = es[i] * now % self.mod
now = now * ies[i] % self.mod
for ph in range(1, h + 1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
now = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p] * now % self.mod
a[i + offset] = (l + r) % self.mod
a[i + offset + p] = (l - r) % self.mod
now = now * sum_e[(~s & -~s).bit_length() - 1] % self.mod
def butterfly_inv(self, a: list) -> None:
n = len(a)
h = (n - 1).bit_length()
sum_ie = [0] * 30
first = True
if first:
first = False
es = [0] * 30
ies = [0] * 30
cnt2 = self.bsf(self.mod - 1)
e = pow(self.g, (self.mod - 1) >> cnt2, self.mod)
ie = invmod(e, self.mod)
for i in range(cnt2, 1, -1):
es[i - 2] = e
ies[i - 2] = ie
e = e ** 2 % self.mod
ie = ie ** 2 % self.mod
now = 1
for i in range(cnt2 - 2):
sum_ie[i] = ies[i] * now % self.mod
now = now * es[i] % self.mod
for ph in range(h, 0, -1):
w = 1 << (ph - 1)
p = 1 << (h - ph)
inow = 1
for s in range(w):
offset = s << (h - ph + 1)
for i in range(p):
l = a[i + offset]
r = a[i + offset + p]
a[i + offset] = (l + r) % self.mod
a[i + offset + p] = (l - r) * inow % self.mod
inow = inow * sum_ie[(~s & -~s).bit_length() - 1] % self.mod
def convolution(self, a: list, b: list) -> list:
n = len(a)
m = len(b)
if not a or not b: return []
z = 1 << ((n + m - 2).bit_length())
a += [0] * (z - n)
b += [0] * (z - m)
self.butterfly(a)
self.butterfly(b)
c = [0] * z
for i in range(z):
c[i] = (a[i] * b[i]) % self.mod
self.butterfly_inv(c)
iz = invmod(z, self.mod)
for i in range(n + m - 1):
c[i] = c[i] * iz % self.mod
return c[:n + m - 1]
# 形式的冪級数（未完成）
class FormalPowerSeries:
def __init__(self, n: int, l: list = [], mod: int = 998244353) -> None:
self.n = n
self.l = l + [0] * (n - len(l))
self.mod = mod
def __add__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] + other.l[i]
res.l[i] %= self.mod
return res
def __sub__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] - other.l[i]
res.l[i] %= self.mod
return res
def __mul__(self, other):
res = FormalPowerSeries(self.n, [], self.mod)
NTT = NumberTheoreticTransform(self.mod)
cv = NTT.convolution(self.l, other.l)
for i in range(self.n):
res.l[i] = cv[i]
return res
def resize(self, n: int):
res = FormalPowerSeries(n, [], self.mod)
for i in range(min(n, self.n)):
res.l[i] = self.l[i]
return res
def times(self, k: int):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n):
res.l[i] = self.l[i] * k % self.mod
return res
def inverse(self):
r = invmod(self.l[0], self.mod)
m = 1
res = FormalPowerSeries(m, [r], self.mod)
while m < self.n:
m *= 2
res = res.resize(m)
res = res.times(2).subtract(res.multiply(res.resize(m)).multiply(self.resize(m)))
res = res.resize(self.n)
return res
def divide(self, other) -> None:
self.multiply(self, other.inverse())
def differentiate(self):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(1, self.n):
res.l[i - 1] = self.l[i] * i % self.mod
return res
def integrate(self):
res = FormalPowerSeries(self.n, [], self.mod)
for i in range(self.n - 1):
res.l[i + 1] = self.l[i] * invmod(i + 1, self.mod)
return res
# BitVector
class BitVector:
def __init__(self, size: int) -> None:
self.block = (size + 31) >> 5
self.bit = [0] * self.block
self.cnt = [0] * self.block
def set(self, i: int) -> None:
self.bit[i >> 5] |= 1 << (i & 31)
def build(self) -> None:
for i in range(self.block - 1):
self.cnt[i + 1] = self.cnt[i] + self.popcount(self.bit[i])
def popcount(self, x: int) -> int:
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def rank1(self, r: int) -> int:
msk = (1 << (r & 31)) - 1
return self.cnt[r >> 5] + self.popcount(self.bit[r >> 5] & msk)
def rank0(self, r: int) -> int:
return r - self.rank1(r)
# Wavelet Matrix
class WaveletMatrix:
def __init__(self, array: list, log: int = 32) -> None:
self.n = len(array)
self.mat = []
self.zs = []
self.log = log
for d in range(self.log)[::-1]:
ls, rs = [], []
BV = BitVector(self.n + 1)
for ind, val in enumerate(array):
if val & (1 << d):
rs.append(val)
BV.set(ind)
else:
ls.append(val)
BV.build()
self.mat.append(BV)
self.zs.append(len(ls))
array = ls + rs
def access(self, i: int) -> int:
res = 0
for d in range(self.log):
res <<= 1
if self.mat[d][i]:
res |= 1
i = self.mat[d].rank1(i) + self.zs[d]
else:
i = self.mat[d].rank0(i)
return res
def rank(self, val: int, l: int, r: int) -> int:
for d in range(self.log):
if val >> (self.log - d - 1) & 1:
l = self.mat[d].rank1(l) + self.zs[d]
r = self.mat[d].rank1(r) + self.zs[d]
else:
l = self.mat[d].rank0(l)
r = self.mat[d].rank0(r)
return r - l
def quantile(self, l: int, r: int, k: int) -> int:
res = 0
for d in range(self.log):
res <<= 1
cntl, cntr = self.mat[d].rank1(l), self.mat[d].rank1(r)
if cntr - cntl >= k:
l = cntl + self.zs[d]
r = cntr + self.zs[d]
res |= 1
else:
l -= cntl
r -= cntr
k -= cntr - cntl
return res
def kth_smallest(self, l: int, r: int, k: int) -> int:
return self.quantile(l, r, r - l - k)
class CompressedWaveletMatrix:
def __init__(self, array: list) -> None:
self.array = sorted(set(array))
self.comp = {val: ind for ind, val in enumerate(self.array)}
array = [self.comp[val] for val in array]
log = len(self.array).bit_length()
self.WM = WaveletMatrix(array, log)
def access(self, i: int) -> int:
return self.array[self.WM.access(i)]
def rank(self, l: int, r: int, val: int) -> int:
if val not in self.comp: return 0
return self.WM.rank(self.comp[val], l, r)
def kth_smallest(self, l: int, r: int, k: int) -> int:
return self.array[self.WM.kth_smallest(l, r, k)]
# 中国剰余定理
def invgcd(a: int, b: int) -> typing.Tuple[int, int]:
a %= b
if a == 0: return (b, 0)
s, t, m0, m1 = b, a, 0, 1
while t:
u = s // t
s %= t
m0 -= m1 * u
s, t = t, s
m0, m1 = m1, m0
if m0 < 0: m0 += b // s
return (s, m0)
def garner(r: list, m: list) -> typing.Tuple[int, int]:
n = len(r)
r0, m0 = 0, 1
for i in range(n):
r1, m1 = r[i] % m[i], m[i]
if m0 < m1:
r0, r1 = r1, r0
m0, m1 = m1, m0
if m0 % m1 == 0:
if r0 % m1 != r1: return (0, 0)
continue
g, im = invgcd(m0, m1)
u1 = m1 // g
if (r1 - r0) % g: return (0, 0)
x = (r1 - r0) // g % u1 * im % u1
r0 += x * m0
m0 *= u1
if r0 < 0: r0 += m0
return (r0, m0)
# Bitwise And Convolution
class BitwiseAndConvolution:
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
def fast_zeta_transform_and(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
a[j] += a[bit | j]
a[j] %= self.mod
return a
def fast_mobius_transform_and(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
a[j] -= a[bit | j]
a[j] %= self.mod
return a
def bitwise_and_convolution(self, a: list, b: list) -> list:
n = len(a)
A = self.fast_zeta_transform_and(a)
B = self.fast_zeta_transform_and(b)
C = [i * j % self.mod for i, j in zip(A, B)]
return self.fast_mobius_transform_and(C)
# Bitwise Or Convolution
class BitwiseOrConvolution:
def __init__(self, mod: int = 9888244353) -> None:
self.mod = mod
def fast_zeta_transform_or(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if bit & j:
a[j] += a[bit ^ j]
a[j] %= self.mod
return a
def fast_mobius_transform_or(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if bit & j:
a[j] -= a[bit ^ j]
a[j] %= self.mod
return a
def bitwise_or_convolution(self, a: list, b: list) -> list:
n = len(a)
A = self.fast_zeta_transform_or(a)
B = self.fast_zeta_transform_or(b)
C = [i * j % self.mod for i, j in zip(A, B)]
return self.fast_mobius_transform_or(C)
# Bitwise Xor Convolution
class BitwiseXorConvolution:
def __init__(self, mod: int = 998244353) -> None:
self.mod = mod
def fast_hadamard_transform(self, a: list) -> list:
n = len(a)
b = (n - 1).bit_length()
for i in range(b):
bit = 1 << i
for j in range(n):
if not bit & j:
x, y = a[j], a[j | bit]
a[j] = (x + y) % self.mod
a[j | bit] = (x - y) % self.mod
return a
def inv_fast_hadamard_transform(self, a: list) -> list:
a = self.fast_hadamard_transform(a)
n = len(a)
inv = invmod(n, self.mod)
for i in range(n):
a[i] *= inv
a[i] %= self.mod
return a
def bitwise_xor_convolution(self, a: list, b: list) -> list:
A = self.fast_hadamard_transform(a)
B = self.fast_hadamard_transform(b)
n = len(a)
C = [i * j for i, j in zip(A, B)]
C = self.inv_fast_hadamard_transform(C)
return C
# HLD
class HeavyLightDecomposition:
def __init__(self, G: list) -> None:
self.G = G
self.n = len(G)
self.par = [-1] * self.n
self.size = [1] * self.n
self.head = [0] * self.n
self.preord = [0] * self.n
self.k = 0
for v in range(self.n):
if self.par[v] == -1:
self.dfs_sz(v)
self.dfs_hld(v)
def dfs_sz(self, v: int) -> None:
G = self.G
stack, order = [v], [v]
while stack:
p = stack.pop()
for u in G[p]:
if self.par[p] == u: continue
self.par[u] = p
stack.append(u)
order.append(u)
while order:
p = order.pop()
ch = G[p]
if len(ch) and ch[0] == self.par[p]:
ch[0], ch[-1] = ch[-1], ch[0]
for i, u in enumerate(ch):
if u == self.par[p]: continue
self.size[p] += self.size[u]
if self.size[u] > self.size[ch[0]]:
ch[i], ch[0] = ch[0], ch[i]
def dfs_hld(self, v: int) -> None:
G = self.G
stack = [v]
while stack:
p = stack.pop()
self.preord[p] = self.k
self.k += 1
top = self.G[p][0]
for u in G[p][::-1]:
if u == self.par[p]: continue
if u == top:
self.head[u] = self.head[p]
else:
self.head[u] = u
stack.append(u)
def enumerate_vertices(self, u: int, v: int) -> typing.Generator[typing.Tuple[int, int], None, None]:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
l = max(self.preord[self.head[v]], self.preord[u])
r = self.preord[v]
yield l, r
if self.head[u] != self.head[v]:
v = self.par[self.head[v]]
else:
return
def enumerate_edges(self, u: int, v: int) -> typing.Generator[typing.Tuple[int, int], None, None]:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
if self.head[u] != self.head[v]:
yield self.preord[self.head[v]], self.preord[v]
v = self.par[self.head[v]]
else:
if u != v:
yield self.preord[u] + 1, self.preord[v]
break
def subtree(self, v: int) -> typing.Tuple[int, int]:
l = self.preord[v]
r = self.preord[v] + self.size(v)
return l, r
def lowest_common_ancestor(self, u: int, v: int) -> int:
while True:
if self.preord[u] > self.preord[v]: u, v = v, u
if self.head[u] == self.head[v]: return u
v = self.par[self.head[v]]
# 行列ライブラリ(遅い)
class Matrix:
def __init__(self, n: int, m: int, mat: typing.Union[list, None] = None, mod: int = 998244353) -> None:
self.n = n
self.m = m
self.mat = [[0] * self.m for i in range(self.n)]
self.mod = mod
if mat:
for i in range(self.n):
self.mat[i] = mat[i]
def is_square(self) -> None:
return self.n == self.m
def __getitem__(self, key: int) -> int:
if isinstance(key, slice):
return self.mat[key]
else:
assert key >= 0
return self.mat[key]
@classmethod
def id(n: int) -> "Matrix":
res = Matrix(n, n)
for i in range(n):
res[i][i] = 1
return res
def __len__(self) -> int:
return len(self.mat)
def __str__(self) -> str:
return "\n".join(" ".join(map(str, self[i])) for i in range(self.n))
def times(self, k: int) -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = k * self[i][j] % self.mod
return Matrix(self.n, self.m, res)
def __pos__(self) -> "Matrix":
return self
def __neg__(self) -> "Matrix":
return self.times(-1)
def __add__(self, other: "Matrix") -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = (self[i][j] + other[i][j]) % self.mod
return Matrix(self.n, self.m, res)
def __sub__(self, other: "Matrix") -> "Matrix":
res = [[0] * self.m for i in range(self.n)]
for i in range(self.n):
for j in range(self.m):
res[i][j] = (self[i][j] - other[i][j]) % self.mod
return Matrix(self.n, self.m, res)
def __mul__(self, other: typing.Union["Matrix", int]) -> "Matrix":
if other.__class__ == Matrix:
res = [[0] * other.m for i in range(self.n)]
for i in range(self.n):
for k in range(self.m):
for j in range(other.m):
res[i][j] += self[i][k] * other[k][j]
res[i][j] %= self.mod
return Matrix(self.n, other.m, res)
else:
return self.times(other)
def __rmul__(self, other: typing.Union["Matrix", int]) -> "Matrix":
return self.times(other)
def __pow__(self, k: int) -> "Matrix":
tmp = Matrix(self.n, self.n, self.mat)
res = Matrix.id(self.n)
while k:
if k & 1:
res *= tmp
tmp *= tmp
k >>= 1
return res
def determinant(self) -> int:
res = 1
tmp = Matrix(self.n, self.n, self.mat)
for j in range(self.n):
if tmp[j][j] == 0:
for i in range(j + 1, self.n):
if tmp[i][j] != 0: break
else:
return 0
tmp.mat[j], tmp.mat[i] = tmp.mat[i], tmp.mat[j]
res *= -1
inv = invmod(tmp[j][j], self.mod)
for i in range(j + 1, self.n):
c = -inv * tmp[i][j] % self.mod
for k in range(self.n):
tmp[i][k] += c * tmp[j][k]
tmp[i][k] %= self.mod
for i in range(self.n):
res *= tmp[i][i]
res %= self.mod
return res
# 多項式補間
class PolynomialInterpolation:
def __init__(self, mod: int = 99824353) -> None:
self.mod = mod
# 多項式補間(普通の O(N^2))
def polynomial_interpolation(self, X: list, Y: list, t: int) -> int:
n = len(X) - 1
c = [0] * (n + 1)
for i, xi in enumerate(X):
f = 1
for j, xj in enumerate(X):
if i == j: continue
f *= (xi - xj)
f %= self.mod
c[i] = (Y[i] * invmod(f, self.mod)) % self.mod
res = 0
f = 1
for i, x in enumerate(X):
f *= (t - x)
f %= self.mod
for i, a in enumerate(c):
res += a * f * invmod(t - X[i], self.mod) % self.mod
res %= self.mod
return res
# 多項式補間(等差の O(N log N))
def polynomial_interpolation_arithmetic(self, a: int, d: int, Y: list, t: int) -> int:
n = len(Y) - 1
C = [0] * (n + 1)
f = 1
for i in range(1, n + 1):
f *= -d * i
f %= self.mod
C[0] = (Y[0] * invmod(f, self.mod)) % self.mod
for i in range(1, n + 1):
f *= invmod(-d * (n - i + 1), self.mod) * d * i
f %= self.mod
C[i] = (Y[i] * invmod(f, self.mod)) % self.mod
res = 0
f = 1
for i in range(n + 1):
f = f * (t - (a + d * i))
f %= self.mod
for i, c in enumerate(C):
res += c * f * invmod(t - (a + d * i), self.mod)
res %= self.mod
return res
# 拡張Euclidの互除法
def extgcd(a: int, b: int, d: int = 0) -> typing.Tuple[int, int, int]:
g = a
if b == 0:
x, y = 1, 0
else:
x, y, g = extgcd(b, a % b)
x, y = y, x - a // b * y
return x, y, g
# mod p における逆元
def invmod(a: int, p: int) -> int:
x, y, g = extgcd(a, p)
x %= p
return x
# モンモール数（長さ N の完全順列の数）を 1,2,...,N について求める
def montmort_number(n: int, mod: int = 998244353) -> list:
res = [0]
for i in range(2, n + 1): res.append((i * res[-1] + pow(-1, i)) % mod)
return res
# 偏角ソート
def sort_by_argument(points: list) -> list:
def compare(p1: tuple, p2: tuple) -> int:
x1, y1 = p1; x2, y2 = p2
tmp = x1 * y2 - y1 * x2
if tmp < 0: return 1
elif tmp > 0: return -1
else: return 0
quad = [[] for i in range(4)]
for x, y in points:
if x == y == 0: quad[2].append((x, y))
elif x <= 0 and y < 0: quad[0].append((x, y))
elif x > 0 and y <= 0: quad[1].append((x, y))
elif x >= 0 and y > 0: quad[2].append((x, y))
else: quad[3].append((x, y))
res = []
for i in range(4):
quad[i].sort(key=functools.cmp_to_key(compare))
for point in quad[i]: res.append(point)
return res
# SlidingWindowAggretgation
class SlidingWindowAggretgation:
def __init__(self, op: typing.Callable[[typing.Any, typing.Any], typing.Any]) -> None:
self.op = op
self.front_stack = []
self.back_stack = []
def __len__(self) -> int:
return len(self.front_stack) + len(self.back_stack)
def __bool__(self) -> bool:
return len(self) > 0
def __str__(self) -> str:
data = [x for x, _ in self.front_stack][::-1] + [x for x, _ in self.back_stack]
return str(data)
def append(self, x: int) -> None:
fx = x
if self.back_stack:
fx = self.op(self.back_stack[-1][1], x)
self.back_stack.append((x, fx))
def popleft(self) -> None:
if not self.front_stack:
x = fx = self.back_stack.pop()[0]
self.front_stack.append((x, fx))
while self.back_stack:
x = self.back_stack.pop()[0]
fx = self.op(x, fx)
self.front_stack.append((x, fx))
self.front_stack.pop()
def all_prod(self) -> int:
res = None
if self.front_stack:
res = self.front_stack[-1][1]
if self.back_stack:
if res is None:
res = self.back_stack[-1][1]
else:
res = self.op(res, self.back_stack[-1][1])
return res
# トポロジカルソート
def topological_sort(G: list, d: list) -> list:
n = len(G)
s = []
for i in range(n):
if d[i] == 0: s.append(i)
ans = []
while s:
u = s.pop()
ans.append(u)
for v in G[u]:
d[v] -= 1
if d[v] == 0: s.append(v)
if len(ans) != n: return -1
return ans
# maxflow (Ford-Fulkerson)
class FordFulkerson:
def __init__(self, n: int) -> None:
self.n = n
self.G = [[] for _ in range(n)]
self.inf = 10 ** 9
def add_edge(self, fr: int, to: int, cap: int) -> None:
fwd = [to, cap, None]
fwd[2] = bwd = [fr, 0, fwd]
self.G[fr].append(fwd)
self.G[to].append(bwd)
def add_multi_edge(self, v1, v2, cap1, cap2):
edge1 = [v2, cap1, None]
edge1[2] = edge2 = [v1, cap2, edge1]
self.G[v1].append(edge1)
self.G[v2].append(edge2)
def dfs(self, v: int, t: int, f: int) -> int:
if v == t: return f
self.visit[v] = 1
for e in self.G[v]:
w, cap, rev = e
if cap and not self.visit[w]:
d = self.dfs(w, t, min(f, cap))
if d:
e[1] -= d
rev[1] += d
return d
return 0
def max_flow(self, s: int, t: int) -> int:
flow = 0
f = self.inf
while f:
self.visit = [0] * self.n
f = self.dfs(s, t, self.inf)
flow += f
return flow
# maxflow (Dinic)
class Dinic:
def __init__(self, n: int) -> None:
self.n = n
self.G = [[] for _ in range(n)]
self.inf = 10 ** 9
def add_edge(self, fr: int, to: int, cap: int) -> None:
fwd = [to, cap, None]
fwd[2] = bwd = [fr, 0, fwd]
self.G[fr].append(fwd)
self.G[to].append(bwd)
def add_multi_edge(self, v1: int, v2: int, cap1: int, cap2: int) -> None:
edge1 = [v2, cap1, None]
edge1[2] = edge2 = [v1, cap2, edge1]
self.G[v1].append(edge1)
self.G[v2].append(edge2)
def bfs(self, s: int, t: int) -> bool:
self.level = [None] * self.n
Q = collections.deque([s])
self.level[s] = 0
while Q:
u = Q.popleft()
lv = self.level[u] + 1
for v, cap, _ in self.G[u]:
if cap and self.level[v] is None:
self.level[v] = lv
Q.append(v)
return self.level[t] is not None
def dfs(self, v: int, t: int, f: int) -> int:
if v == t: return f
for e in self.it[v]:
w, cap, rev = e
if cap and self.level[v] < self.level[w]:
d = self.dfs(w, t, min(f, cap))
if d:
e[1] -= d
rev[1] += d
return d
return 0
def max_flow(self, s: int, t: int) -> int:
flow = 0
while self.bfs(s, t):
*self.it, = map(iter, self.G)
f = self.inf
while f:
f = self.dfs(s, t, self.inf)
flow += f
return flow
n, m = map(int, input().split())
s = set()
cx, cy = 1, 1
for _ in range(min(2 * 10 ** 5, max(2 * 10 ** 5, n * 100))):
for i in range(3):
for j in range(3):
if cx + i <= n and cy + j <= m: s.add((cx + i, cy + j))
cx = min(cx + 2, n); cy = min(cy + 2, m)
print(len(s))
for a, b in s: print(a, b)
|
ConDefects/ConDefects/Code/arc139_c/Python/31269738
|
condefects-python_data_808
|
n, m = map(int, input().split())
ab = []
nexts = list(range(8))
for a in range(n + 3 * m):
br = (3 * a) % 8
b = nexts[br]
mn = max((a + 2) // 3, 3 * a - 8 * m + 1)
mx = min(3 * a, (a + 8 * n - 1) // 3)
if mn > mx:
continue
if b < mn:
b += (mn - br + 7) // 8 * 8
if b <= mx:
ab.append((a, b))
nexts[br] = b + 8
print(len(ab))
for a, b in ab:
x, y = (-a + 3 * b) // 8, (3 * a - b) // 8
print(x + 1, y + 1)
n, m = map(int, input().split())
ab = []
nexts = list(range(8))
for a in range(n + 3 * m):
br = (3 * a) % 8
b = nexts[br]
mn = max((a + 2) // 3, 3 * a - 8 * m + 1)
mx = min(3 * a, (a + 8 * n - 1) // 3)
if mn > mx:
continue
if b < mn:
b += (mn - b + 7) // 8 * 8
if b <= mx:
ab.append((a, b))
nexts[br] = b + 8
print(len(ab))
for a, b in ab:
x, y = (-a + 3 * b) // 8, (3 * a - b) // 8
print(x + 1, y + 1)
|
ConDefects/ConDefects/Code/arc139_c/Python/31249723
|
condefects-python_data_809
|
n,m=map(int,input().split())
hi=False
if n<m:
hi=True
n,m=m,n
l1=[2,4,-2,0,2,-4,-2,0]
canr=(m-1)//2
ll=[[4,4]]
nows=4
for i in range(canr):
for j in l1:
nows+=1
ll.append([nows,nows+j])
if m%2==1:
nowt=nows
for i in range(n-m):
nows+=1
nowt+=3
ll.append([nows,nowt])
else:
nowt=nows
if m==n:
ll.append([nows+1,nowt+3])
ll.append([nows+3,nowt+1])
ll.append([nows+4,nowt+4])
else:
ll.append([nows+1,nowt+3])
ll.append([nows+2,nowt+6])
nows+=2
nowt-=2
for i in range(n-m+1):
nows+=1
nowt+=3
ll.append([nows,nowt])
print(len(ll))
if hi==False:
for l in ll:
s=l[0]
t=l[1]
x=(3*t-s)//8
y=(3*s-t)//8
print(x,y)
else:
for l in ll:
s=l[0]
t=l[1]
y=(3*t-s)//8
x=(3*s-t)//8
print(x,y)
n,m=map(int,input().split())
hi=False
if n<m:
hi=True
n,m=m,n
l1=[2,4,-2,0,2,-4,-2,0]
canr=(m-1)//2
ll=[[4,4]]
nows=4
for i in range(canr):
for j in l1:
nows+=1
ll.append([nows,nows+j])
if m%2==1:
nowt=nows
for i in range(n-m):
nows+=1
nowt+=3
ll.append([nows,nowt])
else:
nowt=nows
if m==n:
ll.append([nows+1,nowt+3])
ll.append([nows+3,nowt+1])
ll.append([nows+4,nowt+4])
else:
ll.append([nows+1,nowt+3])
ll.append([nows+2,nowt+6])
nows+=2
nowt-=2
for i in range(n-m+2):
nows+=1
nowt+=3
ll.append([nows,nowt])
print(len(ll))
if hi==False:
for l in ll:
s=l[0]
t=l[1]
x=(3*t-s)//8
y=(3*s-t)//8
print(x,y)
else:
for l in ll:
s=l[0]
t=l[1]
y=(3*t-s)//8
x=(3*s-t)//8
print(x,y)
|
ConDefects/ConDefects/Code/arc139_c/Python/31246555
|
condefects-python_data_810
|
N, M = map(int, input().split())
if N > M:
r = N
N = M
M = r
swap = 1
else:
swap = 0
ans = [(1, 1)]
for i in range(1, N - 1, 2):
for j in range(3):
for k in range(3):
if j + k == 0:
continue
ans.append((i + j, i + k))
if N & 1:
for i in range(N + 1, M + 1):
ans.append((N, i))
else:
ans.append((N - 1, N))
if N + 1 <= M:
ans.append((N - 1, N + 1))
for i in range(N - 1, M + 1):
ans.append((N, i))
print(len(ans))
for u, v in ans:
if swap:
print(u, v)
else:
print(u, v)
X3_Y = set()
X_Y3 = set()
for u, v in ans:
assert 1 <= u <= N and 1 <= v <= M
X3_Y.add(u * 3 + v)
X_Y3.add(u + v * 3)
assert len(X3_Y) == len(ans) and len(X_Y3) == len(ans), f'{X_Y3}, {X_Y3}'
if (N & 1) or M > N:
assert len(ans) == N * 3 + M - 3
else:
assert len(ans) >= N * 3 + M - 3 - 1
# if N > 4:
# assert len(ans) >= N * 3 + M - 3
N, M = map(int, input().split())
if N > M:
r = N
N = M
M = r
swap = 1
else:
swap = 0
ans = [(1, 1)]
for i in range(1, N - 1, 2):
for j in range(3):
for k in range(3):
if j + k == 0:
continue
ans.append((i + j, i + k))
if N & 1:
for i in range(N + 1, M + 1):
ans.append((N, i))
else:
ans.append((N - 1, N))
if N + 1 <= M:
ans.append((N - 1, N + 1))
for i in range(N - 1, M + 1):
ans.append((N, i))
print(len(ans))
for u, v in ans:
if swap:
print(v, u)
else:
print(u, v)
X3_Y = set()
X_Y3 = set()
for u, v in ans:
assert 1 <= u <= N and 1 <= v <= M
X3_Y.add(u * 3 + v)
X_Y3.add(u + v * 3)
assert len(X3_Y) == len(ans) and len(X_Y3) == len(ans), f'{X_Y3}, {X_Y3}'
if (N & 1) or M > N:
assert len(ans) == N * 3 + M - 3
else:
assert len(ans) >= N * 3 + M - 3 - 1
# if N > 4:
# assert len(ans) >= N * 3 + M - 3
|
ConDefects/ConDefects/Code/arc139_c/Python/31456138
|
condefects-python_data_811
|
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
from atcoder.dsu import DSU
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n = LI()
A = LLMI()
uf = DSU(n)
for i, a in enumerate(A):
uf.merge(i, a)
groups = uf.groups()
print(n - len(groups))
for g in groups:
u = g[0]
for _ in range(len(g) - 1):
print(u + 1, A[u] + 1)
A[u], A[A[u]] = A[A[u]], A[u]
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
from atcoder.dsu import DSU
readline = sys.stdin.readline
LS = lambda: readline().strip()
LI = lambda: int(readline().strip())
LLS = lambda: readline().strip().split()
LL = lambda: list(map(int, readline().strip().split()))
LLMI = lambda: list(map((1).__rsub__, LL()))
n = LI()
A = LLMI()
uf = DSU(n)
for i, a in enumerate(A):
uf.merge(i, a)
groups = uf.groups()
print(n - len(groups))
for g in groups:
u = g[0]
for _ in range(len(g) - 1):
print(u + 1, A[u] + 1)
A[A[u]], A[u] = A[u], A[A[u]]
|
ConDefects/ConDefects/Code/abc350_c/Python/54963583
|
condefects-python_data_812
|
N = int(input())
A = list(map(int, input().split()))
ans = []
num = 0
i = 0
while i < N:
if A[i] == i + 1:
i += 1
continue
else:
j = A[i] - 1
num += 1
ans.append([A[j], A[i]])
A[i], A[j] = A[j], A[i]
print(num)
for i in range(num):
print(' '.join(map(str, ans[i])))
N = int(input())
A = list(map(int, input().split()))
ans = []
num = 0
i = 0
while i < N:
if A[i] == i + 1:
i += 1
continue
else:
j = A[i] - 1
num += 1
ans.append([i + 1, j + 1])
A[i], A[j] = A[j], A[i]
print(num)
for i in range(num):
print(' '.join(map(str, ans[i])))
|
ConDefects/ConDefects/Code/abc350_c/Python/54896149
|
condefects-python_data_813
|
n = int(input())
a = list(map(int,input().split()))
for i in range(n):
a[i] -= 1
ans = []
for i in range(n):
while a[i] != i:
now = a[i]
ans.append([now+1,a[now]+1])
a[i], a[now] = a[now], a[i]
print(len(ans))
for x in ans:
print(*sorted(x))
n = int(input())
a = list(map(int,input().split()))
for i in range(n):
a[i] -= 1
ans = []
for i in range(n):
while a[i] != i:
now = a[i]
ans.append([i+1,a[i]+1])
a[i], a[now] = a[now], a[i]
print(len(ans))
for x in ans:
print(*sorted(x))
|
ConDefects/ConDefects/Code/abc350_c/Python/55151814
|
condefects-python_data_814
|
import sys
input = sys.stdin.readline
H,W=map(int,input().split())
MAP=[input().strip() for i in range(H)]
mod=998244353
E=[[] for i in range(H*W)]
for i in range(H):
for j in range(W):
if i+1<H and MAP[i][j]=="#" and MAP[i+1][j]=="#":
E[i*W+j].append((i+1)*W+j)
E[(i+1)*W+j].append(i*W+j)
if j+1<W and MAP[i][j]=="#" and MAP[i][j+1]=="#":
E[i*W+j].append(i*W+j+1)
E[i*W+j+1].append(i*W+j)
SUM=0
ANS=0
LANS=0
V=H*W
USED=[0]*(H*W)
USE = [0]*V
DFS_ORD = [0]*V # DFSした順に番号をつける。DFS_ORD[i]=xで、頂点iの次数はx
DFS_Parent = [-1]*V # DFS木の親
LOWLINK = [0]*V # LOWLINK。後退辺を一回まで使ってたどりつける次数（DFSで何番目にたどりついたか）の最小値。
DFS_Child=[[] for i in range(V)]
for i in range(H*W):
if USE[i]==0 and MAP[i//W][i%W]=="#":
ANS+=1
ROOT = i # ROOTを定める。
Q = [(ROOT, ROOT)]
ordnum = 1
LIST=[]
DFS_SORT = [] # DFSで見た頂点の順番。
while Q:
fr, x = Q.pop()
if USE[x] == 1:
continue
LIST.append(x)
SUM+=1
DFS_SORT.append(x)
if fr != x:
DFS_Parent[x] = fr
DFS_Child[fr].append(x)
DFS_ORD[x] = ordnum
ordnum += 1
LOWLINK[x] = DFS_ORD[x] # LOWLINKをDFS_ORDで初期化。
USE[x] = 1
for to in E[x]:
if USE[to] == 0:
Q.append((x, to))
for i in DFS_SORT[::-1]: # DFS_ORDの大きい頂点から順番に見て、LOWLINKを更新していく。
for to in E[i]:
if to != DFS_Parent[i]:
LOWLINK[i] = min(LOWLINK[i], DFS_ORD[to], LOWLINK[to])
Articulation = []
ROOT_DEG = 0
for i in LIST: # DFS木の各辺を調べる。
if i == ROOT:
continue
if DFS_Parent[i] == ROOT:
ROOT_DEG += 1
# DFS木の頂点u（ROOTでない）が関節点になるのは、子から自分の祖先への後退辺がないとき
if DFS_ORD[DFS_Parent[i]] <= LOWLINK[i] and DFS_Parent[i] != ROOT:
Articulation.append(DFS_Parent[i])
for x in Articulation+[ROOT]:
if x==ROOT:
now=-1
for c in DFS_Child[x]:
if DFS_ORD[x]<=LOWLINK[c]:
now+=1
else:
now=0
for c in DFS_Child[x]:
if DFS_ORD[x]<=LOWLINK[c]:
now+=1
LANS+=now
print((LANS+ANS*SUM)*pow(SUM,mod-2,mod)%mod)
import sys
input = sys.stdin.readline
H,W=map(int,input().split())
MAP=[input().strip() for i in range(H)]
mod=998244353
E=[[] for i in range(H*W)]
for i in range(H):
for j in range(W):
if i+1<H and MAP[i][j]=="#" and MAP[i+1][j]=="#":
E[i*W+j].append((i+1)*W+j)
E[(i+1)*W+j].append(i*W+j)
if j+1<W and MAP[i][j]=="#" and MAP[i][j+1]=="#":
E[i*W+j].append(i*W+j+1)
E[i*W+j+1].append(i*W+j)
SUM=0
ANS=0
LANS=0
V=H*W
USED=[0]*(H*W)
USE = [0]*V
DFS_ORD = [0]*V # DFSした順に番号をつける。DFS_ORD[i]=xで、頂点iの次数はx
DFS_Parent = [-1]*V # DFS木の親
LOWLINK = [0]*V # LOWLINK。後退辺を一回まで使ってたどりつける次数（DFSで何番目にたどりついたか）の最小値。
DFS_Child=[[] for i in range(V)]
for i in range(H*W):
if USE[i]==0 and MAP[i//W][i%W]=="#":
ANS+=1
ROOT = i # ROOTを定める。
Q = [(ROOT, ROOT)]
ordnum = 1
LIST=[]
DFS_SORT = [] # DFSで見た頂点の順番。
while Q:
fr, x = Q.pop()
if USE[x] == 1:
continue
LIST.append(x)
SUM+=1
DFS_SORT.append(x)
if fr != x:
DFS_Parent[x] = fr
DFS_Child[fr].append(x)
DFS_ORD[x] = ordnum
ordnum += 1
LOWLINK[x] = DFS_ORD[x] # LOWLINKをDFS_ORDで初期化。
USE[x] = 1
for to in E[x]:
if USE[to] == 0:
Q.append((x, to))
for i in DFS_SORT[::-1]: # DFS_ORDの大きい頂点から順番に見て、LOWLINKを更新していく。
for to in E[i]:
if to != DFS_Parent[i]:
LOWLINK[i] = min(LOWLINK[i], DFS_ORD[to], LOWLINK[to])
Articulation = []
ROOT_DEG = 0
for i in LIST: # DFS木の各辺を調べる。
if i == ROOT:
continue
if DFS_Parent[i] == ROOT:
ROOT_DEG += 1
# DFS木の頂点u（ROOTでない）が関節点になるのは、子から自分の祖先への後退辺がないとき
if DFS_ORD[DFS_Parent[i]] <= LOWLINK[i] and DFS_Parent[i] != ROOT:
Articulation.append(DFS_Parent[i])
for x in LIST:
if x==ROOT:
now=-1
for c in DFS_Child[x]:
if DFS_ORD[x]<=LOWLINK[c]:
now+=1
else:
now=0
for c in DFS_Child[x]:
if DFS_ORD[x]<=LOWLINK[c]:
now+=1
LANS+=now
print((LANS+ANS*SUM)*pow(SUM,mod-2,mod)%mod)
|
ConDefects/ConDefects/Code/abc334_g/Python/50711635
|
condefects-python_data_815
|
N = int(input())
l=0; r=N
while r-l>1:
m = (l+r)//2
print('?', m)
a = input()
if a=='0': l = m
else : r = m
print(l)
N = int(input())
l=0; r=N
while r-l>1:
m = (l+r)//2
print('?', m)
a = input()
if a=='0': l = m
else : r = m
print('!', l)
|
ConDefects/ConDefects/Code/abc299_d/Python/45261350
|
condefects-python_data_816
|
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()
left, right = 1, n
for i in range(20):
p = (left + right) // 2
print('?', p)
s = input()
if s == 0:
left = p
else:
right = p
print('!', left)
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()
left, right = 1, n
for i in range(20):
p = (left + right) // 2
print('?', p)
s = input()
if s == '0':
left = p
else:
right = p
print('!', left)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc299_d/Python/46179112
|
condefects-python_data_817
|
n = int(input())
high = n
low = -1
while low + 1 < high:
mid = (low + high) // 2
print(f'? {mid}')
s = input()
if s == "0":
low = mid
else:
high = mid
print(f"! {low + 1}")
n = int(input())
high = n
low = -1
while low + 1 < high:
mid = (low + high) // 2
print(f'? {mid + 1}')
s = input()
if s == "0":
low = mid
else:
high = mid
print(f"! {low + 1}")
|
ConDefects/ConDefects/Code/abc299_d/Python/45452741
|
condefects-python_data_818
|
n = int(input())
max = n
min = 0
past = -1
cnt = 0
ans = -1
while cnt <= 20 and max-min > 1:
mid = (max+min)//2
print("? " + str(mid) + '\n')
s = int(input())
if s == 1:
max = mid
else:
min = mid
cnt += 1
print("! " + str(min))
exit()
n = int(input())
max = n
min = 0
past = -1
cnt = 0
ans = -1
while cnt <= 20 and max-min > 1:
mid = (max+min)//2
print("? " + str(mid),flush=True)
s = int(input())
if s == 1:
max = mid
else:
min = mid
cnt += 1
print("! " + str(min))
exit()
|
ConDefects/ConDefects/Code/abc299_d/Python/45471725
|
condefects-python_data_819
|
def main():
N = int(input())
l = [0,0]
r = [N-1,1]
for i in range(20):
m = (r[0]+l[0])//2
print(f"? {m+1}")
N = int(input())
if N == l[1]:
l[0] = m
elif N == r[1]:
r[0] = m
if abs(r[0]-l[0]) <= 1:
break
print(l[0]+1)
if __name__ == "__main__":
main()
def main():
N = int(input())
l = [0,0]
r = [N-1,1]
for i in range(20):
m = (r[0]+l[0])//2
print(f"? {m+1}")
N = int(input())
if N == l[1]:
l[0] = m
elif N == r[1]:
r[0] = m
if abs(r[0]-l[0]) <= 1:
break
print(f"! {l[0]+1}")
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc299_d/Python/45280139
|
condefects-python_data_820
|
N,M,K = map(int,input().split())
UVA = [list(map(int,input().split())) for _ in range(M)]
S = set(map(int,input().split()))
E = [[] for _ in range(N+1)]
INF = 10 ** 6
for i,(u,v,a) in enumerate(UVA,start = 1):
E[u].append((v,a,i))
E[v].append((u,a,i))
C = [[INF,INF] for _ in range(N+1)]
C[1][1] = 0
q = [(1,1)]
cnt = 0
while q:
cnt += 1
q2 = []
while q:
u,a = q.pop(-1)
for v,b,i in E[u]:
if a == b:
if C[v][a] == INF:
C[v][a] = cnt
q2.append((v,a))
else:
if u in S:
if C[v][b] == INF:
C[v][b] = cnt
q2.append((v, b))
q,q2 = q2,q
if min(C[N]) == N:
print(-1)
else:
print(min(C[N]))
N,M,K = map(int,input().split())
UVA = [list(map(int,input().split())) for _ in range(M)]
S = set(map(int,input().split()))
E = [[] for _ in range(N+1)]
INF = 10 ** 6
for i,(u,v,a) in enumerate(UVA,start = 1):
E[u].append((v,a,i))
E[v].append((u,a,i))
C = [[INF,INF] for _ in range(N+1)]
C[1][1] = 0
q = [(1,1)]
cnt = 0
while q:
cnt += 1
q2 = []
while q:
u,a = q.pop(-1)
for v,b,i in E[u]:
if a == b:
if C[v][a] == INF:
C[v][a] = cnt
q2.append((v,a))
else:
if u in S:
if C[v][b] == INF:
C[v][b] = cnt
q2.append((v, b))
q,q2 = q2,q
if min(C[N]) == INF:
print(-1)
else:
print(min(C[N]))
|
ConDefects/ConDefects/Code/abc277_e/Python/46166743
|
condefects-python_data_821
|
from collections import deque
n, m, k = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(m):
u, v, a = map(int, input().split())
u -= 1
v -= 1
g[u].append((v, a))
g[v].append((u, a))
sw = set(map(lambda x: int(x) - 1, input().split()))
INF = float("INF")
dist = [[INF, INF] for _ in range(n)]
dist[0][0] = 0
q = deque([(0, 0)])
while q:
v, s = q.popleft()
if v in sw:
dist[v][1 - s] = dist[v][s]
sw.discard(v)
q.append((v, 1 - s))
for to, a in g[v]:
if a == s:
continue
if dist[to][s] > dist[v][s] + 1:
dist[to][s] = dist[v][s] + 1
q.append((to, s))
ans = min(dist[n - 1])
print(ans if ans != INF else -1)
from collections import deque
n, m, k = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(m):
u, v, a = map(int, input().split())
u -= 1
v -= 1
g[u].append((v, a))
g[v].append((u, a))
sw = set(map(lambda x: int(x) - 1, input().split()))
INF = float("INF")
dist = [[INF, INF] for _ in range(n)]
dist[0][0] = 0
q = deque([(0, 0)])
while q:
v, s = q.popleft()
if v in sw:
dist[v][1 - s] = dist[v][s]
sw.discard(v)
q.appendleft((v, 1 - s))
for to, a in g[v]:
if a == s:
continue
if dist[to][s] > dist[v][s] + 1:
dist[to][s] = dist[v][s] + 1
q.append((to, s))
ans = min(dist[n - 1])
print(ans if ans != INF else -1)
|
ConDefects/ConDefects/Code/abc277_e/Python/45112675
|
condefects-python_data_822
|
S = input()
K = int(input())
N = len(S)
X = [0]*N
if N==1:
if (S[0]=='.' and K==1) or (S[0]=='X' and K==0):
print(1)
exit()
if K==0:
ans = 0
for i in range(N):
if S[i]=='X':
if i!=N-1:
for j in range(i+1,N):
if S[j]!='X':
break
ans = max(ans,j-i+1)
else:
ans = max(ans,1)
print(ans)
exit()
for i in range(N):
if S[i]=='.':
X[i]+=1
for i in range(1,N):
X[i] = X[i] + X[i-1]
X = [0] + X
#print(X)
ans = 0
for i in range(1,N):
ok,ng =i,N+1
while abs(ok-ng)>1:
ic = (ok+ng)//2
#print(ok,ic,ng)
if X[ic]-X[i-1]<=K:
ok = ic
else:
ng = ic
#print(ok,ok-i+1)
ans = max(ans,ok-i+1)
print(ans)
S = input()
K = int(input())
N = len(S)
X = [0]*N
if N==1:
if (S[0]=='.' and K==1) or (S[0]=='X' and K==0):
print(1)
exit()
if K==0:
ans = 0
for i in range(N):
if S[i]=='X':
if i!=N-1:
for j in range(i+1,N):
if S[j]!='X':
break
ans = max(ans,j-i)
else:
ans = max(ans,1)
print(ans)
exit()
for i in range(N):
if S[i]=='.':
X[i]+=1
for i in range(1,N):
X[i] = X[i] + X[i-1]
X = [0] + X
#print(X)
ans = 0
for i in range(1,N):
ok,ng =i,N+1
while abs(ok-ng)>1:
ic = (ok+ng)//2
#print(ok,ic,ng)
if X[ic]-X[i-1]<=K:
ok = ic
else:
ng = ic
#print(ok,ok-i+1)
ans = max(ans,ok-i+1)
print(ans)
|
ConDefects/ConDefects/Code/abc229_d/Python/45424479
|
condefects-python_data_823
|
s=input()
k=int(input())
s=s.split(".")
l=[0]
ans=0
for i in s:
l.append(l[-1]+len(i))
if len(s)-1>k:
for i in range(len(s)-k-1):
ans=max(ans,l[i+k+1]-l[i]+k)
else:
ans=l[-1]+len(s)-1
print(ans)
s=input()
k=int(input())
s=s.split(".")
l=[0]
ans=0
for i in s:
l.append(l[-1]+len(i))
if len(s)-1>k:
for i in range(len(s)-k):
ans=max(ans,l[i+k+1]-l[i]+k)
else:
ans=l[-1]+len(s)-1
print(ans)
|
ConDefects/ConDefects/Code/abc229_d/Python/44842027
|
condefects-python_data_824
|
from collections import deque
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
dist = [-1 for i in range(N)]
que = deque()
for i in range(N):
if G[i] == 1:
dist[i] = 0
que.append(i)
break
while que:
v = que.popleft()
for v2 in G[v]:
if dist[v2] != -1:
continue
dist[v2] = dist[v] + 1
que.append(v2)
center = [i for i in range(N) if dist[i]%3==1]
ans = [len(G[i]) for i in center]
ans.sort()
print(*ans)
from collections import deque
N = int(input())
G = [[] for _ in range(N)]
for _ in range(N-1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a].append(b)
G[b].append(a)
dist = [-1 for i in range(N)]
que = deque()
for i in range(N):
if len(G[i]) == 1:
dist[i] = 0
que.append(i)
break
while que:
v = que.popleft()
for v2 in G[v]:
if dist[v2] != -1:
continue
dist[v2] = dist[v] + 1
que.append(v2)
center = [i for i in range(N) if dist[i]%3==1]
ans = [len(G[i]) for i in center]
ans.sort()
print(*ans)
|
ConDefects/ConDefects/Code/abc303_e/Python/53920661
|
condefects-python_data_825
|
T=int(input())
for t in range(T):
B,K,Sx,Sy,Gx,Gy=map(int,input().split())
ans=(abs(Sx-Gx)+abs(Sy-Gy))*K
for a,b in ((Sx,Sy//B*B),(Sx,(Sy+B-1)//B*B),(Sx//B*B,Sy),((Sx+B-1)//B*B,Sy)):
for c,d in ((Gx,Gy//B*B),(Gx,(Gy+B-1)//B*B),(Gx//B*B,Gy),((Gx+B-1)//B*B,Gy)):
if a==c or b==d:
ans=min(ans,(abs(Sx-a)+abs(Sy-b)+abs(Gx-c)+abs(Gy-d))*K+abs(a-c)+abs(b-d))
for a in (Sx//B*B,(Sx+B-1)//B*B):
for b in (Sy//B*B,(Sy+B-1)//B*B):
for c in (Gx//B*B,(Gx+B-1)//B*B):
for d in (Gy//B*B,(Gy+B-1)//B*B):
ans=min(ans,min(abs(Sx-a),abs(Sy-b))*K+max(abs(Sx-a),abs(Sy-b))+min(abs(Gx-c),abs(Gy-d))*K+max(abs(Gx-c),abs(Gy-d))+abs(a-c)+abs(b-d))
print(ans)
T=int(input())
for t in range(T):
B,K,Sx,Sy,Gx,Gy=map(int,input().split())
ans=(abs(Sx-Gx)+abs(Sy-Gy))*K
for a,b in ((Sx,Sy//B*B),(Sx,(Sy+B-1)//B*B),(Sx//B*B,Sy),((Sx+B-1)//B*B,Sy)):
for c,d in ((Gx,Gy//B*B),(Gx,(Gy+B-1)//B*B),(Gx//B*B,Gy),((Gx+B-1)//B*B,Gy)):
if a==c and a%B==0 or b==d and b%B==0:
ans=min(ans,(abs(Sx-a)+abs(Sy-b)+abs(Gx-c)+abs(Gy-d))*K+abs(a-c)+abs(b-d))
for a in (Sx//B*B,(Sx+B-1)//B*B):
for b in (Sy//B*B,(Sy+B-1)//B*B):
for c in (Gx//B*B,(Gx+B-1)//B*B):
for d in (Gy//B*B,(Gy+B-1)//B*B):
ans=min(ans,min(abs(Sx-a),abs(Sy-b))*K+max(abs(Sx-a),abs(Sy-b))+min(abs(Gx-c),abs(Gy-d))*K+max(abs(Gx-c),abs(Gy-d))+abs(a-c)+abs(b-d))
print(ans)
|
ConDefects/ConDefects/Code/abc258_f/Python/53486241
|
condefects-python_data_826
|
import sys
input = sys.stdin.readline
def dist(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
def push(x, y, B, K):
if x % B == 0 or y % B == 0:
return [(x, y, 0)]
dx, ux = x//B*B, (x+B-1)//B*B
L = []
L.append((dx, y, K * abs(x - dx)))
L.append((ux, y, K * abs(x - ux)))
dy, uy = y//B*B, (y+B-1)//B*B
L.append((x, dy, K * abs(y - dy)))
L.append((x, uy, K * abs(y - uy)))
return L
def push2(x, y, B):
L = []
if y % B != 0:
dy, uy = y//B*B, (y+B-1)//B*B
L.append((x, dy, abs(y - dy)))
L.append((x, uy, abs(y - uy)))
else:
dx, ux = x//B*B, (x+B-1)//B*B
L.append((dx, y, abs(x - dx)))
L.append((ux, y, abs(x - ux)))
return L
T = int(input())
for _ in range(T):
B, K, sx, sy, gx, gy = map(int, input().split())
start = push(sx, sy, B, K)
goal = push(gx, gy, B, K)
ans = dist(sx, sy, gx, gy) * K
for sx, sy, sc in start:
for gx, gy, gc in goal:
if sx == gx or sy == gy:
ans = min(ans, sc + gc + dist(sx, sy, gx, gy))
continue
start2 = push2(sx, sy, B)
goal2 = push2(gx, gy, B)
for sx2, sy2, sc2 in start2:
for gx2, gy2, gc2 in goal2:
ans = min(ans, sc + gc + sc2 + gc2 + dist(sx2, sy2, gx2, gy2))
print(ans)
import sys
input = sys.stdin.readline
def dist(x1, y1, x2, y2):
return abs(x1 - x2) + abs(y1 - y2)
def push(x, y, B, K):
if x % B == 0 or y % B == 0:
return [(x, y, 0)]
dx, ux = x//B*B, (x+B-1)//B*B
L = []
L.append((dx, y, K * abs(x - dx)))
L.append((ux, y, K * abs(x - ux)))
dy, uy = y//B*B, (y+B-1)//B*B
L.append((x, dy, K * abs(y - dy)))
L.append((x, uy, K * abs(y - uy)))
return L
def push2(x, y, B):
L = []
if y % B != 0:
dy, uy = y//B*B, (y+B-1)//B*B
L.append((x, dy, abs(y - dy)))
L.append((x, uy, abs(y - uy)))
else:
dx, ux = x//B*B, (x+B-1)//B*B
L.append((dx, y, abs(x - dx)))
L.append((ux, y, abs(x - ux)))
return L
T = int(input())
for _ in range(T):
B, K, sx, sy, gx, gy = map(int, input().split())
start = push(sx, sy, B, K)
goal = push(gx, gy, B, K)
ans = dist(sx, sy, gx, gy) * K
for sx, sy, sc in start:
for gx, gy, gc in goal:
if (sx == gx and sx % B == 0) or (sy == gy and sy % B == 0):
ans = min(ans, sc + gc + dist(sx, sy, gx, gy))
continue
start2 = push2(sx, sy, B)
goal2 = push2(gx, gy, B)
for sx2, sy2, sc2 in start2:
for gx2, gy2, gc2 in goal2:
ans = min(ans, sc + gc + sc2 + gc2 + dist(sx2, sy2, gx2, gy2))
print(ans)
|
ConDefects/ConDefects/Code/abc258_f/Python/54437029
|
condefects-python_data_827
|
# 大通りだけを通って (sx, sy) -> (gx, gy) にいく最短距離
def path(sx, sy, gx, gy, b):
if sx == gx or sy == gy:
return abs(sx - gx) + abs(sy - gy)
if (sx - sy) % b and (gx - gy) % b:
if sy % b:
sx, sy = sy, sx
gx, gy = gy, gx
rem = sx % b
return min(
path(sx - rem, sy, gx, gy, b) + rem,
path(sx + b - rem, sy, gx, gy, b) + b - rem,
)
return abs(sx - gx) + abs(sy - gy)
t = int(input())
for _ in range(t):
b, k, sx, sy, gx, gy = map(int, input().split())
ans = k * (abs(sx - gx) + abs(sy - gy))
rx = sx % b
ry = sy % b
ars = [
[sx - rx, sy, rx * k],
[sx + b - rx, sy, (b - rx) * k],
[sx, sy - ry, ry * k],
[sx, sy + b - ry, (b - ry) * k],
]
rx = gx % b
ry = gy % b
arg = [
[gx - rx, gy, rx * k],
[gx + b - rx, gy, (b - rx) * k],
[gx, gy - ry, ry * k],
[gx, gy + b - ry, (b - ry) * k],
]
for sx, sy, s1 in ars:
for gx, gy, s2 in arg:
ans = min(ans, path(sx, sy, gx, gy, b) + s1 + s2)
print(ans)
# 大通りだけを通って (sx, sy) -> (gx, gy) にいく最短距離
def path(sx, sy, gx, gy, b):
if (not sx % b and sx == gx) or (not sy % b and sy == gy):
return abs(sx - gx) + abs(sy - gy)
if (sx - sy) % b and (gx - gy) % b:
if sy % b:
sx, sy = sy, sx
gx, gy = gy, gx
rem = sx % b
return min(
path(sx - rem, sy, gx, gy, b) + rem,
path(sx + b - rem, sy, gx, gy, b) + b - rem,
)
return abs(sx - gx) + abs(sy - gy)
t = int(input())
for _ in range(t):
b, k, sx, sy, gx, gy = map(int, input().split())
ans = k * (abs(sx - gx) + abs(sy - gy))
rx = sx % b
ry = sy % b
ars = [
[sx - rx, sy, rx * k],
[sx + b - rx, sy, (b - rx) * k],
[sx, sy - ry, ry * k],
[sx, sy + b - ry, (b - ry) * k],
]
rx = gx % b
ry = gy % b
arg = [
[gx - rx, gy, rx * k],
[gx + b - rx, gy, (b - rx) * k],
[gx, gy - ry, ry * k],
[gx, gy + b - ry, (b - ry) * k],
]
for sx, sy, s1 in ars:
for gx, gy, s2 in arg:
ans = min(ans, path(sx, sy, gx, gy, b) + s1 + s2)
print(ans)
|
ConDefects/ConDefects/Code/abc258_f/Python/46362422
|
condefects-python_data_828
|
from math import gcd
N, K = map(int, input().split())
if N % 2 == 0:
exit(print(-1))
g = gcd(N, K)
a = N // g
x = K // g
ans = []
if g == 1:
for i in range((a - 1) // 2):
ans.append((2 * i, 2 * i + 1))
else:
for i in range((a - 1) // 2):
base = 2 * g * i
for j in range(g // 2):
ans.append((base + 2 * j, base + 2 * j + 1))
ans.append((base + 2 * j, base + 2 * j + g))
ans.append((base + g - 1, base + 2 * g - 1))
for j in range(g // 2):
ans.append(((a - 1) * g + 1 + 2 * j, (a - 1) * g + 1 + 2 * j + 1))
print(len(ans))
for u, v in ans:
print((u * x) % N, (v * x) % N)
from math import gcd
N, K = map(int, input().split())
if N % 2 == 0:
exit(print(-1))
g = gcd(N, K)
a = N // g
x = K // g
ans = []
if g == 1:
for i in range((a - 1) // 2):
ans.append((2 * i, 2 * i + 1))
else:
for i in range((a - 1) // 2):
base = 2 * g * i
for j in range(g // 2):
ans.append((base + 2 * j, base + 2 * j + 1))
ans.append((base + 2 * j, base + 2 * j + g))
ans.append((base + g - 1, base + 2 * g - 1))
for j in range(g // 2):
ans.append(((a - 1) * g + 1 + 2 * j, (a - 1) * g + 1 + 2 * j + 1))
print(len(ans))
for u, v in ans:
print((u % g + (u // g) * K) % N, (v % g + (v // g) * K) % N)
|
ConDefects/ConDefects/Code/arc152_d/Python/36680742
|
condefects-python_data_829
|
import sys
input = sys.stdin.readline
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
#sys.setrecursionlimit(10000000)
from collections import defaultdict,deque
import bisect
inf=10**20
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
#bisect.bisect_left(A,x):Aの内x未満のものの個数
def bisectlow(A,x,low=0):
#Aのうちx以下で最大の数字を返す
if A[0]>x:
return low
else:
return A[bisect.bisect_right(A,x)-1]
def bisecthigh(A,x,high=inf):
#Aのうちx以上で最小の数字を返す
if A[-1]<x:
return high
else:
return A[bisect.bisect_left(A,x)]
#入力
def II():
return int(input().strip("\n"))
def MI():
return map(int,input().strip("\n").split())
def LI():
return list(map(int,input().strip("\n").split()))
def SI():
return input().strip("\n")
N,K=MI()
if N%2==0:
print(-1)
exit()
M=N//2
import math
if math.gcd(N,K)==1:
print(M)
for i in range(M):
print((2*i*K)%N,((2*i+1)*K)%N)
else:
print(M)
g=math.gcd(N,K)
n=N//g
k=K//g
S=set()
for i in range(0,n-1,2):
print((i*g*k)%N,((i+1)*g*k)%N)
for j in range(1,g):
print((i*g*k)%N,(i*g*k + j*k)%N)
x=(N-K)
for i in range(x+1,x+g-1,2):
print((i+1-K)%N,i)
import sys
input = sys.stdin.readline
import pypyjit
pypyjit.set_param('max_unroll_recursion=-1')
#sys.setrecursionlimit(10000000)
from collections import defaultdict,deque
import bisect
inf=10**20
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
#bisect.bisect_left(A,x):Aの内x未満のものの個数
def bisectlow(A,x,low=0):
#Aのうちx以下で最大の数字を返す
if A[0]>x:
return low
else:
return A[bisect.bisect_right(A,x)-1]
def bisecthigh(A,x,high=inf):
#Aのうちx以上で最小の数字を返す
if A[-1]<x:
return high
else:
return A[bisect.bisect_left(A,x)]
#入力
def II():
return int(input().strip("\n"))
def MI():
return map(int,input().strip("\n").split())
def LI():
return list(map(int,input().strip("\n").split()))
def SI():
return input().strip("\n")
N,K=MI()
if N%2==0:
print(-1)
exit()
M=N//2
import math
if math.gcd(N,K)==1:
print(M)
for i in range(M):
print((2*i*K)%N,((2*i+1)*K)%N)
else:
print(M)
g=math.gcd(N,K)
n=N//g
k=K//g
S=set()
for i in range(0,n-1,2):
print((i*g*k)%N,((i+1)*g*k)%N)
for j in range(1,g):
print((i*g*k)%N,(i*g*k + j)%N)
x=(N-K)
for i in range(x+1,x+g-1,2):
print((i+1-K)%N,i)
|
ConDefects/ConDefects/Code/arc152_d/Python/36684114
|
condefects-python_data_830
|
H,W = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(H)]
maze = [[1]*4 for _ in range(H)]
for i in range(H):
for j in range(W):
F = True
if j >= 1:
if A[i][j] == A[i][j-1]:
F = False
if j <= W-2:
if A[i][j] == A[i][j+1]:
F = False
if F:
if i == 0:
x = A[i][j]^A[i+1][j]
if x == 1:
maze[i][0],maze[i][2] = 0,0
else:
maze[i][1],maze[i][3] = 0,0
elif i == H-1:
x = A[i][j]^A[i-1][j]
if x == 1:
maze[i][0],maze[i][1] = 0,0
else:
maze[i][2],maze[i][3] = 0,0
else:
x,y = A[i][j]^A[i-1][j],A[i][j]^A[i+1][j]
maze[i][3^((x<<1)+y)] = 0
inf = 10**12
dp = [[inf]*4 for _ in range(H+1)]
dp[0][1],dp[0][3] = 1,1
dp[0][0],dp[0][2] = 0,0
for i in range(1,H+1):
for j in range(4):
for k in range(4):
if (k&1)^(j&2) == 1:
continue
if maze[i-1][j^k]:
if i == H:
dp[i][j] = min(dp[i][j],dp[i-1][k])
else:
dp[i][j] = min(dp[i][j],dp[i-1][k]+(j&1))
print(min(dp[-1]) if min(dp[-1]) < inf else -1)
H,W = map(int,input().split())
A = [list(map(int,input().split())) for _ in range(H)]
maze = [[1]*4 for _ in range(H)]
for i in range(H):
for j in range(W):
F = True
if j >= 1:
if A[i][j] == A[i][j-1]:
F = False
if j <= W-2:
if A[i][j] == A[i][j+1]:
F = False
if F:
if i == 0:
x = A[i][j]^A[i+1][j]
if x == 1:
maze[i][0],maze[i][2] = 0,0
else:
maze[i][1],maze[i][3] = 0,0
elif i == H-1:
x = A[i][j]^A[i-1][j]
if x == 1:
maze[i][0],maze[i][1] = 0,0
else:
maze[i][2],maze[i][3] = 0,0
else:
x,y = A[i][j]^A[i-1][j],A[i][j]^A[i+1][j]
maze[i][3^((x<<1)+y)] = 0
inf = 10**12
dp = [[inf]*4 for _ in range(H+1)]
dp[0][1],dp[0][3] = 1,1
dp[0][0],dp[0][2] = 0,0
for i in range(1,H+1):
for j in range(4):
for k in range(4):
if (k&1)^(j>>1&1) == 1:
continue
if maze[i-1][j^k]:
if i == H:
dp[i][j] = min(dp[i][j],dp[i-1][k])
else:
dp[i][j] = min(dp[i][j],dp[i-1][k]+(j&1))
print(min(dp[-1]) if min(dp[-1]) < inf else -1)
|
ConDefects/ConDefects/Code/abc283_e/Python/45759088
|
condefects-python_data_831
|
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
import os
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 10**18
MOD = 998244353
# MOD = 10**9 + 7
isTest = os.path.exists("input.txt")
File = open("input.txt", "r") if isTest else sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N = int(input())
str_N = str(N)
len_N = len(str_N)
s = set()
for i in range(1, len_N // 2 + 1):
if len_N % i == 0:
periodic = int(str_N[:i] * (len_N // i))
# print(periodic, 1)
if periodic > N:
if int(str_N[:i]) % 10 == 0:
periodic = 0
else:
periodic = int(str(int(str_N[:i]) - 1) * (len_N // i))
# print(periodic, 2)
if periodic == 0:
continue
s.add(periodic)
s.add(int("9" * (len_N - 1)))
print(max(s))
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from math import *
# from datetime import *
# from decimal import * # PyPyだと遅い
# from string import ascii_lowercase,ascii_uppercase
# import numpy as np
import sys
import os
# sys.setrecursionlimit(10**6) # PyPyだと遅い
INF = 10**18
MOD = 998244353
# MOD = 10**9 + 7
isTest = os.path.exists("input.txt")
File = open("input.txt", "r") if isTest else sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
for _ in range(int(input())):
N = int(input())
str_N = str(N)
len_N = len(str_N)
s = set()
for i in range(1, len_N // 2 + 1):
if len_N % i == 0:
periodic = int(str_N[:i] * (len_N // i))
# print(periodic, 1)
if periodic > N:
if len(str_N[:i]) != len(str(int(str_N[:i]) - 1)):
periodic = 0
else:
periodic = int(str(int(str_N[:i]) - 1) * (len_N // i))
# print(periodic, 2)
if periodic == 0:
continue
s.add(periodic)
s.add(int("9" * (len_N - 1)))
print(max(s))
|
ConDefects/ConDefects/Code/arc141_a/Python/43463915
|
condefects-python_data_832
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
T = int(readline())
for _ in range(T):
N = readline().rstrip()
LEN = len(N)
if LEN % 2:
LEN += 1
ans = int('9' * (LEN - 1))
for i in range(1, LEN // 2 + 1):
num1 = N[:i]
num2 = str(max(int(num1) - 1, 1))
tmp1 = num1 * 2
tmp2 = num2 * 2
while True:
if int(tmp1) <= int(N):
ans = max(ans, int(tmp1))
tmp1 += num1
else:
break
while True:
if int(tmp2) <= int(N):
ans = max(ans, int(tmp2))
tmp2 += num2
else:
break
print(ans)
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
T = int(readline())
for _ in range(T):
N = readline().rstrip()
LEN = len(N)
ans = int('9' * (LEN - 1))
if LEN % 2:
LEN += 1
for i in range(1, LEN // 2 + 1):
num1 = N[:i]
num2 = str(max(int(num1) - 1, 1))
tmp1 = num1 * 2
tmp2 = num2 * 2
while True:
if int(tmp1) <= int(N):
ans = max(ans, int(tmp1))
tmp1 += num1
else:
break
while True:
if int(tmp2) <= int(N):
ans = max(ans, int(tmp2))
tmp2 += num2
else:
break
print(ans)
|
ConDefects/ConDefects/Code/arc141_a/Python/42776036
|
condefects-python_data_833
|
T = int(input())
for _ in range(T):
s = list(input())
m = len(s)
ans = -1
for k in range(1,m//2+1):
if m%k!=0:
continue
mini = s[:k]
temp = mini*(m//k)
if temp>s:
mini = list(str(int("".join(mini))-1))
temp = mini*(m//k)
ans = max(ans,int("".join(temp)))
print(ans)
T = int(input())
for _ in range(T):
s = list(input())
m = len(s)
ans = -1
for k in range(1,m//2+1):
if m%k!=0:
continue
mini = s[:k]
temp = mini*(m//k)
if temp>s:
mini = list(str(int("".join(mini))-1))
temp = mini*(m//k)
ans = max(ans,int("".join(temp)))
temp = int("9"*(m-1))
ans = max(ans,temp)
print(ans)
|
ConDefects/ConDefects/Code/arc141_a/Python/44827544
|
condefects-python_data_834
|
T=int(input())
for _ in range(T):
N=input()
ans=0
for i in range(1,len(N)):
if len(N)%i==0:
if int(N[:i]*(len(N)//i))<=int(N):
ans=max(ans,int(N[:i]*(len(N)//i)))
else:
ans=max(ans,int(str(int(N[:i])-1)*(len(N)//i)))
print(ans)
T=int(input())
for _ in range(T):
N=input()
ans=pow(10,len(N)-1)-1
for i in range(1,len(N)):
if len(N)%i==0:
if int(N[:i]*(len(N)//i))<=int(N):
ans=max(ans,int(N[:i]*(len(N)//i)))
else:
ans=max(ans,int(str(int(N[:i])-1)*(len(N)//i)))
print(ans)
|
ConDefects/ConDefects/Code/arc141_a/Python/44321950
|
condefects-python_data_835
|
t = int(input())
for _ in range(t):
s = input()
ints = int(s)
ans = 1
lens = len(s)
for length in range(1, len(s)):
if lens % length != 0:
continue
base = s[:length]
num = int(base * (lens // length))
while ints < num:
base = str(int(base) - 1)
num = int(base * (lens // length))
ans = max(ans, num)
print(ans)
t = int(input())
for _ in range(t):
s = input()
ints = int(s)
lens = len(s)
ans = int('9' * (lens-1))
for length in range(1, len(s)):
if lens % length != 0:
continue
base = s[:length]
num = int(base * (lens // length))
while ints < num:
base = str(int(base) - 1)
num = int(base * (lens // length))
ans = max(ans, num)
print(ans)
|
ConDefects/ConDefects/Code/arc141_a/Python/44207258
|
condefects-python_data_836
|
T = int(input())
for _ in range(T):
case = input()
length = len(case)
max_val = 0
for i in range(1, length):
if length % i == 0:
tmp = case[:i]
tmp = "".join(tmp)
val1 = int(tmp*(length//i))
val2 = int(str(int(tmp)-1)*(length//i))
if int(case) >= val1:
max_val = max(max_val, val1)
if int(case) >= val2:
max_val = max(max_val, val2)
print(max_val)
T = int(input())
for _ in range(T):
case = input()
length = len(case)
max_val = int("9"*(length-1))
for i in range(1, length):
if length % i == 0:
tmp = case[:i]
tmp = "".join(tmp)
val1 = int(tmp*(length//i))
val2 = int(str(int(tmp)-1)*(length//i))
if int(case) >= val1:
max_val = max(max_val, val1)
if int(case) >= val2:
max_val = max(max_val, val2)
print(max_val)
|
ConDefects/ConDefects/Code/arc141_a/Python/41469868
|
condefects-python_data_837
|
def make_div(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
T = int(input())
for _ in range(T):
N = int(input())
res = make_div(len(str(N)))
ans = 11
for i in res:
if i == len(str(N)):
continue
cnt = len(str(N)) // i
num = int(str(N)[:i] * cnt)
if num > N:
num = int(str(N)[:i]) - 1
num = int(str(num) * cnt)
ans = max(ans, num)
print(ans)
def make_div(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
T = int(input())
for _ in range(T):
N = int(input())
res = make_div(len(str(N)))
ans = int("9" * (len(str(N)) - 1))
for i in res:
if i == len(str(N)):
continue
cnt = len(str(N)) // i
num = int(str(N)[:i] * cnt)
if num > N:
num = int(str(N)[:i]) - 1
num = int(str(num) * cnt)
ans = max(ans, num)
print(ans)
|
ConDefects/ConDefects/Code/arc141_a/Python/43307420
|
condefects-python_data_838
|
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = (1 << 63)-1
# inf = (1 << 31)-1
# md = 10**9+7
md = 998244353
from itertools import combinations
n,k=LI()
base=[]
aa={}
s=1
for ii in combinations(range(n),k):
a0=a=sum(1<<i for i in ii)
for b in base:a=min(a,b^a)
if a:
base.append(a)
aa[s]=a
s<<=1
if len(base)==n:break
if len(base)!=n:
print("No")
exit()
ans=[0]*(1<<n)
for i in range((1<<n)-1):
s=i^i>>1^i+1^i+1>>1
ans[i+1]=ans[i]^aa[s]
print("Yes")
print(*ans)
import sys
# sys.setrecursionlimit(200005)
int1 = lambda x: int(x)-1
pDB = lambda *x: print(*x, end="\n", file=sys.stderr)
p2D = lambda x: print(*x, sep="\n", end="\n\n", file=sys.stderr)
def II(): return int(sys.stdin.readline())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
def SI(): return sys.stdin.readline().rstrip()
# dij = [(0, 1), (-1, 0), (0, -1), (1, 0)]
dij = [(0, 1), (-1, 0), (0, -1), (1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
inf = (1 << 63)-1
# inf = (1 << 31)-1
# md = 10**9+7
md = 998244353
from itertools import combinations
n,k=LI()
base=[]
aa={}
s=1
for ii in combinations(range(n),k):
a0=a=sum(1<<i for i in ii)
for b in base:a=min(a,b^a)
if a:
base.append(a)
aa[s]=a0
s<<=1
if len(base)==n:break
if len(base)!=n:
print("No")
exit()
ans=[0]*(1<<n)
for i in range((1<<n)-1):
s=i^i>>1^i+1^i+1>>1
ans[i+1]=ans[i]^aa[s]
print("Yes")
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/38710598
|
condefects-python_data_839
|
n,k = map(int,input().split())
if k == n or k%2 == 0:
print("No")
exit()
graycode = [i^(i>>1) for i in range(1<<n)]
basis = []
cand = []
for i in range(1<<n):
if bin(i).count("1") != k:
continue
now = i
for b in basis:
now = min(now,now^b)
if now:
basis.append(now)
cand.append(i)
ans = []
for g in graycode:
num = 0
for i in range(n):
if g >> i & 1:
num ^= cand[i]
ans.append(num)
print("Yes")
print(*ans)
n,k = map(int,input().split())
if (k == n and n != 1) or k%2 == 0:
print("No")
exit()
graycode = [i^(i>>1) for i in range(1<<n)]
basis = []
cand = []
for i in range(1<<n):
if bin(i).count("1") != k:
continue
now = i
for b in basis:
now = min(now,now^b)
if now:
basis.append(now)
cand.append(i)
ans = []
for g in graycode:
num = 0
for i in range(n):
if g >> i & 1:
num ^= cand[i]
ans.append(num)
print("Yes")
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/31152215
|
condefects-python_data_840
|
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
n, k = map(int,input().split())
if n == 1 and k == 1:
print("Yes")
print("0")
return
if k >= n:
print("No")
return
if k % 2 == 0:
print("No")
else:
if k == 1:
ans = []
for i in range(1 << n):
ans.append(i ^ (i >> 1))
print("Yes")
print(" ".join(map(str, ans)))
return
curN = k + 1
curAns = []
MAX = (1 << curN) - 1
for i in range(1 << curN):
if i & 1:
curAns.append(MAX ^ i ^ (i >> 1))
else:
curAns.append(i ^ (i >> 1))
while curN < n:
flag = False
for t in range(1 << curN):
for i in range(1 << curN):
iCpy = curAns[t] ^ curAns[i]
cnt = 0
while iCpy:
cnt += (iCpy & 1)
iCpy >>= 1
iCpy = curAns[t-1] ^ curAns[i - 1]
cnt1 = 0
while iCpy:
cnt1 += (iCpy & 1)
iCpy >>= 1
if cnt == k - 1 and cnt1 == k - 1:
flag = True
break
if flag == True:
if t == 0:
nextAns = curAns[::-1] + curAns[i:] + curAns[:i]
for i in range(1 << curN):
nextAns[i] ^= (1 << curN)
else:
nextAns = curAns[:t - 1:-1] + curAns[i:] + curAns[:i] + curAns[t - 1::-1]
for i in range((1 << curN) - t, (1 << curN) * 2 - t):
nextAns[i] ^= (1 << curN)
break
curN += 1
curAns = nextAns
print("Yes")
print(" ".join(map(str, curAns)))
for i in range(len(curAns)):
iCpy = curAns[i] ^ curAns[(i + 1) % len(curAns)]
cnt = 0
while iCpy:
cnt += (iCpy & 1)
iCpy >>= 1
if cnt != k:
print("NOWOER")
curAns.sort()
for i in range(len(curAns)):
if curAns[i] != i:
print("NOOOO")
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._file = 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")
# endregion
if __name__ == "__main__":
main()
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
n, k = map(int,input().split())
if n == 1 and k == 1:
print("Yes")
print("0 1")
return
if k >= n:
print("No")
return
if k % 2 == 0:
print("No")
else:
if k == 1:
ans = []
for i in range(1 << n):
ans.append(i ^ (i >> 1))
print("Yes")
print(" ".join(map(str, ans)))
return
curN = k + 1
curAns = []
MAX = (1 << curN) - 1
for i in range(1 << curN):
if i & 1:
curAns.append(MAX ^ i ^ (i >> 1))
else:
curAns.append(i ^ (i >> 1))
while curN < n:
flag = False
for t in range(1 << curN):
for i in range(1 << curN):
iCpy = curAns[t] ^ curAns[i]
cnt = 0
while iCpy:
cnt += (iCpy & 1)
iCpy >>= 1
iCpy = curAns[t-1] ^ curAns[i - 1]
cnt1 = 0
while iCpy:
cnt1 += (iCpy & 1)
iCpy >>= 1
if cnt == k - 1 and cnt1 == k - 1:
flag = True
break
if flag == True:
if t == 0:
nextAns = curAns[::-1] + curAns[i:] + curAns[:i]
for i in range(1 << curN):
nextAns[i] ^= (1 << curN)
else:
nextAns = curAns[:t - 1:-1] + curAns[i:] + curAns[:i] + curAns[t - 1::-1]
for i in range((1 << curN) - t, (1 << curN) * 2 - t):
nextAns[i] ^= (1 << curN)
break
curN += 1
curAns = nextAns
print("Yes")
print(" ".join(map(str, curAns)))
for i in range(len(curAns)):
iCpy = curAns[i] ^ curAns[(i + 1) % len(curAns)]
cnt = 0
while iCpy:
cnt += (iCpy & 1)
iCpy >>= 1
if cnt != k:
print("NOWOER")
curAns.sort()
for i in range(len(curAns)):
if curAns[i] != i:
print("NOOOO")
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._file = 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")
# endregion
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/arc138_d/Python/30827068
|
condefects-python_data_841
|
def gray_code(n):
g=[0]*(2**n)
for k in range(2 ** n):
g[k]=format(bin(k^(k>>1))[2:],"0>"+str(n))
return(g)
import array
n,k=map(int,input().split())
if k%2==0 or n==k:
print("No");exit()
print("Yes")
xornum=[]
s={0}
for i in range(2**n):
if bin(i).count("1")==k and i not in s:
news=set()
for j in s: news.add(j^i)
s|=news
xornum.append(i)
#print(bin(xornum[l])[2:])
g=gray_code(n)
#print(g)
ans=array.array("i",[0]*(2**n))
tmp=0
for j in range(2**n):
tmp=0
for i in range(n):
if g[j][i]=="1":tmp=tmp^xornum[i]
ans[j]=tmp
print(*ans)
def gray_code(n):
g=[0]*(2**n)
for k in range(2 ** n):
g[k]=format(bin(k^(k>>1))[2:],"0>"+str(n))
return(g)
import array
n,k=map(int,input().split())
if n==k==1:
print("Yes");print(0,1);exit()
if k%2==0 or n==k:
print("No");exit()
print("Yes")
xornum=[]
s={0}
for i in range(2**n):
if bin(i).count("1")==k and i not in s:
news=set()
for j in s: news.add(j^i)
s|=news
xornum.append(i)
#print(bin(xornum[l])[2:])
g=gray_code(n)
#print(g)
ans=array.array("i",[0]*(2**n))
tmp=0
for j in range(2**n):
tmp=0
for i in range(n):
if g[j][i]=="1":tmp=tmp^xornum[i]
ans[j]=tmp
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/33049315
|
condefects-python_data_842
|
N,K=map(int, input().split())
if K%2==0 or N==K:
print("No")
exit()
print("Yes")
def calc(bit,n,rets):
if n==-1:
rets.append(bit)
return bit
bit=calc(bit,n-1,rets)
bit^=1<<n
return calc(bit,n-1,rets)
gray=[]
calc(0,N-1,gray)
norm=[(1<<K)-1]
for i in range(K-1):
norm.append((1<<K+1)-1-(1<<i))
for i in range(K, N):
norm.append((1<<K-1)-1+(1<<i))
rets=[]
for g in gray:
ret=0
for i in range(N):
if 1<<i&g!=0:
ret^=norm[i]
rets.append(ret)
print(*rets)
N,K=map(int, input().split())
if K!=1 and (K%2==0 or N==K):
print("No")
exit()
print("Yes")
def calc(bit,n,rets):
if n==-1:
rets.append(bit)
return bit
bit=calc(bit,n-1,rets)
bit^=1<<n
return calc(bit,n-1,rets)
gray=[]
calc(0,N-1,gray)
norm=[(1<<K)-1]
for i in range(K-1):
norm.append((1<<K+1)-1-(1<<i))
for i in range(K, N):
norm.append((1<<K-1)-1+(1<<i))
rets=[]
for g in gray:
ret=0
for i in range(N):
if 1<<i&g!=0:
ret^=norm[i]
rets.append(ret)
print(*rets)
|
ConDefects/ConDefects/Code/arc138_d/Python/31059522
|
condefects-python_data_843
|
import math
def map_int(s):
try:
return list(map(int, s.split()))
except ValueError:
return s.strip().split()
def main():
(n,k), = [map_int(s) for s in open(0)]
s = set()
for i in range(2 ** n):
j = i
t = 0
while i:
t += i % 2
i >>= 1
if t == k:
s.add(j)
ans = [0]
for i in range(n):
if len(s) == 0:
print(-1)
return
for ss in s:
break
t = ans[-1] ^ ss
for a in ans[:1 << i]:
at = a ^ t
if at in s:
s.remove(at)
ans.append(at)
print('Yes')
print(*ans)
if __name__ == '__main__':
main()
import math
def map_int(s):
try:
return list(map(int, s.split()))
except ValueError:
return s.strip().split()
def main():
(n,k), = [map_int(s) for s in open(0)]
s = set()
for i in range(2 ** n):
j = i
t = 0
while i:
t += i % 2
i >>= 1
if t == k:
s.add(j)
ans = [0]
for i in range(n):
if len(s) == 0:
print('No')
return
for ss in s:
break
t = ans[-1] ^ ss
for a in ans[:1 << i]:
at = a ^ t
if at in s:
s.remove(at)
ans.append(at)
print('Yes')
print(*ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc138_d/Python/30830027
|
condefects-python_data_844
|
import sys
from collections import deque,defaultdict
def input():
return sys.stdin.readline()[:-1]
def popcount(n):
#O(logn)
answer=0
while n>0:
answer+=n&0b1
n>>=1
return answer
def popcount_fast(n):
assert n.bit_length()<=64
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
def graycode(n):
return n^(n>>1)
def get_base(bases,n):
res=[]
tmp=[]
for i in range(len(bases)):
if len(res)>=n:
return res
v=bases[i]
#print("v",v)
for e in tmp:
v=min(v,v^e)
#print(v)
if v>0:
tmp.append(v)
res.append(bases[i])
return res
def main():
n,k=map(int,input().split())
answer="Yes" if k&0b1==1 and k<n else "No"
print(answer)
if answer=="Yes":
array=[]
bases=list(filter(lambda x: popcount(x)==k,range(1<<n)))
bases=get_base(bases,n)
#print(bases)
graycodes=list(map(graycode,range(1<<n)))
for gc in graycodes:
answer=0
for i in range(n):
if gc&0b1==1:
answer^=bases[i]
gc>>=1
array.append(answer)
print(*array)
return 0
if __name__=="__main__":
main()
import sys
from collections import deque,defaultdict
def input():
return sys.stdin.readline()[:-1]
def popcount(n):
#O(logn)
answer=0
while n>0:
answer+=n&0b1
n>>=1
return answer
def popcount_fast(n):
assert n.bit_length()<=64
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
def graycode(n):
return n^(n>>1)
def get_base(bases,n):
res=[]
tmp=[]
for i in range(len(bases)):
if len(res)>=n:
return res
v=bases[i]
#print("v",v)
for e in tmp:
v=min(v,v^e)
#print(v)
if v>0:
tmp.append(v)
res.append(bases[i])
return res
def main():
n,k=map(int,input().split())
answer="Yes" if n==1 or k&0b1==1 and k<n else "No"
print(answer)
if answer=="Yes":
array=[]
bases=list(filter(lambda x: popcount(x)==k,range(1<<n)))
bases=get_base(bases,n)
#print(bases)
graycodes=list(map(graycode,range(1<<n)))
for gc in graycodes:
answer=0
for i in range(n):
if gc&0b1==1:
answer^=bases[i]
gc>>=1
array.append(answer)
print(*array)
return 0
if __name__=="__main__":
main()
|
ConDefects/ConDefects/Code/arc138_d/Python/30842365
|
condefects-python_data_845
|
n,k=map(int,input().split())
if n==1:
print('Yes')
print(1,1)
exit()
if (not k&1) or k==n:
print('No')
exit()
gray = [0]
for i in range(n):
nxt = []
flip = False
for ai in gray:
if flip:
nxt.append(ai|(1<<i))
nxt.append(ai)
else:
nxt.append(ai)
nxt.append(ai|(1<<i))
flip^=1
gray=nxt
def bit_cnt(x):
return sum((x>>i)&1 for i in range(n))
bb = [i for i in range(1<<n) if bit_cnt(i)==k]
base = set()
base2 = set()
for bi in bb:
bi2 = bi
for x in base2:
bi2 = min(bi2,bi2^x)
if bi2:
base.add(bi)
base2.add(bi2)
base = list(base)
def f(x):
res = 0
for i in range(n):
if (x>>i)&1:
res^=base[i]
return res
ans = [f(gi) for gi in gray]
print('Yes')
print(*ans)
n,k=map(int,input().split())
if n==1:
print('Yes')
print(0,1)
exit()
if (not k&1) or k==n:
print('No')
exit()
gray = [0]
for i in range(n):
nxt = []
flip = False
for ai in gray:
if flip:
nxt.append(ai|(1<<i))
nxt.append(ai)
else:
nxt.append(ai)
nxt.append(ai|(1<<i))
flip^=1
gray=nxt
def bit_cnt(x):
return sum((x>>i)&1 for i in range(n))
bb = [i for i in range(1<<n) if bit_cnt(i)==k]
base = set()
base2 = set()
for bi in bb:
bi2 = bi
for x in base2:
bi2 = min(bi2,bi2^x)
if bi2:
base.add(bi)
base2.add(bi2)
base = list(base)
def f(x):
res = 0
for i in range(n):
if (x>>i)&1:
res^=base[i]
return res
ans = [f(gi) for gi in gray]
print('Yes')
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/30833301
|
condefects-python_data_846
|
def popcount(n):
cnt = 0
while n:
cnt += n & 1
n //= 2
return cnt
def basis01(N, K):
lst = []
lst2 = []
for i in range(1 << N):
if popcount(i) != K:
continue
temp = i
for e in lst:
temp = min(temp, e^temp)
if temp != 0:
lst.append(temp)
lst2.append(i)
return lst2
def make_grey(N):
lst = []
for i in range(1 << N):
lst.append(i ^(i >> 1))
return lst
N, K = map(int, input().split())
if K % 2 == 0 or K == N:
print("No")
exit()
basis = basis01(N, K)
grey = make_grey(N)
ans = [0]
for n in grey:
v = 0
ind = 0
while n:
if n % 2:
v ^= basis[ind]
n //= 2
ind += 1
if v != 0:
ans.append(v)
print("Yes")
print(*ans)
def popcount(n):
cnt = 0
while n:
cnt += n & 1
n //= 2
return cnt
def basis01(N, K):
lst = []
lst2 = []
for i in range(1 << N):
if popcount(i) != K:
continue
temp = i
for e in lst:
temp = min(temp, e^temp)
if temp != 0:
lst.append(temp)
lst2.append(i)
return lst2
def make_grey(N):
lst = []
for i in range(1 << N):
lst.append(i ^(i >> 1))
return lst
N, K = map(int, input().split())
if K % 2 == 0 or (N != 1 and K == N):
print("No")
exit()
basis = basis01(N, K)
grey = make_grey(N)
ans = [0]
for n in grey:
v = 0
ind = 0
while n:
if n % 2:
v ^= basis[ind]
n //= 2
ind += 1
if v != 0:
ans.append(v)
print("Yes")
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/34316813
|
condefects-python_data_847
|
import sys
input = sys.stdin.readline
import random
N,K=map(int,input().split())
if N==K or K%2==0:
print("No")
exit()
A=0
B=1
check=[0]*(1<<N)
ANS=[]
check[A]=1
check[B]=1
def route(x,i,j):#xから始まるルート,bit iは固定.j 残りbitの個数
NOW=x
ANS.append(NOW)
check[NOW]=1
for k in range(1<<j):
for l in range(N):
if check[NOW ^ (1<<l)]==0 and l!=i:
NOW=NOW ^ (1<<l)
check[NOW]=1
ANS.append(NOW)
break
return NOW^(1<<i)
checkbit=[0]*N
for i in range(N-1,-1,-1):
for j in range(N):
if (1<<j)&A!=(1<<j)&B and checkbit[j]==0:
break
A=route(A,j,i)
checkbit[j]=1
ANS.append(B)
# xorの掃き出し法・基底
BASE=[]
def sweep(x):
for b in BASE:
if b^x<x:
x=b^x
return x
BASE2=[]
LIST=list(range(N))
while len(BASE)<N:
random.shuffle(LIST)
c=0
for i in range(K):
c|=(1<<LIST[i])
k=sweep(c)
if k!=0:
BASE.append(k)
BASE2.append(c)
DICT={i:BASE2[i] for i in range(N)}
ANS2=[0]
for i in range(1,len(ANS)):
b=ANS[i]^ANS[i-1]
for i in range(20):
if 1<<i==b:
x=i
break
ANS2.append(ANS2[-1]^DICT[x])
if len(ANS2)!=len(set(ANS2)):
print("No")
else:
print("Yes")
print(*ANS2)
import sys
input = sys.stdin.readline
import random
N,K=map(int,input().split())
if (N>=2 and N==K) or K%2==0:
print("No")
exit()
A=0
B=1
check=[0]*(1<<N)
ANS=[]
check[A]=1
check[B]=1
def route(x,i,j):#xから始まるルート,bit iは固定.j 残りbitの個数
NOW=x
ANS.append(NOW)
check[NOW]=1
for k in range(1<<j):
for l in range(N):
if check[NOW ^ (1<<l)]==0 and l!=i:
NOW=NOW ^ (1<<l)
check[NOW]=1
ANS.append(NOW)
break
return NOW^(1<<i)
checkbit=[0]*N
for i in range(N-1,-1,-1):
for j in range(N):
if (1<<j)&A!=(1<<j)&B and checkbit[j]==0:
break
A=route(A,j,i)
checkbit[j]=1
ANS.append(B)
# xorの掃き出し法・基底
BASE=[]
def sweep(x):
for b in BASE:
if b^x<x:
x=b^x
return x
BASE2=[]
LIST=list(range(N))
while len(BASE)<N:
random.shuffle(LIST)
c=0
for i in range(K):
c|=(1<<LIST[i])
k=sweep(c)
if k!=0:
BASE.append(k)
BASE2.append(c)
DICT={i:BASE2[i] for i in range(N)}
ANS2=[0]
for i in range(1,len(ANS)):
b=ANS[i]^ANS[i-1]
for i in range(20):
if 1<<i==b:
x=i
break
ANS2.append(ANS2[-1]^DICT[x])
if len(ANS2)!=len(set(ANS2)):
print("No")
else:
print("Yes")
print(*ANS2)
|
ConDefects/ConDefects/Code/arc138_d/Python/30896644
|
condefects-python_data_848
|
N, K = map(int, input().split())
if K % 2 == 0 or K == N:
print("No")
else:
print("Yes")
z = [(1 << K) - 1]
for i in range(K - 1):
z.append((1 << K + 1) - 1 - (1 << i))
for i in range(K, N):
z.append((1 << K - 1) - 1 + (1 << i))
ans = [0]
a = 0
for i in range(1, 1 << N):
a ^= z[(i & -i).bit_length() - 1]
ans.append(a)
print(*ans)
N, K = map(int, input().split())
if (K % 2 == 0 or K == N) and not (K == N == 1):
print("No")
else:
print("Yes")
z = [(1 << K) - 1]
for i in range(K - 1):
z.append((1 << K + 1) - 1 - (1 << i))
for i in range(K, N):
z.append((1 << K - 1) - 1 + (1 << i))
ans = [0]
a = 0
for i in range(1, 1 << N):
a ^= z[(i & -i).bit_length() - 1]
ans.append(a)
print(*ans)
|
ConDefects/ConDefects/Code/arc138_d/Python/31052535
|
condefects-python_data_849
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(list(set(a)))
p, ans = 0, 0
for i in range(min(len(a), k)):
if p==i:
ans+=1
p+=1
else:
break
print(ans)
n, k = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(list(set(a)))
p, ans = 0, 0
for i in range(min(len(a), k)):
if p==a[i]:
ans+=1
p+=1
else:
break
print(ans)
|
ConDefects/ConDefects/Code/abc290_c/Python/46128954
|
condefects-python_data_850
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
d = {}
for i in range(10):
d[i] = 0
A.sort()
if A[0] != 0:
print(0)
else:
i = 1
while i < N:
if (A[i] >= K):
print(A[i-1]+1)
break
if (A[i]-A[i-1] > 1):
print(A[i-1]+1)
break
i += 1
else:
print(A[i-1])
N, K = map(int, input().split())
A = list(map(int, input().split()))
d = {}
for i in range(10):
d[i] = 0
A.sort()
if A[0] != 0:
print(0)
else:
i = 1
while i < N:
if (A[i] >= K):
print(A[i-1]+1)
break
if (A[i]-A[i-1] > 1):
print(A[i-1]+1)
break
i += 1
else:
print(A[i-1]+1)
|
ConDefects/ConDefects/Code/abc290_c/Python/45270856
|
condefects-python_data_851
|
n,k=map(int,input().split())
a=sorted(list(set(map(int,input().split()))))
for i in range(min(len(a),k)):
if i!=a[i]:
exit(print(i))
print(k)
n,k=map(int,input().split())
a=sorted(list(set(map(int,input().split()))))
for i in range(min(len(a),k)):
if i!=a[i]:
exit(print(i))
print(min(len(a),k))
|
ConDefects/ConDefects/Code/abc290_c/Python/45296084
|
condefects-python_data_852
|
n,k=(int(x) for x in input().split())
a=set([])
A=input().split()
for i in range(n):
if not A[i] in a:
a.add(int(A[i]))
if k>=10:
k=10
ans=0
for i in range(k):
if i in a:
ans+=1
else:
break
print(ans)
n,k=(int(x) for x in input().split())
a=set([])
A=input().split()
for i in range(n):
if not A[i] in a:
a.add(int(A[i]))
ans=0
for i in range(k):
if i in a:
ans+=1
else:
break
print(ans)
|
ConDefects/ConDefects/Code/abc290_c/Python/45228128
|
condefects-python_data_853
|
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
A_lim = list(set(A))
for i in range(len(A)-len(A_lim)):
A_lim.append(A_lim[-1])
check = 0
ans = 0
flag = True
for i in range(K):
if A_lim[i] == check:
check += 1
else:
ans = i
Flag = False
break
if flag == True:
print(K)
elif flag == False:
print(ans)
N,K = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
A_lim = list(set(A))
for i in range(len(A)-len(A_lim)):
A_lim.append(A_lim[-1])
check = 0
ans = 0
flag = True
for i in range(K):
if A_lim[i] == check:
check += 1
else:
ans = i
flag = False
break
if flag == True:
print(K)
elif flag == False:
print(ans)
|
ConDefects/ConDefects/Code/abc290_c/Python/46162962
|
condefects-python_data_854
|
N, K = map(int, input().split())
A = sorted(list(map(int, input().split())))
mex = 0
count = 0
for a in A:
if mex == a and count < K:
mex += 1
count += 1
else:
break
print(mex)
N, K = map(int, input().split())
A = sorted(list(set(map(int, input().split()))))
mex = 0
count = 0
for a in A:
if mex == a and count < K:
mex += 1
count += 1
else:
break
print(mex)
|
ConDefects/ConDefects/Code/abc290_c/Python/46194587
|
condefects-python_data_855
|
def solve():
n=int(input())
r=list(map(int,input().split()))
c=list(map(int,input().split()))
q=int(input())
for i in range(q):
x,y=map(int,input().split())
x-=1
y-=1
if r[x]+c[y]>5:
print("#",end="")
else:
print(".",end="")
for test in range(1):
solve()
def solve():
n=int(input())
r=list(map(int,input().split()))
c=list(map(int,input().split()))
q=int(input())
for i in range(q):
x,y=map(int,input().split())
x-=1
y-=1
if r[x]+c[y]>n:
print("#",end="")
else:
print(".",end="")
for test in range(1):
solve()
|
ConDefects/ConDefects/Code/arc132_a/Python/38864069
|
condefects-python_data_856
|
import sys, math, itertools, heapq, copy, collections, bisect, random, time
from collections import deque, defaultdict, Counter
from decimal import Decimal
from functools import lru_cache
def MI(): return map(int, sys.stdin.buffer.readline().split())
def MI1(): return map(lambda x:int(x)-1, sys.stdin.buffer.readline().split())
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def SL(): return list(sys.stdin.buffer.readline().rstrip().decode('utf-8'))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def SLR(n): return [SL() for _ in range(n)]
def resolve():
N = I()
Rs = LI()
Cs = LI()
for i in range(I()):
r, c = MI1()
rr = Rs[r]
cc = Cs[c]
print('#' if rr+cc > 5 else '.', end='')
print()
if __name__ == "__main__":
resolve()
import sys, math, itertools, heapq, copy, collections, bisect, random, time
from collections import deque, defaultdict, Counter
from decimal import Decimal
from functools import lru_cache
def MI(): return map(int, sys.stdin.buffer.readline().split())
def MI1(): return map(lambda x:int(x)-1, sys.stdin.buffer.readline().split())
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def SL(): return list(sys.stdin.buffer.readline().rstrip().decode('utf-8'))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def SLR(n): return [SL() for _ in range(n)]
def resolve():
N = I()
Rs = LI()
Cs = LI()
for i in range(I()):
r, c = MI1()
rr = Rs[r]
cc = Cs[c]
print('#' if rr+cc > N else '.', end='')
print()
if __name__ == "__main__":
resolve()
|
ConDefects/ConDefects/Code/arc132_a/Python/43293149
|
condefects-python_data_857
|
n = int(input())
r = list(map(int, input().split()))
c = list(map(int, input().split()))
q = int(input())
ans = ""
for i in range(q):
a, b = map(int, input().split())
a-=1
b-=1
if(r[a] > 5-c[b]):ans += "#"
else:ans += "."
print(ans)
n = int(input())
r = list(map(int, input().split()))
c = list(map(int, input().split()))
q = int(input())
ans = ""
for i in range(q):
a, b = map(int, input().split())
a-=1
b-=1
if(r[a]+c[b] >= n+1):ans += "#"
else:ans += "."
print(ans)
|
ConDefects/ConDefects/Code/arc132_a/Python/44360542
|
condefects-python_data_858
|
# 長さnのリストRと長さnのリストCが与えられます。
# また、q個のクエリが与えられます。
# 各クエリは、2つの整数aとbが与えられ、Rのa番目の要素とCのb番目の要素を足した値がnより大きい場合は'#'を、そうでない場合は'.'を出力してください。
# という問題と同義。
def solve(n,R,C,Q,queries):
ans = []
for r,c in queries:
if R[r-1]+C[c-1] > n:
ans.append("#")
else:
ans.append(".")
return ans
if __name__=="__main__":
n = int(input())
R = list(map(int,input().split()))
C = list(map(int,input().split()))
Q = int(input())
queries = [list(map(int,input().split())) for _ in range(Q)]
ans = solve(n,R,C,Q,queries)
print(*ans)
# 長さnのリストRと長さnのリストCが与えられます。
# また、q個のクエリが与えられます。
# 各クエリは、2つの整数aとbが与えられ、Rのa番目の要素とCのb番目の要素を足した値がnより大きい場合は'#'を、そうでない場合は'.'を出力してください。
# という問題と同義。
def solve(n,R,C,Q,queries):
ans = []
for r,c in queries:
if R[r-1]+C[c-1] > n:
ans.append("#")
else:
ans.append(".")
return ans
if __name__=="__main__":
n = int(input())
R = list(map(int,input().split()))
C = list(map(int,input().split()))
Q = int(input())
queries = [list(map(int,input().split())) for _ in range(Q)]
ans = solve(n,R,C,Q,queries)
print("".join(ans))
|
ConDefects/ConDefects/Code/arc132_a/Python/39808227
|
condefects-python_data_859
|
n=int(input())
r=list(map(int,input().split()))
c=list(map(int,input().split()))
q=int(input())
ans=""
for i in range(q):
y,x=map(int,input().split())
ans+="#" if r[y-1]+c[y-1]>n else "."
print (ans)
n=int(input())
r=list(map(int,input().split()))
c=list(map(int,input().split()))
q=int(input())
ans=""
for i in range(q):
y,x=map(int,input().split())
ans+="#" if r[y-1]+c[x-1]>n else "."
print (ans)
|
ConDefects/ConDefects/Code/arc132_a/Python/45439715
|
condefects-python_data_860
|
n=int(input())
R=list(map(int,input().split()))
C=list(map(int,input().split()))
q=int(input())
ans=""
for i in range(q):
r,c=map(int,input().split())
if R[r-1]+C[c-1]>5:
ans+="#"
else:
ans+="."
print(ans)
n=int(input())
R=list(map(int,input().split()))
C=list(map(int,input().split()))
q=int(input())
ans=""
for i in range(q):
r,c=map(int,input().split())
if R[r-1]+C[c-1]>n:
ans+="#"
else:
ans+="."
print(ans)
|
ConDefects/ConDefects/Code/arc132_a/Python/37932148
|
condefects-python_data_861
|
N=int(input())
P=list(map(int,input().split()))
flg=[[False]*N for i in range(N)]
for i in range(1,N):
for j in range(i):
flg[j][i]=True
Q=int(input())
for i in range(Q):
A,B=map(int,input().split())
if flg[A-1][B-1]:
print(A)
else:
print(B)
N=int(input())
P=list(map(int,input().split()))
flg=[[False]*N for i in range(N)]
for i in range(1,N):
for j in range(i):
flg[P[j]-1][P[i]-1]=True
Q=int(input())
for i in range(Q):
A,B=map(int,input().split())
if flg[A-1][B-1]:
print(A)
else:
print(B)
|
ConDefects/ConDefects/Code/abc342_b/Python/54862037
|
condefects-python_data_862
|
import heapq
def prev(l,d,k,c,t):
if l+d*(k-1)+c<=t: a=l+d*(k-1)
elif t<l+c: a=-1
else: a=l+d*((t-l)//d)
return a
def dijkstra(P,T,v,s):
H,T[v]=[],s
heapq.heappush(H,(-s,v))
while H:
t,v=heapq.heappop(H)
if T[v]>-t: continue
for l,d,k,c,a in P[v]:
s=prev(l,d,k,c,-t)
if T[a]<s:
T[a]=s
heapq.heappush(H,(-s,a))
n,m=map(int,input().split())
x,P,T=0,[list() for _ in range(n)],[-1]*n
for i in range(m):
l,d,k,c,a,b=map(int,input().split())
P[b-1]+=[[l,d,k,c,a-1]]
x=max(x,l+d*(k-1)+c)
dijkstra(P,T,n-1,x)
for i in range(n-1):
print('Unreachable' if T[i]==-1 else T[i])
import heapq
def prev(l,d,k,c,t):
if l+d*(k-1)+c<=t: a=l+d*(k-1)
elif t<l+c: a=-1
else: a=l+d*((t-l-c)//d)
return a
def dijkstra(P,T,v,s):
H,T[v]=[],s
heapq.heappush(H,(-s,v))
while H:
t,v=heapq.heappop(H)
if T[v]>-t: continue
for l,d,k,c,a in P[v]:
s=prev(l,d,k,c,-t)
if T[a]<s:
T[a]=s
heapq.heappush(H,(-s,a))
n,m=map(int,input().split())
x,P,T=0,[list() for _ in range(n)],[-1]*n
for i in range(m):
l,d,k,c,a,b=map(int,input().split())
P[b-1]+=[[l,d,k,c,a-1]]
x=max(x,l+d*(k-1)+c)
dijkstra(P,T,n-1,x)
for i in range(n-1):
print('Unreachable' if T[i]==-1 else T[i])
|
ConDefects/ConDefects/Code/abc342_e/Python/52012139
|
condefects-python_data_863
|
#!/usr/bin/env python3
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush
from math import gcd
from sys import setrecursionlimit
dpos4 = ((1, 0), (0, 1), (-1, 0), (0, -1))
dpos8 = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
mod1 = 10**9 + 7
mod2 = 998244353
inf = 1 << 62
def main():
N, M = map(int, input().split())
edges = [[] for _ in range(N)]
for _ in range(M):
l, d, k, c, a, b = map(int, input().split())
a -= 1
b -= 1
edges[b].append((a, l, d, k, c))
que = []
que.append((-1 << 60, N - 1))
dist = [-1 << 60] * N
dist[-1] = 1 << 60
while que:
fd, fr = heappop(que)
fd *= -1
if dist[fr] != fd:
continue
for to, l, d, k, c in edges[fr]:
td = fd - c
if td < l:
continue
r = l + (k - 1) * d
if r <= td:
td = r
else:
td = l + (td - l + d - 1) // d * d
if dist[to] >= td:
continue
dist[to] = td
heappush(que, (-td, to))
for i in range(N - 1):
if dist[i] == -1 << 60:
print("Unreachable")
else:
print(dist[i])
if __name__ == "__main__":
main()
#!/usr/bin/env python3
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from heapq import heappop, heappush
from math import gcd
from sys import setrecursionlimit
dpos4 = ((1, 0), (0, 1), (-1, 0), (0, -1))
dpos8 = ((0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1))
mod1 = 10**9 + 7
mod2 = 998244353
inf = 1 << 62
def main():
N, M = map(int, input().split())
edges = [[] for _ in range(N)]
for _ in range(M):
l, d, k, c, a, b = map(int, input().split())
a -= 1
b -= 1
edges[b].append((a, l, d, k, c))
que = []
que.append((-1 << 60, N - 1))
dist = [-1 << 60] * N
dist[-1] = 1 << 60
while que:
fd, fr = heappop(que)
fd *= -1
if dist[fr] != fd:
continue
for to, l, d, k, c in edges[fr]:
td = fd - c
if td < l:
continue
r = l + (k - 1) * d
if r <= td:
td = r
else:
td = l + (td - l) // d * d
if dist[to] >= td:
continue
dist[to] = td
heappush(que, (-td, to))
for i in range(N - 1):
if dist[i] == -1 << 60:
print("Unreachable")
else:
print(dist[i])
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc342_e/Python/52271105
|
condefects-python_data_864
|
import heapq
from collections import Counter,deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
N,M=map(int,input().split())
graph=[[] for x in range(N)]
for m in range(M):
l,d,k,c,a,b=map(int,input().split())
a-=1;b-=1
graph[b].append((a,l,d,k,c))
inf=1<<60
time=[-inf]*N
time[N-1]=inf
queue=[(inf,N-1)]
while queue:
tx,x=_heappop_max(queue)
if time[x]>tx:
continue
for y,l,d,k,c in graph[x]:
if tx<l+c:
continue
if l+(k-1)*d+c<=tx:
ty=l+(k-1)*d
else:
ty=tx-(tx-c-l)%d
if time[y]<ty:
time[y]=ty
_heappush_max(queue,(ty,y))
for i in range(N-1):
ans=time[i]
if ans==-inf:
ans="Unreachable"
print(ans)
import heapq
from collections import Counter,deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
N,M=map(int,input().split())
graph=[[] for x in range(N)]
for m in range(M):
l,d,k,c,a,b=map(int,input().split())
a-=1;b-=1
graph[b].append((a,l,d,k,c))
inf=1<<60
time=[-inf]*N
time[N-1]=inf
queue=[(inf,N-1)]
while queue:
tx,x=_heappop_max(queue)
if time[x]>tx:
continue
for y,l,d,k,c in graph[x]:
if tx<l+c:
continue
if l+(k-1)*d+c<=tx:
ty=l+(k-1)*d
else:
ty=tx-(tx-c-l)%d-c
if time[y]<ty:
time[y]=ty
_heappush_max(queue,(ty,y))
for i in range(N-1):
ans=time[i]
if ans==-inf:
ans="Unreachable"
print(ans)
|
ConDefects/ConDefects/Code/abc342_e/Python/55130298
|
condefects-python_data_865
|
import heapq
N,M=map(int,input().split())
edge=[[] for i in range(N)]
for i in range(M):
l,d,k,c,A,B=map(int,input().split())
A-=1;B-=1
edge[B].append((l,d,k,c,A))
P=[(-10**20,N-1)]
heapq.heapify(P)
ans=[-1]*N
while P:
time,pos=heapq.heappop(P)
time*=-1
if ans[pos]>0:
continue
ans[pos]=time
for l,d,k,c,A in edge[pos]:
if ans[A]>0:
continue
kt=(time-c-l)//d
if kt<0:
continue
if kt>k-1:
kt=k-1
heapq.heappush(P,(-kt*d-l,A))
for a in ans:
print(a if a>=0 else 'Unreachable')
import heapq
N,M=map(int,input().split())
edge=[[] for i in range(N)]
for i in range(M):
l,d,k,c,A,B=map(int,input().split())
A-=1;B-=1
edge[B].append((l,d,k,c,A))
P=[(-10**20,N-1)]
heapq.heapify(P)
ans=[-1]*N
while P:
time,pos=heapq.heappop(P)
time*=-1
if ans[pos]>0:
continue
ans[pos]=time
for l,d,k,c,A in edge[pos]:
if ans[A]>0:
continue
kt=(time-c-l)//d
if kt<0:
continue
if kt>k-1:
kt=k-1
heapq.heappush(P,(-kt*d-l,A))
for a in ans[:-1]:
print(a if a>=0 else 'Unreachable')
|
ConDefects/ConDefects/Code/abc342_e/Python/54872777
|
condefects-python_data_866
|
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print(l, file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
n, m = gl()
g = [[] for i in range(n)]
for i in range(m):
l, d, k, c, a, b = gl()
a -= 1
b -= 1
g[b].append((l, d, k, c, a))
h = Maxheapq()
h.append((inf, n-1))
vi = set()
ans = [-inf] * n
while len(h) != 0:
while len(h) > 0 and h[0][1] in vi:
h.pop()
if len(h) == 0:
break
(lst, to) = h.pop()
vi.add(to)
ans[to] = lst
for (l, d, k, c, st) in g[to]:
if lst < l + c:
continue
ok = 0
ng = k
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if l + d * mid <= lst:
ok = mid
else:
ng = mid
h.append((l + d * ok, st))
for e in ans[:-1]:
if e == -inf:
print('Unreachable')
else:
print(e)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')
# import sys
# sys.setrecursionlimit(10**7)
import re
# import more_itertools
import functools
import sys
import bisect
import math
import itertools
from collections import deque
from collections import defaultdict
from collections import Counter
from copy import copy, deepcopy
from heapq import heapify, heappush, heappop, heappushpop, heapreplace
from functools import cmp_to_key as cmpk
al = "abcdefghijklmnopqrstuvwxyz"
au = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
# io
# begin fastio
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin = IOWrapper(sys.stdin)
# sys.stdout = IOWrapper(sys.stdout)
_log = True # if False, perr() do notiong
import sys
import itertools
def ii(): return int(sys.stdin.readline().rstrip())
def gl(): return list(map(int, sys.stdin.readline().split()))
def gs(): return list(input().split())
def gr(l):
res = itertools.groupby(l)
return list([(key, len(list(v))) for key, v in res])
def glm(h,w):
a = []
for i in range(h):
a.append(gl())
return a
def gsm(h):
a = []
for i in range(h):
a.append(input().split())
return a
def perr(*l):
if _log:
print(l, file=sys.stderr)
def pex(con):
pyn(con)
exit()
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
def putedges(g, idx = 0):
n = len(g)
e = []
cnt2 = 0
for i in range(n):
for j in g[i]:
cnt2 += 1
e.append((i, j))
m = len(g)
print(n, cnt2)
for i in e:
if idx == 0:
print(*[i[0], i[1]])
else:
print(*[i[0] + 1, i[1] + 1])
# end io
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
# return group_members
return dict(group_members)
def __str__(self):
return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
# begin util/util
def rev(a):
a = a[:]
return list(reversed(a))
def drev(d):
newd = {}
for k in rev(list(d.keys())):
newd[k] = d[k]
return newd
def dvsort(d):
return dict(sorted(d.items(), key = lambda x: x[1]))
def dksort(d):
return dict(sorted(d.items()))
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def kiriage(n, r):
if n % r == 0:
return n // r
else:
return (n // r) + 1
def ketawa(n):
ans = 0
s = str(n)
for i in s:
ans += int(i)
return ans
def sinhen(n, l):
if n < l:
return [n]
else:
return sinhen(n // l, l) + [n % l]
import re
def search(q, b):
return re.search(b, q)
def cut_yoko(a, y):
a_copy = deepcopy(a)
res = []
for x in range(len(a[0])):
res.append(a_copy[y][x])
return res
def cut_tate(a, x):
a_copy = deepcopy(a)
res = []
for y in range(len(a)):
res.append(a_copy[y][x])
return res
def rmwh(a):
s = set([len(e) for e in a])
assert len(s) == 1
while not '#' in a[0]:
a = a[1:]
while not '#' in a[-1]:
a = a[:-1]
ok = True
while True:
for y in range(len(a)):
if a[y][0] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][1:]
else:
break
ok = True
while True:
for y in range(len(a)):
if a[y][-1] == '#':
ok = False
if ok:
for y in range(len(a)):
a[y] = a[y][:-1]
else:
break
return a
def cntsep(a, b, k):
r = a % k
m = a - r
ans = (b - m) // (k+1)
if r > 0:
ans -= 1
return ans
def compress(a, base = 1):
s = set()
for e in a:
s.add(e)
s = list(sorted(s))
d = {}
for i in range(len(s)):
d[s[i]] = i
b = []
for e in a:
b.append(d[e] + base)
return b
# from decimal import *
def myround(x, k):
if k < 0:
return float(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
else:
return int(Decimal(str(x)).quantize(Decimal('1E' + str(k+1)), rounding = ROUND_HALF_UP))
def rp(s, d):
return s.translate(str.maketrans(d))
def tr(s, a, b):
assert len(a) == len(b)
res = []
d = {}
for i in len(a):
d[a] = b[b]
return ''.join([d[e] for e in s])# ned
# end util/util
# begin permutation
# https://strangerxxx.hateblo.jp/entry/20220201/1643705539
def next_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] < a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] < a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
def prev_permutation(a, l = 0, r = None):
if r is None:
r = len(a)
for i in range(r - 2, l - 1, -1):
if a[i] > a[i + 1]:
for j in range(r - 1, i, -1):
if a[i] > a[j]:
a[i], a[j] = a[j], a[i]
p, q = i + 1, r - 1
while p < q:
a[p], a[q] = a[q], a[p]
p += 1
q -= 1
return True
return False
# end permutation
# begin math/gcd
def lcm2(x, y):
return (x * y) // math.gcd(x, y)
def lcm3(*ints):
return functools.reduce(lcm2, ints)
def gcd(*ints):
return math.gcd(*ints)
# end math/gcd
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
n = self.size = len(a)
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
# https://stackoverflow.com/questions/2501457/what-do-i-use-for-a-max-heap-implementation-in-python#answer-40455775
class Heapq():
# def __init__(self, arr = []):
# self.hq = arr
# heapify(self.hq)
def __init__(self, arr = None):
if arr == None:
arr = []
self.hq = arr
heapify(self.hq)
def pop(self): return heappop(self.hq)
def append(self, a): heappush(self.hq, a)
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx]
class _MaxHeapObj(object):
def __init__(self, val): self.val = val
def __lt__(self, other): return self.val > other.val
def __eq__(self, other): return self.val == other.val
def __str__(self): return str(self.val)
class Maxheapq():
def __init__(self, arr = []):
self.hq = [_MaxHeapObj(e) for e in arr]
heapify(self.hq)
def pop(self): return heappop(self.hq).val
def append(self, a): heappush(self.hq, _MaxHeapObj(a))
def __len__(self): return len(self.hq)
def __getitem__(self, idx): return self.hq[idx].val
def dijkstra(g, st):
h = Heapq()
h.append((0, st))
vi = set()
res = [inf for i in range(len(g))]
while len(vi) != n and len(h) != 0:
d, now = h.pop()
if now in vi:
continue
vi.add(now)
res[now] = d
for to in g[now]:
if not to in vi:
h.append((d + g[now][to], to))
return res
def tarjan(g):
n = len(g)
scc, s, p = [], [], []
q = [i for i in range(n)]
state = [0] * n
while q:
node = q.pop()
if node < 0:
d = state[~node] - 1
if p[-1] > d:
scc.append(s[d:])
del s[d:]
p.pop()
for v in scc[-1]:
state[v] = -1
elif state[node] > 0:
while p[-1] > state[node]:
p.pop()
elif state[node] == 0:
s.append(node)
p.append(len(s))
state[node] = len(s)
q.append(~node)
q.extend(g[node])
return scc
def top_sort(g):
res = []
vi = set()
q = deque()
din = [0 for i in range(len(g))]
for i in range(len(g)):
for e in g[i]:
din[e] += 1
for i in range(len(din)):
if din[i] == 0:
q.append(i)
while len(q) != 0:
st = q.popleft()
res.append(st)
for to in g[st]:
din[to] -= 1
if din[to] == 0:
q.append(to)
return res
# begin combination
# https://rin204.github.io/Library-Python/expansion/math/Combination.py
import math
class Combination:
def __init__(self, n, MOD=998244353):
n = min(n, MOD - 1)
self.fact = [1] * (n + 1)
self.invfact = [1] * (n + 1)
self.MOD = MOD
for i in range(1, n + 1):
self.fact[i] = self.fact[i - 1] * i % MOD
self.invfact[n] = pow(self.fact[n], MOD - 2, MOD)
for i in range(n - 1, -1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % MOD
def extend(self, n):
le = len(self.fact)
if n < le:
return
self.fact.extend([1] * (n - le + 1))
self.invfact.extend([1] * (n - le + 1))
for i in range(le, n + 1):
self.fact[i] = self.fact[i - 1] * i % self.MOD
self.invfact[n] = pow(self.fact[n], self.MOD - 2, self.MOD)
for i in range(n - 1, le - 1, -1):
self.invfact[i] = self.invfact[i + 1] * (i + 1) % self.MOD
def nPk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return self.fact[n] * self.invfact[n - k] % self.MOD
def nCk(self, n, k):
if k < 0 or n < k:
return 0
if n >= len(self.fact):
self.extend(n)
return (self.fact[n] * self.invfact[n - k] % self.MOD) * self.invfact[k] % self.MOD
def nHk(self, n, k):
if n == 0 and k == 0:
return 1
return self.nCk(n + k - 1, k)
def Catalan(self, n):
return (self.nCk(2 * n, n) - self.nCk(2 * n, n - 1)) % self.MOD
def nCk(n, k):
return math.comb(n, k)
def nCk_mod(n, k, mod = 998244353):
if k < 0 or n < k:
return 0
res = 1
for i in range(k):
res *= (n - i)
res %= mod
res *= pow((k - i), -1, mod)
res %= mod
return res
# end combination
def mbs(a, key):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if a[mid] >= key:
ok = mid
else:
ng = mid
return ok
def satlow(f, lower = 0, upper = 10**9):
ng = lower
ok = upper
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(mid):
ok = mid
else:
ng = mid
return ok
def listsatlow(a, f):
ng = -1
ok = len(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if f(a[mid]):
ok = mid
else:
ng = mid
return ok
_log=True
def pex(con):
pyn(con)
exit()
def yn(con, yes = 'Yes', no = 'No'):
if con:
return yes
else:
return no
def pp(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def pyn(con, yes = 'Yes', no = 'No'):
if con:
print(yes)
else:
print(no)
def py(yes = 'Yes'):
print(yes)
def pn(no = 'No'):
print(no)
yes='Yes'
no='No'
v4 = [[-1, 0], [0, -1], [0, 1], [1, 0]]
inf = float('inf')
ans = inf
cnt=0
#main
n, m = gl()
g = [[] for i in range(n)]
for i in range(m):
l, d, k, c, a, b = gl()
a -= 1
b -= 1
g[b].append((l, d, k, c, a))
h = Maxheapq()
h.append((inf, n-1))
vi = set()
ans = [-inf] * n
while len(h) != 0:
while len(h) > 0 and h[0][1] in vi:
h.pop()
if len(h) == 0:
break
(lst, to) = h.pop()
vi.add(to)
ans[to] = lst
for (l, d, k, c, st) in g[to]:
if lst < l + c:
continue
ok = 0
ng = k
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if l + d * mid + c <= lst:
ok = mid
else:
ng = mid
h.append((l + d * ok, st))
for e in ans[:-1]:
if e == -inf:
print('Unreachable')
else:
print(e)
|
ConDefects/ConDefects/Code/abc342_e/Python/53929087
|
condefects-python_data_867
|
from heapq import*;f=lambda:map(int,input().split());N,M=f();G=[[]for x in" "*N*2];I=1e18;T=[-I]*N+[I];Q=[(-I,N)]
for m in " "*M:*t,b=f();G[b]+=[t]
while Q:
s,x=heappop(Q)
for l,d,k,c,y in G[x]:
t=min((a:=-s-c-l)//d*d,(k-1)*d)+l
if T[y]<t and a>=0:T[y]=t;heappush(Q,(-t,y))
for t in T[1:N]:print([t,"Unreachable"][t==-I])
from heapq import*;f=lambda:map(int,input().split());N,M=f();G=[[]for x in" "*N*2];I=1<<60;T=[-I]*N+[I];Q=[(-I,N)]
for m in " "*M:*t,b=f();G[b]+=[t]
while Q:
s,x=heappop(Q)
for l,d,k,c,y in G[x]:
t=min((a:=-s-c-l)//d*d,(k-1)*d)+l
if T[y]<t and a>=0:T[y]=t;heappush(Q,(-t,y))
for t in T[1:N]:print([t,"Unreachable"][t==-I])
|
ConDefects/ConDefects/Code/abc342_e/Python/55130748
|
condefects-python_data_868
|
n,s=map(int, input().split())
c=[0]*n
d=[]
for i in range(n):
a,b=map(int, input().split())
if a<=b:
d.append(b-a)
s-=a
else:
c[i]=1
d.append(a-b)
s-=b
if s<=0:
print("No")
exit()
dp=[[0]*(s+1) for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
D=d[i]
for j in range(s+1):
if dp[i][j]==1:
dp[i+1][j]=1
if j+D<=s:
dp[i+1][j+D]=1
if dp[-1][-1]==0:
print("No")
exit()
ans=""
e=["H","T"]
now=s
for i in reversed(range(n)):
if dp[i][now]==1:
ans+=e[c[i]]
else:
ans+=e[(c[i]+1)%2]
now-=d[i]
ans=ans[::-1]
print("Yes")
print(ans)
n,s=map(int, input().split())
c=[0]*n
d=[]
for i in range(n):
a,b=map(int, input().split())
if a<=b:
d.append(b-a)
s-=a
else:
c[i]=1
d.append(a-b)
s-=b
if s<0:
print("No")
exit()
dp=[[0]*(s+1) for _ in range(n+1)]
dp[0][0]=1
for i in range(n):
D=d[i]
for j in range(s+1):
if dp[i][j]==1:
dp[i+1][j]=1
if j+D<=s:
dp[i+1][j+D]=1
if dp[-1][-1]==0:
print("No")
exit()
ans=""
e=["H","T"]
now=s
for i in reversed(range(n)):
if dp[i][now]==1:
ans+=e[c[i]]
else:
ans+=e[(c[i]+1)%2]
now-=d[i]
ans=ans[::-1]
print("Yes")
print(ans)
|
ConDefects/ConDefects/Code/abc271_d/Python/46008428
|
condefects-python_data_869
|
M=998244353
n,m,k=map(int,input().split())
c=[0]*(m+1)
for a in list(map(int,input().split())):
c[a]+=1
z=c[0]
c[0]=0
fa=[1]
fb=[1]
for i in range(1,z+1):
fa.append((fa[-1]*i)%M)
fb.append((fb[-1]*pow(i,M-2,M))%M)
for i in range(m):
c[i+1]+=c[i]
f=0
for i in range(1,m+1):
if c[i-1]>k-1:
break
g=0
for j in range(z+1):
if c[i-1]+j>k-1:
break
g+=fa[z]*fb[j]*fb[z-j]*pow(i-1,j,M)*pow(m-i+1,z-j,M)
g%=M
f+=g
f%=M
print((f*pow(pow(m,z,M-1),M-2,M))%M)
M=998244353
n,m,k=map(int,input().split())
c=[0]*(m+1)
for a in list(map(int,input().split())):
c[a]+=1
z=c[0]
c[0]=0
fa=[1]
fb=[1]
for i in range(1,z+1):
fa.append((fa[-1]*i)%M)
fb.append((fb[-1]*pow(i,M-2,M))%M)
for i in range(m):
c[i+1]+=c[i]
f=0
for i in range(1,m+1):
if c[i-1]>k-1:
break
g=0
for j in range(z+1):
if c[i-1]+j>k-1:
break
g+=fa[z]*fb[j]*fb[z-j]*pow(i-1,j,M)*pow(m-i+1,z-j,M)
g%=M
f+=g
f%=M
print((f*pow(pow(m,z,M),M-2,M))%M)
|
ConDefects/ConDefects/Code/abc295_e/Python/42176175
|
condefects-python_data_870
|
import sys
input = sys.stdin.readline
ii = lambda: int(input())
mi = lambda: map(int, input().split())
N, M, K = mi()
A = list(mi())
# N, M, K = 10,20,7
# A = [6, 5, 0, 2, 0, 0, 0, 15, 0, 0]
# N,M,K = [3, 5, 2]
# A = [2, 0, 4]
###############
MAX = N+1
MOD = 998244353
fac = [0 for i in range(0,MAX)]
finv = [0 for i in range(0,MAX)]
inv = [0 for i in range(0,MAX)]
fac[0] = fac[1] = 1
inv[1] = 1
finv[0] = finv[1] = 1
for i in range(2,MAX):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - MOD//i*inv[MOD%i]%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def comb(n, r):
if n < r or n < 0 or r < 0:
return 0
return fac[n]*finv[r]%MOD*finv[n-r]%MOD
###############
A = [a for a in A if a > 0]
A.sort()
Z = N - len(A) # 0 の個数
import bisect
NC = 0 # 場合の数
NA = pow(M,Z,MOD) # 全ての場合の数
NAI = pow(NA,MOD-2,MOD) # その逆数
for i in range(1,M+1):
# i以上となる要素数が N-K+1 以上となる確率の和を求める
C = len(A)-bisect.bisect_left(A,i) # i以上の非零要素の個数
if C >= N-K+1:
NC = (NC + NA) % MOD
elif C+Z < N-K+1:
continue
else:
# Z個の零要素中N-K+1-C個以上をi以上に置換える
for m in range(N-K+1-C, Z+1):
# print(f'i={i}, comb({Z},{m})*pow({M-i+1},{m})*pow({M},{Z-m})')
NC = (NC + comb(Z,m)*pow(M-i+1,m,MOD)*pow(M,Z-m,MOD)) % MOD
print((NC*NAI)%MOD)
import sys
input = sys.stdin.readline
ii = lambda: int(input())
mi = lambda: map(int, input().split())
N, M, K = mi()
A = list(mi())
# N, M, K = 10,20,7
# A = [6, 5, 0, 2, 0, 0, 0, 15, 0, 0]
# N,M,K = [3, 5, 2]
# A = [2, 0, 4]
###############
MAX = N+1
MOD = 998244353
fac = [0 for i in range(0,MAX)]
finv = [0 for i in range(0,MAX)]
inv = [0 for i in range(0,MAX)]
fac[0] = fac[1] = 1
inv[1] = 1
finv[0] = finv[1] = 1
for i in range(2,MAX):
fac[i] = fac[i-1] * i % MOD
inv[i] = MOD - MOD//i*inv[MOD%i]%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def comb(n, r):
if n < r or n < 0 or r < 0:
return 0
return fac[n]*finv[r]%MOD*finv[n-r]%MOD
###############
A = [a for a in A if a > 0]
A.sort()
Z = N - len(A) # 0 の個数
import bisect
NC = 0 # 場合の数
NA = pow(M,Z,MOD) # 全ての場合の数
NAI = pow(NA,MOD-2,MOD) # その逆数
for i in range(1,M+1):
# i以上となる要素数が N-K+1 以上となる確率の和を求める
C = len(A)-bisect.bisect_left(A,i) # i以上の非零要素の個数
if C >= N-K+1:
NC = (NC + NA) % MOD
elif C+Z < N-K+1:
continue
else:
# Z個の零要素中N-K+1-C個以上をi以上に置換える
for m in range(N-K+1-C, Z+1):
# print(f'i={i}, comb({Z},{m})*pow({M-i+1},{m})*pow({M},{Z-m})')
NC = (NC + comb(Z,m)*pow(M-i+1,m,MOD)*pow(i-1,Z-m,MOD)) % MOD
print((NC*NAI)%MOD)
|
ConDefects/ConDefects/Code/abc295_e/Python/42264948
|
condefects-python_data_871
|
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
mod=998244353
cnt=[0]*(m+1)
for i in a:
cnt[i]+=1
q=pow(m,-cnt[0],mod)
p=[1]
pr=[1]
for i in range(1,n+1):
p.append(p[-1]*i%mod)
pr.append(pow(p[-1],-1,mod))
now=0
ans=0
for i in range(1,m+1):
if now>=k:
break
for j in range(k-now):
ans+=p[cnt[0]]*pr[cnt[0]-j]%mod*pr[j]*pow(i-1,j,mod)%mod*pow(m-i+1,cnt[0]-j,mod)%mod
ans%=mod
now+=cnt[i]
print(ans*q%mod)
n,m,k=map(int,input().split())
a=list(map(int,input().split()))
mod=998244353
cnt=[0]*(m+1)
for i in a:
cnt[i]+=1
q=pow(m,-cnt[0],mod)
p=[1]
pr=[1]
for i in range(1,n+1):
p.append(p[-1]*i%mod)
pr.append(pow(p[-1],-1,mod))
now=0
ans=0
for i in range(1,m+1):
if now>=k:
break
for j in range(min(k-now,cnt[0]+1)):
ans+=p[cnt[0]]*pr[cnt[0]-j]%mod*pr[j]*pow(i-1,j,mod)%mod*pow(m-i+1,cnt[0]-j,mod)%mod
ans%=mod
now+=cnt[i]
print(ans*q%mod)
|
ConDefects/ConDefects/Code/abc295_e/Python/54729841
|
condefects-python_data_872
|
h,w,k=map(int,input().split())
sy,sx=map(lambda x: int(x)-1,input().split())
A=[list(map(int,input().split())) for _ in range(h)]
dp=[[0]*w for _ in range(h)]
ans=0
dp=[[[-1]*w for _ in range(h)]for _ in range(h*w+10)]
dp[0][sy][sx]=0
for t in range(min(h*w,k)+1):
for i in range(h):
for j in range(w):
ans=max(ans,A[i][j]*(k-t)+dp[t][i][j])
for dy,dx in [(0,1),(0,-1),(1,0),(-1,0)]:
ny=i+dy;nx=j+dx
if 0<=ny<h and 0<=nx<w:
dp[t+1][ny][nx]=max(dp[t+1][ny][nx],dp[t][i][j]+A[ny][nx])
print(ans)
h,w,k=map(int,input().split())
sy,sx=map(lambda x: int(x)-1,input().split())
A=[list(map(int,input().split())) for _ in range(h)]
dp=[[0]*w for _ in range(h)]
ans=0
dp=[[[-1<<60]*w for _ in range(h)]for _ in range(h*w+10)]
dp[0][sy][sx]=0
for t in range(min(h*w,k)+1):
for i in range(h):
for j in range(w):
ans=max(ans,A[i][j]*(k-t)+dp[t][i][j])
for dy,dx in [(0,1),(0,-1),(1,0),(-1,0)]:
ny=i+dy;nx=j+dx
if 0<=ny<h and 0<=nx<w:
dp[t+1][ny][nx]=max(dp[t+1][ny][nx],dp[t][i][j]+A[ny][nx])
print(ans)
|
ConDefects/ConDefects/Code/abc358_g/Python/54747596
|
condefects-python_data_873
|
H, W, K = map(int,input().split())
sh, sw = map(int,input().split())
sh, sw = sh-1, sw-1
A = []
for _ in range(H):
A.append(list(map(int,input().split())))
trial = min(H*W-1,K)
# dp[i][h][w]:i回目に(h,w)にいるときの「楽しさ」の最大
dp = [[[-1 for _ in range(W)] for _ in range(H)] for _ in range(trial+1)]
dp[0][sh][sw] = 0
mv = [(0,1),(1,0),(0,-1),(-1,0)]
def enable(h,w):
return 0 <= h < H and 0 <= w < W
for i in range(trial):
for h in range(H):
for w in range(W):
if dp[i][h][w] == -1:
continue
for dh, dw in mv:
nh, nw = h+dh, w+dw
if enable(nh,nw):
dp[i+1][nh][nw] = max(dp[i+1][nh][nw],dp[i][h][w]+A[nh][nw])
maxv = -1
for i in range(trial+1):
for h in range(H):
for w in range(W):
maxv = max(maxv,dp[i][h][w]+A[h][w]*(K-i))
print(maxv)
H, W, K = map(int,input().split())
sh, sw = map(int,input().split())
sh, sw = sh-1, sw-1
A = []
for _ in range(H):
A.append(list(map(int,input().split())))
trial = min(H*W-1,K)
# dp[i][h][w]:i回目に(h,w)にいるときの「楽しさ」の最大
dp = [[[-1 for _ in range(W)] for _ in range(H)] for _ in range(trial+1)]
dp[0][sh][sw] = 0
mv = [(0,1),(1,0),(0,-1),(-1,0)]
def enable(h,w):
return 0 <= h < H and 0 <= w < W
for i in range(trial):
for h in range(H):
for w in range(W):
if dp[i][h][w] == -1:
continue
for dh, dw in mv:
nh, nw = h+dh, w+dw
if enable(nh,nw):
dp[i+1][nh][nw] = max(dp[i+1][nh][nw],dp[i][h][w]+A[nh][nw])
maxv = -1
for i in range(trial+1):
for h in range(H):
for w in range(W):
if dp[i][h][w] == -1:
continue
maxv = max(maxv,dp[i][h][w]+A[h][w]*(K-i))
print(maxv)
|
ConDefects/ConDefects/Code/abc358_g/Python/54855434
|
condefects-python_data_874
|
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
import typing
# sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
LS = lambda: readline()
LI = lambda: int(readline())
LLS = lambda: readline().split()
LL = lambda: list(map(int, readline().split()))
h, w, k = LL()
sx, sy = LL()
sx -= 1
sy -= 1
A = [LL() for _ in range(h)]
moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]
f = [[[float("-inf")] * w for _ in range(h)] for _ in range(min(k, h * w) + 2)]
f[0][sx][sy] = 0
res = 0
for i in range(min(k, h * w) + 1):
for hh in range(h):
for ww in range(w):
res = max(res, f[i][hh][ww] + A[hh][ww] * (k - i))
for dh, dw in moves:
nh, nw = hh + dh, ww + dw
if 0 <= nh < h and 0 <= nw < w:
f[i + 1][nh][nw] = max(f[i + 1][nh][nw], f[i][hh][ww] + A[hh][ww])
print(res)
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import string
import sys
import typing
# sys.setrecursionlimit(1000000)
readline = sys.stdin.readline
LS = lambda: readline()
LI = lambda: int(readline())
LLS = lambda: readline().split()
LL = lambda: list(map(int, readline().split()))
h, w, k = LL()
sx, sy = LL()
sx -= 1
sy -= 1
A = [LL() for _ in range(h)]
moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]
f = [[[float("-inf")] * w for _ in range(h)] for _ in range(min(k, h * w) + 2)]
f[0][sx][sy] = 0
res = 0
for i in range(min(k, h * w) + 1):
for hh in range(h):
for ww in range(w):
res = max(res, f[i][hh][ww] + A[hh][ww] * (k - i))
for dh, dw in moves:
nh, nw = hh + dh, ww + dw
if 0 <= nh < h and 0 <= nw < w:
f[i + 1][nh][nw] = max(f[i + 1][nh][nw], f[i][hh][ww] + A[nh][nw])
print(res)
|
ConDefects/ConDefects/Code/abc358_g/Python/54786782
|
condefects-python_data_875
|
import sys
readline = sys.stdin.readline
LS = lambda: readline()
LI = lambda: int(readline())
LLS = lambda: readline().split()
LL = lambda: list(map(int, readline().split()))
h, w, k = LL()
sx, sy = LL()
sx -= 1
sy -= 1
A = [LL() for _ in range(h)]
moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]
INF = 10**18
f = [[[INF] * w for _ in range(h)] for _ in range(min(k, h * w) + 2)]
f[0][sx][sy] = 0
res = 0
for i in range(min(k, h * w) + 1):
for hh in range(h):
for ww in range(w):
res = max(res, f[i][hh][ww] + A[hh][ww] * (k - i))
for dh, dw in moves:
nh, nw = hh + dh, ww + dw
if 0 <= nh < h and 0 <= nw < w:
f[i + 1][nh][nw] = max(f[i + 1][nh][nw], f[i][hh][ww] + A[nh][nw])
print(res)
import sys
readline = sys.stdin.readline
LS = lambda: readline()
LI = lambda: int(readline())
LLS = lambda: readline().split()
LL = lambda: list(map(int, readline().split()))
h, w, k = LL()
sx, sy = LL()
sx -= 1
sy -= 1
A = [LL() for _ in range(h)]
moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]
INF = 10**18
f = [[[-INF] * w for _ in range(h)] for _ in range(min(k, h * w) + 2)]
f[0][sx][sy] = 0
res = 0
for i in range(min(k, h * w) + 1):
for hh in range(h):
for ww in range(w):
res = max(res, f[i][hh][ww] + A[hh][ww] * (k - i))
for dh, dw in moves:
nh, nw = hh + dh, ww + dw
if 0 <= nh < h and 0 <= nw < w:
f[i + 1][nh][nw] = max(f[i + 1][nh][nw], f[i][hh][ww] + A[nh][nw])
print(res)
|
ConDefects/ConDefects/Code/abc358_g/Python/54786893
|
condefects-python_data_876
|
from random import randint, shuffle
from math import gcd, log2, log, sqrt, hypot, pi, degrees
from fractions import Fraction
from bisect import bisect_left, bisect_right
from itertools import accumulate, permutations, combinations, product, chain, groupby
from sortedcontainers import SortedList
from collections import Counter, deque, defaultdict as ddict
from heapq import heappush as push, heappop as pop
from functools import reduce, lru_cache
import sys
input = sys.stdin.readline
inf = 10**18
def read(dtype=int):
return list(map(dtype, input().split()))
h, w, K = read()
si, sj = read()
si -= 1
sj -= 1
a = [read() for _ in range(h)]
def valid(i, j):
return 0 <= i < h and 0 <= j < w
dx = [1, -1, 0, 0, 0]
dy = [0, 0, 1, -1, 0]
ans = 0
dp = [[-inf] * w for _ in range(h)]
c = min(h+w, K)
dp[si][sj] = 0
ans = a[si][sj] * K
for i in range(1, c+1):
ndp = [[-inf] * w for _ in range(h)]
for x in range(h):
for y in range(w):
if dp[x][y] == -inf:
continue
for k in range(5):
u = x + dx[k]
v = y + dy[k]
if valid(u, v):
ndp[u][v] = max(ndp[u][v], dp[x][y] + a[u][v])
dp = ndp
for x in range(h):
for y in range(w):
if dp[x][y] != -inf:
ans = max(ans, dp[x][y] + (K-i) * a[x][y])
print(ans)
from random import randint, shuffle
from math import gcd, log2, log, sqrt, hypot, pi, degrees
from fractions import Fraction
from bisect import bisect_left, bisect_right
from itertools import accumulate, permutations, combinations, product, chain, groupby
from sortedcontainers import SortedList
from collections import Counter, deque, defaultdict as ddict
from heapq import heappush as push, heappop as pop
from functools import reduce, lru_cache
import sys
input = sys.stdin.readline
inf = 10**18
def read(dtype=int):
return list(map(dtype, input().split()))
h, w, K = read()
si, sj = read()
si -= 1
sj -= 1
a = [read() for _ in range(h)]
def valid(i, j):
return 0 <= i < h and 0 <= j < w
dx = [1, -1, 0, 0, 0]
dy = [0, 0, 1, -1, 0]
ans = 0
dp = [[-inf] * w for _ in range(h)]
c = min(h*w, K)
dp[si][sj] = 0
ans = a[si][sj] * K
for i in range(1, c+1):
ndp = [[-inf] * w for _ in range(h)]
for x in range(h):
for y in range(w):
if dp[x][y] == -inf:
continue
for k in range(5):
u = x + dx[k]
v = y + dy[k]
if valid(u, v):
ndp[u][v] = max(ndp[u][v], dp[x][y] + a[u][v])
dp = ndp
for x in range(h):
for y in range(w):
if dp[x][y] != -inf:
ans = max(ans, dp[x][y] + (K-i) * a[x][y])
print(ans)
|
ConDefects/ConDefects/Code/abc358_g/Python/54886527
|
condefects-python_data_877
|
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
from random import random, randint
def main():
n = int(input())
a = [list(map(int,input().split())) for _ in range(n)]
fixed = [[a[i][j] != 0 for j in range(n)] for i in range(n)]
minAns = float("inf")
p2 = []
for _ in range(700):
ans = 0
for i in range(n):
for j in range(n):
if fixed[i][j] == 0:
a[i][j] = randint(1, 5)
for t in range(80):
for i in range(n):
for j in range(n):
cnt = 0
p = 0
if fixed[i][j]:
continue
if i > 0:
cnt += 1
p += a[i - 1][j]
if j > 0:
cnt += 1
p += a[i][j - 1]
if i < n - 1:
cnt += 1
p += a[i + 1][j]
if j < n - 1:
cnt += 1
p += a[i][j + 1]
if cnt != 0:
if random() < 0.5:
a[i][j] = round((p - 0.000001) / cnt)
else:
a[i][j] = round((p + 0.000001) / cnt)
for i in range(n):
for j in range(n - 1):
ans += (a[i][j] - a[i][j + 1]) ** 2
for i in range(n - 1):
for j in range(n):
ans += (a[i + 1][j] - a[i][j]) ** 2
if ans < minAns:
minAns = ans
p2 = []
for i in range(n):
p2.append(tuple(a[i]))
for i in range(n):
print(" ".join(map(str, p2[i])))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._file = 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")
# endregion
if __name__ == "__main__":
main()
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
from random import random, randint
def main():
n = int(input())
a = [list(map(int,input().split())) for _ in range(n)]
fixed = [[a[i][j] != 0 for j in range(n)] for i in range(n)]
minAns = float("inf")
p2 = []
for _ in range(700):
ans = 0
for i in range(n):
for j in range(n):
if fixed[i][j] == 0:
a[i][j] += randint(1, 3) - 2
for t in range(80):
for i in range(n):
for j in range(n):
cnt = 0
p = 0
if fixed[i][j]:
continue
if i > 0:
cnt += 1
p += a[i - 1][j]
if j > 0:
cnt += 1
p += a[i][j - 1]
if i < n - 1:
cnt += 1
p += a[i + 1][j]
if j < n - 1:
cnt += 1
p += a[i][j + 1]
if cnt != 0:
if random() < 0.5:
a[i][j] = round((p - 0.000001) / cnt)
else:
a[i][j] = round((p + 0.000001) / cnt)
for i in range(n):
for j in range(n - 1):
ans += (a[i][j] - a[i][j + 1]) ** 2
for i in range(n - 1):
for j in range(n):
ans += (a[i + 1][j] - a[i][j]) ** 2
if ans < minAns:
minAns = ans
p2 = []
for i in range(n):
p2.append(tuple(a[i]))
for i in range(n):
print(" ".join(map(str, p2[i])))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._file = 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")
# endregion
if __name__ == "__main__":
main()
|
ConDefects/ConDefects/Code/abc347_g/Python/51866544
|
condefects-python_data_878
|
def calc_area(y, x):
ret = score[N][N] * (x//N) * (y//N)
ret += score[N][x%N] * (y//N)
ret += score[y%N][N] * (x//N)
ret += score[y%N][x%N]
return ret
N, Q = map(int, input().split())
P = [list(input()) for i in range(N)]
score = [[0] * (N+1) for i in range(N+1)]
ABCD = [list(map(int, input().split())) for i in range(Q)]
for i in range(1, N+1):
for j in range(1, N+1):
if P[i-1][j-1] == "B":
score[i][j] = 1
for i in range(N+1):
for j in range(1, N+1):
score[i][j] += score[i][j-1]
for j in range(N+1):
for i in range(1, N+1):
score[i][j] += score[i-1][j]
for i in score:
print(*i)
for a, b, c, d in ABCD:
c += 1
d += 1
print(calc_area(c, d) -calc_area(a, d) -calc_area(c, b) + calc_area(a, b))
def calc_area(y, x):
ret = score[N][N] * (x//N) * (y//N)
ret += score[N][x%N] * (y//N)
ret += score[y%N][N] * (x//N)
ret += score[y%N][x%N]
return ret
N, Q = map(int, input().split())
P = [list(input()) for i in range(N)]
score = [[0] * (N+1) for i in range(N+1)]
ABCD = [list(map(int, input().split())) for i in range(Q)]
for i in range(1, N+1):
for j in range(1, N+1):
if P[i-1][j-1] == "B":
score[i][j] = 1
for i in range(N+1):
for j in range(1, N+1):
score[i][j] += score[i][j-1]
for j in range(N+1):
for i in range(1, N+1):
score[i][j] += score[i-1][j]
for a, b, c, d in ABCD:
c += 1
d += 1
print(calc_area(c, d) -calc_area(a, d) -calc_area(c, b) + calc_area(a, b))
|
ConDefects/ConDefects/Code/abc331_d/Python/53655797
|
condefects-python_data_879
|
#!/usr/bin/env python3
#import sys
#sys.setrecursionlimit(10**8)
#import math
#from itertools import product,permutations,combinations,combinations_with_replacement
#from sortedcontainers import SortedDict,SortedSet,SortedKeyList
#from collections import deque
#from heapq import heapify,heappop,heappush
#from bisect import bisect,bisect_left
#from atcoder.dsu import DSU as UFT
#from atcoder.fenwicktree import FenwickTree as FT
#from atcoder.math import floor_sum
#from atcoder.maxflow import MFGraph
#from atcoder.mincostflow import MCFGraph
#from atcoder.convolution import convolution
#from atcoder.scc import SCCGraph
#from atcoder.twosat import TwoSAT
#from atcoder.string import suffix_array, lcp_array
#from atcoder.segtree import SegTree
#from atcoder.lazysegtree import LazySegTree
def main():
n,q = map(int,input().split())
grid = list(input() for _ in range(n))
cnt = [[0]*n for _ in range(n)]
if grid[0][0] == 'B':
cnt[0][0] = 1
for i in range(1,n):
if grid[i][0] == 'B':
cnt[i][0] = cnt[i-1][0]+1
else:
cnt[i][0] = cnt[i-1][0]
for j in range(1,n):
if grid[0][j] == 'B':
cnt[0][j] = cnt[0][j-1]+1
else:
cnt[0][j] = cnt[0][j-1]
for i in range(1,n):
for j in range(1,n):
if grid[i][j] == 'B':
cnt[i][j] = cnt[i-1][j]+cnt[i][j-1]-cnt[i-1][j-1]+1
else:
cnt[i][j] = cnt[i-1][j]+cnt[i][j-1]-cnt[i-1][j-1]
def calc(a,b,c,d):
res = cnt[c][d]
if a == b == 0:
pass
elif a == 0:
res -= cnt[c][b-1]
elif b == 0:
res -= cnt[a-1][d]
else:
res -= cnt[c][b-1]
res -= cnt[a-1][d]
res += cnt[a-1][b-1]
return res
for _ in range(q):
a,b,c,d = map(int,input().split())
ans = 0
ma,mb,mc,md = a//n, b//n, c//n, d//n
ra,rb,rc,rd = a%n, b%n, c%n, d%n
if ma == mc and mb == md:
ans += calc(ra,rb,rc,rd)
elif ma == mc:
ans += calc(ra,rb,rc,n-1)+calc(ra,0,ra,rd)
ans += (md-mb-1)*calc(ra,0,rc,n-1)
elif mb == md:
ans += calc(ra,rb,n-1,rd)+calc(0,rb,rc,rd)
ans += (mc-ma-1)*calc(0,rb,n-1,rd)
else:
ans += calc(ra,rb,n-1,n-1)
ans += calc(ra,0,n-1,rd)
ans += calc(0,rb,rc,n-1)
ans += calc(0,0,rc,rd)
ans += (mc-ma-1)*(calc(0,rb,n-1,n-1)+calc(0,0,n-1,rd))
ans += (md-mb-1)*(calc(ra,0,n-1,n-1)+calc(0,0,rc,n-1))
ans += (mc-ma-1)*(md-mb-1)*calc(0,0,n-1,n-1)
print(ans)
if __name__ == '__main__':
main()
#!/usr/bin/env python3
#import sys
#sys.setrecursionlimit(10**8)
#import math
#from itertools import product,permutations,combinations,combinations_with_replacement
#from sortedcontainers import SortedDict,SortedSet,SortedKeyList
#from collections import deque
#from heapq import heapify,heappop,heappush
#from bisect import bisect,bisect_left
#from atcoder.dsu import DSU as UFT
#from atcoder.fenwicktree import FenwickTree as FT
#from atcoder.math import floor_sum
#from atcoder.maxflow import MFGraph
#from atcoder.mincostflow import MCFGraph
#from atcoder.convolution import convolution
#from atcoder.scc import SCCGraph
#from atcoder.twosat import TwoSAT
#from atcoder.string import suffix_array, lcp_array
#from atcoder.segtree import SegTree
#from atcoder.lazysegtree import LazySegTree
def main():
n,q = map(int,input().split())
grid = list(input() for _ in range(n))
cnt = [[0]*n for _ in range(n)]
if grid[0][0] == 'B':
cnt[0][0] = 1
for i in range(1,n):
if grid[i][0] == 'B':
cnt[i][0] = cnt[i-1][0]+1
else:
cnt[i][0] = cnt[i-1][0]
for j in range(1,n):
if grid[0][j] == 'B':
cnt[0][j] = cnt[0][j-1]+1
else:
cnt[0][j] = cnt[0][j-1]
for i in range(1,n):
for j in range(1,n):
if grid[i][j] == 'B':
cnt[i][j] = cnt[i-1][j]+cnt[i][j-1]-cnt[i-1][j-1]+1
else:
cnt[i][j] = cnt[i-1][j]+cnt[i][j-1]-cnt[i-1][j-1]
def calc(a,b,c,d):
res = cnt[c][d]
if a == b == 0:
pass
elif a == 0:
res -= cnt[c][b-1]
elif b == 0:
res -= cnt[a-1][d]
else:
res -= cnt[c][b-1]
res -= cnt[a-1][d]
res += cnt[a-1][b-1]
return res
for _ in range(q):
a,b,c,d = map(int,input().split())
ans = 0
ma,mb,mc,md = a//n, b//n, c//n, d//n
ra,rb,rc,rd = a%n, b%n, c%n, d%n
if ma == mc and mb == md:
ans += calc(ra,rb,rc,rd)
elif ma == mc:
ans += calc(ra,rb,rc,n-1)+calc(ra,0,rc,rd)
ans += (md-mb-1)*calc(ra,0,rc,n-1)
elif mb == md:
ans += calc(ra,rb,n-1,rd)+calc(0,rb,rc,rd)
ans += (mc-ma-1)*calc(0,rb,n-1,rd)
else:
ans += calc(ra,rb,n-1,n-1)
ans += calc(ra,0,n-1,rd)
ans += calc(0,rb,rc,n-1)
ans += calc(0,0,rc,rd)
ans += (mc-ma-1)*(calc(0,rb,n-1,n-1)+calc(0,0,n-1,rd))
ans += (md-mb-1)*(calc(ra,0,n-1,n-1)+calc(0,0,rc,n-1))
ans += (mc-ma-1)*(md-mb-1)*calc(0,0,n-1,n-1)
print(ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/abc331_d/Python/53468592
|
condefects-python_data_880
|
import sys
from collections import deque, defaultdict
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
import math
from bisect import bisect_left, insort_left, bisect_right, insort_right
# product : bit全探索 product(range(2),repeat=n)
# permutations : 順列全探索
# combinations : 組み合わせ（重複無し）
# combinations_with_replacement : 組み合わせ（重複可）
# from sortedcontainers import SortedSet, SortedList, SortedDict
sys.setrecursionlimit(10**7)
around4 = ((0, -1), (0, 1), (-1, 0), (1, 0))
around8 = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1))
inf = float("inf")
deq = deque()
dd = defaultdict()
II = lambda: int(input())
MII = lambda: map(int, input().split())
LMII = lambda: list(map(int, input().split()))
Ary2 = lambda w, h, element: [[element] * w for _ in range(h)]
is_not_Index_Er = lambda x, y, h, w: 0 <= x < h and 0 <= y < w # 範囲外参照
n, q = MII()
P = [input() for _ in range(n)]
Q = [LMII() for _ in range(q)]
acc = [[0] * n for i in range(n)]
temp = 0
for i in range(n):
yoko = 0
for j in range(n):
if P[i][j] == "B":
yoko += 1
acc[i][j] = yoko
for j in range(n):
for i in range(1, n):
acc[i][j] += acc[i - 1][j]
def f(a, b):
if a < 0 or b < 0:
return 0
h, h_amari = (a + 1) // n, a % n
w, w_amari = (b + 1) // n, b % n
if a < n and b < n:
return acc[a][b]
result = 0
if h > 0 and w > 0:
result += h * w * acc[n - 1][n - 1]
if w_amari != n - 1 and h > 0:
result += f(n - 1, w_amari) * h
if h_amari != n - 1 and w > 0:
result += f(h_amari, n - 1) * w
if h_amari != n - 1 or w_amari != n - 1:
result += f(h_amari, w_amari)
# print(a, b, result)
return result
for a, b, c, d in Q:
print(f(c, d) + f(a - 1, b - 1) - f(c, b - 1) - f(a - 1, d))
# def f(a, b, c, d):
# if a < 0 or b < 0 or c < 0 or d < 0 or a > c or b > d:
# return 0
# if c < n and d < n:
# if a == b == 0:
# return acc[c][d]
# else:
# result = (
# acc[c][d]
# - f(0, 0, c, b - 1)
# - f(0, 0, a - 1, d)
# + f(0, 0, a - 1, b - 1)
# )
# return result
# else:
# h, w = ((c + 1) // n + (-a // n), (d + 1) // n + (-b // n))
# result = 0
# if h > 0 and w > 0:
# result = h * w * acc[n - 1][n - 1]
# if b % n != 0 and h > 0 and b % n < d % n:
# result += f(0, b % n, n - 1, n - 1) * h
# if d % n != n - 1 and h > 0 and b % n < d % n:
# result += f(0, 0, n - 1, d % n) * h
# if a % n != 0 and w > 0 and a % n < c % n:
# result += f(a % n, 0, n - 1, n - 1) * w
# if c % n != n - 1 and w > 0 and a % n < c % n:
# result += f(0, 0, c % n, n - 1) * w
# if a // n < c // n:
# if b // n < d // n:
# if a % n != 0 and b % n != 0:
# result += f(a % n, b % n, n - 1, n - 1)
# if c % n != n - 1 and d % n != n - 1:
# result += f(0, 0, c % n, d % n)
# if a % n != 0 and d % n != n - 1:
# result += f(a % n, 0, n - 1, d % n)
# if b % n != 0 and c % n != n - 1:
# result += f(0, b % n, c % n, n - 1)
# else:
# if a % n != 0 and b % n != 0 and a % n != 0 and d % n != n - 1:
# result += f(a % n, b % n, n - 1, d % n)
# if c % n != n - 1 and d % n != n - 1 and b % n != 0 and c % n != n - 1:
# result += f(0, b % n, c % n, d % n)
# else:
# if b // n < d // n:
# if a % n != 0 and b % n != 0 and b % n != 0 and c % n != n - 1:
# result += f(a % n, b % n, c % n, n - 1)
# if c % n != n - 1 and d % n != n - 1 and a % n != 0 and d % n != n - 1:
# result += f(a % n, 0, c % n, d % n)
# else:
# result += f(a % n, b % n, c % n, d % n)
# return result
# for a, b, c, d in Q:
# print(f(a, b, c, d))
import sys
from collections import deque, defaultdict
from itertools import (
accumulate,
product,
permutations,
combinations,
combinations_with_replacement,
)
import math
from bisect import bisect_left, insort_left, bisect_right, insort_right
# product : bit全探索 product(range(2),repeat=n)
# permutations : 順列全探索
# combinations : 組み合わせ（重複無し）
# combinations_with_replacement : 組み合わせ（重複可）
# from sortedcontainers import SortedSet, SortedList, SortedDict
sys.setrecursionlimit(10**7)
around4 = ((0, -1), (0, 1), (-1, 0), (1, 0))
around8 = ((-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1))
inf = float("inf")
deq = deque()
dd = defaultdict()
II = lambda: int(input())
MII = lambda: map(int, input().split())
LMII = lambda: list(map(int, input().split()))
Ary2 = lambda w, h, element: [[element] * w for _ in range(h)]
is_not_Index_Er = lambda x, y, h, w: 0 <= x < h and 0 <= y < w # 範囲外参照
n, q = MII()
P = [input() for _ in range(n)]
Q = [LMII() for _ in range(q)]
acc = [[0] * n for i in range(n)]
temp = 0
for i in range(n):
yoko = 0
for j in range(n):
if P[i][j] == "B":
yoko += 1
acc[i][j] = yoko
for j in range(n):
for i in range(1, n):
acc[i][j] += acc[i - 1][j]
def f(a, b):
if a < 0 or b < 0:
return 0
h, h_amari = (a + 1) // n, a % n
w, w_amari = (b + 1) // n, b % n
if a < n and b < n:
return acc[a][b]
result = 0
if h > 0 and w > 0:
result += h * w * acc[n - 1][n - 1]
if w_amari != n - 1 and h > 0:
result += f(n - 1, w_amari) * h
if h_amari != n - 1 and w > 0:
result += f(h_amari, n - 1) * w
if h_amari != n - 1 and w_amari != n - 1:
result += f(h_amari, w_amari)
# print(a, b, result)
return result
for a, b, c, d in Q:
print(f(c, d) + f(a - 1, b - 1) - f(c, b - 1) - f(a - 1, d))
# def f(a, b, c, d):
# if a < 0 or b < 0 or c < 0 or d < 0 or a > c or b > d:
# return 0
# if c < n and d < n:
# if a == b == 0:
# return acc[c][d]
# else:
# result = (
# acc[c][d]
# - f(0, 0, c, b - 1)
# - f(0, 0, a - 1, d)
# + f(0, 0, a - 1, b - 1)
# )
# return result
# else:
# h, w = ((c + 1) // n + (-a // n), (d + 1) // n + (-b // n))
# result = 0
# if h > 0 and w > 0:
# result = h * w * acc[n - 1][n - 1]
# if b % n != 0 and h > 0 and b % n < d % n:
# result += f(0, b % n, n - 1, n - 1) * h
# if d % n != n - 1 and h > 0 and b % n < d % n:
# result += f(0, 0, n - 1, d % n) * h
# if a % n != 0 and w > 0 and a % n < c % n:
# result += f(a % n, 0, n - 1, n - 1) * w
# if c % n != n - 1 and w > 0 and a % n < c % n:
# result += f(0, 0, c % n, n - 1) * w
# if a // n < c // n:
# if b // n < d // n:
# if a % n != 0 and b % n != 0:
# result += f(a % n, b % n, n - 1, n - 1)
# if c % n != n - 1 and d % n != n - 1:
# result += f(0, 0, c % n, d % n)
# if a % n != 0 and d % n != n - 1:
# result += f(a % n, 0, n - 1, d % n)
# if b % n != 0 and c % n != n - 1:
# result += f(0, b % n, c % n, n - 1)
# else:
# if a % n != 0 and b % n != 0 and a % n != 0 and d % n != n - 1:
# result += f(a % n, b % n, n - 1, d % n)
# if c % n != n - 1 and d % n != n - 1 and b % n != 0 and c % n != n - 1:
# result += f(0, b % n, c % n, d % n)
# else:
# if b // n < d // n:
# if a % n != 0 and b % n != 0 and b % n != 0 and c % n != n - 1:
# result += f(a % n, b % n, c % n, n - 1)
# if c % n != n - 1 and d % n != n - 1 and a % n != 0 and d % n != n - 1:
# result += f(a % n, 0, c % n, d % n)
# else:
# result += f(a % n, b % n, c % n, d % n)
# return result
# for a, b, c, d in Q:
# print(f(a, b, c, d))
|
ConDefects/ConDefects/Code/abc331_d/Python/52719206
|
condefects-python_data_881
|
n,m=map(int,input().split())
S=[]
for i in range(2,2*n+1,2):
s,tmp=0,1
for j in range(15):
if i>>j&1:
s+=tmp
tmp*=3
S.append(s)
x=(m-sum(S))%n
for i in range(x):
S[i]+=1
diff=(sum(S)-m)
print(*[s-diff for s in S])
n,m=map(int,input().split())
S=[]
for i in range(2,2*n+1,2):
s,tmp=0,1
for j in range(15):
if i>>j&1:
s+=tmp
tmp*=3
S.append(s)
x=(m-sum(S))%n
for i in range(x):
S[i]+=1
diff=(sum(S)-m)
print(*[s-diff//n for s in S])
|
ConDefects/ConDefects/Code/arc145_d/Python/39783538
|
condefects-python_data_882
|
from random import randrange
N, M = map(int, input().split())
S = [0]
for k in range(15):
for a in S[:]:
S.append(a + 3 ** k)
T = S[:N]
s = sum(T)
while (s - M) % N:
j = randrange(N)
s += S[-1] - T[j]
T[j] = S.pop()
print(*[a - (s - M) // N for a in T])
from random import randrange
N, M = map(int, input().split())
S = [0]
for k in range(15):
for a in S[:]:
S.append(a + 3 ** k)
S, T = S[N:][::-1], S[:N]
s = sum(T)
while (s - M) % N:
j = randrange(N)
s += S[-1] - T[j]
T[j] = S.pop()
print(*[a - (s - M) // N for a in T])
|
ConDefects/ConDefects/Code/arc145_d/Python/33637469
|
condefects-python_data_883
|
from functools import lru_cache
@lru_cache(maxsize=None)
def a(x):
if x==0:return 1
if x&1:return 3*a(x//2)-1
return 3*a(x//2)-2
n,m=map(int,input().split())
if n==1:
print(m)
exit(0)
ANS=[a(x) for x in range(n-1)]
s=sum(ANS)
# print(ANS,s)
target=abs(m)+2*10**6
plus=(target-s)//(n-1)+1
ANS=[num+plus for num in ANS]
s=sum(ANS)
# print(ANS,s)
ANS.append(abs(m)-s)
# print(ANS,sum(ANS))
if m<0:
ANS=[-num for num in ANS]
print(*ANS)
# print(sum(ANS))
from functools import lru_cache
@lru_cache(maxsize=None)
def a(x):
if x==0:return 1
if x&1:return 3*a(x//2)-1
return 3*a(x//2)-2
n,m=map(int,input().split())
if n==1:
print(m)
exit(0)
ANS=[a(x) for x in range(n-1)]
s=sum(ANS)
# print(ANS,s)
target=abs(m)+5*10**6
plus=(target-s)//(n-1)+1
ANS=[num+plus for num in ANS]
s=sum(ANS)
# print(ANS,s)
ANS.append(abs(m)-s)
# print(ANS,sum(ANS))
if m<0:
ANS=[-num for num in ANS]
print(*ANS)
# print(sum(ANS))
|
ConDefects/ConDefects/Code/arc145_d/Python/34667900
|
condefects-python_data_884
|
N, M = map(int, input().split())
ans = []
SUM = 0
count = 0
for i in range(10**7)[::-1]:
OK = True
cur = i
while cur > 0:
if cur % 3 == 2:
OK = False
break
else:
cur //= 3
if OK:
ans.append(i)
SUM += i
count += 1
if count == N-2:
break
to_increase = (M-SUM)%N
cur = to_increase
append1 = 0
append2 = 0
while cur > 0:
i = 0
if cur % 3 >= 1:
append1 += 3**i
if cur % 3 >= 2:
append2 += 3**i
cur //= 3
i += 1
while append1 == append2:
to_increase += N
cur = to_increase
append1 = 0
append2 = 0
i = 0
while cur > 0:
if cur % 3 >= 1:
append1 += 3**i
if cur % 3 >= 2:
append2 += 3**i
cur //= 3
i += 1
SUM += to_increase
diff = (M-SUM)//N
ans.append(append1)
ans.append(append2)
for i in range(N):
ans[i] += diff
print(*ans)
N, M = map(int, input().split())
ans = []
SUM = 0
count = 0
for i in range(10**7)[::-1]:
OK = True
cur = i
while cur > 0:
if cur % 3 == 2:
OK = False
break
else:
cur //= 3
if OK:
ans.append(i)
SUM += i
count += 1
if count == N-2:
break
to_increase = (M-SUM)%N
cur = to_increase
append1 = 0
append2 = 0
i = 0
while cur > 0:
if cur % 3 >= 1:
append1 += 3**i
if cur % 3 >= 2:
append2 += 3**i
cur //= 3
i += 1
while append1 == append2:
to_increase += N
cur = to_increase
append1 = 0
append2 = 0
i = 0
while cur > 0:
if cur % 3 >= 1:
append1 += 3**i
if cur % 3 >= 2:
append2 += 3**i
cur //= 3
i += 1
SUM += to_increase
diff = (M-SUM)//N
ans.append(append1)
ans.append(append2)
for i in range(N):
ans[i] += diff
print(*ans)
|
ConDefects/ConDefects/Code/arc145_d/Python/33635092
|
condefects-python_data_885
|
import sys
#input = sys.stdin.readline
#input = sys.stdin.buffer.readline #文字列はダメ
#sys.setrecursionlimit(1000000)
import math
#import bisect
#import itertools
#import random
#from heapq import heapify, heappop, heappush
#from collections import defaultdict
#from collections import deque
#import copy #DeepCopy: hoge = [_[:] for _ in hogehoge]
#from functools import lru_cache
#@lru_cache(maxsize=None)
#MOD = pow(10,9) + 7
MOD = 998244353
#dx = [1,0,-1,0]
#dy = [0,1,0,-1]
#dx8 = [1,1,0,-1,-1,-1,0,1]
#dy8 = [0,1,1,1,0,-1,-1,-1]
def two_three(x):
L = []
while x > 0:
L.append(x%3)
x //= 3
L = set(L)
if 2 in L:
return False
else:
return True
def main():
N,M = map(int,input().split()); MAX = pow(10,7)
num = 0
val = 1
total = 0
ans = []
while num < N:
if two_three(val):
ans.append(val*3)
total += val*3 #ここで3倍しておくことで3進数としたときの1桁目を常に0として後で調整可能とする。
num += 1
val += 1
# print(ans)
idx = 0
while total%N != 0:
ans[idx] += 1
idx += 1
total += 1
# print(ans)
dif = (total - M)//N
ans = [v - dif for v in ans]
print(*ans)
if __name__ == '__main__':
main()
import sys
#input = sys.stdin.readline
#input = sys.stdin.buffer.readline #文字列はダメ
#sys.setrecursionlimit(1000000)
import math
#import bisect
#import itertools
#import random
#from heapq import heapify, heappop, heappush
#from collections import defaultdict
#from collections import deque
#import copy #DeepCopy: hoge = [_[:] for _ in hogehoge]
#from functools import lru_cache
#@lru_cache(maxsize=None)
#MOD = pow(10,9) + 7
MOD = 998244353
#dx = [1,0,-1,0]
#dy = [0,1,0,-1]
#dx8 = [1,1,0,-1,-1,-1,0,1]
#dy8 = [0,1,1,1,0,-1,-1,-1]
def two_three(x):
L = []
while x > 0:
L.append(x%3)
x //= 3
L = set(L)
if 2 in L:
return False
else:
return True
def main():
N,M = map(int,input().split()); MAX = pow(10,7)
num = 0
val = 1
total = 0
ans = []
while num < N:
if two_three(val):
ans.append(val*3)
total += val*3 #ここで3倍しておくことで3進数としたときの1桁目を常に0として後で調整可能とする。
num += 1
val += 1
# print(ans)
idx = 0
while (total-M)%N != 0:
ans[idx] += 1
idx += 1
total += 1
# print(ans)
dif = (total - M)//N
ans = [v - dif for v in ans]
print(*ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc145_d/Python/34720181
|
condefects-python_data_886
|
def main():
import sys, operator, math
if sys.implementation.name == 'pypy':
import pypyjit
pypyjit.set_param('max_unroll_recursion=1')
from math import gcd, floor, ceil, sqrt, isclose, pi, sin, cos, tan, asin, acos, atan, atan2, hypot, degrees, radians, log, log2, log10
from array import array
from collections import deque, Counter as counter, defaultdict as ddict
from bisect import bisect_left, bisect_right
from heapq import heappush, heappop, heapify, heappushpop, heapreplace as heappoppush, nlargest, nsmallest
from functools import lru_cache, reduce
from itertools import count, cycle, accumulate, chain, groupby, islice, product, permutations, combinations, combinations_with_replacement
inf = 3074457345618258602
sys.setrecursionlimit(2147483647)
readline = sys.stdin.buffer.readline
cache = lru_cache(None)
def input(): return readline().rstrip().decode()
def S(): return readline().rstrip().decode()
def Ss(): return readline().rstrip().decode().split(' ')
def I(): return int(readline())
def I1(): return int(readline()) - 1
def Is(): return [int(i) for i in readline().rstrip().split(b' ')]
def I1s(): return [int(i) - 1 for i in readline().rstrip().split(b' ')]
def F(): return float(readline())
def Fs(): return [float(i) for i in readline().rstrip().split(b' ')]
n, m = Is()
if n == 1:
exit(print(m))
if n == 2:
x = m // 2
exit(print(x - 1, (m - x) + 1))
x = []
for i in range(n):
res = 0
p = 1
while i:
res += p * (i & 1)
p *= 3
i >>= 1
x.append(res)
s = m - sum(x)
z = 10000000 - x[-1]
e = (s - z) // (n - 1)
for i in range(n - 1):
x[i] += e
x[-1] += s - e * (n - 1)
print(*x)
main()
def main():
import sys, operator, math
if sys.implementation.name == 'pypy':
import pypyjit
pypyjit.set_param('max_unroll_recursion=1')
from math import gcd, floor, ceil, sqrt, isclose, pi, sin, cos, tan, asin, acos, atan, atan2, hypot, degrees, radians, log, log2, log10
from array import array
from collections import deque, Counter as counter, defaultdict as ddict
from bisect import bisect_left, bisect_right
from heapq import heappush, heappop, heapify, heappushpop, heapreplace as heappoppush, nlargest, nsmallest
from functools import lru_cache, reduce
from itertools import count, cycle, accumulate, chain, groupby, islice, product, permutations, combinations, combinations_with_replacement
inf = 3074457345618258602
sys.setrecursionlimit(2147483647)
readline = sys.stdin.buffer.readline
cache = lru_cache(None)
def input(): return readline().rstrip().decode()
def S(): return readline().rstrip().decode()
def Ss(): return readline().rstrip().decode().split(' ')
def I(): return int(readline())
def I1(): return int(readline()) - 1
def Is(): return [int(i) for i in readline().rstrip().split(b' ')]
def I1s(): return [int(i) - 1 for i in readline().rstrip().split(b' ')]
def F(): return float(readline())
def Fs(): return [float(i) for i in readline().rstrip().split(b' ')]
n, m = Is()
if n == 1:
exit(print(m))
if n == 2:
x = m // 2
exit(print(x - 1, (m - x) + 1))
x = []
for i in range(n):
res = 0
p = 1
while i:
res += p * (i & 1)
p *= 3
i >>= 1
x.append(res)
s = m - sum(x)
z = 10000000 - x[-1]
e = (s - z + n - 2) // (n - 1)
for i in range(n - 1):
x[i] += e
x[-1] += s - e * (n - 1)
print(*x)
main()
|
ConDefects/ConDefects/Code/arc145_d/Python/33636883
|
condefects-python_data_887
|
n, m = map(int, input().split())
d = [1]
while len(d) < n:
d = d + [sum(d)] + d
d = d[:n - 1]
d += [sum(d) + 1]
for i in range(1, n):
d[i] += d[i - 1]
sub = (sum(d) - m) // n + 1
for i in range(n):
d[i] -= sub
d[-1] -= sum(d) - m
print(*d)
n, m = map(int, input().split())
d = [1]
while len(d) < n:
d = d + [sum(d) + 1] + d
d = d[:n - 1]
d += [sum(d) + 1]
for i in range(1, n):
d[i] += d[i - 1]
sub = (sum(d) - m) // n + 1
for i in range(n):
d[i] -= sub
d[-1] -= sum(d) - m
print(*d)
|
ConDefects/ConDefects/Code/arc145_d/Python/35361966
|
condefects-python_data_888
|
import collections,sys,math,functools,operator,itertools,bisect,heapq,decimal,string,time,random
#sys.setrecursionlimit(10**9)
#n = int(input())
#alist = list(map(int,input().split()))
#alist = []
#s = input()
n,m,q = map(int,input().split())
#for i in range(n):
# alist.append(list(map(int,input().split())))
query = []
class cheapSegTree:
def __init__(self,n,segfunc,e):
self.segfunc=segfunc
self.num = 1<<(n-1).bit_length()
self.lazy = [e]*2*self.num
self.e = e
def update(self,l,r,x):
l+=self.num
r+=self.num
while l<r:
if l&1:
self.lazy[l]=self.segfunc(self.lazy[l],x)
l+=1
if r&1:
self.lazy[r-1]=self.segfunc(self.lazy[r-1],x)
l>>=1
r>>=1
def get(self,i):
res=self.e
i+=self.num
while i:
res=self.segfunc(res,self.lazy[i])
i>>=1
return res
cst = cheapSegTree(m,operator.add,0)
okikae = [[] for i in range(n)]
nibannme = []
a = collections.defaultdict(int)
for i in range(q):
alist = list(map(int,input().split()))
query.append(alist)
if alist[0] == 1:
l,r,x = alist[1],alist[2],alist[3]
l-=1
r-=1
cst.update(l,r+1,x)
if alist[0] == 2:
ii,x = alist[1],alist[2]
ii-=1
okikae[ii].append((i,x))
elif alist[0] == 3:
ii,jj = alist[1],alist[2]
if okikae[ii-1]:
nibannme.append((okikae[ii-1][-1][0],i,jj-1))
else:
a[i] = 0
nibannme.reverse()
cst = cheapSegTree(m,operator.add,0)
for i in range(q):
alist = query[i][:]
if alist[0] == 1:
l,r,x = alist[1],alist[2],alist[3]
l-=1
r-=1
cst.update(l,r+1,x)
if alist[0] == 2:
while nibannme and nibannme[-1][0] == i:
a[nibannme[-1][1]] = alist[2]-cst.get(nibannme[-1][2])
nibannme.pop()
if alist[0] == 3:
print(a[i]+cst.get(alist[2]-1))
import collections,sys,math,functools,operator,itertools,bisect,heapq,decimal,string,time,random
#sys.setrecursionlimit(10**9)
#n = int(input())
#alist = list(map(int,input().split()))
#alist = []
#s = input()
n,m,q = map(int,input().split())
#for i in range(n):
# alist.append(list(map(int,input().split())))
query = []
class cheapSegTree:
def __init__(self,n,segfunc,e):
self.segfunc=segfunc
self.num = 1<<(n-1).bit_length()
self.lazy = [e]*2*self.num
self.e = e
def update(self,l,r,x):
l+=self.num
r+=self.num
while l<r:
if l&1:
self.lazy[l]=self.segfunc(self.lazy[l],x)
l+=1
if r&1:
self.lazy[r-1]=self.segfunc(self.lazy[r-1],x)
l>>=1
r>>=1
def get(self,i):
res=self.e
i+=self.num
while i:
res=self.segfunc(res,self.lazy[i])
i>>=1
return res
cst = cheapSegTree(m,operator.add,0)
okikae = [[] for i in range(n)]
nibannme = []
a = collections.defaultdict(int)
for i in range(q):
alist = list(map(int,input().split()))
query.append(alist)
if alist[0] == 1:
l,r,x = alist[1],alist[2],alist[3]
l-=1
r-=1
cst.update(l,r+1,x)
if alist[0] == 2:
ii,x = alist[1],alist[2]
ii-=1
okikae[ii].append((i,x))
elif alist[0] == 3:
ii,jj = alist[1],alist[2]
if okikae[ii-1]:
nibannme.append((okikae[ii-1][-1][0],i,jj-1))
else:
a[i] = 0
nibannme.sort(reverse=True)
cst = cheapSegTree(m,operator.add,0)
for i in range(q):
alist = query[i][:]
if alist[0] == 1:
l,r,x = alist[1],alist[2],alist[3]
l-=1
r-=1
cst.update(l,r+1,x)
if alist[0] == 2:
while nibannme and nibannme[-1][0] == i:
a[nibannme[-1][1]] = alist[2]-cst.get(nibannme[-1][2])
nibannme.pop()
if alist[0] == 3:
print(a[i]+cst.get(alist[2]-1))
|
ConDefects/ConDefects/Code/abc253_f/Python/45527428
|
condefects-python_data_889
|
from collections import Counter
import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
inf = 2 ** 63 - 1
mod = 998244353
n, m = mi()
N = 1
while N <= n:
N *= 2
a = li()
class andconvolution():
def __init__(self):
self.mod = 2
def zetatransform(self, a):
N = len(a)
n = 0
for i in range(0, 21):
if 2 ** i >= N:
a += [0] * (N - 2 ** i)
n = i
break
g = []
for i in range(2 ** n):
g.append(a[i])
for j in range(n):
bit = 1 << j
for i in range(1 << n):
if i & bit == 0:
g[i] ^= g[i | bit]
return g
def mebioustransform(self, a):
N = len(a)
n = 0
for i in range(0, 21):
if 2 ** i >= N:
a += [0] * (N - 2 ** i)
n = i
break
g = []
for i in range(2 ** n):
g.append(a[i])
for j in range(n):
bit = 1 << j
for i in range(1 << n):
if i & bit == 0:
g[i] -= g[i | bit]
g[i] %= self.mod
return g
def ANDconv(self, a, b):
a = self.zetatransform(a)
b = self.zetatransform(b)
N = max(len(a), len(b))
a += [0] * (N - len(a))
b += [0] * (N - len(b))
c = [0] * N
for i in range(N):
c[i] = (a[i] * b[i]) % self.mod
c = self.mebioustransform(c)
for i in range(N):
c[i] %= self.mod
return c
C = andconvolution()
A = [0 for i in range(N)]
for i in range(n):
A[N - 1 - (n - i - 1)] = a[i]
A = C.zetatransform(A)
print(*A[:m])
from collections import Counter
import sys
input = lambda: sys.stdin.readline().rstrip()
ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(mi())
inf = 2 ** 63 - 1
mod = 998244353
n, m = mi()
N = 1
while N <= n or N <= m:
N *= 2
a = li()
class andconvolution():
def __init__(self):
self.mod = 2
def zetatransform(self, a):
N = len(a)
n = 0
for i in range(0, 21):
if 2 ** i >= N:
a += [0] * (N - 2 ** i)
n = i
break
g = []
for i in range(2 ** n):
g.append(a[i])
for j in range(n):
bit = 1 << j
for i in range(1 << n):
if i & bit == 0:
g[i] ^= g[i | bit]
return g
def mebioustransform(self, a):
N = len(a)
n = 0
for i in range(0, 21):
if 2 ** i >= N:
a += [0] * (N - 2 ** i)
n = i
break
g = []
for i in range(2 ** n):
g.append(a[i])
for j in range(n):
bit = 1 << j
for i in range(1 << n):
if i & bit == 0:
g[i] -= g[i | bit]
g[i] %= self.mod
return g
def ANDconv(self, a, b):
a = self.zetatransform(a)
b = self.zetatransform(b)
N = max(len(a), len(b))
a += [0] * (N - len(a))
b += [0] * (N - len(b))
c = [0] * N
for i in range(N):
c[i] = (a[i] * b[i]) % self.mod
c = self.mebioustransform(c)
for i in range(N):
c[i] %= self.mod
return c
C = andconvolution()
A = [0 for i in range(N)]
for i in range(n):
A[N - 1 - (n - i - 1)] = a[i]
A = C.zetatransform(A)
print(*A[:m])
|
ConDefects/ConDefects/Code/arc137_d/Python/36174552
|
condefects-python_data_890
|
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
import time
from collections import Counter, deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
N,M=map(int,readline().split())
A=list(map(int,readline().split()))
n=(M-1).bit_length()+1
ans_lst=[None]*(1<<n)
A=A[::-1]
A=A+[0]*((1<<n)-len(A))
for nn in range(n):
for bit in range(1<<n):
if bit&1<<nn:
A[bit]^=A[bit^1<<nn]
A=A[::-1]
print(*A[:M])
import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
import time
from collections import Counter, deque,defaultdict
from functools import lru_cache,reduce
from heapq import heappush,heappop,heapify,heappushpop,_heappop_max,_heapify_max
def _heappush_max(heap,item):
heap.append(item)
heapq._siftdown_max(heap, 0, len(heap)-1)
def _heappushpop_max(heap, item):
if heap and item < heap[0]:
item, heap[0] = heap[0], item
heapq._siftup_max(heap, 0)
return item
from math import gcd as GCD
read=sys.stdin.read
readline=sys.stdin.readline
readlines=sys.stdin.readlines
N,M=map(int,readline().split())
A=list(map(int,readline().split()))
n=(max(M,N)-1).bit_length()+2
ans_lst=[None]*(1<<n)
A=A[::-1]
A=A+[0]*((1<<n)-len(A))
for nn in range(n):
for bit in range(1<<n):
if bit&1<<nn:
A[bit]^=A[bit^1<<nn]
A=A[::-1]
print(*A[:M])
|
ConDefects/ConDefects/Code/arc137_d/Python/30239419
|
condefects-python_data_891
|
from random import randrange
from time import time
def calc(t):
X.sort(key = lambda x: -x[0] * t - x[1])
su1, su0 = 0, 0
for i in range(K):
su1 += X[i][0]
su0 += X[i][1]
return (1 if su1 > t else -1, su1 ** 2 + su0)
sTime = time()
N, K = map(int, input().split())
C = [int(a) * 36 for a in input().split()]
X = []
for i in range(N):
b = [int(a) for a in input().split()]
s1 = sum(b)
s2 = sum([a ** 2 for a in b])
X.append((s1, 6 * s2 - s1 ** 2 - C[i]))
sss = sorted([x[0] for x in X])
ans = - 10 ** 18
while time() - sTime < 1.8:
l, r = sum(sss[:K]), sum(sss[-K:])
m = randrange(l, r + 1)
d, ret = calc(m)
if d > 0:
l = m
else:
r = m
ans = max(ans, ret)
while r - l > 1:
m = l + r >> 1
d, ret = calc(m)
ans = max(ans, ret)
if d > 0:
l = m
else:
r = m
print(ans * 859599304 % 998244353)
from random import randrange
from time import time
def calc(t):
X.sort(key = lambda x: -x[0] * t * 2 - x[1])
su1, su0 = 0, 0
for i in range(K):
su1 += X[i][0]
su0 += X[i][1]
return (1 if su1 > t else -1, su1 ** 2 + su0)
sTime = time()
N, K = map(int, input().split())
C = [int(a) * 36 for a in input().split()]
X = []
for i in range(N):
b = [int(a) for a in input().split()]
s1 = sum(b)
s2 = sum([a ** 2 for a in b])
X.append((s1, 6 * s2 - s1 ** 2 - C[i]))
sss = sorted([x[0] for x in X])
ans = - 10 ** 18
while time() - sTime < 1.8:
l, r = sum(sss[:K]), sum(sss[-K:])
m = randrange(l, r + 1)
d, ret = calc(m)
if d > 0:
l = m
else:
r = m
ans = max(ans, ret)
while r - l > 1:
m = l + r >> 1
d, ret = calc(m)
ans = max(ans, ret)
if d > 0:
l = m
else:
r = m
print(ans * 859599304 % 998244353)
|
ConDefects/ConDefects/Code/abc257_h/Python/32762821
|
condefects-python_data_892
|
S = input()
if S[0].isupper() and S[-1].isupper():
T = S[1:-1]
if T.isdigit():
if 100000 <= int(T) <= 999999:
print('Yes')
else:
print('No')
else:
print('No')
else:
print('No')
S = input()
if S[0].isupper() and S[-1].isupper():
T = S[1:-1]
if T.isdigit():
if 100000 <= int(T) <= 999999 and len(T) == 6:
print('Yes')
else:
print('No')
else:
print('No')
else:
print('No')
|
ConDefects/ConDefects/Code/abc281_b/Python/45944374
|
condefects-python_data_893
|
S = list(input())
x = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
if len(S) != 8:
print("No")
exit()
elif not(S[0] in x) and not(S[-1] in x) and S[1] != "0":
for i in range(6):
if not(S[i + 1] in x):
print("No")
exit()
else:
print("No")
exit()
print("Yes")
S = list(input())
x = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
if len(S) != 8:
print("No")
exit()
elif not(S[0] in x) and not(S[-1] in x) and S[1] != "0":
for i in range(6):
if not(S[i + 1] in x):
print("No")
exit()
else:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc281_b/Python/45344289
|
condefects-python_data_894
|
def solve(s: str) :
""" You are given a string S consisting of uppercase English letters and digits. Determine whether
S satisfies the following condition.
S is a concatenation of the following characters and string in the order listed.
1 - An uppercase English letter
2 - A string of length 6 that is a decimal representation of an integer between 100000 and 999999, inclusive
3 - An uppercase English letter
"""
if len(s) != 8:
return "No"
number = ""
if 'A' <= s[0] <= 'Z':
for i in range(1, len(s) - 1):
if '0' <= s[i] <= '9':
number += s[i]
else:
return "No"
if 100000 <= int(number) <= 999999:
if 'A' <= s[-1] <= 'Z':
return "Yes"
else:
return "No"
else:
return "No"
s = str(input())
print(solve(s))
def solve(s: str) :
""" You are given a string S consisting of uppercase English letters and digits. Determine whether
S satisfies the following condition.
S is a concatenation of the following characters and string in the order listed.
1 - An uppercase English letter
2 - A string of length 6 that is a decimal representation of an integer between 100000 and 999999, inclusive
3 - An uppercase English letter
"""
if len(s) != 8:
return "No"
number = ""
if 'A' <= s[0] <= 'Z':
for i in range(1, len(s) - 1):
if '0' <= s[i] <= '9':
number += s[i]
else:
return "No"
if 100000 <= int(number) <= 999999:
if 'A' <= s[-1] <= 'Z':
return "Yes"
else:
return "No"
else:
return "No"
else:
return "No"
s = str(input())
print(solve(s))
|
ConDefects/ConDefects/Code/abc281_b/Python/45430441
|
condefects-python_data_895
|
s = input()
s_list = []
for i in range(len(s)):
if s[i] in [chr(i) for i in range(65, 91)]:
s_list.append(s[i])
if len(s_list) == 2 and s[0] in [chr(i) for i in range(65, 91)] and s[len(s) - 1] in [chr(i) for i in range(65, 91)]:
if (s[0] in [chr(i) for i in range(65, 91)]) and (s[len(s) - 1] in [chr(i) for i in range(65, 91)]) and (100000 <= int(s[1:len(s) - 1]) <= 999999):
res = 'Yes'
else:
res = 'No'
else:
res = 'No'
print(res)
s = input()
s_list = []
for i in range(len(s)):
if s[i] in [chr(i) for i in range(65, 91)]:
s_list.append(s[i])
if len(s_list) == 2 and s[0] in [chr(i) for i in range(65, 91)] and s[len(s) - 1] in [chr(i) for i in range(65, 91)]:
if (s[0] in [chr(i) for i in range(65, 91)]) and (s[len(s) - 1] in [chr(i) for i in range(65, 91)]) and (100000 <= int(s[1:len(s) - 1]) <= 999999) and len(s[1:len(s) - 1]) == 6:
res = 'Yes'
else:
res = 'No'
else:
res = 'No'
print(res)
|
ConDefects/ConDefects/Code/abc281_b/Python/46135181
|
condefects-python_data_896
|
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from sortedcontainers import *
# from math import gcd, lcm
# from datetime import *
# from decimal import * # PyPyだと遅い
from string import ascii_lowercase, ascii_uppercase
# import numpy as np
# from atcoder.dsu import *
# from atcoder.segtree import *
# from sortedcontainers import *
# from random import *
import sys
import os
is_test = os.getenv("ATCODER", 0)
# sys.setrecursionlimit(10**6) # PyPyは呪文を付ける
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
S = input()
if len(S) != 8:
print("No")
else:
l, r = S[0], S[-1]
n = S[1:-1]
print(n)
if l in ascii_uppercase and r in ascii_uppercase and n.isdecimal():
if 100000 <= int(n) <= 999999:
print("Yes")
exit()
print("No")
# import pypyjit;pypyjit.set_param("max_unroll_recursion=-1")
# from bisect import *
# from collections import *
# from heapq import *
# from itertools import *
# from sortedcontainers import *
# from math import gcd, lcm
# from datetime import *
# from decimal import * # PyPyだと遅い
from string import ascii_lowercase, ascii_uppercase
# import numpy as np
# from atcoder.dsu import *
# from atcoder.segtree import *
# from sortedcontainers import *
# from random import *
import sys
import os
is_test = os.getenv("ATCODER", 0)
# sys.setrecursionlimit(10**6) # PyPyは呪文を付ける
INF = 1 << 61
MOD = 998244353
# MOD = 10**9 + 7
File = sys.stdin
def input():
return File.readline()[:-1]
# ///////////////////////////////////////////////////////////////////////////
S = input()
if len(S) != 8:
print("No")
else:
l, r = S[0], S[-1]
n = S[1:-1]
# print(n)
if l in ascii_uppercase and r in ascii_uppercase and n.isdecimal():
if 100000 <= int(n) <= 999999:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc281_b/Python/45944008
|
condefects-python_data_897
|
s=input()
t=s[1:-1]
ans='No'
if s[0].isupper() and s[-1].isupper():
if t.isdigit() and 100000<=int(t)<=999999:
ans='Yes'
print(ans)
s=input()
t=s[1:-1]
ans='No'
if s[0].isupper() and s[-1].isupper():
if len(s)==8 and t.isdigit() and 100000<=int(t)<=999999:
ans='Yes'
print(ans)
|
ConDefects/ConDefects/Code/abc281_b/Python/45943845
|
condefects-python_data_898
|
s = input()
n = len(s)
keyA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
key0 = "0123456789"
turn = 0
idx = 0
i = 0
while i < n:
if turn == 0:
if s[i] in keyA:
turn = 1
else:
break
elif turn == 1:
if s[i] == "0":
break
else:
turn = 2
idx = 1
elif turn == 2:
if s[i] in key0 and idx < 6:
idx += 1
else:
break
if idx == 6:
idx = 0
turn = 0
i += 1
if i >= n or s[i] not in keyA:
break
i += 1
else:
print("Yes" if idx == 0 else "No")
exit()
print("No")
s = input()
n = len(s)
keyA = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
key0 = "0123456789"
turn = 0
idx = 0
i = 0
while i < n:
if turn == 0:
if s[i] in keyA:
turn = 1
else:
break
elif turn == 1:
if s[i] == "0":
break
else:
turn = 2
idx = 1
elif turn == 2:
if s[i] in key0 and idx < 6:
idx += 1
else:
break
if idx == 6:
idx = 0
turn = 0
i += 1
if i >= n or s[i] not in keyA:
break
i += 1
else:
print("Yes" if idx == 0 and turn == 0 else "No")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc281_b/Python/45699589
|
condefects-python_data_899
|
def prefix_sum(A) :
N = len(A)
res = [0 for i in range(N)]
res[0] = A[0]
for i in range(1, N) : res[i] = A[i] + res[i - 1]
return res
N = int(input())
A = list(map(int, input().split()))
S = list(reversed(prefix_sum(list(reversed(A)))))
dit = [10 ** len(str(A[i])) for i in range(N)]
ditsum = list(reversed(prefix_sum(list(reversed(dit)))))
res = 0
for i in range(N - 1) :
res += A[i] * ditsum[i + 1] + S[i + 1]
print(res)
def prefix_sum(A) :
N = len(A)
res = [0 for i in range(N)]
res[0] = A[0]
for i in range(1, N) : res[i] = A[i] + res[i - 1]
return res
MOD = 998244353
N = int(input())
A = list(map(int, input().split()))
S = list(reversed(prefix_sum(list(reversed(A)))))
dit = [10 ** len(str(A[i])) for i in range(N)]
ditsum = list(reversed(prefix_sum(list(reversed(dit)))))
res = 0
for i in range(N - 1) :
res += A[i] * ditsum[i + 1] + S[i + 1]
res %= MOD
print(res)
|
ConDefects/ConDefects/Code/abc353_d/Python/54729259
|
condefects-python_data_900
|
N = int(input())
S = []
for i in range(N):
s = input()
S.append(s)
flag = False
for i in range(N):
for j in range(N):
if i == j:
break
a = S[i] + S[j]
if a == a[::-1]:
flag = True
print('Yes' if flag else 'No')
N = int(input())
S = []
for i in range(N):
s = input()
S.append(s)
flag = False
for i in range(N):
for j in range(N):
if i == j:
continue
a = S[i] + S[j]
if a == a[::-1]:
flag = True
print('Yes' if flag else 'No')
|
ConDefects/ConDefects/Code/abc307_b/Python/45983540
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.