id
stringlengths 24
27
| content
stringlengths 37
384k
| max_stars_repo_path
stringlengths 51
51
|
|---|---|---|
condefects-python_data_901
|
n,*s=open(0).read().split()
n=int(n)
for i in range(n):
for j in range(n):
if i!=j and s[i]+s[j]==[s[i]+s[j]][::-1]:
print("Yes")
exit()
print("No")
n,*s=open(0).read().split()
n=int(n)
for i in range(n):
for j in range(n):
if i!=j and s[i]+s[j]==(s[i]+s[j])[::-1]:
print("Yes")
exit()
print("No")
|
ConDefects/ConDefects/Code/abc307_b/Python/45786032
|
condefects-python_data_902
|
X=int(input())
numbers=[]
for k in range(1,18):
for d in range(1,10):
for l in range(-8,10):
number=d
digits=[str(d)]
for _ in range(k):
number+=l
digits.append(str(number))
if 0<=int(digits[-1])<10:
numbers.append(int(''.join(digits)))
numbers.sort()
for number in numbers:
if number>=X:
print(number)
exit()
X=int(input())
numbers=[]
for k in range(18):
for d in range(1,10):
for l in range(-8,10):
number=d
digits=[str(d)]
for _ in range(k):
number+=l
digits.append(str(number))
if 0<=int(digits[-1])<10:
numbers.append(int(''.join(digits)))
numbers.sort()
for number in numbers:
if number>=X:
print(number)
exit()
|
ConDefects/ConDefects/Code/abc234_e/Python/45285849
|
condefects-python_data_903
|
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log,sqrt
from atcoder.modint import ModContext, Modint
from atcoder.dsu import DSU
ModContext(1).context.append(998244353)
sys.setrecursionlimit(1000000)
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
X = int(input())
def isOK(x):
x = str(x)
dif = ord(x[1]) - ord(x[0])
for i in range(len(x) - 1):
if ord(x[i + 1]) - ord(x[i]) != dif:
return False
return True
s = str(X)
if len(s) <= 2:
print(X)
elif len(s) <= 7:
for i in range(X, 10000000):
if isOK(i):
print(i)
exit()
else:
cand = [12345678, 23456789, 76543210, 87654321, 98765432, 876543210, 987654321, 9876543210]
cand.append(int(s[0] * len(s)))
if s[0] == '9':
cand.append(int('1' * (len(s) + 1)))
else:
cand.append(int(chr(ord(s[0]) + 1) * len(s)))
cand.sort()
print(cand[bisect.bisect_left(cand, X)])
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import gcd,log,sqrt
from atcoder.modint import ModContext, Modint
from atcoder.dsu import DSU
ModContext(1).context.append(998244353)
sys.setrecursionlimit(1000000)
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
X = int(input())
def isOK(x):
x = str(x)
dif = ord(x[1]) - ord(x[0])
for i in range(len(x) - 1):
if ord(x[i + 1]) - ord(x[i]) != dif:
return False
return True
s = str(X)
if len(s) <= 2:
print(X)
elif len(s) <= 7:
for i in range(X, 10000000):
if isOK(i):
print(i)
exit()
else:
cand = [12345678, 23456789, 76543210, 87654321, 98765432, 876543210, 987654321, 9876543210, 123456789]
cand.append(int(s[0] * len(s)))
if s[0] == '9':
cand.append(int('1' * (len(s) + 1)))
else:
cand.append(int(chr(ord(s[0]) + 1) * len(s)))
cand.sort()
print(cand[bisect.bisect_left(cand, X)])
|
ConDefects/ConDefects/Code/abc234_e/Python/45484479
|
condefects-python_data_904
|
X = str(input())
if len(X) <= 2:
print(X)
else:
d = -9
a0 = int(X[0])
for i in range(d, 10):
num = ""
for j in range(len(X)):
if 0 <= a0 + i * j <= 9:
num += str(a0 + i * j)
if num >= X:
print(num)
exit()
a0 += 1
d = -9
for i in range(d, 10):
num = ""
for j in range(len(X)):
if 0 <= a0 + i * j <= 9:
num += str(a0 + i * j)
if int(num) >= int(X):
print(num)
exit()
X = str(input())
if len(X) <= 2:
print(X)
else:
d = -9
a0 = int(X[0])
for i in range(d, 10):
num = ""
for j in range(len(X)):
if 0 <= a0 + i * j <= 9:
num += str(a0 + i * j)
if int(num) >= int(X):
print(num)
exit()
a0 += 1
d = -9
for i in range(d, 10):
num = ""
for j in range(len(X)):
if 0 <= a0 + i * j <= 9:
num += str(a0 + i * j)
if int(num) >= int(X):
print(num)
exit()
|
ConDefects/ConDefects/Code/abc234_e/Python/45477719
|
condefects-python_data_905
|
# cf. https://atcoder.jp/contests/abc345/editorial/9580
INF = 10**10
def solve(n, k, c, v):
C1 = [-1]*(k+1) # 最大の価値になる色
V1 = [-INF]*(k+1) # 最大の価値
C2 = [-1]*(k+1) # 次善の価値になる色
V2 = [-INF]*(k+1) # 次善の価値
C1[0] = 0
V1[0] = 0
for ci, vi in zip(c, v):
for j in range(k, 0, -1):
# 最大価値の更新
if C1[j] != ci:
C1[j] = ci
V1[j] += vi
else:
C1[j] = ci
V1[j] = V2[j] + vi
# 次点の価値のリセット
C2[j] = -1
V2[j] = -INF
# 以前のアイテムと比較して更新
for C, V in [(C1, V1), (C2, V2)]:
if V[j-1] >= V1[j]:
if C[j-1] != C1[j]:
C2[j] = C1[j]
V2[j] = V1[j]
C1[j] = C[j-1]
V1[j] = V[j-1]
elif V[j-1] >= V2[j] and C[j-1] != C1[j]:
C2[j] = C[j-1]
V2[j] = V[j-1]
if C1[0] != ci:
C1[0] = ci
V1[0] += vi
else:
V1[0] = -INF
return -1 if V1[k] < 0 else V1[k]
n, k = map(int, input().split())
c, v = zip(*[map(int, input().split()) for i in range(n)])
print(solve(n, k, c, v))
# cf. https://atcoder.jp/contests/abc345/editorial/9580
INF = 10**15
def solve(n, k, c, v):
C1 = [-1]*(k+1) # 最大の価値になる色
V1 = [-INF]*(k+1) # 最大の価値
C2 = [-1]*(k+1) # 次善の価値になる色
V2 = [-INF]*(k+1) # 次善の価値
C1[0] = 0
V1[0] = 0
for ci, vi in zip(c, v):
for j in range(k, 0, -1):
# 最大価値の更新
if C1[j] != ci:
C1[j] = ci
V1[j] += vi
else:
C1[j] = ci
V1[j] = V2[j] + vi
# 次点の価値のリセット
C2[j] = -1
V2[j] = -INF
# 以前のアイテムと比較して更新
for C, V in [(C1, V1), (C2, V2)]:
if V[j-1] >= V1[j]:
if C[j-1] != C1[j]:
C2[j] = C1[j]
V2[j] = V1[j]
C1[j] = C[j-1]
V1[j] = V[j-1]
elif V[j-1] >= V2[j] and C[j-1] != C1[j]:
C2[j] = C[j-1]
V2[j] = V[j-1]
if C1[0] != ci:
C1[0] = ci
V1[0] += vi
else:
V1[0] = -INF
return -1 if V1[k] < 0 else V1[k]
n, k = map(int, input().split())
c, v = zip(*[map(int, input().split()) for i in range(n)])
print(solve(n, k, c, v))
|
ConDefects/ConDefects/Code/abc345_e/Python/52899692
|
condefects-python_data_906
|
import sys
input = sys.stdin.readline ###
n, k = map(int, input().split())
cv = [ list(map(int, input().split())) for _ in range(n) ]
INF = 1<<62
dp = [[-1,-1,-1,-1] for _ in range(k+1)]
dp[0] = [0, 0, -1,-1]
for c, v in cv:
np = [[-1,-1,-1,-1] for _ in range(k+1)]
for i in range(k):
np[i+1] = dp[i]
for i in range(k+1):
w = dp[i][0] if dp[i][1] !=c else dp[i][2]
if w == -1:
continue
w += v
ni = np[i]
if ni[1] == c:
if ni[0] < w:
np[i][0] = v
elif ni[3] ==c:
if ni[0] >= ni[2] >= w: continue
if ni[0] >= w > ni[2]:
np[i] = [ni[0], ni[1], w, c]
if w > ni[0] >= ni[2]:
np[i] = [w, c, ni[0], ni[1]]
else:
if ni[0] >= ni[2] >= w: continue
if ni[0] >= w > ni[2]:
np[i] = [ni[0], ni[1], w, c]
if w > ni[0] >= ni[2]:
np[i] = [w, c, ni[0], ni[1]]
dp = np
print(dp[-1][0])
import sys
input = sys.stdin.readline ###
n, k = map(int, input().split())
cv = [ list(map(int, input().split())) for _ in range(n) ]
INF = 1<<62
dp = [[-1,-1,-1,-1] for _ in range(k+1)]
dp[0] = [0, 0, -1,-1]
for c, v in cv:
np = [[-1,-1,-1,-1] for _ in range(k+1)]
for i in range(k):
np[i+1] = dp[i]
for i in range(k+1):
w = dp[i][0] if dp[i][1] !=c else dp[i][2]
if w == -1:
continue
w += v
ni = np[i]
if ni[1] == c:
if ni[0] < w:
np[i][0] = w
elif ni[3] ==c:
if ni[0] >= ni[2] >= w: continue
if ni[0] >= w > ni[2]:
np[i] = [ni[0], ni[1], w, c]
if w > ni[0] >= ni[2]:
np[i] = [w, c, ni[0], ni[1]]
else:
if ni[0] >= ni[2] >= w: continue
if ni[0] >= w > ni[2]:
np[i] = [ni[0], ni[1], w, c]
if w > ni[0] >= ni[2]:
np[i] = [w, c, ni[0], ni[1]]
dp = np
print(dp[-1][0])
|
ConDefects/ConDefects/Code/abc345_e/Python/51995381
|
condefects-python_data_907
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, L, *A = map(int, read().split())
no_more_two = False
for a in A:
if a == 1:
L -= 2
else:
L -= 3
if L <= 0:
no_more_two = True
if no_more_two and a == 2 and L != -1:
print('No')
break
else:
print('Yes')
if __name__ == '__main__':
main()
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N, L, *A = map(int, read().split())
no_more_two = False
for a in A:
if a == 1:
L -= 2
else:
L -= 3
if L <= 0:
no_more_two = True
if no_more_two and a == 2 and L != -1 and L != 0:
print('No')
break
else:
print('Yes')
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/arc152_a/Python/42092015
|
condefects-python_data_908
|
import sys
input = lambda: sys.stdin.readline().rstrip()
mod = 9982444353
# ----------------------- #
Q, K = map(int, input().split())
dp = [0] * (K+1)
dp[0] = 1
for i in range(Q):
com, x = input().split()
x = int(x)
if com == '+':
for j in range(K, x-1, -1):
dp[j] += dp[j-x]
dp[j] %= mod
else:
for j in range(x, K+1):
dp[j] -= dp[j-x]
dp[j] %= mod
print(dp[K])
import sys
input = lambda: sys.stdin.readline().rstrip()
mod = 998244353
# ----------------------- #
Q, K = map(int, input().split())
dp = [0] * (K+1)
dp[0] = 1
for i in range(Q):
com, x = input().split()
x = int(x)
if com == '+':
for j in range(K, x-1, -1):
dp[j] += dp[j-x]
dp[j] %= mod
else:
for j in range(x, K+1):
dp[j] -= dp[j-x]
dp[j] %= mod
print(dp[K])
|
ConDefects/ConDefects/Code/abc321_f/Python/52979507
|
condefects-python_data_909
|
import sys
from collections import Counter, defaultdict, deque
from itertools import accumulate, combinations, permutations
from heapq import heappop, heappush
from math import inf
sys.setrecursionlimit(10**6)
MOD = 998244353
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
q,k = na()
dp = [0]*(k+1)
dp[0] = 1
for _ in range(q):
query = ns().split()
t = query[0]
x = int(query[1])
if t == '+':
for i in range(k,-1,-1):
if i-x < 0: break
dp[i] += dp[i-x]
else:
assert t == '-'
for i in range(k+1):
if i-x < 0: continue
dp[i] -= dp[i-x]
# print(t,x,dp)
print(dp[k])
import sys
from collections import Counter, defaultdict, deque
from itertools import accumulate, combinations, permutations
from heapq import heappop, heappush
from math import inf
sys.setrecursionlimit(10**6)
MOD = 998244353
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
q,k = na()
dp = [0]*(k+1)
dp[0] = 1
for _ in range(q):
query = ns().split()
t = query[0]
x = int(query[1])
if t == '+':
for i in range(k,-1,-1):
if i-x < 0: break
dp[i] += dp[i-x]
else:
assert t == '-'
for i in range(k+1):
if i-x < 0: continue
dp[i] -= dp[i-x]
# print(t,x,dp)
print(dp[k]%MOD)
|
ConDefects/ConDefects/Code/abc321_f/Python/50314783
|
condefects-python_data_910
|
q, k = map(int, input().split())
mod = 998244353
dp = [0] * (k + 1)
dp[0] = 1
for i in range(q):
t, x = map(str, input().split())
x = int(x)
if t == "+":
for j in reversed(range(k+1-x)):
dp[j+x] += dp[j]
else:
for j in range(k+1-x):
dp[j+x] -= dp[j]
print(dp[k])
# print(dp)
q, k = map(int, input().split())
mod = 998244353
dp = [0] * (k + 1)
dp[0] = 1
for i in range(q):
t, x = map(str, input().split())
x = int(x)
if t == "+":
for j in reversed(range(k+1-x)):
dp[j+x] += dp[j]
dp[j+x] %= mod
else:
for j in range(k+1-x):
dp[j+x] -= dp[j]
dp[j+x] %= mod
print(dp[k])
# print(dp)
|
ConDefects/ConDefects/Code/abc321_f/Python/50281141
|
condefects-python_data_911
|
class BIT:
n=1
data=[0 for i in range(n)]
def __init__(self,N):
self.n=N
self.data=[0 for i in range(N)]
def add(self,p,x):
assert 0<=p<self.n,"0<=p<n,p={0},n={1}".format(p,self.n)
p+=1
while(p<=self.n):
self.data[p-1]+=x
p+=p& -p
def sum(self,l,r):
# assert (0<=l and l<=r and r<=self.n),"0<=l<=r<=n,l={0},r={1},n={2}".format(l,r,self.n)
return self.sum0(r)-self.sum0(l)
def sum0(self,r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
n = int(input())
M = 10**5+5
le = M*2
point = [[] for i in range(le)]
for i in range(n):
x,y = map(int,input().split())
point[x+y].append(x-y+M)
q = int(input())
ABK = []
for i in range(q):
a,b,k = map(int,input().split())
ABK.append([a+b,a-b+M,k])
L = [-1]*q
R = [le]*q
for _ in range(18):
bit = BIT(le)
query = [[] for i in range(le)]
count = [0]*q
for i,(x,y,_) in enumerate(ABK):
s = (L[i]+R[i])//2
query[max(0,x-s)].append(i+q)
query[min(le-1,x+s+1)].append(i)
for i in range(le):
for ind in query[i]:
sign = 1 if ind < q else -1
ind = ind%q
s = (L[ind]+R[ind])//2
c = ABK[ind][1]
count[ind] += sign*bit.sum(max(0,c-s),min(le,c+s+1))
for p in point[i]:
bit.add(p,1)
for i in range(q):
if count[i] >= ABK[i][2]:
R[i] = (L[i]+R[i])//2
else:
L[i] = (L[i]+R[i])//2
for i in R:
print(i)
class BIT:
n=1
data=[0 for i in range(n)]
def __init__(self,N):
self.n=N
self.data=[0 for i in range(N)]
def add(self,p,x):
assert 0<=p<self.n,"0<=p<n,p={0},n={1}".format(p,self.n)
p+=1
while(p<=self.n):
self.data[p-1]+=x
p+=p& -p
def sum(self,l,r):
# assert (0<=l and l<=r and r<=self.n),"0<=l<=r<=n,l={0},r={1},n={2}".format(l,r,self.n)
return self.sum0(r)-self.sum0(l)
def sum0(self,r):
s=0
while(r>0):
s+=self.data[r-1]
r-=r&-r
return s
n = int(input())
M = 10**5+5
le = M*2
point = [[] for i in range(le)]
for i in range(n):
x,y = map(int,input().split())
point[x+y].append(x-y+M)
q = int(input())
ABK = []
for i in range(q):
a,b,k = map(int,input().split())
ABK.append([a+b,a-b+M,k])
L = [-1]*q
R = [le]*q
for _ in range(18):
bit = BIT(le)
query = [[] for i in range(le)]
count = [0]*q
for i,(x,y,_) in enumerate(ABK):
s = (L[i]+R[i])//2
query[max(0,x-s)].append(i+q)
query[min(le-1,x+s+1)].append(i)
for i in range(le):
for ind in query[i]:
sign = 1 if ind < q else -1
ind = ind%q
s = (L[ind]+R[ind])//2
c = ABK[ind][1]
count[ind] += sign*bit.sum(max(0,c-s),min(le,c+s+1))
for p in point[i]:
bit.add(p,1)
for i in range(q):
if R[i] == L[i]+1:
continue
if count[i] >= ABK[i][2]:
R[i] = (L[i]+R[i])//2
else:
L[i] = (L[i]+R[i])//2
for i in R:
print(i)
|
ConDefects/ConDefects/Code/abc233_h/Python/29975845
|
condefects-python_data_912
|
import os
import sys
import numpy as np
def solve(inp):
n = inp[0]
points = []
offset = 100_001
for i in range(n):
x = inp[i * 2 + 1]
y = inp[i * 2 + 2]
X = x + y
Y = x - y + offset
points.append((X, 1, Y))
inp_offset = n * 2 + 1
q = inp[inp_offset]
xxx_ = inp[inp_offset + 1::3]
yyy_ = inp[inp_offset + 2::3]
query_xs = xxx_ + yyy_
query_ys = xxx_ - yyy_ + offset
query_ks = inp[inp_offset + 3::3]
# === Fenwick Tree 定義 ====
fenwick_n = 200_200 # CUSTOM
fenwick_table = np.zeros(fenwick_n + 1, np.int64)
def fenwick_add(i, x):
i += 1
while i <= fenwick_n:
fenwick_table[i] += x
i += i & -i
def fenwick_sum(i):
s = 0
i += 1
while i > 0:
s += fenwick_table[i]
i -= i & -i
return s
# === / ここまで Fenwick Tree 定義 ====
lo_list = np.full(q, -1, np.int64)
hi_list = np.full(q, 200_000, np.int64)
mid_list = np.zeros(q, np.int64)
res_list = np.zeros(q, np.int64)
for _ in range(18):
events = points.copy()
for i in range(q):
lo = lo_list[i]
hi = hi_list[i]
mid_list[i] = mid = (lo + hi) >> 1
x = query_xs[i]
events.append((x - mid, 0, i))
events.append((x + mid, 2, i))
events.sort()
fenwick_table.fill(0)
for x, op, i in events:
if op == 0:
y1 = query_ys[i] - mid_list[i]
y2 = query_ys[i] + mid_list[i]
res = fenwick_sum(min(fenwick_n - 1, y2))
if y1 > 0:
res -= fenwick_sum(y1 - 1)
res_list[i] = -res
elif op == 1:
y1 = i
fenwick_add(y1, 1)
elif op == 2:
y1 = query_ys[i] - mid_list[i]
y2 = query_ys[i] + mid_list[i]
res = fenwick_sum(min(fenwick_n - 1, y2))
if y1 > 0:
res -= fenwick_sum(y1 - 1)
res_list[i] += res
if res_list[i] < query_ks[i]:
lo_list[i] = mid_list[i]
else:
hi_list[i] = mid_list[i]
return hi_list
SIGNATURE = '(i8[:],)'
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', SIGNATURE)(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit(SIGNATURE, cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
import os
import sys
import numpy as np
def solve(inp):
n = inp[0]
points = []
offset = 100_001
for i in range(n):
x = inp[i * 2 + 1]
y = inp[i * 2 + 2]
X = x + y
Y = x - y + offset
points.append((X, 1, Y))
inp_offset = n * 2 + 1
q = inp[inp_offset]
xxx_ = inp[inp_offset + 1::3]
yyy_ = inp[inp_offset + 2::3]
query_xs = xxx_ + yyy_
query_ys = xxx_ - yyy_ + offset
query_ks = inp[inp_offset + 3::3]
# === Fenwick Tree 定義 ====
fenwick_n = 200_200 # CUSTOM
fenwick_table = np.zeros(fenwick_n + 1, np.int64)
def fenwick_add(i, x):
i += 1
while i <= fenwick_n:
fenwick_table[i] += x
i += i & -i
def fenwick_sum(i):
s = 0
i += 1
while i > 0:
s += fenwick_table[i]
i -= i & -i
return s
# === / ここまで Fenwick Tree 定義 ====
lo_list = np.full(q, -1, np.int64)
hi_list = np.full(q, 200_000, np.int64)
mid_list = np.zeros(q, np.int64)
res_list = np.zeros(q, np.int64)
for _ in range(18):
events = points.copy()
for i in range(q):
lo = lo_list[i]
hi = hi_list[i]
if lo + 1 == hi:
continue
mid_list[i] = mid = (lo + hi) >> 1
x = query_xs[i]
events.append((x - mid, 0, i))
events.append((x + mid, 2, i))
events.sort()
fenwick_table.fill(0)
for x, op, i in events:
if op == 0:
y1 = query_ys[i] - mid_list[i]
y2 = query_ys[i] + mid_list[i]
res = fenwick_sum(min(fenwick_n - 1, y2))
if y1 > 0:
res -= fenwick_sum(y1 - 1)
res_list[i] = -res
elif op == 1:
y1 = i
fenwick_add(y1, 1)
elif op == 2:
y1 = query_ys[i] - mid_list[i]
y2 = query_ys[i] + mid_list[i]
res = fenwick_sum(min(fenwick_n - 1, y2))
if y1 > 0:
res -= fenwick_sum(y1 - 1)
res_list[i] += res
if res_list[i] < query_ks[i]:
lo_list[i] = mid_list[i]
else:
hi_list[i] = mid_list[i]
return hi_list
SIGNATURE = '(i8[:],)'
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', SIGNATURE)(solve)
cc.compile()
exit()
if os.name == 'posix':
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit(SIGNATURE, cache=True)(solve)
print('compiled', file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ')
ans = solve(inp)
print('\n'.join(map(str, ans)))
|
ConDefects/ConDefects/Code/abc233_h/Python/53067892
|
condefects-python_data_913
|
import sys
readline=sys.stdin.readline
from collections import defaultdict
class Segment_Tree:
def __init__(self,N,f,e,lst=None,dynamic=False):
self.f=f
self.e=e
self.N=N
if dynamic:
self.segment_tree=defaultdict(lambda:self.e)
else:
if lst==None:
self.segment_tree=[self.e]*2*self.N
else:
assert len(lst)<=self.N
self.segment_tree=[self.e]*self.N+[x for x in lst]+[self.e]*(N-len(lst))
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def __getitem__(self,i):
if type(i)==int:
if -self.N<=i<0:
return self.segment_tree[i+self.N*2]
elif 0<=i<self.N:
return self.segment_tree[i+self.N]
else:
raise IndexError("list index out of range")
else:
a,b,c=i.start,i.stop,i.step
if a==None:
a=self.N
else:
a+=self.N
if b==None:
b=self.N*2
else:
b+=self.N
return self.segment_tree[slice(a,b,c)]
def __setitem__(self,i,x):
if -self.N<=i<0:
i+=self.N*2
elif 0<=i<self.N:
i+=self.N
else:
raise IndexError("list index out of range")
self.segment_tree[i]=x
while i>1:
i>>= 1
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Build(self,lst):
for i,x in enumerate(lst,self.N):
self.segment_tree[i]=x
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Fold(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
vL=self.e
vR=self.e
while L<R:
if L&1:
vL=self.f(vL,self.segment_tree[L])
L+=1
if R&1:
R-=1
vR=self.f(self.segment_tree[R],vR)
L>>=1
R>>=1
return self.f(vL,vR)
def Fold_Index(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
if L==R:
return None
x=self.Fold(L-self.N,R-self.N)
while L<R:
if L&1:
if self.segment_tree[L]==x:
i=L
break
L+=1
if R&1:
R-=1
if self.segment_tree[R]==x:
i=R
break
L>>=1
R>>=1
while i<self.N:
if self.segment_tree[i]==self.segment_tree[i<<1]:
i<<=1
else:
i<<=1
i|=1
i-=self.N
return i
def Bisect_Right(self,L=None,f=None):
if L==self.N:
return self.N
if L==None:
L=0
L+=self.N
vl=self.e
vr=self.e
l,r=L,self.N*2
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return self.N
v=self.e
while True:
while L%2==0:
L>>=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
else:
while L<self.N:
L<<=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
return L-self.N
def Bisect_Left(self,R=None,f=None):
if R==0:
return 0
if R==None:
R=self.N
R+=self.N
vl=self.e
vr=self.e
l,r=self.N,R
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return 0
v=self.e
while True:
R-=1
while R>1 and R%2:
R>>=1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
else:
while R<self.N:
R=2*R+1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
R-=1
return R+1-self.N
def __str__(self):
return "["+", ".join(map(str,self.segment_tree[self.N:]))+"]"
def Parallel_Bisect(ok_list,ng_list,is_ok):
while True:
mid_list=[]
for i,(ok,ng) in enumerate(zip(ok_list,ng_list)):
if abs(ok-ng)>=2:
mid_list.append(((ok+ng)//2,i))
if not mid_list:
break
for (mid,i),bl in zip(mid_list,is_ok(mid_list)):
if bl:
ok_list[i]=mid
else:
ng_list[i]=mid
return ok_list
N=int(readline())
M=10**5
Y=[[] for x in range(2*M+2)]
for n in range(N):
x,y=map(int,readline().split())
x,y=x+y,x-y+M
Y[x].append(y)
Q=int(readline())
A,B,K=[],[],[]
for q in range(Q):
a,b,k=map(int,readline().split())
a,b=a+b,a-b+M
A.append(a)
B.append(b)
K.append(k)
ok_list=[0]*Q
ng_list=[2*M+10]*Q
def is_ok(mid_list):
query=[[] for m in range(2*M+2)]
cnt=[0]*len(mid_list)
for q,(mid,i) in enumerate(mid_list):
query[max(0,A[i]-mid)].append((q,max(0,B[i]-mid),min(2*M+1,B[i]+mid+1),-1))
query[min(2*M+1,A[i]+mid+1)].append((q,max(0,B[i]-mid),min(2*M+1,B[i]+mid+1),1))
ST=Segment_Tree(2*M+1,lambda x,y:x+y,0)
for x in range(2*M+2):
for q,l,r,s in query[x]:
cnt[q]+=s*ST.Fold(l,r)
for y in Y[x]:
ST[y]+=1
return [c<K[i] for c,(mid,i) in zip(cnt,mid_list)]
ans_lst=Parallel_Bisect(ok_list,ng_list,is_ok)
for ans in ans_lst:
print(ans+1)
import sys
readline=sys.stdin.readline
from collections import defaultdict
class Segment_Tree:
def __init__(self,N,f,e,lst=None,dynamic=False):
self.f=f
self.e=e
self.N=N
if dynamic:
self.segment_tree=defaultdict(lambda:self.e)
else:
if lst==None:
self.segment_tree=[self.e]*2*self.N
else:
assert len(lst)<=self.N
self.segment_tree=[self.e]*self.N+[x for x in lst]+[self.e]*(N-len(lst))
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def __getitem__(self,i):
if type(i)==int:
if -self.N<=i<0:
return self.segment_tree[i+self.N*2]
elif 0<=i<self.N:
return self.segment_tree[i+self.N]
else:
raise IndexError("list index out of range")
else:
a,b,c=i.start,i.stop,i.step
if a==None:
a=self.N
else:
a+=self.N
if b==None:
b=self.N*2
else:
b+=self.N
return self.segment_tree[slice(a,b,c)]
def __setitem__(self,i,x):
if -self.N<=i<0:
i+=self.N*2
elif 0<=i<self.N:
i+=self.N
else:
raise IndexError("list index out of range")
self.segment_tree[i]=x
while i>1:
i>>= 1
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Build(self,lst):
for i,x in enumerate(lst,self.N):
self.segment_tree[i]=x
for i in range(self.N-1,0,-1):
self.segment_tree[i]=self.f(self.segment_tree[i<<1],self.segment_tree[i<<1|1])
def Fold(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
vL=self.e
vR=self.e
while L<R:
if L&1:
vL=self.f(vL,self.segment_tree[L])
L+=1
if R&1:
R-=1
vR=self.f(self.segment_tree[R],vR)
L>>=1
R>>=1
return self.f(vL,vR)
def Fold_Index(self,L=None,R=None):
if L==None:
L=self.N
else:
L+=self.N
if R==None:
R=self.N*2
else:
R+=self.N
if L==R:
return None
x=self.Fold(L-self.N,R-self.N)
while L<R:
if L&1:
if self.segment_tree[L]==x:
i=L
break
L+=1
if R&1:
R-=1
if self.segment_tree[R]==x:
i=R
break
L>>=1
R>>=1
while i<self.N:
if self.segment_tree[i]==self.segment_tree[i<<1]:
i<<=1
else:
i<<=1
i|=1
i-=self.N
return i
def Bisect_Right(self,L=None,f=None):
if L==self.N:
return self.N
if L==None:
L=0
L+=self.N
vl=self.e
vr=self.e
l,r=L,self.N*2
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return self.N
v=self.e
while True:
while L%2==0:
L>>=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
else:
while L<self.N:
L<<=1
vv=self.f(v,self.segment_tree[L])
if f(vv):
v=vv
L+=1
return L-self.N
def Bisect_Left(self,R=None,f=None):
if R==0:
return 0
if R==None:
R=self.N
R+=self.N
vl=self.e
vr=self.e
l,r=self.N,R
while l<r:
if l&1:
vl=self.f(vl,self.segment_tree[l])
l+=1
if r&1:
r-=1
vr=self.f(self.segment_tree[r],vr)
l>>=1
r>>=1
if f(self.f(vl,vr)):
return 0
v=self.e
while True:
R-=1
while R>1 and R%2:
R>>=1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
else:
while R<self.N:
R=2*R+1
vv=self.f(self.segment_tree[R],v)
if f(vv):
v=vv
R-=1
return R+1-self.N
def __str__(self):
return "["+", ".join(map(str,self.segment_tree[self.N:]))+"]"
def Parallel_Bisect(ok_list,ng_list,is_ok):
while True:
mid_list=[]
for i,(ok,ng) in enumerate(zip(ok_list,ng_list)):
if abs(ok-ng)>=2:
mid_list.append(((ok+ng)//2,i))
if not mid_list:
break
for (mid,i),bl in zip(mid_list,is_ok(mid_list)):
if bl:
ok_list[i]=mid
else:
ng_list[i]=mid
return ok_list
N=int(readline())
M=10**5
Y=[[] for x in range(2*M+2)]
for n in range(N):
x,y=map(int,readline().split())
x,y=x+y,x-y+M
Y[x].append(y)
Q=int(readline())
A,B,K=[],[],[]
for q in range(Q):
a,b,k=map(int,readline().split())
a,b=a+b,a-b+M
A.append(a)
B.append(b)
K.append(k)
ok_list=[-1]*Q
ng_list=[2*M+10]*Q
def is_ok(mid_list):
query=[[] for m in range(2*M+2)]
cnt=[0]*len(mid_list)
for q,(mid,i) in enumerate(mid_list):
query[max(0,A[i]-mid)].append((q,max(0,B[i]-mid),min(2*M+1,B[i]+mid+1),-1))
query[min(2*M+1,A[i]+mid+1)].append((q,max(0,B[i]-mid),min(2*M+1,B[i]+mid+1),1))
ST=Segment_Tree(2*M+1,lambda x,y:x+y,0)
for x in range(2*M+2):
for q,l,r,s in query[x]:
cnt[q]+=s*ST.Fold(l,r)
for y in Y[x]:
ST[y]+=1
return [c<K[i] for c,(mid,i) in zip(cnt,mid_list)]
ans_lst=Parallel_Bisect(ok_list,ng_list,is_ok)
for ans in ans_lst:
print(ans+1)
|
ConDefects/ConDefects/Code/abc233_h/Python/44313828
|
condefects-python_data_914
|
n=int(input())
X=10**5
p=[]
for i in range(n):
x,y=map(int,input().split())
p+=[(x-y+X,x+y)]
q=int(input())
b=[]
k=[0]*q
for i in range(q):
x,y,k[i]=map(int,input().split())
b+=[(x-y+X,x+y)]
ok=[2*X+1]*q
ng=[0]*q
from atcoder import fenwicktree
while any(ok[i]-ng[i]>1 for i in range(q)):
m=[(ok[i]+ng[i])//2 for i in range(q)]
d0=[[] for i in range(2*X+1)]
d1=[[] for i in range(2*X+1)]
d2=[[] for i in range(2*X+1)]
for i in range(n):
x,y=p[i]
d1[y]+=[i]
for i in range(q):
if ok[i]-ng[i]>1:
x,y=b[i]
d0[max(0,y-m[i])]+=[i]
d2[min(2*X,y+m[i])]+=[i]
c=[0]*q
st=fenwicktree.FenwickTree(2*X+1)
for i in range(2*X+1):
for j in d0[i]:
x,y=b[j]
l=m[j]
c[j]=st.sum(max(0,x-l),min(2*X,x+l)+1)
for j in d1[i]:
x,y=p[j]
st.add(x,1)
for j in d2[i]:
x,y=b[j]
l=m[j]
c[j]=st.sum(max(0,x-l),min(2*X,x+l)+1)-c[j]
for i in range(q):
if c[i]>=k[i]:
ok[i]=m[i]
else:
ng[i]=m[i]
print(*ok,sep="\n")
n=int(input())
X=10**5
p=[]
for i in range(n):
x,y=map(int,input().split())
p+=[(x-y+X,x+y)]
q=int(input())
b=[]
k=[0]*q
for i in range(q):
x,y,k[i]=map(int,input().split())
b+=[(x-y+X,x+y)]
ok=[2*X+1]*q
ng=[-1]*q
from atcoder import fenwicktree
while any(ok[i]-ng[i]>1 for i in range(q)):
m=[(ok[i]+ng[i])//2 for i in range(q)]
d0=[[] for i in range(2*X+1)]
d1=[[] for i in range(2*X+1)]
d2=[[] for i in range(2*X+1)]
for i in range(n):
x,y=p[i]
d1[y]+=[i]
for i in range(q):
if ok[i]-ng[i]>1:
x,y=b[i]
d0[max(0,y-m[i])]+=[i]
d2[min(2*X,y+m[i])]+=[i]
c=[0]*q
st=fenwicktree.FenwickTree(2*X+1)
for i in range(2*X+1):
for j in d0[i]:
x,y=b[j]
l=m[j]
c[j]=st.sum(max(0,x-l),min(2*X,x+l)+1)
for j in d1[i]:
x,y=p[j]
st.add(x,1)
for j in d2[i]:
x,y=b[j]
l=m[j]
c[j]=st.sum(max(0,x-l),min(2*X,x+l)+1)-c[j]
for i in range(q):
if c[i]>=k[i]:
ok[i]=m[i]
else:
ng[i]=m[i]
print(*ok,sep="\n")
|
ConDefects/ConDefects/Code/abc233_h/Python/46688976
|
condefects-python_data_915
|
s=input()
n=len(s)
mod=998244353
dp=[[0]*27 for _ in range(n+1)]
dp2=[0]*(n+1)
dp[0][0]=1
check=[0]*26
cnt=0
x=ord('A')
for i in range(n):
if s[i]=='?':
for j in range(27):
dp[i+1][j]+=dp[i][j]*26
dp2[i+1]+=dp[i][j]*j
dp[i+1][j]%=mod
dp2[i+1]%=mod
for j in range(26):
dp[i+1][j+1]+=dp[i][j]*(26-j)
dp[i+1][j+1]%=mod
elif s[i].isupper():
if check[ord(s[i])-x]:
dp2[i+1]=sum(dp[i])%mod
break
for j in range(26):
if j<cnt:
continue
if j==0:
dp[i+1][j+1]=dp[i][j]
else:
dp[i+1][j+1]+=dp[i][j]*(25-j+1)*pow(26-cnt,-1,mod)%mod
dp2[i+1]+=dp[i][j]*(1-(25-j+1)*pow(26-cnt,-1,mod))%mod
dp2[-1]+=dp[i][-1]
check[ord(s[i])-x]+=1
cnt+=1
else:
for j in range(27):
dp[i+1][j]=dp[i][j]
dp3=[[0,0] for _ in range(n+1)]
dp3[-1][0]=1
for i in reversed(range(n)):
if s[i]=='?':
dp3[i][0]+=dp3[i+1][0]*26
dp3[i][1]+=dp3[i+1][0]*26
dp3[i][1]+=dp3[i+1][1]*26
dp3[i][0]%=mod
dp3[i][1]%=mod
elif s[i].isupper():
dp3[i][1]=sum(dp3[i+1])%mod
else:
dp3[i][0]=dp3[i+1][0]
ans=sum(dp[-1])%mod
for i in range(n+1):
ans+=dp2[i]*sum(dp3[i])
ans%=mod
print(ans)
s=input()
n=len(s)
mod=998244353
dp=[[0]*27 for _ in range(n+1)]
dp2=[0]*(n+1)
dp[0][0]=1
check=[0]*26
cnt=0
x=ord('A')
for i in range(n):
if s[i]=='?':
for j in range(27):
dp[i+1][j]+=dp[i][j]*26
dp2[i+1]+=dp[i][j]*j
dp[i+1][j]%=mod
dp2[i+1]%=mod
for j in range(26):
dp[i+1][j+1]+=dp[i][j]*(26-j)
dp[i+1][j+1]%=mod
elif s[i].isupper():
if check[ord(s[i])-x]:
dp2[i+1]=sum(dp[i])%mod
break
for j in range(26):
if j<cnt:
continue
if j==0:
dp[i+1][j+1]=dp[i][j]
else:
dp[i+1][j+1]+=dp[i][j]*(25-j+1)*pow(26-cnt,-1,mod)%mod
dp2[i+1]+=dp[i][j]*(1-(25-j+1)*pow(26-cnt,-1,mod))%mod
dp2[i+1]+=dp[i][-1]
check[ord(s[i])-x]+=1
cnt+=1
else:
for j in range(27):
dp[i+1][j]=dp[i][j]
dp3=[[0,0] for _ in range(n+1)]
dp3[-1][0]=1
for i in reversed(range(n)):
if s[i]=='?':
dp3[i][0]+=dp3[i+1][0]*26
dp3[i][1]+=dp3[i+1][0]*26
dp3[i][1]+=dp3[i+1][1]*26
dp3[i][0]%=mod
dp3[i][1]%=mod
elif s[i].isupper():
dp3[i][1]=sum(dp3[i+1])%mod
else:
dp3[i][0]=dp3[i+1][0]
ans=sum(dp[-1])%mod
for i in range(n+1):
ans+=dp2[i]*sum(dp3[i])
ans%=mod
print(ans)
|
ConDefects/ConDefects/Code/abc301_f/Python/51429838
|
condefects-python_data_916
|
p=998244353
S=input()
N=len(S)
UC=[0 for _ in range(26)]
#S[i]までに現れる大文字の種類数
UK=[0 for _ in range(N)]
#S[i]が2回目以上の大文字かどうか
DB=[0 for _ in range(N)]
for n in range(N):
i=ord(S[n])
if 65<=i<=90:
if UC[i-65]>=1:
DB[n]=1
UK[n]=UK[n-1]
else:
if n==0:
UK[n]=1
else:
UK[n]=UK[n-1]+1
UC[i-65]+=1
else:
if n==0:
UK[n]=0
else:
UK[n]=UK[n-1]
inv=[0,1]
for i in range(2,30):
inv.append(p//i*(-inv[p%i])%p)
#dp(n)[st]:S[n]まで見て、異なる大文字がst種類(0<=st<=26)、
#大文字重複ありかつその後小文字なし(st=27)、
#大文字重複ありかつその後小文字ありかつその後大文字なし(st=28)
dp=[0 for _ in range(29)]
dp[0]=1
for n in range(N):
dpn=[0 for _ in range(29)]
i=ord(S[n])
if i>=97:
for st in range(27):
dpn[st]+=dp[st];dpn[st]%=p
dpn[28]+=dp[27]+dp[28];dpn[28]%=p
elif i>=65:
for st in range(27):
if DB[n]:
dpn[27]+=dp[st];dpn[27]%=p
elif st<=25:
if n==0:
y=0
else:
y=UK[n-1]
dpn[st+1]+=dp[st]*(26-st)*inv[26-y];dpn[st+1]%=p
dpn[27]+=dp[st]*(st-y)*inv[26-y];dpn[27]%=p
dpn[27]+=dp[27];dpn[27]%=p
else:
for st in range(27):
dpn[st]+=dp[st]*26;dpn[st]%=p
dpn[st+1]+=dp[st]*(26-st);dpn[st+1]%=p
dpn[27]+=dp[st]*st;dpn[st]%=p
dpn[27]+=dp[27]*26;dpn[27]%=p
dpn[28]+=dp[27]*26;dpn[28]%=p
dpn[28]+=dp[28]*26;dpn[28]%=p
dp=dpn
print(sum(dp)%p)
p=998244353
S=input()
N=len(S)
UC=[0 for _ in range(26)]
#S[i]までに現れる大文字の種類数
UK=[0 for _ in range(N)]
#S[i]が2回目以上の大文字かどうか
DB=[0 for _ in range(N)]
for n in range(N):
i=ord(S[n])
if 65<=i<=90:
if UC[i-65]>=1:
DB[n]=1
UK[n]=UK[n-1]
else:
if n==0:
UK[n]=1
else:
UK[n]=UK[n-1]+1
UC[i-65]+=1
else:
if n==0:
UK[n]=0
else:
UK[n]=UK[n-1]
inv=[0,1]
for i in range(2,30):
inv.append(p//i*(-inv[p%i])%p)
#dp(n)[st]:S[n]まで見て、異なる大文字がst種類(0<=st<=26)、
#大文字重複ありかつその後小文字なし(st=27)、
#大文字重複ありかつその後小文字ありかつその後大文字なし(st=28)
dp=[0 for _ in range(29)]
dp[0]=1
for n in range(N):
dpn=[0 for _ in range(29)]
i=ord(S[n])
if i>=97:
for st in range(27):
dpn[st]+=dp[st];dpn[st]%=p
dpn[28]+=dp[27]+dp[28];dpn[28]%=p
elif i>=65:
for st in range(27):
if DB[n]:
dpn[27]+=dp[st];dpn[27]%=p
else:
if n==0:
y=0
else:
y=UK[n-1]
dpn[st+1]+=dp[st]*(26-st)*inv[26-y];dpn[st+1]%=p
dpn[27]+=dp[st]*(st-y)*inv[26-y];dpn[27]%=p
dpn[27]+=dp[27];dpn[27]%=p
else:
for st in range(27):
dpn[st]+=dp[st]*26;dpn[st]%=p
dpn[st+1]+=dp[st]*(26-st);dpn[st+1]%=p
dpn[27]+=dp[st]*st;dpn[st]%=p
dpn[27]+=dp[27]*26;dpn[27]%=p
dpn[28]+=dp[27]*26;dpn[28]%=p
dpn[28]+=dp[28]*26;dpn[28]%=p
dp=dpn
print(sum(dp)%p)
|
ConDefects/ConDefects/Code/abc301_f/Python/53511062
|
condefects-python_data_917
|
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
e = [[0]*n for i in range(n)]
for _ in range(m):
a,b = [int(x)-1 for x in input().split()]
e[a][b] = 1
for i in range(n):
e[i][i] = 1
q = int(input())
ST = [[int(x)-1 for x in input().split()] for i in range(q)]
ans = [-1]*q
le = (n+61)//62
bits = []
for i in range(n):
bi = []
for j in range(le):
num = 0
for x in range(62):
if j*le+x < n and e[i][j*le+x]:
num |= 1<<x
bi.append(num)
bits.append(bi)
for k in range(n):
kx,ky = divmod(k,62)
for i in range(n):
if bits[i][kx] & 1<<ky == 0:
continue
for j in range(le):
bits[i][j] |= bits[k][j]
for i,(s,t) in enumerate(ST):
if ans[i] != -1:
continue
if s > k or t > k:
continue
x,y = divmod(t,62)
if bits[s][x] & 1<<y:
ans[i] = k+1
for i in ans:
print(i)
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
e = [[0]*n for i in range(n)]
for _ in range(m):
a,b = [int(x)-1 for x in input().split()]
e[a][b] = 1
for i in range(n):
e[i][i] = 1
q = int(input())
ST = [[int(x)-1 for x in input().split()] for i in range(q)]
ans = [-1]*q
le = (n+61)//62
bits = []
for i in range(n):
bi = []
for j in range(le):
num = 0
for x in range(62):
if j*62+x < n and e[i][j*62+x]:
num |= 1<<x
bi.append(num)
bits.append(bi)
for k in range(n):
kx,ky = divmod(k,62)
for i in range(n):
if bits[i][kx] & 1<<ky == 0:
continue
for j in range(le):
bits[i][j] |= bits[k][j]
for i,(s,t) in enumerate(ST):
if ans[i] != -1:
continue
if s > k or t > k:
continue
x,y = divmod(t,62)
if bits[s][x] & 1<<y:
ans[i] = k+1
for i in ans:
print(i)
|
ConDefects/ConDefects/Code/abc287_h/Python/38508416
|
condefects-python_data_918
|
import sys, bisect, math, itertools, string, queue, copy
from collections import *
from itertools import *
from heapq import *
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 998244353
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplt(n): return [tuple(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
def make_divisors(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]
n = inp()
s = input()
shift = []
for ss in s:
if ss == '#':
shift.append('0')
else:
shift.append('1')
divisor = make_divisors(n)
tmp = defaultdict(int)
for d in divisor:
if d == n: continue
if d == 1:
tmp[1] = 1
if '1' not in shift:
tmp[1] += 1
continue
bit = 0
for i in range(n//d):
bit = bit | int(''.join(shift[i*d:i*d+d]),2)
bit = bin(bit)
cnt = 0
for ss in str(bit):
if ss == '1':
cnt += 1
cnt = d - cnt
tmp[d] = pow(2,cnt,mod)
for k,v in tmp.items():
for d in make_divisors(k):
if d == k: continue
tmp[k] -= tmp[d]
ans = sum(tmp.values())
print(ans)
import sys, bisect, math, itertools, string, queue, copy
from collections import *
from itertools import *
from heapq import *
# input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 998244353
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplt(n): return [tuple(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
def make_divisors(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]
n = inp()
s = input()
shift = []
for ss in s:
if ss == '#':
shift.append('0')
else:
shift.append('1')
divisor = make_divisors(n)
tmp = defaultdict(int)
for d in divisor:
if d == n: continue
if d == 1:
tmp[1] = 1
if '1' not in shift:
tmp[1] += 1
continue
bit = 0
for i in range(n//d):
bit = bit | int(''.join(shift[i*d:i*d+d]),2)
bit = bin(bit)
cnt = 0
for ss in str(bit):
if ss == '1':
cnt += 1
cnt = d - cnt
tmp[d] = pow(2,cnt,mod)
for k,v in tmp.items():
for d in make_divisors(k):
if d == k: continue
tmp[k] -= tmp[d]
ans = sum(tmp.values()) % mod
print(ans)
|
ConDefects/ConDefects/Code/abc304_f/Python/45077270
|
condefects-python_data_919
|
n=int(input())
if n==3:
s=[3,2,3,1,3,2]
elif n%2==1:
t=[3,2,3,1,2,3]
s=[]
for i in range((n-5)//2,-1,-1):
for j in range(3+i*2):
if i==(n-5)//2:
s.append(4+i*2)
s.append(5+i*2)
else:
s.append(5+i*2)
s.append(4+i*2)
s+=t
for i in range((n-2)//2):
s.append(i*2+5)
s.append(i*2+4)
s.append(i*2+5)
else:
s=[]
for i in range((n-4)//2,-1,-1):
for j in range(i*2+2):
if i==0:
s.append(i*2+3)
s.append(i*2+4)
else:
s.append(i*2+4)
s.append(i*2+3)
for i in range(n//2):
s.append(i*2+2)
s.append(i*2+1)
s.append(i*2+2)
print(*s)
n=int(input())
if n==3:
s=[3,2,3,1,3,2]
elif n%2==1:
t=[3,2,3,1,2,3]
s=[]
for i in range((n-5)//2,-1,-1):
for j in range(3+i*2):
if i==(n-5)//2:
s.append(4+i*2)
s.append(5+i*2)
else:
s.append(5+i*2)
s.append(4+i*2)
s+=t
for i in range((n-2)//2):
s.append(i*2+5)
s.append(i*2+4)
s.append(i*2+5)
else:
s=[]
for i in range((n-4)//2,-1,-1):
for j in range(i*2+2):
if i==(n-4)//2:
s.append(i*2+3)
s.append(i*2+4)
else:
s.append(i*2+4)
s.append(i*2+3)
for i in range(n//2):
s.append(i*2+2)
s.append(i*2+1)
s.append(i*2+2)
print(*s)
|
ConDefects/ConDefects/Code/agc064_a/Python/44640326
|
condefects-python_data_920
|
def main():
n = int(input())
memo = {i: i for i in range(2, n + 1)}
ans = [1]
for i in range(2, n - 1):
ans.append(i)
memo[i] -= 2
p = n
d = -1
while memo[p]:
ans.append(p)
memo[p] -= 1
p += d
if not memo.get(p, 0):
d = -d
p += d * 2
for i in range(n - 2, 1, -1):
ans.append(i)
print(*ans)
if __name__ == '__main__':
main()
def main():
n = int(input())
memo = {i: i for i in range(2, n + 1)}
ans = [1]
for i in range(2, n - 1):
ans.append(i)
memo[i] -= 2
p = n
d = -1
while memo[p]:
ans.append(p)
memo[p] -= 1
p += d
if not memo.get(p, 0):
d = -d
p += d * 2
if d == 1 and p == n - 1:
p += 1
for i in range(n - 2, 1, -1):
ans.append(i)
print(*ans)
if __name__ == '__main__':
main()
|
ConDefects/ConDefects/Code/agc064_a/Python/46045029
|
condefects-python_data_921
|
S = input()
N = len(S)
ans = 0
for i in range(N):
for j in range(i + 1, N + 1):
T = S[i:j]
if T == T[::-1]:
ans = max(ans, len(T))
print(T)
S = input()
N = len(S)
ans = 0
for i in range(N):
for j in range(i + 1, N + 1):
T = S[i:j]
if T == T[::-1]:
ans = max(ans, len(T))
print(ans)
|
ConDefects/ConDefects/Code/abc320_b/Python/54935207
|
condefects-python_data_922
|
s=list(input())
ans=0
for i in range(len(s)):
for j in range(i+1,len(s)):
if s[i:j]==list(reversed(s[i:j])):
ans=max(j-i,ans)
print(ans)
s=list(input())
ans=0
for i in range(len(s)):
for j in range(i+1,len(s)+1):
if s[i:j]==list(reversed(s[i:j])):
ans=max(j-i,ans)
print(ans)
|
ConDefects/ConDefects/Code/abc320_b/Python/54242807
|
condefects-python_data_923
|
s=input()
ans=0
for i in range(len(s)):
for j in range(len(s)-i):
t=s[i:j+1]
tr=t[::-1]
if t==tr:
ans=max(ans,len(t))
print(ans)
s=input()
ans=0
for i in range(len(s)):
for j in range(i,len(s)):
t=s[i:j+1]
tr=t[::-1]
if t==tr:
ans=max(ans,len(t))
print(ans)
|
ConDefects/ConDefects/Code/abc320_b/Python/54975112
|
condefects-python_data_924
|
s = list(input())
max = 0
for i in range(len(s)):
for j in range(i+1,len(s)):
x = s[i:j]
x.reverse()
if s[i:j]==x and max<j-i:
max = j-i
print("{}".format(max))
s = list(input())
max = 0
for i in range(len(s)):
for j in range(i+1,len(s)+1):
x = s[i:j]
x.reverse()
if s[i:j]==x and max<j-i:
max = j-i
print("{}".format(max))
|
ConDefects/ConDefects/Code/abc320_b/Python/54243171
|
condefects-python_data_925
|
s = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679'
n = int(input())
print(float(s[:n+2]))
s = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679'
n = int(input())
print(s[:n+2])
|
ConDefects/ConDefects/Code/abc314_a/Python/45968783
|
condefects-python_data_926
|
pi = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
n = int(input())
print(pi[:n+1])
pi = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
n = int(input())
print(pi[:n+2])
|
ConDefects/ConDefects/Code/abc314_a/Python/46017209
|
condefects-python_data_927
|
S = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
N = int(input())
print(S[:N+3])
S = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
N = int(input())
print(S[:N+2])
|
ConDefects/ConDefects/Code/abc314_a/Python/45895663
|
condefects-python_data_928
|
pie = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
e = ""
for i in range(int(input())):
e += pie[i]
print(e)
pie = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
e = ""
for i in range(int(input())+2):
e += pie[i]
print(e)
|
ConDefects/ConDefects/Code/abc314_a/Python/46027498
|
condefects-python_data_929
|
S="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
N=int(input())
print(S[N+1])
S="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"
N=int(input())
print(S[0:N+2])
|
ConDefects/ConDefects/Code/abc314_a/Python/46014506
|
condefects-python_data_930
|
#ABC298G Strawberry War
'''
高々6行6列なのに、なんでこんなに難しそうなんだ。
区間DPに持ち込みたいところだが、切断方法からして難しすぎるんだよな。
より簡単な区間DPの問題はこうだよね。
「数直線上にケーキがある。適切に分割し、差を最小化せよ」
これだとしても難しいんだけど。残り切断回数を保持したDPにするかもね。
実際にシミュレートすると場合の数どうなるんだろ。
わからんね。解説ACを目指そう。
典型: 最小値を固定して最大値を最小化せよ
とのことだった。いうほど典型か？
ケーキの苺数候補の全列挙は？
これは簡単で、頂点のひとつを固定すればできる。O(H^2 * W^2)くらい。
DP[a][b][c][d][e]: a<=x<b, c<=y<d を満たす部分長方形を、苺の最小個数がX個になるよう
e個に切り分けるときの、最大値の最小値
不可能ならinf
'''
f=lambda:list(map(int,input().split()))
H,W,T=f(); S=[f() for i in range(H)]; Rh=range(H+1); Rw=range(W+1)
Ichigo=[[[[0]*(W+1) for i in Rw] for j in Rh] for k in Rh]; Candidate=set()
for h in Rh:
for w in Rw:
for L in range(h+1,H+1):
for D in range(w+1,W+1):
Ichigo[h][L][w][D]=sum(S[i][j] for i in range(h,L) for j in range(w,D))
Candidate.add(Ichigo[h][L][w][D])
INF=1e100; ans=INF
for X in Candidate: #各ピースの最小値をXとしてDP
DP=[[[[[INF]*(T+1) for i in Rw] for j in Rw] for k in Rh] for L in Rh]
for e in range(T+1):
for a in Rh:
for b in range(a+1,H+1):
for c in Rw:
for d in range(c+1,W+1):
if e==0 and Ichigo[a][b][c][d]>=X:
DP[a][b][c][d][e]=Ichigo[a][b][c][d]
if e and DP[a][b][c][d][e-1]==INF: continue #強めに枝刈り
if e and (b-a+1)*(d-c+1)<e: continue #時短
for t in range(1,e+1):
for x in range(a+1,b):
DP[a][b][c][d][e]=min(DP[a][b][c][d][e],
max(DP[a][x][c][d][t-1],
DP[x][b][c][d][e-t]))
for x in range(c+1,d):
DP[a][b][c][d][e]=min(DP[a][b][c][d][e],
max(DP[a][b][c][x][t-1],
DP[a][b][x][d][e-t]))
if DP[a][b][c][d][e]<X: DP[a][b][c][d][e]=INF
ans=min(ans,min(DP[a][b][c][d][T] for a in Rh for b in Rh for c in Rw for d in Rw)-X)
print(ans)
#ABC298G Strawberry War
'''
高々6行6列なのに、なんでこんなに難しそうなんだ。
区間DPに持ち込みたいところだが、切断方法からして難しすぎるんだよな。
より簡単な区間DPの問題はこうだよね。
「数直線上にケーキがある。適切に分割し、差を最小化せよ」
これだとしても難しいんだけど。残り切断回数を保持したDPにするかもね。
実際にシミュレートすると場合の数どうなるんだろ。
わからんね。解説ACを目指そう。
典型: 最小値を固定して最大値を最小化せよ
とのことだった。いうほど典型か？
ケーキの苺数候補の全列挙は？
これは簡単で、頂点のひとつを固定すればできる。O(H^2 * W^2)くらい。
DP[a][b][c][d][e]: a<=x<b, c<=y<d を満たす部分長方形を、苺の最小個数がX個になるよう
e個に切り分けるときの、最大値の最小値
不可能ならinf
'''
f=lambda:list(map(int,input().split()))
H,W,T=f(); S=[f() for i in range(H)]; Rh=range(H+1); Rw=range(W+1)
Ichigo=[[[[0]*(W+1) for i in Rw] for j in Rh] for k in Rh]; Candidate=set()
for h in Rh:
for w in Rw:
for L in range(h+1,H+1):
for D in range(w+1,W+1):
Ichigo[h][L][w][D]=sum(S[i][j] for i in range(h,L) for j in range(w,D))
Candidate.add(Ichigo[h][L][w][D])
INF=1e100; ans=INF
for X in Candidate: #各ピースの最小値をXとしてDP
DP=[[[[[INF]*(T+1) for i in Rw] for j in Rw] for k in Rh] for L in Rh]
for e in range(T+1):
for a in Rh:
for b in range(a+1,H+1):
for c in Rw:
for d in range(c+1,W+1):
if e==0 and Ichigo[a][b][c][d]>=X:
DP[a][b][c][d][e]=Ichigo[a][b][c][d]
if e and DP[a][b][c][d][e-1]==INF: continue #強めに枝刈り
if e and (b-a+1)*(d-c+1)<e: continue #時短
for t in range(1,e+1):
for x in range(a+1,b):
DP[a][b][c][d][e]=min(DP[a][b][c][d][e],
max(DP[a][x][c][d][t-1],
DP[x][b][c][d][e-t]))
for x in range(c+1,d):
DP[a][b][c][d][e]=min(DP[a][b][c][d][e],
max(DP[a][b][c][x][t-1],
DP[a][b][x][d][e-t]))
if DP[a][b][c][d][e]<X: DP[a][b][c][d][e]=INF
ans=min(ans,DP[0][H][0][W][T]-X)
print(ans)
|
ConDefects/ConDefects/Code/abc298_g/Python/41059627
|
condefects-python_data_931
|
s = list(input())
S = sorted(list(set(s)))
str = ""
for i in range(len(S)-1):
if i == 0:
str = S[0]
elif s.count(S[i]) > s.count(str):
str = S[i]
print(str)
s = list(input())
S = sorted(list(set(s)))
str = ""
for i in range(len(S)):
if i == 0:
str = S[0]
elif s.count(S[i]) > s.count(str):
str = S[i]
print(str)
|
ConDefects/ConDefects/Code/abc338_b/Python/54399591
|
condefects-python_data_932
|
mod = 998244353
N = int(input())
def S(A,B):
return (B-A+1)*(A+B)//2
ans = 0
for x in range(1,18):
if 10**x <= N:
ans += S(1,9*10**(x-1))
ans %= mod
else:
ans += S(1,N-10**(x-1)+1)
ans %= mod
break
print(ans)
mod = 998244353
N = int(input())
def S(A,B):
return (B-A+1)*(A+B)//2
ans = 0
for x in range(1,19):
if 10**x <= N:
ans += S(1,9*10**(x-1))
ans %= mod
else:
ans += S(1,N-10**(x-1)+1)
ans %= mod
break
print(ans)
|
ConDefects/ConDefects/Code/abc238_c/Python/44668354
|
condefects-python_data_933
|
N = int(input())
ans = 0
mod = 998244353
for i in range(1,19):
if i==1:
if N<9:
print(N)
exit()
ans += (9*10)//2
else:
MAX = int('9'*i)
if N <= MAX:
a = (N-(10**(i-1))+1)
ans += (a%mod)*((a+1)%mod)//2
ans %= mod
break
else:
a = (MAX-(10**(i-1))+1)
ans += (a%mod)*((a+1)%mod)//2
ans %= mod
print(ans)
N = int(input())
ans = 0
mod = 998244353
for i in range(1,19):
if i==1:
if N<9:
print(N*(N+1)//2)
exit()
ans += (9*10)//2
else:
MAX = int('9'*i)
if N <= MAX:
a = (N-(10**(i-1))+1)
ans += (a%mod)*((a+1)%mod)//2
ans %= mod
break
else:
a = (MAX-(10**(i-1))+1)
ans += (a%mod)*((a+1)%mod)//2
ans %= mod
print(ans)
|
ConDefects/ConDefects/Code/abc238_c/Python/45122649
|
condefects-python_data_934
|
def sum_of_f(n):
ans = 0
n1 = 1
while 10*n1 < n:
ans += (10*n1-1-n1+1)*(10*n1-1-n1+1+1)//2
ans = ans % 998244353
n1 *= 10
ans += (n-n1+1)*(n-n1+1+1)//2
ans = ans % 998244353
return ans
n = int(input())
print(sum_of_f(n))
def sum_of_f(n):
ans = 0
n1 = 1
while 10*n1 <= n:
ans += (10*n1-1-n1+1)*(10*n1-1-n1+1+1)//2
ans = ans % 998244353
n1 *= 10
ans += (n-n1+1)*(n-n1+1+1)//2
ans = ans % 998244353
return ans
n = int(input())
print(sum_of_f(n))
|
ConDefects/ConDefects/Code/abc238_c/Python/44681618
|
condefects-python_data_935
|
n = int(input())
a = [0] + list(map(int, input().split()))
ans = 0
b = [0 for i in range(25)]
f = [[0 for i in range(25)] for i in range(25)]
mx=0;
for i in range(1, n + 1):
for j in range(10):
mx=max(mx,f[j][a[i]-j+9])
ans+=mx
for j in range(10):
if(b[j]):f[a[i]][a[i]-j+9]=max(b[j],f[a[i]][a[i]-j+9])
b[a[i]]=i
print(ans)
n = int(input())
a = [0] + list(map(lambda x: int(x) - 1, input().split()))
ans = 0
b = [0 for i in range(25)]
f = [[0 for i in range(25)] for i in range(25)]
mx=0;
for i in range(1, n + 1):
for j in range(10):
mx=max(mx,f[j][a[i]-j+9])
ans+=mx
for j in range(10):
if(b[j]):f[a[i]][a[i]-j+9]=max(b[j],f[a[i]][a[i]-j+9])
b[a[i]]=i
print(ans)
|
ConDefects/ConDefects/Code/arc170_b/Python/52957349
|
condefects-python_data_936
|
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
single_last = [-1]*11
pair_last = [[-1]*11 for _ in range(11)]
triplet_dict = defaultdict(list)
for start in range(1,11):
for delta in range(-4,5):
if 1 <= start + 2*delta <= 10:
triplet_dict[start+2*delta].append((start, start + delta))
#print(triplet_dict[1])
count = 0
for i in range(N):
a = A[i]
last_idx = -1
for val1, val2 in triplet_dict[a]:
last_idx = max(last_idx, pair_last[val1][val2])
#print(val1, val2, pair_last[val1][val2])
if last_idx != -1:
#print("here")
count += last_idx + 1
# update data
for j in range(1,11):
pair_last[j][a] = single_last[j]
single_last[a] = i
# print(single_last)
# print("pl", pair_last[9][5])
print(count)
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
single_last = [-1]*11
pair_last = [[-1]*11 for _ in range(11)]
triplet_dict = defaultdict(list)
for start in range(1,11):
for delta in range(-4,5):
if 1 <= start + 2*delta <= 10:
triplet_dict[start+2*delta].append((start, start + delta))
#print(triplet_dict[1])
count = 0
last_idx = -1
for i in range(N):
a = A[i]
for val1, val2 in triplet_dict[a]:
last_idx = max(last_idx, pair_last[val1][val2])
#print(val1, val2, pair_last[val1][val2])
if last_idx != -1:
#print("here")
count += last_idx + 1
# update data
for j in range(1,11):
pair_last[j][a] = single_last[j]
single_last[a] = i
# print(single_last)
# print("pl", pair_last[9][5])
print(count)
|
ConDefects/ConDefects/Code/arc170_b/Python/50713909
|
condefects-python_data_937
|
n = int(input())
A = list(map(int, input().split()))
que = [[0 for i in range(n * 2 + 100)] for i in range(11)]
ql = [n + 2 for i in range(11)]
qr = [n + 2 for i in range(11)]
l = 0; r = -1
ans = 0
while l <= n - 1:
fl = 0
while fl == 0 and r <= n - 1:
for i in range(11):
if qr[i] > ql[i] and fl == 0:
for j in range(11):
if qr[j] > ql[j]:
k = j * 2 - i
if i == j:
if qr[j] - ql[j] < 3:
continue
if k in range(11) and qr[k] > ql[k]:
# print('nownumber:', i, j, k)
L = que[i][ql[i] + 1]
ql[i] += 1
R = que[k][qr[k]]
qr[k] -= 1
liml = n
limr = -1
# print(L, R)
bl = ql[j] + 1; br = qr[j]
# print(bl, br)
while bl <= br:
mid = (bl+br) // 2
# print(mid, que[j][mid])
if que[j][mid] > L:
liml = mid; br = mid - 1
else:
bl = mid + 1
# print(liml)
bl = ql[j] + 1; br = qr[j]
# print(bl, br)
while bl <= br:
mid = (bl+br) // 2
if que[j][mid] < R:
limr = mid; bl = mid + 1
else:
br = mid - 1
# print(limr)
ql[i] -= 1
qr[k] += 1
if liml <= limr:
fl = 1
break
# print('result :: ', fl, l, r)
# for i in range(11):
# print(i, end = ': ')
# for o in range(ql[i] + 1, qr[i] + 1):
# print(que[i][o], end=' ')
# print('\n')
if fl == 1:
break
if r == n - 1:
break
r += 1
qr[A[r]] += 1
que[A[r]][qr[A[r]]] = r
# print(fl, l, r)
if fl == 1:
ans += n - r
if l == n - 1:
break
ql[A[l]] += 1
l += 1
print(ans)
n = int(input())
A = list(map(int, input().split()))
que = [[0 for i in range(n * 2 + 100)] for i in range(11)]
ql = [n + 2 for i in range(11)]
qr = [n + 2 for i in range(11)]
l = 0; r = -1
ans = 0
while l <= n - 1:
fl = 0
while fl == 0 and r <= n - 1:
for i in range(11):
if qr[i] > ql[i] and fl == 0:
for j in range(11):
if qr[j] > ql[j]:
k = j * 2 - i
if i == j:
if qr[j] - ql[j] < 3:
continue
if k in range(11) and qr[k] > ql[k]:
# print('nownumber:', i, j, k)
L = que[i][ql[i] + 1]
ql[i] += 1
R = que[k][qr[k]]
qr[k] -= 1
liml = 2 * n + 100
limr = -1
# print(L, R)
bl = ql[j] + 1; br = qr[j]
# print(bl, br)
while bl <= br:
mid = (bl+br) // 2
# print(mid, que[j][mid])
if que[j][mid] > L:
liml = mid; br = mid - 1
else:
bl = mid + 1
# print(liml)
bl = ql[j] + 1; br = qr[j]
# print(bl, br)
while bl <= br:
mid = (bl+br) // 2
if que[j][mid] < R:
limr = mid; bl = mid + 1
else:
br = mid - 1
# print(limr)
ql[i] -= 1
qr[k] += 1
if liml <= limr:
fl = 1
break
# print('result :: ', fl, l, r)
# for i in range(11):
# print(i, end = ': ')
# for o in range(ql[i] + 1, qr[i] + 1):
# print(que[i][o], end=' ')
# print('\n')
if fl == 1:
break
if r == n - 1:
break
r += 1
qr[A[r]] += 1
que[A[r]][qr[A[r]]] = r
# print(fl, l, r)
if fl == 1:
ans += n - r
if l == n - 1:
break
ql[A[l]] += 1
l += 1
print(ans)
|
ConDefects/ConDefects/Code/arc170_b/Python/49807049
|
condefects-python_data_938
|
n = int(input())
A = list(map(lambda x: int(x)-1, input().split()))
d = 10
seen = [-1] * d
pair = [[-1] * d for _ in range(d)]
ret = 0
for r, rv in enumerate(A):
cnt = -1
for mv in range(d):
lv = 2*mv - rv
if lv < 0 or lv >= d: continue
# print(lv, mv, pair[lv][mv])
cnt = max(cnt, pair[lv][mv])
ret += cnt + 1
# print(r, rv, cnt)
for lv in range(d):
if seen[lv] == -1: continue
pair[lv][rv] = max(pair[lv][rv], seen[lv])
seen[rv] = r
# print("seen", seen)
# print("pair")
# for pi in pair:
# print(pi)
print(ret)
n = int(input())
A = list(map(lambda x: int(x)-1, input().split()))
d = 10
seen = [-1] * d
pair = [[-1] * d for _ in range(d)]
ret = 0
cnt = -1
for r, rv in enumerate(A):
for mv in range(d):
lv = 2*mv - rv
if lv < 0 or lv >= d: continue
# print(lv, mv, pair[lv][mv])
cnt = max(cnt, pair[lv][mv])
ret += cnt + 1
# print(r, rv, cnt)
for lv in range(d):
if seen[lv] == -1: continue
pair[lv][rv] = max(pair[lv][rv], seen[lv])
seen[rv] = r
# print("seen", seen)
# print("pair")
# for pi in pair:
# print(pi)
print(ret)
|
ConDefects/ConDefects/Code/arc170_b/Python/50027323
|
condefects-python_data_939
|
N = int(input())
A = list(map(int,input().split()))
def hantei(lst):
seen = set()
out = set()
for i in range(len(lst)):
if lst[i] in out:
return 0
for s in seen:
out.add(s+(s-lst[i]))
out.add(lst[i]+(lst[i]-s))
seen.add(lst[i])
return 1
bad = 0
for n in range(N):
for m in range(1,min(21,N-n+1)):
# print(*A[n:n+m],hantei(A[n:n+m]))
bad += hantei(A[n:n+m])
print((N*(N+1))//2-bad)
N = int(input())
A = list(map(int,input().split()))
def hantei(lst):
seen = set()
out = set()
for i in range(len(lst)):
if lst[i] in out:
return 0
for s in seen:
# out.add(s+(s-lst[i]))
out.add(lst[i]+(lst[i]-s))
seen.add(lst[i])
return 1
bad = 0
for n in range(N):
for m in range(1,min(21,N-n+1)):
# print(*A[n:n+m],hantei(A[n:n+m]))
bad += hantei(A[n:n+m])
print((N*(N+1))//2-bad)
|
ConDefects/ConDefects/Code/arc170_b/Python/50477019
|
condefects-python_data_940
|
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, d = mi()
r = li()
s = li()
L = []
R = []
S = []
for i in range(m - 1, 0, -1):
L.append(-r[i + 1])
R.append(-r[i])
S.append(s[i])
L.append(-r[1])
R.append(r[1] + 1)
S.append(s[0])
for i in range(1, m):
L.append(r[i] + 1)
R.append(r[i + 1] + 1)
S.append(s[i])
x = [0] * (d + 1)
a = -(n * d) // 2
for i in range(2 * m - 1):
if L[i] - a >= n * d:
x[0] -= n * S[i]
x[d] += n * S[i]
elif L[i] - a >= 1:
x[0] -= (L[i] - a + d) // d * S[i]
x[(L[i] - a) % d] += S[i]
x[d] += (L[i] - a) // d * S[i]
if R[i] - a >= n * d:
x[0] += n * S[i]
x[d] -= n * S[i]
elif R[i] - a >= 1:
x[0] += (R[i] - a + d) // d * S[i]
x[(R[i] - a) % d] -= S[i]
x[d] -= (R[i] - a) // d * S[i]
ans = 0
now = 0
for i in range(0, d):
now += x[i]
ans = max(ans, now)
print(ans)
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, d = mi()
r = li()
s = li()
L = []
R = []
S = []
for i in range(m - 1, 0, -1):
L.append(-r[i + 1])
R.append(-r[i])
S.append(s[i])
L.append(-r[1])
R.append(r[1] + 1)
S.append(s[0])
for i in range(1, m):
L.append(r[i] + 1)
R.append(r[i + 1] + 1)
S.append(s[i])
x = [0] * (d + 1)
a = -(n * d // 2)
for i in range(2 * m - 1):
if L[i] - a >= n * d:
x[0] -= n * S[i]
x[d] += n * S[i]
elif L[i] - a >= 1:
x[0] -= (L[i] - a + d) // d * S[i]
x[(L[i] - a) % d] += S[i]
x[d] += (L[i] - a) // d * S[i]
if R[i] - a >= n * d:
x[0] += n * S[i]
x[d] -= n * S[i]
elif R[i] - a >= 1:
x[0] += (R[i] - a + d) // d * S[i]
x[(R[i] - a) % d] -= S[i]
x[d] -= (R[i] - a) // d * S[i]
ans = 0
now = 0
for i in range(0, d):
now += x[i]
ans = max(ans, now)
print(ans)
|
ConDefects/ConDefects/Code/arc131_d/Python/33558182
|
condefects-python_data_941
|
n, m, d = map(int, input().split())
arr = list(map(int, input().split()))
scores = list(map(int, input().split()))+[0]
if n == 1:
print(scores[0])
exit()
pos = list(range(-d*(n//2), d*((n+1)//2), d))
ans = 0
i = 1
for sc in range(0, d*((n+1)//2), d):
while i <= m and arr[i] < sc:
i += 1
ans += scores[i-1]
i = 1
for sc in range(d, d*(n//2+1), d):
while i <= m and arr[i] < sc:
i += 1
ans += scores[i-1]
xd = [0]*d
for i in range(1, m+1):
x = arr[i]
if x < d*((n+1)//2):
xd[x%d] += scores[i]-scores[i-1]
for i in range(1, m+1):
x = -arr[i]
if x > -d*(n//2):
xd[(x%d-1)%d] -= scores[i]-scores[i-1]
for i in range(1, d):
xd[i] += xd[i-1]
print(ans+max(xd))
n, m, d = map(int, input().split())
arr = list(map(int, input().split()))
scores = list(map(int, input().split()))+[0]
if n == 1:
print(scores[0])
exit()
pos = list(range(-d*(n//2), d*((n+1)//2), d))
ans = 0
i = 1
for sc in range(0, d*((n+1)//2), d):
while i <= m and arr[i] < sc:
i += 1
ans += scores[i-1]
i = 1
for sc in range(d, d*(n//2+1), d):
while i <= m and arr[i] < sc:
i += 1
ans += scores[i-1]
xd = [0]*d
for i in range(1, m+1):
x = arr[i]
if x < d*((n+1)//2):
xd[x%d] += scores[i]-scores[i-1]
for i in range(1, m+1):
x = -arr[i]
if x > -d*(n//2):
xd[(x%d-1)%d] -= scores[i]-scores[i-1]
for i in range(1, d):
xd[i] += xd[i-1]
print(ans+max(0, max(xd)))
|
ConDefects/ConDefects/Code/arc131_d/Python/27742025
|
condefects-python_data_942
|
N, M, D = map(int, input().split())
R = list(map(int, input().split()))
S = list(map(int, input().split())) + [0]
imos = [0]*D
p = (N+1)//2 * D
m = N//2 * D
imos[0] = S[0]
ind = 1
for i in range(1,N//2+1):
if i*D > R[-1]: break
while i*D > R[ind]: ind += 1
imos[0] += S[ind-1]
if i<N//2 or N%2: imos[0] += S[ind-1]
for i in range(1,M+1):
if R[i]+1 <= p and (R[i]+1)%D!=0:
imos[(R[i]+1)%D] += S[i]-S[i-1]
if -R[i] >= -m:
r = (-R[i])%D
imos[r] += S[i-1]
if r > 0:
imos[r] -= S[i]
ans = score = imos[0]
for i in range(1,D):
score += imos[i]
ans = max(ans, score)
print(ans)
N, M, D = map(int, input().split())
R = list(map(int, input().split()))
S = list(map(int, input().split())) + [0]
imos = [0]*D
p = (N+1)//2 * D
m = N//2 * D
imos[0] = S[0]
ind = 1
for i in range(1,N//2+1):
if i*D > R[-1]: break
while i*D > R[ind]: ind += 1
imos[0] += S[ind-1]
if i<N//2 or N%2: imos[0] += S[ind-1]
for i in range(1,M+1):
if R[i]+1 <= p and (R[i]+1)%D!=0:
imos[(R[i]+1)%D] += S[i]-S[i-1]
if -R[i] >= -m:
r = (-R[i])%D
if r > 0:
imos[r] += S[i-1]
imos[r] -= S[i]
ans = score = imos[0]
for i in range(1,D):
score += imos[i]
ans = max(ans, score)
print(ans)
|
ConDefects/ConDefects/Code/arc131_d/Python/27741393
|
condefects-python_data_943
|
import sys
if sys.argv[-1] == 'ONLINE_JUDGE':
import os
import re
with open(__file__) as f:
source = f.read().split('###''nbacl')
for s in source[1:]:
s = re.sub("'''.*", '', s)
sp = s.split(maxsplit=1)
if os.path.dirname(sp[0]):
os.makedirs(os.path.dirname(sp[0]), exist_ok=True)
with open(sp[0], 'w') as f:
f.write(sp[1])
from nbmodule import cc
cc.compile()
import numpy as np
from numpy import int64
from nbmodule import solve
def main(in_file):
f = open(in_file)
N, M, D = np.fromstring(f.readline(), dtype=int64, sep=' ')
r = np.fromstring(f.readline(), dtype=int64, sep=' ')
s = np.fromstring(f.readline(), dtype=int64, sep=' ')
s = np.append(s, 0)
ans = solve(N, M, D, r[1:], s)
print(ans)
if __name__ == '__main__':
main(0)
'''
###nbacl nbmodule.py
import numpy as np
from numpy import int64
from numba import njit, i8
from numba.pycc import CC
cc = CC('nbmodule')
# @njit
@cc.export('solve', (i8, i8, i8, i8[:], i8[:]))
def solve(N, M, D, r, s):
dif = s[: -1] - s[1:]
n_left = N // 2
maxc = (D + 1) // 2
imo = np.zeros(maxc, int64)
b = -D * n_left
p = M
for i in range(n_left):
babs = -b
while p > 0 and babs <= r[p - 1]:
p -= 1
imo[0] += s[p]
k = p
for i in range(k - 1, -1, -1):
x = babs - r[i]
if x < maxc:
imo[x] += dif[i]
else:
break
b += D
p = 0
for i in range(n_left, N):
while p < M and b > r[p]:
p += 1
imo[0] += s[p]
k = p
for i in range(k, M):
x = r[i] - b + 1
if x < maxc:
imo[x] -= dif[i]
else:
break
b += D
point = imo[0]
pmax = imo[0]
for i in range(1, maxc):
point += imo[i]
pmax = max(pmax, point)
return pmax
if __name__ == '__main__':
cc.compile()
'''
import sys
if sys.argv[-1] == 'ONLINE_JUDGE':
import os
import re
with open(__file__) as f:
source = f.read().split('###''nbacl')
for s in source[1:]:
s = re.sub("'''.*", '', s)
sp = s.split(maxsplit=1)
if os.path.dirname(sp[0]):
os.makedirs(os.path.dirname(sp[0]), exist_ok=True)
with open(sp[0], 'w') as f:
f.write(sp[1])
from nbmodule import cc
cc.compile()
import numpy as np
from numpy import int64
from nbmodule import solve
def main(in_file):
f = open(in_file)
N, M, D = np.fromstring(f.readline(), dtype=int64, sep=' ')
r = np.fromstring(f.readline(), dtype=int64, sep=' ')
s = np.fromstring(f.readline(), dtype=int64, sep=' ')
s = np.append(s, 0)
ans = solve(N, M, D, r[1:], s)
print(ans)
if __name__ == '__main__':
main(0)
'''
###nbacl nbmodule.py
import numpy as np
from numpy import int64
from numba import njit, i8
from numba.pycc import CC
cc = CC('nbmodule')
# @njit
@cc.export('solve', (i8, i8, i8, i8[:], i8[:]))
def solve(N, M, D, r, s):
dif = s[: -1] - s[1:]
n_left = N // 2
maxc = D // 2 + 1
imo = np.zeros(maxc, int64)
b = -D * n_left
p = M
for i in range(n_left):
babs = -b
while p > 0 and babs <= r[p - 1]:
p -= 1
imo[0] += s[p]
k = p
for i in range(k - 1, -1, -1):
x = babs - r[i]
if x < maxc:
imo[x] += dif[i]
else:
break
b += D
p = 0
for i in range(n_left, N):
while p < M and b > r[p]:
p += 1
imo[0] += s[p]
k = p
for i in range(k, M):
x = r[i] - b + 1
if x < maxc:
imo[x] -= dif[i]
else:
break
b += D
point = imo[0]
pmax = imo[0]
for i in range(1, maxc):
point += imo[i]
pmax = max(pmax, point)
return pmax
if __name__ == '__main__':
cc.compile()
'''
|
ConDefects/ConDefects/Code/arc131_d/Python/27771010
|
condefects-python_data_944
|
N=int(input())
C=list(map(int,input().split()))
mn=min(C)
cnt=N//mn
ans=[]
print(cnt,mn)
for i in range(cnt):
for j in range(8,-1,-1):
if C[j]+(cnt-(i+1))*mn<=N:
ans.append(j+1)
N-=C[j]
break
print(''.join(map(str, ans)))
N=int(input())
C=list(map(int,input().split()))
mn=min(C)
cnt=N//mn
ans=[]
#print(cnt,mn)
for i in range(cnt):
for j in range(8,-1,-1):
if C[j]+(cnt-(i+1))*mn<=N:
ans.append(j+1)
N-=C[j]
break
print(''.join(map(str, ans)))
|
ConDefects/ConDefects/Code/abc257_e/Python/46192635
|
condefects-python_data_945
|
import sys
from functools import lru_cache
from collections import defaultdict
sys.setrecursionlimit(10**9)
def I(): return input()
def IS(): return input().split()
def II(): return int(input())
def LI(): return list(input())
def MI(): return map(int,input().split())
def LMI(): return list(map(int,input().split()))
def LLMI(number): return [list(map(int,input().split())) for _ in range(number)]
def generate_input()->list:
import random
inputdata = []
n = random.randint(0, 100)
inputdata.append(n)
return inputdata
def simple_solve(n):
ans = 0
return ans
def solve(n, c):
min_cost = min(c)
digits = n // min_cost
new_c = []
for v in c:
new_c.append(v - min_cost)
remain_cash = n - (digits * min_cost)
new_c.reverse()
ans = []
for i, v in enumerate(new_c):
if remain_cash >= v:
if v == 0:
cnt = digits - len(ans)
else:
cnt = remain_cash // v
remain_cash -= cnt * v
for j in range(cnt):
ans.append(str(9-i))
else:
continue
return ''.join(ans)
if __name__=='__main__':
test = False
if test:
inputdata = generate_input()
a = simple_solve(*inputdata)
b = solve(*inputdata)
if a != b:
print(*inputdata)
print(a, b)
exit(1)
else:
inputdata = []
inputdata.append(II())
inputdata.append(LMI())
print(solve(*inputdata))
import sys
from functools import lru_cache
from collections import defaultdict
sys.setrecursionlimit(10**9)
def I(): return input()
def IS(): return input().split()
def II(): return int(input())
def LI(): return list(input())
def MI(): return map(int,input().split())
def LMI(): return list(map(int,input().split()))
def LLMI(number): return [list(map(int,input().split())) for _ in range(number)]
def generate_input()->list:
import random
inputdata = []
n = random.randint(0, 100)
inputdata.append(n)
return inputdata
def simple_solve(n):
ans = 0
return ans
def solve(n, c):
min_cost = min(c)
digits = n // min_cost
new_c = []
for v in c:
new_c.append(v - min_cost)
remain_cash = n - (digits * min_cost)
new_c.reverse()
ans = []
for i, v in enumerate(new_c):
if remain_cash >= v:
if v == 0:
cnt = digits - len(ans)
else:
cnt = remain_cash // v
remain_cash -= cnt * v
for j in range(cnt):
ans.append(str(9-i))
else:
continue
if len(ans) == digits:
break
return ''.join(ans)
if __name__=='__main__':
test = False
if test:
inputdata = generate_input()
a = simple_solve(*inputdata)
b = solve(*inputdata)
if a != b:
print(*inputdata)
print(a, b)
exit(1)
else:
inputdata = []
inputdata.append(II())
inputdata.append(LMI())
print(solve(*inputdata))
|
ConDefects/ConDefects/Code/abc257_e/Python/45047426
|
condefects-python_data_946
|
n, m = map(int, input().split())
A, B, C = map(lambda x : int(x) - 1, input().split())
G = [[] for _ in range(n)]
for _ in range(m) :
u, v = map(lambda x : int(x) - 1, input().split())
G[u].append(v); G[v].append(u)
dfn, low = [-1] * n, [-1] * n
tot = 0
bcc = []
stk_DFS = [(-1, A, 0)]
stk_v = []
while len(stk_DFS) > 0:
f, u, vid = stk_DFS.pop()
if vid == 0 :
stk_v.append(u)
dfn[u] = low[u] = tot
tot += 1
if vid < len(G[u]) and G[u][vid] == f : vid += 1
if vid >= len(G[u]) :
if f == -1 : continue
low[f] = min(low[f], low[u])
if low[u] < dfn[f]: continue
else:
nbcc = []
while len(stk_v) > 0 and stk_v[-1] != u :
nbcc.append(stk_v.pop())
nbcc.append(stk_v.pop())
nbcc.append(f)
bcc.append(nbcc)
else:
v = G[u][vid]
stk_DFS.append((f, u, vid + 1))
if dfn[v] == -1:
stk_DFS.append((u, v, 0))
else:
low[u] = min(low[u], low[v])
old_n = n
bcc_cnt = len(bcc)
nG = [[] for _ in range(n + bcc_cnt)]
for b in bcc:
for v in b:
nG[v].append(n)
nG[n].append(v)
n += 1
fa = [-1] * n
ndfn, nbot = [-1] * n, [-1] * n
tot = 0
stk_DFS = [(-1, A, 0)]
reach = [-1] * n
while len(stk_DFS) > 0:
f, u, vid = stk_DFS.pop()
if vid == 0:
reach[u] = 1
ndfn[u] = tot
tot += 1
if vid < len(nG[u]) and nG[u][vid] == f : vid += 1
if vid >= len(nG[u]):
nbot[u] = tot - 1
else:
v = nG[u][vid]
fa[v] = u
stk_DFS.append((f, u, vid + 1))
stk_DFS.append((u, v, 0))
q = 1
ans = [0] * q
if reach[B] and reach[C] and ndfn[C] >= ndfn[fa[B]] \
and ndfn[C] <= nbot[fa[B]] : ans[0] = 1
else : ans[0] = 0
for i in range(q):
print('Yes' if ans[i] else 'No')
n, m = map(int, input().split())
A, B, C = map(lambda x : int(x) - 1, input().split())
G = [[] for _ in range(n)]
for _ in range(m) :
u, v = map(lambda x : int(x) - 1, input().split())
G[u].append(v); G[v].append(u)
dfn, low = [-1] * n, [-1] * n
tot = 0
bcc = []
stk_DFS = [(-1, A, 0)]
stk_v = []
while len(stk_DFS) > 0:
f, u, vid = stk_DFS.pop()
if vid == 0 :
stk_v.append(u)
dfn[u] = low[u] = tot
tot += 1
if vid < len(G[u]) and G[u][vid] == f : vid += 1
if vid >= len(G[u]) :
if f == -1 : continue
low[f] = min(low[f], low[u])
if low[u] < dfn[f]: continue
else:
nbcc = []
while len(stk_v) > 0 and stk_v[-1] != u :
nbcc.append(stk_v.pop())
nbcc.append(stk_v.pop())
nbcc.append(f)
bcc.append(nbcc)
else:
v = G[u][vid]
stk_DFS.append((f, u, vid + 1))
if dfn[v] == -1:
stk_DFS.append((u, v, 0))
else:
low[u] = min(low[u], dfn[v])
old_n = n
bcc_cnt = len(bcc)
nG = [[] for _ in range(n + bcc_cnt)]
for b in bcc:
for v in b:
nG[v].append(n)
nG[n].append(v)
n += 1
fa = [-1] * n
ndfn, nbot = [-1] * n, [-1] * n
tot = 0
stk_DFS = [(-1, A, 0)]
reach = [-1] * n
while len(stk_DFS) > 0:
f, u, vid = stk_DFS.pop()
if vid == 0:
reach[u] = 1
ndfn[u] = tot
tot += 1
if vid < len(nG[u]) and nG[u][vid] == f : vid += 1
if vid >= len(nG[u]):
nbot[u] = tot - 1
else:
v = nG[u][vid]
fa[v] = u
stk_DFS.append((f, u, vid + 1))
stk_DFS.append((u, v, 0))
q = 1
ans = [0] * q
if reach[B] and reach[C] and ndfn[C] >= ndfn[fa[B]] \
and ndfn[C] <= nbot[fa[B]] : ans[0] = 1
else : ans[0] = 0
for i in range(q):
print('Yes' if ans[i] else 'No')
|
ConDefects/ConDefects/Code/abc318_g/Python/53538516
|
condefects-python_data_947
|
numbers = []
nine = set(list(i for i in range(1,10)))
def check_row(data):
for i in data:
if nine != set(i):
return False
return True
def check_col(data):
for i in zip(*data):
if nine != set(i):
return False
return True
def check_block(data):
for i in range(0,9,3):
for j in range(0,9,3):
num = set()
for row in range(3):
for col in range(3):
num.add(data[row][col])
if nine != num:
return False
return True
for i in range(9):
a = list(map(int,input().split()))
numbers.append(a)
if check_col(numbers) and check_row(numbers) and check_block(numbers):
print("Yes")
else:
print("No")
numbers = []
nine = set(list(i for i in range(1,10)))
def check_row(data):
for i in data:
if nine != set(i):
return False
return True
def check_col(data):
for i in zip(*data):
if nine != set(i):
return False
return True
def check_block(data):
for i in range(0,9,3):
for j in range(0,9,3):
num = set()
for row in range(3):
for col in range(3):
num.add(data[row+i][col+j])
if nine != num:
return False
return True
for i in range(9):
a = list(map(int,input().split()))
numbers.append(a)
if check_col(numbers) and check_row(numbers) and check_block(numbers):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_c/Python/55003503
|
condefects-python_data_948
|
n, n2 = 3, 9
grid = [list(map(int, input().split())) for _ in range(n2)]
rows = [[False] * n2 for _ in range(n2)]
cols = [[False] * n2 for _ in range(n2)]
blocks = [[[False] * n2 for _ in range(n)] for _ in range(n)]
# print(blocks)
valid = True
for i, line in enumerate(grid):
for j, num in enumerate(line):
if not rows[i][num - 1] and not cols[j][num - 1] and not blocks[i // n][j // n][num - 1]:
rows[i][num - 1] = True
cols[j][num - 1] = True
blocks[i % n][j % n][num - 1] = True
else:
valid = False
break
print('Yes' if valid else 'No')
n, n2 = 3, 9
grid = [list(map(int, input().split())) for _ in range(n2)]
rows = [[False] * n2 for _ in range(n2)]
cols = [[False] * n2 for _ in range(n2)]
blocks = [[[False] * n2 for _ in range(n)] for _ in range(n)]
# print(blocks)
valid = True
for i, line in enumerate(grid):
for j, num in enumerate(line):
if not rows[i][num - 1] and not cols[j][num - 1] and not blocks[i // n][j // n][num - 1]:
rows[i][num - 1] = True
cols[j][num - 1] = True
blocks[i // n][j // n][num - 1] = True
else:
valid = False
break
print('Yes' if valid else 'No')
|
ConDefects/ConDefects/Code/abc327_c/Python/54292566
|
condefects-python_data_949
|
n, m = 9, 3
a = [list(map(int, input().split())) for _ in range(n)]
row = [set() for _ in range(n)]
col = [set() for _ in range(n)]
block = [[set() for j in range(m)] for i in range(m)]
for i in range(n):
for j in range(n):
row[i].add(a[i][j])
col[j].add(a[i][j])
block[i//m][j//m].add(a[i][j])
if (
all(len(r) == 9 for r in row)
and all(len(c) == 9 for c in col)
and all(len(b) == 9 for b in block)
):
print("Yes")
else:
print("No")
n, m = 9, 3
a = [list(map(int, input().split())) for _ in range(n)]
row = [set() for _ in range(n)]
col = [set() for _ in range(n)]
block = [[set() for j in range(m)] for i in range(m)]
for i in range(n):
for j in range(n):
row[i].add(a[i][j])
col[j].add(a[i][j])
block[i//m][j//m].add(a[i][j])
if (
all(len(r) == 9 for r in row)
and all(len(c) == 9 for c in col)
and all(all(len(b) == 9 for b in br) for br in block)
):
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc327_c/Python/53953010
|
condefects-python_data_950
|
N = [0]*9
print()
for i in range(9):
l = list(map(int,input().split()))
if len(set(l))<9:
print("No")
exit()
N[i] = l
RN = list(zip(*reversed(N)))
for l in RN:
if len(set(l))<9:
print("No")
exit()
a = set()
b = set()
c = set()
for i in range(3):
for j in range(3):
a|=set(N[3*i+j][:3])
b|=set(N[3*i+j][3:6])
c|=set(N[3*i+j][-3:])
if len(a)<9 or len(b)<9 or len(c)<9:
print(i,a,b,c)
print("No")
exit()
a = set()
b = set()
c = set()
print("Yes")
N = [0]*9
for i in range(9):
l = list(map(int,input().split()))
if len(set(l))<9:
print("No")
exit()
N[i] = l
RN = list(zip(*reversed(N)))
for l in RN:
if len(set(l))<9:
print("No")
exit()
a = set()
b = set()
c = set()
for i in range(3):
for j in range(3):
a|=set(N[3*i+j][:3])
b|=set(N[3*i+j][3:6])
c|=set(N[3*i+j][-3:])
if len(a)<9 or len(b)<9 or len(c)<9:
print("No")
exit()
a = set()
b = set()
c = set()
print("Yes")
|
ConDefects/ConDefects/Code/abc327_c/Python/53791551
|
condefects-python_data_951
|
def dfs(s):
time = [-1] * n
st = [s]
time[s] = 0
parent = [-1] * n
while st:
i = st.pop()
ti = time[i]
for j in edges[i]:
if time[j] > -1:
continue
parent[j] = i
time[j] = ti + 1
st.append(j)
return time, parent
n = int(input())
edges = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
time, parent = dfs(0)
s = time.index(max(time))
time, parent = dfs(s)
d = max(time)
t = time.index(d)
c = [t]
while t != s:
t = parent[t]
c.append(t)
rc = c.copy()
rc.reverse()
ln = len(bin(n)) - 1
left = [-1] * (n * ln)
right = [-1] * (n * ln)
for i in range(len(c) - 1):
left[rc[i] * ln] = rc[i + 1]
right[c[i] * ln] = c[i + 1]
for i in range(n):
if right[i * ln] > -1:
continue
p = parent[i]
left[i * ln] = p
right[i * ln] = p
for j in range(ln - 1):
for i in range(n):
lij = left[i * ln + j]
if lij > -1:
left[i * ln + j + 1] = left[lij * ln + j]
rij = right[i * ln + j]
if rij > -1:
right[i * ln + j + 1] = right[rij * ln + j]
def solve(go, u, k):
while k:
l = len(bin(k)) - 3
u = go[u * ln + l]
if u < 0:
return -1
k -= 1 << l
return u + 1
q = int(input())
for i in range(q):
u, k = map(int, input().split())
u -= 1
print(max(solve(left, u, k), solve(right, u, k)))
def dfs(s):
time = [-1] * n
st = [s]
time[s] = 0
parent = [-1] * n
while st:
i = st.pop()
ti = time[i]
for j in edges[i]:
if time[j] > -1:
continue
parent[j] = i
time[j] = ti + 1
st.append(j)
return time, parent
n = int(input())
edges = [[] for i in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
edges[a].append(b)
edges[b].append(a)
time, parent = dfs(0)
s = time.index(max(time))
time, parent = dfs(s)
d = max(time)
t = time.index(d)
c = [t]
while t != s:
t = parent[t]
c.append(t)
rc = c.copy()
rc.reverse()
ln = len(bin(n)) - 1
left = [-1] * (n * ln)
right = [-1] * (n * ln)
for i in range(len(c) - 1):
left[rc[i] * ln] = rc[i + 1]
right[c[i] * ln] = c[i + 1]
for i in range(n):
if right[i * ln] > -1 or left[i * ln] > -1:
continue
p = parent[i]
left[i * ln] = p
right[i * ln] = p
for j in range(ln - 1):
for i in range(n):
lij = left[i * ln + j]
if lij > -1:
left[i * ln + j + 1] = left[lij * ln + j]
rij = right[i * ln + j]
if rij > -1:
right[i * ln + j + 1] = right[rij * ln + j]
def solve(go, u, k):
while k:
l = len(bin(k)) - 3
u = go[u * ln + l]
if u < 0:
return -1
k -= 1 << l
return u + 1
q = int(input())
for i in range(q):
u, k = map(int, input().split())
u -= 1
print(max(solve(left, u, k), solve(right, u, k)))
|
ConDefects/ConDefects/Code/abc267_f/Python/45545460
|
condefects-python_data_952
|
import numpy as np
import bisect
w, h = map(int,input().split())
n = int(input())
ichigo = [ list(map(int,input().split())) for _ in range(n)]
A = int(input())
a = list(map(int,input().split()))
B = int(input())
b = list(map(int,input().split()))
ans = {}
for i in range(n):
s = bisect.bisect(a,ichigo[i][0])
t = bisect.bisect(b,ichigo[i][1])
if (s,t) in ans:
ans[(s,t)] += 1
else:
ans[(s,t)] = 1
lis = list(ans.values())
M = max(lis)
if len(ans) == (A+1)*(B+1):
n = min(lis)
else:
n = 0
print(M,n)
import numpy as np
import bisect
w, h = map(int,input().split())
n = int(input())
ichigo = [ list(map(int,input().split())) for _ in range(n)]
A = int(input())
a = list(map(int,input().split()))
B = int(input())
b = list(map(int,input().split()))
ans = {}
for i in range(n):
s = bisect.bisect(a,ichigo[i][0])
t = bisect.bisect(b,ichigo[i][1])
if (s,t) in ans:
ans[(s,t)] += 1
else:
ans[(s,t)] = 1
lis = list(ans.values())
M = max(lis)
if len(ans) == (A+1)*(B+1):
n = min(lis)
else:
n = 0
print(n,M)
|
ConDefects/ConDefects/Code/abc304_d/Python/45574429
|
condefects-python_data_953
|
def judge1():
def judge2(u, idx):
for i in range(N):
if i == idx:
continue
if u in ST[i]:
return False
return True
N = int(input())
ST = [input().split() for _ in range(N)]
for i in range(N):
si, ti = ST[i]
if judge2(si, i) == False or judge2(ti, i) == False:
return False
return True
print('Yes' if judge1() == True else 'No')
def judge1():
def judge2(u, idx):
for i in range(N):
if i == idx:
continue
if u in ST[i]:
return False
return True
N = int(input())
ST = [input().split() for _ in range(N)]
for i in range(N):
si, ti = ST[i]
if not (judge2(si, i) or judge2(ti, i)):
return False
return True
print('Yes' if judge1() == True else 'No')
|
ConDefects/ConDefects/Code/abc247_b/Python/46174870
|
condefects-python_data_954
|
# 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]
# ///////////////////////////////////////////////////////////////////////////
N = int(input())
names = [input().split() for _ in range(N)]
counter = Counter()
for i, j in names:
counter[i] += 1
counter[j] += 1
for i, j in names:
if counter[i] > 1 and counter[j] > 1:
print("No")
exit()
print("Yes")
# 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]
# ///////////////////////////////////////////////////////////////////////////
N = int(input())
names = [input().split() for _ in range(N)]
counter = Counter()
for i, j in names:
counter[i] += 1
counter[j] += 1
for i, j in names:
if counter[i] > 1 and counter[j] > 1:
if i == j and counter[i] == 2:
continue
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc247_b/Python/46187946
|
condefects-python_data_955
|
from collections import defaultdict
N = int(input())
name = []
d = defaultdict(int)
for i in range(N):
s, t = input().split()
name.append((s, t))
d[s] += 1
d[t] += 1
dp = [[set()]*(2) for _ in range(N+1)]
for i in range(N):
for j in range(2):
if d[name[i][j]] != 1:
continue
dp[i+1][j] = dp[i][j].copy()
dp[i+1][j].add(name[i][j])
if len(dp[-1][0]) == N or len(dp[-1][1]) == N:
print("Yes")
else:
print("No")
from collections import defaultdict
N = int(input())
name = []
d = defaultdict(int)
for i in range(N):
s, t = input().split()
name.append((s, t))
d[s] += 1
if s == t:
continue
d[t] += 1
dp = [[set()]*(2) for _ in range(N+1)]
for i in range(N):
for j in range(2):
if d[name[i][j]] != 1:
continue
dp[i+1][j] = dp[i][j].copy()
dp[i+1][j].add(name[i][j])
if len(dp[-1][0]) == N or len(dp[-1][1]) == N:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc247_b/Python/46225194
|
condefects-python_data_956
|
N = int(input())
names = []
for _ in range(N):
first, last = input().split()
names.append((first, last))
for i in range(N):
i_first, i_last = names[i]
is_first_ok, is_last_ok = True, True
for j in range(N):
if i_first in names[j]:
is_first_ok = False
if i_last in names[j]:
is_last_ok = False
if is_first_ok or is_last_ok:
continue
else:
print("No")
exit()
print("Yes")
N = int(input())
names = []
for _ in range(N):
first, last = input().split()
names.append((first, last))
for i in range(N):
i_first, i_last = names[i]
is_first_ok, is_last_ok = True, True
for j in range(N):
if i == j:
continue
if i_first in names[j]:
is_first_ok = False
if i_last in names[j]:
is_last_ok = False
if is_first_ok or is_last_ok:
continue
else:
print("No")
exit()
print("Yes")
|
ConDefects/ConDefects/Code/abc247_b/Python/45068335
|
condefects-python_data_957
|
from collections import defaultdict
n = int(input())
s = [""] * n
t = [""] * n
d = defaultdict(int)
for i in range(n):
s[i], t[i] = input().split()
d[s[i]] += 1
d[t[i]] += 1
for i in range(n):
if d[s[i]] >= 2 and d[t[i]] >= 2:
exit(print("No"))
print("Yes")
from collections import defaultdict
n = int(input())
s = [""] * n
t = [""] * n
d = defaultdict(int)
for i in range(n):
s[i], t[i] = input().split()
d[s[i]] += 1
d[t[i]] += 1
for i in range(n):
if (s[i] == t[i] and d[s[i]] > 2) or (s[i] != t[i] and d[s[i]] >= 2 and d[t[i]] >= 2):
exit(print("No"))
print("Yes")
|
ConDefects/ConDefects/Code/abc247_b/Python/46048925
|
condefects-python_data_958
|
import math
a, b = list(map(int, input().split(' ')))
if a < b:
tmp = b
b = a
a = tmp
ans = 0
while b > 0:
ans += int(a / b)
a = a % b
tmp = a
a = b
b = tmp
print(ans-1)
import math
a, b = list(map(int, input().split(' ')))
if a < b:
tmp = b
b = a
a = tmp
ans = 0
while b > 0:
ans += a // b
a = a % b
tmp = a
a = b
b = tmp
print(ans-1)
|
ConDefects/ConDefects/Code/abc297_d/Python/45529790
|
condefects-python_data_959
|
n = int(input())
A = list(map(int, input().split()))
p = int(input())
X = list(map(int, input().split()))
q = int(input())
Y = list(map(int, input().split()))
MOD1 = 10 ** 9 + 7
MOD2 = 10 ** 9 + 7
base = 123451000
hX = [0]
hX2 = [0]
for v in X:
nex = (hX[-1] * base) + v
hX.append(nex % MOD1)
nex = (hX2[-1] * base) + v
hX2.append(nex % MOD2)
hY = [0]
hY2 = [0]
for v in Y:
nex = (hY[-1] * base) + v
hY.append(nex % MOD1)
nex = (hY2[-1] * base) + v
hY2.append(nex % MOD2)
hA = [0]
hA2 = [0]
for v in A:
nex = (hA[-1] * base) + v
hA.append(nex % MOD1)
nex = (hA2[-1] * base) + v
hA2.append(nex % MOD2)
lo = 0
hi = min(p, q) + 1
while hi - lo > 1:
mid = (lo + hi) // 2
mult = pow(base, mid, MOD1)
mult2 = pow(base, mid, MOD2)
wX = []
for i in range(p - mid + 1):
h1 = (hX[i + mid] - mult * hX[i]) % MOD1
h2 = (hX2[i + mid] - mult2 * hX2[i]) % MOD2
wX.append((h1 << 30) + h2)
wY = []
for i in range(q - mid + 1):
h1 = (hY[i + mid] - mult * hY[i]) % MOD1
h2 = (hY2[i + mid] - mult2 * hY2[i]) % MOD2
wY.append((h1 << 30) + h2)
good = True
seen = set(wX)
for v in wY:
if v in seen:
good = False
break
if good:
hi = mid
else:
lo = mid
if lo > 0:
print(p + q - 2 * lo)
exit()
'''
xLoc = [0] * (n + 1)
mult = pow(base, p, MOD1)
mult2 = pow(base, p, MOD2)
for i in range(n - p + 1):
h1 = (hA[i + p] - mult * hA[i]) % MOD1
h2 = (hA2[i + p] - mult2 * hA2[i]) % MOD2
if h1 == hX[p] and h2 == hX2[p]:
xLoc[i] += 1
xLoc[i + p] -= 1
yLoc = [0] * (n + 1)
mult = pow(base, q, MOD1)
mult2 = pow(base, q, MOD2)
for i in range(n - q + 1):
h1 = (hA[i + q] - mult * hA[i]) % MOD1
h2 = (hA2[i + q] - mult2 * hA2[i]) % MOD2
if h1 == hY[q] and h2 == hY2[q]:
yLoc[i] += 1
yLoc[i + q] -= 1
distX = {}
distY = {}
last = -n - 100
cX = 0
for i in range(n):
cX += xLoc[i]
if cX > 0:
last = i
v = A[i]
d = i - last
if v in distX:
distX[v] = min(distX[v], d)
else:
distX[v] = d
last = n + 100
cX = 0
for i in range(n-1,-1,-1):
cX -= xLoc[i+1]
if cX > 0:
last = i
v = A[i]
d = last - i
if v in distX:
distX[v] = min(distX[v], d)
else:
assert False
distX[v] = d
last = -n - 100
cY = 0
for i in range(n):
cY += yLoc[i]
if cY > 0:
last = i
v = A[i]
d = i - last
if v in distY:
distY[v] = min(distY[v], d)
else:
distY[v] = d
last = n + 100
cY = 0
for i in range(n-1,-1,-1):
cY -= yLoc[i+1]
if cY > 0:
last = i
v = A[i]
d = last - i
if v in distY:
distY[v] = min(distY[v], d)
else:
assert False
distY[v] = d
poss = []
for v in A:
poss.append(distX[v] + distY[v])'''
from collections import defaultdict, deque
base = p + q - 2
adj = defaultdict(list)
dist = dict()
for i in range(n - 1):
adj[A[i]].append(A[i + 1])
adj[A[i + 1]].append(A[i])
q = deque()
for v in X:
if v not in dist:
dist[v] = 0
q.append(v)
while q:
u = q.popleft()
for v in adj[u]:
if v not in dist:
dist[v] = dist[u] + 1
q.append(v)
poss = []
for v in Y:
poss.append(dist[v])
best = min(poss)
print(base + 2 * best)
n = int(input())
A = list(map(int, input().split()))
p = int(input())
X = list(map(int, input().split()))
q = int(input())
Y = list(map(int, input().split()))
MOD1 = 10 ** 9 + 7
MOD2 = 10 ** 9 + 9
base = 123451000
hX = [0]
hX2 = [0]
for v in X:
nex = (hX[-1] * base) + v
hX.append(nex % MOD1)
nex = (hX2[-1] * base) + v
hX2.append(nex % MOD2)
hY = [0]
hY2 = [0]
for v in Y:
nex = (hY[-1] * base) + v
hY.append(nex % MOD1)
nex = (hY2[-1] * base) + v
hY2.append(nex % MOD2)
hA = [0]
hA2 = [0]
for v in A:
nex = (hA[-1] * base) + v
hA.append(nex % MOD1)
nex = (hA2[-1] * base) + v
hA2.append(nex % MOD2)
lo = 0
hi = min(p, q) + 1
while hi - lo > 1:
mid = (lo + hi) // 2
mult = pow(base, mid, MOD1)
mult2 = pow(base, mid, MOD2)
wX = []
for i in range(p - mid + 1):
h1 = (hX[i + mid] - mult * hX[i]) % MOD1
h2 = (hX2[i + mid] - mult2 * hX2[i]) % MOD2
wX.append((h1 << 30) + h2)
wY = []
for i in range(q - mid + 1):
h1 = (hY[i + mid] - mult * hY[i]) % MOD1
h2 = (hY2[i + mid] - mult2 * hY2[i]) % MOD2
wY.append((h1 << 30) + h2)
good = True
seen = set(wX)
for v in wY:
if v in seen:
good = False
break
if good:
hi = mid
else:
lo = mid
if lo > 0:
print(p + q - 2 * lo)
exit()
'''
xLoc = [0] * (n + 1)
mult = pow(base, p, MOD1)
mult2 = pow(base, p, MOD2)
for i in range(n - p + 1):
h1 = (hA[i + p] - mult * hA[i]) % MOD1
h2 = (hA2[i + p] - mult2 * hA2[i]) % MOD2
if h1 == hX[p] and h2 == hX2[p]:
xLoc[i] += 1
xLoc[i + p] -= 1
yLoc = [0] * (n + 1)
mult = pow(base, q, MOD1)
mult2 = pow(base, q, MOD2)
for i in range(n - q + 1):
h1 = (hA[i + q] - mult * hA[i]) % MOD1
h2 = (hA2[i + q] - mult2 * hA2[i]) % MOD2
if h1 == hY[q] and h2 == hY2[q]:
yLoc[i] += 1
yLoc[i + q] -= 1
distX = {}
distY = {}
last = -n - 100
cX = 0
for i in range(n):
cX += xLoc[i]
if cX > 0:
last = i
v = A[i]
d = i - last
if v in distX:
distX[v] = min(distX[v], d)
else:
distX[v] = d
last = n + 100
cX = 0
for i in range(n-1,-1,-1):
cX -= xLoc[i+1]
if cX > 0:
last = i
v = A[i]
d = last - i
if v in distX:
distX[v] = min(distX[v], d)
else:
assert False
distX[v] = d
last = -n - 100
cY = 0
for i in range(n):
cY += yLoc[i]
if cY > 0:
last = i
v = A[i]
d = i - last
if v in distY:
distY[v] = min(distY[v], d)
else:
distY[v] = d
last = n + 100
cY = 0
for i in range(n-1,-1,-1):
cY -= yLoc[i+1]
if cY > 0:
last = i
v = A[i]
d = last - i
if v in distY:
distY[v] = min(distY[v], d)
else:
assert False
distY[v] = d
poss = []
for v in A:
poss.append(distX[v] + distY[v])'''
from collections import defaultdict, deque
base = p + q - 2
adj = defaultdict(list)
dist = dict()
for i in range(n - 1):
adj[A[i]].append(A[i + 1])
adj[A[i + 1]].append(A[i])
q = deque()
for v in X:
if v not in dist:
dist[v] = 0
q.append(v)
while q:
u = q.popleft()
for v in adj[u]:
if v not in dist:
dist[v] = dist[u] + 1
q.append(v)
poss = []
for v in Y:
poss.append(dist[v])
best = min(poss)
print(base + 2 * best)
|
ConDefects/ConDefects/Code/arc151_e/Python/35732545
|
condefects-python_data_960
|
n, x, y = map(int, input().split())
a = list(map(int, input().split()))
X = []
Y = []
for i in range(n):
if i %2 == 0:
X.append(a[i])
else:
Y.append(a[i])
dp_x = [[False for _ in range(4 * (sum(X) + 1))] for _ in range(len(X) + 1)]
dp_y = [[False for _ in range(4 * (sum(Y) + 1))] for _ in range(len(Y) + 1)]
dp_x[0][2 * (sum(X) + 1)] = True
dp_y[0][2 * (sum(Y) + 1)] = True
for i in range(len(X)):
for j in range(4 * (sum(X) + 1)):
if dp_x[i][j]:
if i != 0:
dp_x[i + 1][j + X[i]] = True
dp_x[i + 1][j - X[i]] = True
else:
dp_x[i + 1][j + X[i]] = True
for i in range(len(Y)):
for j in range(4 * (sum(Y) + 1)):
if dp_y[i][j]:
dp_y[i + 1][j + Y[i]] = True
dp_y[i + 1][j - Y[i]] = True
if x > sum(X) or y > sum(Y):
print("No")
else:
if dp_x[-1][x + 2 * (sum(X) + 1)] and dp_y[-1][y + 2 * (sum(Y) + 1)]:
print("Yes")
else:
print("No")
n, x, y = map(int, input().split())
a = list(map(int, input().split()))
X = []
Y = []
for i in range(n):
if i %2 == 0:
X.append(a[i])
else:
Y.append(a[i])
dp_x = [[False for _ in range(4 * (sum(X) + 1))] for _ in range(len(X) + 1)]
dp_y = [[False for _ in range(4 * (sum(Y) + 1))] for _ in range(len(Y) + 1)]
dp_x[0][2 * (sum(X) + 1)] = True
dp_y[0][2 * (sum(Y) + 1)] = True
for i in range(len(X)):
for j in range(4 * (sum(X) + 1)):
if dp_x[i][j]:
if i != 0:
dp_x[i + 1][j + X[i]] = True
dp_x[i + 1][j - X[i]] = True
else:
dp_x[i + 1][j + X[i]] = True
for i in range(len(Y)):
for j in range(4 * (sum(Y) + 1)):
if dp_y[i][j]:
dp_y[i + 1][j + Y[i]] = True
dp_y[i + 1][j - Y[i]] = True
if abs(x) > sum(X) or abs(y) > sum(Y):
print("No")
else:
if dp_x[-1][x + 2 * (sum(X) + 1)] and dp_y[-1][y + 2 * (sum(Y) + 1)]:
print("Yes")
else:
print("No")
|
ConDefects/ConDefects/Code/abc274_d/Python/46033282
|
condefects-python_data_961
|
ir = lambda: int(input()) # 数字の読み込み
lr = lambda: list(map(int, input().split())) # 数字の配列の読み込み
N, x, y = lr()
A = lr()
xA = A[2::2]
sxA = sum(xA)
xN = abs(abs(x - A[0]) - sxA)
xdp = [0] * (xN + 1)
xdp[0] = 1
for dx in xA:
for i in range(xN-dx*2, -1, -1):
xdp[dx*2+i] |= xdp[i]
yA = A[1::2]
syA = sum(yA)
yN = abs(y - syA)
ydp = [0] * (yN + 1)
ydp[0] = 1
for dy in yA:
for i in range(yN-dy*2, -1, -1):
ydp[dy*2+i] |= ydp[i]
print('Yes' if xdp[xN] and ydp[yN] else 'No')
ir = lambda: int(input()) # 数字の読み込み
lr = lambda: list(map(int, input().split())) # 数字の配列の読み込み
N, x, y = lr()
A = lr()
xA = A[2::2]
sxA = sum(xA)
xN = abs(x - A[0] - sxA)
xdp = [0] * (xN + 1)
xdp[0] = 1
for dx in xA:
for i in range(xN-dx*2, -1, -1):
xdp[dx*2+i] |= xdp[i]
yA = A[1::2]
syA = sum(yA)
yN = abs(y - syA)
ydp = [0] * (yN + 1)
ydp[0] = 1
for dy in yA:
for i in range(yN-dy*2, -1, -1):
ydp[dy*2+i] |= ydp[i]
print('Yes' if xdp[xN] and ydp[yN] else 'No')
|
ConDefects/ConDefects/Code/abc274_d/Python/46002634
|
condefects-python_data_962
|
from collections import defaultdict,deque
N=int(input())
XY=[]
P=[]
for i in range(N):
x,y,p=list(map(int,input().split()))
XY.append((x,y))
P.append(p)
ok=10**9
ng=0
while abs(ok-ng)>1:
m=(ok+ng)//2
path=defaultdict(list)
for i in range(N):
p=P[i]
for j in range(N):
if i==j:
continue
if p*m>=abs(XY[i][0]-XY[j][0])+abs(XY[i][1]-XY[j][1]):
path[i].append(j)
c=0
for i in range(N):
Q=deque()
check=set()
check.add(i)
Q.append(i)
while len(Q)>0:
a=Q.popleft()
for j in path[a]:
if j not in check:
Q.append(j)
check.add(j)
if len(check)==N:
c=1
break
if c:
ok=m
else:
ng=m
print(ok)
from collections import defaultdict,deque
N=int(input())
XY=[]
P=[]
for i in range(N):
x,y,p=list(map(int,input().split()))
XY.append((x,y))
P.append(p)
ok=10**18
ng=0
while abs(ok-ng)>1:
m=(ok+ng)//2
path=defaultdict(list)
for i in range(N):
p=P[i]
for j in range(N):
if i==j:
continue
if p*m>=abs(XY[i][0]-XY[j][0])+abs(XY[i][1]-XY[j][1]):
path[i].append(j)
c=0
for i in range(N):
Q=deque()
check=set()
check.add(i)
Q.append(i)
while len(Q)>0:
a=Q.popleft()
for j in path[a]:
if j not in check:
Q.append(j)
check.add(j)
if len(check)==N:
c=1
break
if c:
ok=m
else:
ng=m
print(ok)
|
ConDefects/ConDefects/Code/abc257_d/Python/45255202
|
condefects-python_data_963
|
n=int(input())
pp=[]
for i in range(n):
x,y,p=map(int,input().split())
pp.append((x,y,p))
from collections import deque
def bfs(node,s):
used=[False]*n
d=deque()
d.append(node)
used[node]=True
while d:
tmp=d.popleft()
p=s*pp[tmp][2]
for i in range(n):
if i==tmp:
continue
dist=abs(pp[tmp][0]-pp[i][0])+abs(pp[tmp][1]-pp[i][1])
if not(used[i]) and p>=dist:
used[i]=True
d.append(i)
return all(used)
l=1
r=4*10**9
while r-l>1:
frag=True
mid=(l+r)//2
for i in range(n):
if bfs(i,mid):
r=mid
frag=False
break
if frag:
l=mid
print(r)
n=int(input())
pp=[]
for i in range(n):
x,y,p=map(int,input().split())
pp.append((x,y,p))
from collections import deque
def bfs(node,s):
used=[False]*n
d=deque()
d.append(node)
used[node]=True
while d:
tmp=d.popleft()
p=s*pp[tmp][2]
for i in range(n):
if i==tmp:
continue
dist=abs(pp[tmp][0]-pp[i][0])+abs(pp[tmp][1]-pp[i][1])
if not(used[i]) and p>=dist:
used[i]=True
d.append(i)
return all(used)
l=0
r=4*10**9
while r-l>1:
frag=True
mid=(l+r)//2
for i in range(n):
if bfs(i,mid):
r=mid
frag=False
break
if frag:
l=mid
print(r)
|
ConDefects/ConDefects/Code/abc257_d/Python/46215877
|
condefects-python_data_964
|
MOD = 10**9 + 7
N = int(input())
A = list(map(int, input().split()))
dp = [1] + [0]*2000
res = [0]*21
for a in A:
ndp = dp.copy()
for s in range(-1000, 1001):
if s == 0: continue
ns = s + a
if -1000 <= ns <= 1000:
ndp[ns] += dp[s]
ndp[ns] %= MOD
for s in range(-10, 10):
if s == 0: continue
ns = s + a
if -1000 <= ns <= 1000:
ndp[ns] += res[s]
ndp[ns] %= MOD
if a != 0:
res[a] = dp[0]
dp = ndp.copy()
print(sum(dp) % MOD)
MOD = 10**9 + 7
N = int(input())
A = list(map(int, input().split()))
dp = [1] + [0]*2000
res = [0]*21
for a in A:
ndp = dp.copy()
for s in range(-1000, 1001):
if s == 0: continue
ns = s + a
if -1000 <= ns <= 1000:
ndp[ns] += dp[s]
ndp[ns] %= MOD
for s in range(-10, 11):
if s == 0: continue
ns = s + a
if -1000 <= ns <= 1000:
ndp[ns] += res[s]
ndp[ns] %= MOD
if a != 0:
res[a] = dp[0]
dp = ndp.copy()
print(sum(dp) % MOD)
|
ConDefects/ConDefects/Code/arc180_c/Python/55021276
|
condefects-python_data_965
|
N = int(input())
A = input()
count = 0
for i in range(2*N-2):
if A[i] == A[i+2]:
count += 1
print(count)
N = int(input())
A = list(map(int,input().split()))
count = 0
for i in range(2*N-2):
if A[i] == A[i+2]:
count += 1
print(count)
|
ConDefects/ConDefects/Code/abc359_b/Python/55032387
|
condefects-python_data_966
|
n = int(input())
A = list(map(int, input().split()))
count = 0
for i in range(1, n*2-1):
if A[i-1] == A[i+1]:
count =+ 1
print(count)
n = int(input())
A = list(map(int, input().split()))
count = 0
for i in range(1, n*2-1):
if A[i-1] == A[i+1]:
count += 1
print(count)
|
ConDefects/ConDefects/Code/abc359_b/Python/55042277
|
condefects-python_data_967
|
import sys
input = sys.stdin.readline
n = int(input().rstrip())
arr = list(map(int, input().rstrip().split()))
res = 0
for i in range(n-2):
if arr[i+2] == arr[i]: res += 1
print(res)
import sys
input = sys.stdin.readline
n = int(input().rstrip())
arr = list(map(int, input().rstrip().split()))
res = 0
for i in range(2*n-2):
if arr[i+2] == arr[i]: res += 1
print(res)
|
ConDefects/ConDefects/Code/abc359_b/Python/55035410
|
condefects-python_data_968
|
from itertools import accumulate
class RepeatingSequence:
def __init__(self, head, cycle, tail, repeat):
self.head = head
self.cycle = cycle
self.tail = tail
self.repeat = repeat
self.head_cumsums = None
self.cycle_cumsums = None
self.tail_cumsums = None
def __len__(self):
return len(self.head) + len(self.cycle) * self.repeat + len(self.tail)
def sum(self, l, r):
return self.cumsum(r) - self.cumsum(l)
def cumsum(self, r):
if self.head_cumsums is None:
self.calc_cumsums()
if r <= len(self.head):
return self.head_cumsums[r]
sum_ = self.head_cumsums[-1]
r -= len(self.head)
if r <= len(self.cycle) * self.repeat:
return sum_ + self.cycle_cumsums[-1] * (r // len(self.cycle)) + self.cycle_cumsums[r % len(self.cycle)]
sum_ += self.cycle_cumsums[-1] * self.repeat
r -= len(self.cycle) * self.repeat
if r <= len(self.tail):
return sum_ + self.tail_cumsums[r]
return sum_ + self.tail_cumsums[-1]
def calc_cumsums(self):
self.head_cumsums = list(accumulate(self.head, initial=0))
self.cycle_cumsums = list(accumulate(self.cycle, initial=0))
self.tail_cumsums = list(accumulate(self.tail, initial=0))
N, M, K = map(int, input().split())
S = input()
seq = [len(s) for s in S.split("x")]
x_count = S.count("x")
if M == 1:
rep_seq = RepeatingSequence(seq, [], [], 0)
else:
seq1 = seq[:-1]
seq2 = [seq[-1] + seq[0]] + seq[1:-1]
seq3 = [seq[-1] + seq[0]] + seq[1:]
rep_seq = RepeatingSequence(seq1, seq2, seq3, M-2)
ans = 0
for i in range(x_count):
if i + K + 1 > len(rep_seq): break
count = rep_seq.sum(i, i + K + 1) + K
ans = max(ans, count)
print(ans)
from itertools import accumulate
class RepeatingSequence:
def __init__(self, head, cycle, tail, repeat):
self.head = head
self.cycle = cycle
self.tail = tail
self.repeat = repeat
self.head_cumsums = None
self.cycle_cumsums = None
self.tail_cumsums = None
def __len__(self):
return len(self.head) + len(self.cycle) * self.repeat + len(self.tail)
def sum(self, l, r):
return self.cumsum(r) - self.cumsum(l)
def cumsum(self, r):
if self.head_cumsums is None:
self.calc_cumsums()
if r <= len(self.head):
return self.head_cumsums[r]
sum_ = self.head_cumsums[-1]
r -= len(self.head)
if r <= len(self.cycle) * self.repeat:
return sum_ + self.cycle_cumsums[-1] * (r // len(self.cycle)) + self.cycle_cumsums[r % len(self.cycle)]
sum_ += self.cycle_cumsums[-1] * self.repeat
r -= len(self.cycle) * self.repeat
if r <= len(self.tail):
return sum_ + self.tail_cumsums[r]
return sum_ + self.tail_cumsums[-1]
def calc_cumsums(self):
self.head_cumsums = list(accumulate(self.head, initial=0))
self.cycle_cumsums = list(accumulate(self.cycle, initial=0))
self.tail_cumsums = list(accumulate(self.tail, initial=0))
N, M, K = map(int, input().split())
S = input()
seq = [len(s) for s in S.split("x")]
x_count = S.count("x")
if M == 1:
rep_seq = RepeatingSequence(seq, [], [], 0)
else:
seq1 = seq[:-1]
seq2 = [seq[-1] + seq[0]] + seq[1:-1]
seq3 = [seq[-1] + seq[0]] + seq[1:]
rep_seq = RepeatingSequence(seq1, seq2, seq3, M-2)
ans = 0
for i in range(x_count+1):
if i + K + 1 > len(rep_seq): break
count = rep_seq.sum(i, i + K + 1) + K
ans = max(ans, count)
print(ans)
|
ConDefects/ConDefects/Code/abc300_f/Python/45343856
|
condefects-python_data_969
|
N,M,K=list(map(int, input().split()))
S=input()
Sa=[0]
for i in range(N):
a=0
if S[i]=="x":
a=1
Sa.append(Sa[-1]+a)
t=Sa[-1]
ans=0
for i in range(N):
ok=-1
ng=M*N
while abs(ok-ng)>1:
c=(ok+ng)//2
total=0
total+=(c//N)*t
total+=Sa[(c%N)]
total-=Sa[i]
if total<=K:
ok=c
else:
ng=c
ans=max(ans,ok-i)
print(ans)
N,M,K=list(map(int, input().split()))
S=input()
Sa=[0]
for i in range(N):
a=0
if S[i]=="x":
a=1
Sa.append(Sa[-1]+a)
t=Sa[-1]
ans=0
for i in range(N):
ok=-1
ng=M*N+1
while abs(ok-ng)>1:
c=(ok+ng)//2
total=0
total+=(c//N)*t
total+=Sa[(c%N)]
total-=Sa[i]
if total<=K:
ok=c
else:
ng=c
ans=max(ans,ok-i)
print(ans)
|
ConDefects/ConDefects/Code/abc300_f/Python/45923968
|
condefects-python_data_970
|
import sys
# import math
# from bisect import *
# from collections import *
# from functools import *
# from heapq import *
# from itertools import *
# from random import *
# from string import *
# from types import GeneratorType
# region fastio
input = lambda: sys.stdin.readline().rstrip()
sint = lambda: int(input())
mint = lambda: map(int, input().split())
ints = lambda: list(map(int, input().split()))
# print = lambda d: sys.stdout.write(str(d) + "\n")
# endregion fastio
# # region interactive
# def printQry(a, b) -> None:
# sa = str(a)
# sb = str(b)
# print(f"? {sa} {sb}", flush = True)
# def printAns(ans) -> None:
# s = str(ans)
# print(f"! {s}", flush = True)
# # endregion interactive
# # region dfsconvert
# def bootstrap(f, stack=[]):
# def wrappedfunc(*args, **kwargs):
# if stack:
# return f(*args, **kwargs)
# else:
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# else:
# stack.pop()
# if not stack:
# break
# to = stack[-1].send(to)
# return to
# return wrappedfunc
# # endregion dfsconvert
# MOD = 998244353
# MOD = 10 ** 9 + 7
# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
def solve() -> None:
n, m, k = mint()
s = input()
c = s.count('x')
d, k = divmod(k, c)
pos = [i for i, x in enumerate(s) if x == 'x']
ans = n * d + pos[k]
for i in range(len(pos)):
j = i - k - 1
if j < 0:
res = min(n * m, n * d + pos[i] + n) - pos[j] - 1
else:
res = min(n * m, n * d + pos[i]) - pos[j] - 1
ans = max(ans, res)
print(ans)
solve()
import sys
# import math
# from bisect import *
# from collections import *
# from functools import *
# from heapq import *
# from itertools import *
# from random import *
# from string import *
# from types import GeneratorType
# region fastio
input = lambda: sys.stdin.readline().rstrip()
sint = lambda: int(input())
mint = lambda: map(int, input().split())
ints = lambda: list(map(int, input().split()))
# print = lambda d: sys.stdout.write(str(d) + "\n")
# endregion fastio
# # region interactive
# def printQry(a, b) -> None:
# sa = str(a)
# sb = str(b)
# print(f"? {sa} {sb}", flush = True)
# def printAns(ans) -> None:
# s = str(ans)
# print(f"! {s}", flush = True)
# # endregion interactive
# # region dfsconvert
# def bootstrap(f, stack=[]):
# def wrappedfunc(*args, **kwargs):
# if stack:
# return f(*args, **kwargs)
# else:
# to = f(*args, **kwargs)
# while True:
# if type(to) is GeneratorType:
# stack.append(to)
# to = next(to)
# else:
# stack.pop()
# if not stack:
# break
# to = stack[-1].send(to)
# return to
# return wrappedfunc
# # endregion dfsconvert
# MOD = 998244353
# MOD = 10 ** 9 + 7
# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))
def solve() -> None:
n, m, k = mint()
s = input()
c = s.count('x')
d, k = divmod(k, c)
pos = [i for i, x in enumerate(s) if x == 'x']
ans = min(n * m, n * d + pos[k])
for i in range(len(pos)):
j = i - k - 1
if j < 0:
res = min(n * m, n * d + pos[i] + n) - pos[j] - 1
else:
res = min(n * m, n * d + pos[i]) - pos[j] - 1
ans = max(ans, res)
print(ans)
solve()
|
ConDefects/ConDefects/Code/abc300_f/Python/45080334
|
condefects-python_data_971
|
n,m,k = map(int, input().split())
s = input()
li = [0 for i in range(n+1)]
for i in range(1, n+1):
c = s[i-1]
li[i] += li[i-1]
if c == "x":
li[i] += 1
xcnt = li[-1]
ans = -1
for l in range(n):
ok = 1
ng = n*m - l
while abs(ok-ng) > 1:
mid = (ok+ng)//2
# print(ok,mid,ng)
# [l, l+mid)内にxがk個以上存在するか
repeat = (l+mid) // n
res = (l+mid) % n
xnum = xcnt * repeat - li[l] + li[res]
# print(ok,mid,ng, xnum)
if xnum <= k:
ok = mid
else:
ng = mid
if ans < ok:
ans = ok
print(ans)
n,m,k = map(int, input().split())
s = input()
li = [0 for i in range(n+1)]
for i in range(1, n+1):
c = s[i-1]
li[i] += li[i-1]
if c == "x":
li[i] += 1
xcnt = li[-1]
ans = -1
for l in range(n):
ok = 1
ng = n*m - l + 1
while abs(ok-ng) > 1:
mid = (ok+ng)//2
# print(ok,mid,ng)
# [l, l+mid)内にxがk個以上存在するか
repeat = (l+mid) // n
res = (l+mid) % n
xnum = xcnt * repeat - li[l] + li[res]
# print(ok,mid,ng, xnum)
if xnum <= k:
ok = mid
else:
ng = mid
if ans < ok:
ans = ok
print(ans)
|
ConDefects/ConDefects/Code/abc300_f/Python/45435689
|
condefects-python_data_972
|
def II() : return int(input())
def MI() : return map(int,input().split())
def MS() : return map(str,input().split())
def LMI() : return list(MI())
def LMS() : return list(MS())
def LLI(N) : return [LMI() for _ in range(N)]
def LLS(N): return [LMS() for _ in range(N)]
def LS(N) : return [input() for _ in range(N)]
def LI(N) : return [II() for _ in range(N)]
#入力
def ruiseki(i):
if i<=N:
return a[i]
return a[-1]*((i-1)//N)+a[(i-1)%N+1]
def solve(x,i):
if ruiseki(x)-ruiseki(i)<=K:
return 1
return 0
N,M,K=MI()
S=input()
a=[0]*(N+1)
for i in range(N):
if S[i]=='x':
a[i+1]+=1
for i in range(1,N+1):
a[i]+=a[i-1]
ans=0
for i in range(N):
ok=i
ng=10**15
while abs(ok-ng)>1:
mid=(ok+ng)//2
if solve(mid,i):
ok=mid
else:
ng=mid
ans=max(ok-i,ans)
print(ans)
def II() : return int(input())
def MI() : return map(int,input().split())
def MS() : return map(str,input().split())
def LMI() : return list(MI())
def LMS() : return list(MS())
def LLI(N) : return [LMI() for _ in range(N)]
def LLS(N): return [LMS() for _ in range(N)]
def LS(N) : return [input() for _ in range(N)]
def LI(N) : return [II() for _ in range(N)]
#入力
def ruiseki(i):
if i<=N:
return a[i]
return a[-1]*((i-1)//N)+a[(i-1)%N+1]
def solve(x,i):
if x>N*M:
return 0
if ruiseki(x)-ruiseki(i)<=K:
return 1
return 0
N,M,K=MI()
S=input()
a=[0]*(N+1)
for i in range(N):
if S[i]=='x':
a[i+1]+=1
for i in range(1,N+1):
a[i]+=a[i-1]
ans=0
for i in range(N):
ok=i
ng=10**15
while abs(ok-ng)>1:
mid=(ok+ng)//2
if solve(mid,i):
ok=mid
else:
ng=mid
ans=max(ok-i,ans)
print(ans)
|
ConDefects/ConDefects/Code/abc300_f/Python/45948997
|
condefects-python_data_973
|
import sys
sys.setrecursionlimit(10**9)
def dfs(u):
tmp = 1
for v in G[u]:
if not used[v]:
used[v] = 1
tmp += dfs(v)
used[v] = 0
return tmp
n, m = map(int, input().split())
G = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
G[u - 1] += [v - 1]
G[v - 1] += [u - 1]
used = [0] * n
used[0] = 1
print(dfs(0))
import sys
sys.setrecursionlimit(10**9)
def dfs(u):
tmp = 1
for v in G[u]:
if not used[v]:
used[v] = 1
tmp += dfs(v)
used[v] = 0
if tmp > 10**6:
exit(print(10**6))
return tmp
n, m = map(int, input().split())
G = [[] for _ in range(n)]
for _ in range(m):
u, v = map(int, input().split())
G[u - 1] += [v - 1]
G[v - 1] += [u - 1]
used = [0] * n
used[0] = 1
print(dfs(0))
|
ConDefects/ConDefects/Code/abc284_e/Python/45459162
|
condefects-python_data_974
|
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**7)
n,m=map(int,input().split())
L=[[] for _ in range(n)]
for _ in range(m):
u,v=map(int,input().split())
L[u-1]+=[v-1]
L[v-1]+=[u-1]
ans=0
def dfs(i,a):
global ans
ans+=1
a.add(i)
for j in L[i]:
if j not in a:
dfs(j,a)
a.remove(i)
dfs(0,set())
print(ans)
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10**7)
n,m=map(int,input().split())
L=[[] for _ in range(n)]
for _ in range(m):
u,v=map(int,input().split())
L[u-1]+=[v-1]
L[v-1]+=[u-1]
ans=0
def dfs(i,a):
global ans
ans+=1
if ans==10**6:
exit(print(10**6))
a.add(i)
for j in L[i]:
if j not in a:
dfs(j,a)
a.remove(i)
dfs(0,set())
print(ans)
|
ConDefects/ConDefects/Code/abc284_e/Python/46171224
|
condefects-python_data_975
|
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*n
self.rank = [0]*n
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N=int(input())
uf=UnionFind(2003*2003)
black=[False]*2003*2003
for i in range(N):
X,Y=map(int,input().split())
X+=1001
Y+=1001
black[2002*X+Y]=True
if black[2002*(X-1)+Y-1]:
uf.unite(2002*X+Y,2002*(X-1)+Y-1)
if black[2002*(X-1)+Y]:
uf.unite(2002*X+Y,2002*(X-1)+Y)
if black[2002*(X)+Y-1]:
uf.unite(2002*X+Y,2002*(X)+Y-1)
if black[2002*(X+1)+Y+1]:
uf.unite(2002*X+Y,2002*(X+1)+Y+1)
if black[2002*(X+1)+Y]:
uf.unite(2002*X+Y,2002*(X+1)+Y)
if black[2002*(X)+Y+1]:
uf.unite(2002*X+Y,2002*(X)+Y+1)
print(uf.group_size()-(2002*2002-sum(black)))
from collections import defaultdict
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*n
self.rank = [0]*n
def find(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if(x == y):
return
elif(self.rank[x] > self.rank[y]):
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if(self.rank[x] == self.rank[y]):
self.rank[y] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.root) if x < 0]
def group_size(self):
return len(self.roots())
def group_members(self):
group_members = defaultdict(list)
for member in range(self.n):
group_members[self.find(member)].append(member)
return group_members
N=int(input())
uf=UnionFind(2003*2003)
black=[False]*2003*2003
for i in range(N):
X,Y=map(int,input().split())
X+=1001
Y+=1001
black[2002*X+Y]=True
if black[2002*(X-1)+Y-1]:
uf.unite(2002*X+Y,2002*(X-1)+Y-1)
if black[2002*(X-1)+Y]:
uf.unite(2002*X+Y,2002*(X-1)+Y)
if black[2002*(X)+Y-1]:
uf.unite(2002*X+Y,2002*(X)+Y-1)
if black[2002*(X+1)+Y+1]:
uf.unite(2002*X+Y,2002*(X+1)+Y+1)
if black[2002*(X+1)+Y]:
uf.unite(2002*X+Y,2002*(X+1)+Y)
if black[2002*(X)+Y+1]:
uf.unite(2002*X+Y,2002*(X)+Y+1)
print(uf.group_size()-(2003*2003-sum(black)))
|
ConDefects/ConDefects/Code/abc269_d/Python/52213061
|
condefects-python_data_976
|
import sys, random
input = lambda : sys.stdin.readline().rstrip()
write = lambda x: sys.stdout.write(x+"\n"); writef = lambda x: print("{:.12f}".format(x))
debug = lambda x: sys.stderr.write(x+"\n")
YES="Yes"; NO="No"; pans = lambda v: print(YES if v else NO); INF=10**18
LI = lambda v=0: list(map(lambda i: int(i)-v, input().split())); II=lambda : int(input()); SI=lambda : [ord(c)-ord("a") for c in input()]
def debug(_l_):
for s in _l_.split():
print(f"{s}={eval(s)}", end=" ")
print()
def dlist(*l, fill=0):
if len(l)==1:
return [fill]*l[0]
ll = l[1:]
return [dlist(*ll, fill=fill) for _ in range(l[0])]
def merge_interval(lr):
# list of [l,r)
lr.sort()
ans = []
pl = None
max_r = -INF
for l,r in lr:
if l>max_r:
if pl is not None:
ans.append((pl, max_r))
max_r = r
pl = l
else:
max_r = max(max_r, r)
ans.append((pl, max_r))
return ans
t = II()
YES = "Alice"
NO = "Bob"
def sub(a,b):
a,b = min(a,b), max(a,b)
return b-(a-1), b+(a-1)
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
b = LI()
a.sort()
b.sort()
from bisect import bisect_left as bl
for i in range(1,n)[::-1]:
if a[i]-(a[i-1]-1)<=b[0]<=a[i]+(a[i-1]-1):
lr = []
for j in range(n):
if j==i:
continue
ll,rr = sub(a[i], a[j])
lr.append((ll,rr))
lr = merge_interval(lr)
num = 0
for ll,rr in lr:
num += bl(b, rr) - bl(b, ll)
# print(i,lr)
if num==n:
ans = 1
else:
ans = 0
break
else:
for i in range(n):
l = []
js = list(range(i-1,i+2))
for j in js:
if j==i or not (0<=j<n):
continue
x = a[i]
x2 = a[j]
ll = max(x,x2) - min(x,x2) + 1
rr = x+x2
l.append((ll,rr))
lr = merge_interval(l)
# print(lr)
num = 0
for ll,rr in lr:
num += (bl(b, rr) - bl(b, ll))
if num==n:
ans = 1
break
else:
ans = 0
pans(ans)
# break
import sys, random
input = lambda : sys.stdin.readline().rstrip()
write = lambda x: sys.stdout.write(x+"\n"); writef = lambda x: print("{:.12f}".format(x))
debug = lambda x: sys.stderr.write(x+"\n")
YES="Yes"; NO="No"; pans = lambda v: print(YES if v else NO); INF=10**18
LI = lambda v=0: list(map(lambda i: int(i)-v, input().split())); II=lambda : int(input()); SI=lambda : [ord(c)-ord("a") for c in input()]
def debug(_l_):
for s in _l_.split():
print(f"{s}={eval(s)}", end=" ")
print()
def dlist(*l, fill=0):
if len(l)==1:
return [fill]*l[0]
ll = l[1:]
return [dlist(*ll, fill=fill) for _ in range(l[0])]
def merge_interval(lr):
# list of [l,r)
lr.sort()
ans = []
pl = None
max_r = -INF
for l,r in lr:
if l>max_r:
if pl is not None:
ans.append((pl, max_r))
max_r = r
pl = l
else:
max_r = max(max_r, r)
ans.append((pl, max_r))
return ans
t = II()
YES = "Alice"
NO = "Bob"
def sub(a,b):
a,b = min(a,b), max(a,b)
return b-(a-1), b+(a-1)
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
b = LI()
a.sort()
b.sort()
from bisect import bisect_left as bl
for i in range(1,n)[::-1]:
if a[i]-(a[i-1]-1)<=b[0]<=a[i]+(a[i-1]-1):
lr = []
for j in range(n):
if j==i:
continue
ll,rr = sub(a[i], a[j])
lr.append((ll,rr+1))
lr = merge_interval(lr)
num = 0
for ll,rr in lr:
num += bl(b, rr) - bl(b, ll)
# print(i,lr)
if num==n:
ans = 1
else:
ans = 0
break
else:
for i in range(n):
l = []
js = list(range(i-1,i+2))
for j in js:
if j==i or not (0<=j<n):
continue
x = a[i]
x2 = a[j]
ll = max(x,x2) - min(x,x2) + 1
rr = x+x2
l.append((ll,rr))
lr = merge_interval(l)
# print(lr)
num = 0
for ll,rr in lr:
num += (bl(b, rr) - bl(b, ll))
if num==n:
ans = 1
break
else:
ans = 0
pans(ans)
# break
|
ConDefects/ConDefects/Code/arc170_d/Python/49588055
|
condefects-python_data_977
|
import sys
if len(sys.argv) >= 2 and sys.argv[1] == "ONLINE_JUDGE":
import os
from cffi import FFI
ffibuilder = FFI()
current_directory = os.getcwd()
ffibuilder.cdef("""
typedef long long TYPE;
void *multiset_new();
void multiset_insert(void *obj, TYPE val);
void multiset_erase(void *obj, TYPE val);
bool multiset_contain(void *obj, TYPE val);
TYPE multiset_get_max(void *obj);
TYPE multiset_get_min(void *obj);
int multiset_size(void *obj);
""")
ffibuilder.set_source("cpp_interop",
"""
#include <set>
extern "C" {
using MULTISET=std::multiset<long long>;
using TYPE=long long;
void *multiset_new() { return new MULTISET(); }
void multiset_insert(void *obj, TYPE val) { ((MULTISET*)obj)->insert(val); }
void multiset_erase(void *obj, TYPE val) { ((MULTISET*)obj)->erase(((MULTISET*)obj)->find(val)); }
bool multiset_contain(void *obj, TYPE val) { return ((MULTISET*)obj)->find(val) != ((MULTISET*)obj)->end(); }
TYPE multiset_get_max(void *obj) { return *((MULTISET*)obj)->rbegin(); }
TYPE multiset_get_min(void *obj) { return *((MULTISET*)obj)->begin(); }
int multiset_size(void *obj) { return ((MULTISET*)obj)->size(); }
}
""",
source_extension='.cpp',
library_dirs=[current_directory],
extra_link_args=['-Wl,-rpath=' + current_directory])
if __name__ == "__main__":
ffibuilder.compile(verbose=True, debug=True)
else:
from cpp_interop import ffi, lib
from collections import defaultdict
class Multiset:
def __init__(self):
self.obj = lib.multiset_new()
def insert(self, val):
lib.multiset_insert(self.obj, val)
def erase(self, val):
lib.multiset_erase(self.obj, val)
def contain(self, val):
return lib.multiset_contain(self.obj, val)
def get_max(self):
return lib.multiset_get_max(self.obj)
def get_min(self):
return lib.multiset_get_min(self.obj)
def size(self):
return lib.multiset_size(self.obj)
from bisect import bisect_left
def solve():
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ms = Multiset()
A.sort()
B.sort()
C = [0]*N
D = [[0]*3 for i in range(N)]
# righter = [[] for i in range(N)]
lefter = [[] for i in range(N)]
for i,b in enumerate(B):
j = bisect_left(A, b)
C[i] = j
# if 0<=j<N:
# righter[j].append(i)
if 0<=j-1<N:
lefter[j-1].append(i)
if 0<=j<N:
right = A[j]
else:
right = 10**12
if 0<=j-1<N:
left = A[j-1]
else:
left = -10**12
D[i][0] = min(right-b, b-left)
if 0<=j+1<N:
right1 = A[j+1]
else:
right1 = 10**12
D[i][1] = min(right1-b, b-left)
if 0<=j-2<N:
left1 = A[j-2]
else:
left1 = -10**12
D[i][2] = min(right-b, b-left1)
for a,b,c in D:
ms.insert(a)
j = 0
flag = False
for i, a in enumerate(A):
while j<N and B[j]<a:
ms.erase(D[j][0])
j+=1
for k in lefter[i]:
ms.erase(D[k][0])
ms.insert(D[k][2])
flag1 = False
flag3 = False
if ms.size() > 0:
if a > ms.get_max():
flag1 = True
else:
flag1 = True
flag3 = True
flag2 = False
flag4 = False
if B[0] < a:
if i>0:
if A[i-1] > a-B[0]:
flag2 = True
if i<N-1:
if A[i+1] < a+B[0]:
flag2 = True
else:
flag2 = True
flag4 = True
if flag1 and flag2:
flag = True
break
for k in lefter[i]:
ms.erase(D[k][2])
ms.insert(D[k][0])
if flag:
print("Alice")
else:
print("Bob")
T = int(input())
for i in range(T):
solve()
import sys
if len(sys.argv) >= 2 and sys.argv[1] == "ONLINE_JUDGE":
import os
from cffi import FFI
ffibuilder = FFI()
current_directory = os.getcwd()
ffibuilder.cdef("""
typedef long long TYPE;
void *multiset_new();
void multiset_insert(void *obj, TYPE val);
void multiset_erase(void *obj, TYPE val);
bool multiset_contain(void *obj, TYPE val);
TYPE multiset_get_max(void *obj);
TYPE multiset_get_min(void *obj);
int multiset_size(void *obj);
""")
ffibuilder.set_source("cpp_interop",
"""
#include <set>
extern "C" {
using MULTISET=std::multiset<long long>;
using TYPE=long long;
void *multiset_new() { return new MULTISET(); }
void multiset_insert(void *obj, TYPE val) { ((MULTISET*)obj)->insert(val); }
void multiset_erase(void *obj, TYPE val) { ((MULTISET*)obj)->erase(((MULTISET*)obj)->find(val)); }
bool multiset_contain(void *obj, TYPE val) { return ((MULTISET*)obj)->find(val) != ((MULTISET*)obj)->end(); }
TYPE multiset_get_max(void *obj) { return *((MULTISET*)obj)->rbegin(); }
TYPE multiset_get_min(void *obj) { return *((MULTISET*)obj)->begin(); }
int multiset_size(void *obj) { return ((MULTISET*)obj)->size(); }
}
""",
source_extension='.cpp',
library_dirs=[current_directory],
extra_link_args=['-Wl,-rpath=' + current_directory])
if __name__ == "__main__":
ffibuilder.compile(verbose=True, debug=True)
else:
from cpp_interop import ffi, lib
from collections import defaultdict
class Multiset:
def __init__(self):
self.obj = lib.multiset_new()
def insert(self, val):
lib.multiset_insert(self.obj, val)
def erase(self, val):
lib.multiset_erase(self.obj, val)
def contain(self, val):
return lib.multiset_contain(self.obj, val)
def get_max(self):
return lib.multiset_get_max(self.obj)
def get_min(self):
return lib.multiset_get_min(self.obj)
def size(self):
return lib.multiset_size(self.obj)
from bisect import bisect_left
def solve():
N = int(input())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ms = Multiset()
A.sort()
B.sort()
C = [0]*N
D = [[0]*3 for i in range(N)]
# righter = [[] for i in range(N)]
lefter = [[] for i in range(N)]
for i,b in enumerate(B):
j = bisect_left(A, b)
C[i] = j
# if 0<=j<N:
# righter[j].append(i)
if 0<=j-1<N:
lefter[j-1].append(i)
if 0<=j<N:
right = A[j]
else:
right = 10**12
if 0<=j-1<N:
left = A[j-1]
else:
left = -10**12
D[i][0] = min(right-b, b-left)
if 0<=j+1<N:
right1 = A[j+1]
else:
right1 = 10**12
D[i][1] = min(right1-b, b-left)
if 0<=j-2<N:
left1 = A[j-2]
else:
left1 = -10**12
D[i][2] = min(right-b, b-left1)
for a,b,c in D:
ms.insert(a)
j = 0
flag = False
for i, a in enumerate(A):
while j<N and B[j]<a:
ms.erase(D[j][0])
j+=1
for k in lefter[i]:
ms.erase(D[k][0])
ms.insert(D[k][2])
flag1 = False
flag3 = False
if ms.size() > 0:
if a > ms.get_max():
flag1 = True
else:
flag1 = True
flag3 = True
flag2 = False
flag4 = False
if B[0] <= a:
if i>0:
if A[i-1] > a-B[0]:
flag2 = True
if i<N-1:
if A[i+1] < a+B[0]:
flag2 = True
else:
flag2 = True
flag4 = True
if flag1 and flag2:
flag = True
break
for k in lefter[i]:
ms.erase(D[k][2])
ms.insert(D[k][0])
if flag:
print("Alice")
else:
print("Bob")
T = int(input())
for i in range(T):
solve()
|
ConDefects/ConDefects/Code/arc170_d/Python/49565151
|
condefects-python_data_978
|
import sys
sys.setrecursionlimit(10**8)
from sys import stdin
#import numba as nb
#from numba import b1, i4, i8, f8
from collections import defaultdict
from collections import Counter
from collections import deque
import heapq
#import networkx as nx
from itertools import combinations,permutations
from functools import cmp_to_key
import math
import bisect
import sys
sys.setrecursionlimit(10**8)
from sys import stdin
#import numba as nb
#from numba import b1, i4, i8, f8
from collections import defaultdict
from collections import Counter
from collections import deque
import heapq
#import networkx as nx
from itertools import combinations,permutations
from functools import cmp_to_key
import math
import bisect
#import numpy as np
import copy
import random
from collections import defaultdict
class LazSeg:
def __init__(self,n,func,ide,mul,add):
self.sizelog=self.intlog2(n-1)+2
self.size=2**(self.sizelog)-1
self.func=func
self.ide=ide #identity element
self.mul=mul #1 if func==sum, 0 if func==min, max
self.add=add #0 if replacing, 1 if adding
self.lazide= 0 if self.add==1 else None
self.maintree=[self.ide for _ in range(self.size)]
self.subtree=[self.lazide for _ in range(self.size)]
def is2pow(self,x):
return x==2**(self.intlog2(x))
def intlog2(self,x):
return len(bin(x))-3
def ind2seg(self,ind):
segl=2**(self.sizelog-1-self.intlog2(ind+1))
segb=(ind+1-2**(self.intlog2(ind+1)))*segl
return segb,segl
def seg2ind(self,segb,segl):
ind=2**(self.sizelog-1-self.intlog2(segl))+segb//segl-1
return ind
def propagate(self, ind):
if self.subtree[ind]!=self.lazide:
if self.add==1:
self.maintree[ind]+=self.subtree[ind]
else:
self.maintree[ind]=self.subtree[ind]
if 2*ind+2<self.size:
for i in range(2):
if self.add==1:
self.subtree[2*ind+1+i]+=self.subtree[ind]//(2**(self.mul))
else:
self.subtree[2*ind+1+i]=self.subtree[ind]//(2**(self.mul))
self.subtree[ind]=self.lazide
def propagate_root(self,ind):
l=[ind]
z=ind
while z>0:
l.append((z-1)//2)
z=(z-1)//2
while len(l)>0:
q=l.pop()
self.propagate(q)
def segmentize(self,a,b):
v=[]
while b>a:
bb=min(2**self.intlog2(b-a),((b^(b-1))+1)//2)
v.append((b-bb,bb))
b-=bb
return v
def update(self,a,b,x):
v=self.segmentize(a,b)
if len(v)==0:
pass
elif len(v)==1:
ind=self.seg2ind(a,b-a)
self.propagate_root(ind)
self.subtree[ind]=x*((b-a)**self.mul)
while ind>0:
ind=(ind-1)//2
self.maintree[ind]=self.func(self.maintree[ind*2+1]*self.add+self.subtree[ind*2+1],\
self.maintree[ind*2+2]*self.add+self.subtree[ind*2+2])
else:
for vi in v:
self.update(vi[0],vi[0]+vi[1],x)
def query(self,a,b):
v=self.segmentize(a,b)
if len(v)==0:
return self.ide
elif len(v)==1:
ind=self.seg2ind(v[0][0],v[0][1])
self.propagate_root(ind)
return self.maintree[ind]
else:
ind=self.seg2ind(v[0][0],v[0][1])
self.propagate_root(ind)
m=self.maintree[ind]
for vi in v[1:]:
ind=self.seg2ind(vi[0],vi[1])
self.propagate_root(ind)
m=self.func(m,self.maintree[ind])
return m
class LazySegTree_RAQ: #0-index
def __init__(self,init_val,segfunc,ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1<<(n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def gindex(self,l,r):
l += self.num
r += self.num
lm = l>>(l&-l).bit_length()
rm = r>>(r&-r).bit_length()
while r>l:
if l<=lm:
yield l
if r<=rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i]
if v==0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self,l,r,x):
ids = self.gindex(l,r)
l += self.num
r += self.num
while l<r:
if l&1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r&1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self,l,r):
self.propagates(*self.gindex(l,r))
res = self.ide_ele
l += self.num
r += self.num
while l<r:
if l&1:
res = self.segfunc(res,self.tree[l])
l += 1
if r&1:
res = self.segfunc(res,self.tree[r-1])
l >>= 1
r >>= 1
return res
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(N)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
class UnionFind():# 0-index
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())
def z_alg(s):
l=len(s)
d=[0]*(l+1)
d[0]=l
i=1
while i<l:
j=d[i]
while i+j<l and s[i+j]==s[j]:
j+=1
d[i]=j
k=1
while d[k]<j-k:
d[i+k]=d[k]
k+=1
d[i+k]=max(0,j-k)
i+=k
return d
class Bit:# 1-index
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def prime_f(n):
k=2
z=defaultdict(int)
while n>=k**2:
if n%k==0:
z[k]+=1
n//=k
else:
k+=1
if n>1:
z[n]+=1
return z
def pr_fac(n):
counter = Counter()
p=2
while p**2<n:
while n % p == 0:
counter[p] += 1
n //= p
p+=1
if n != 1:
counter[n] += 1
s=[]
for key, value in counter.items():
for i in range(value):
s.append(key)
return s
def base_change(n,nb,ob=10):
n10=int(str(n),ob)
dig="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
q=[]
if n10==0:
return "0"
while n10>0:
q.append(dig[n10%nb])
n10//=nb
return "".join(q[::-1])
mod=998244353
inf=1<<60
lim=3*10**6
fact=[1,1]
inv=[0,1]
factinv=[1,1]
alp="abcdefghijklmnopqrstuvwxyz"
dalp={alp[i]:i for i in range(26)}
def factorial():
for i in range(2,lim):
fact.append((fact[-1]*i)%mod)
inv.append((-(mod//i)*inv[mod%i])%mod)
factinv.append((factinv[-1]*inv[-1])%mod)
return
def binom(a,b):
if 0<=b<=a:
return (fact[a]*factinv[b]*factinv[a-b])%mod
else:
return 0
def cumsum(l):
c=[0]
for li in l:
c.append(c[-1]+li)
return c
#def bfs(edges,cost,vertices,start):# edges are one-way,
# d={i:[] for i in vertices}
# for i in range(len(edges)):
# edges
factorial()
#############
def main(n,a,b):
a=sorted(a)
b=sorted(b)
d=[[] for _ in range(n)]
for i in range(n):
r=bisect.bisect(a,b[i])
d[i]=sorted(range(max(r-3,0),min(r+3,n)),key=lambda x:abs(b[i]-a[x]))[:2]
mx=max([abs(b[i]-a[d[i][0]]) for i in range(n)])
m=[mx]*n
for i in range(n):
m[d[i][0]]=max(m[d[i][0]],abs(b[i]-a[d[i][1]]))
# print(m)
for i in range(n):
yr=bisect.bisect_left(a,b[0]+a[i])
yl=bisect.bisect_right(a,a[i]-b[0])
if (b[0]<a[i] and ((yl<yr and yl!=i) or yl<yr-1)) and a[i]>m[i]:
print("Alice")
return
print("Bob")
return
t,=map(int,input().split())
# s=list(map(int,input().split()))
# p=list(map(int,input().split()))
# n,m,k=input().split()
# nxy=list(input().split())
# s=[input() for _ in range(h)]
# x=[int(input()) for _ in range(q)]
# s=input()
# t=input()
# cp=[input().split() for __ in range(q)]
# uv=[list(map(int,input().split())) for __ in range(m)]
# c=list(map(int,input().split()))
# main(n,m,s)
for _ in range(t):
n,=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
main(n,a,b)
import sys
sys.setrecursionlimit(10**8)
from sys import stdin
#import numba as nb
#from numba import b1, i4, i8, f8
from collections import defaultdict
from collections import Counter
from collections import deque
import heapq
#import networkx as nx
from itertools import combinations,permutations
from functools import cmp_to_key
import math
import bisect
import sys
sys.setrecursionlimit(10**8)
from sys import stdin
#import numba as nb
#from numba import b1, i4, i8, f8
from collections import defaultdict
from collections import Counter
from collections import deque
import heapq
#import networkx as nx
from itertools import combinations,permutations
from functools import cmp_to_key
import math
import bisect
#import numpy as np
import copy
import random
from collections import defaultdict
class LazSeg:
def __init__(self,n,func,ide,mul,add):
self.sizelog=self.intlog2(n-1)+2
self.size=2**(self.sizelog)-1
self.func=func
self.ide=ide #identity element
self.mul=mul #1 if func==sum, 0 if func==min, max
self.add=add #0 if replacing, 1 if adding
self.lazide= 0 if self.add==1 else None
self.maintree=[self.ide for _ in range(self.size)]
self.subtree=[self.lazide for _ in range(self.size)]
def is2pow(self,x):
return x==2**(self.intlog2(x))
def intlog2(self,x):
return len(bin(x))-3
def ind2seg(self,ind):
segl=2**(self.sizelog-1-self.intlog2(ind+1))
segb=(ind+1-2**(self.intlog2(ind+1)))*segl
return segb,segl
def seg2ind(self,segb,segl):
ind=2**(self.sizelog-1-self.intlog2(segl))+segb//segl-1
return ind
def propagate(self, ind):
if self.subtree[ind]!=self.lazide:
if self.add==1:
self.maintree[ind]+=self.subtree[ind]
else:
self.maintree[ind]=self.subtree[ind]
if 2*ind+2<self.size:
for i in range(2):
if self.add==1:
self.subtree[2*ind+1+i]+=self.subtree[ind]//(2**(self.mul))
else:
self.subtree[2*ind+1+i]=self.subtree[ind]//(2**(self.mul))
self.subtree[ind]=self.lazide
def propagate_root(self,ind):
l=[ind]
z=ind
while z>0:
l.append((z-1)//2)
z=(z-1)//2
while len(l)>0:
q=l.pop()
self.propagate(q)
def segmentize(self,a,b):
v=[]
while b>a:
bb=min(2**self.intlog2(b-a),((b^(b-1))+1)//2)
v.append((b-bb,bb))
b-=bb
return v
def update(self,a,b,x):
v=self.segmentize(a,b)
if len(v)==0:
pass
elif len(v)==1:
ind=self.seg2ind(a,b-a)
self.propagate_root(ind)
self.subtree[ind]=x*((b-a)**self.mul)
while ind>0:
ind=(ind-1)//2
self.maintree[ind]=self.func(self.maintree[ind*2+1]*self.add+self.subtree[ind*2+1],\
self.maintree[ind*2+2]*self.add+self.subtree[ind*2+2])
else:
for vi in v:
self.update(vi[0],vi[0]+vi[1],x)
def query(self,a,b):
v=self.segmentize(a,b)
if len(v)==0:
return self.ide
elif len(v)==1:
ind=self.seg2ind(v[0][0],v[0][1])
self.propagate_root(ind)
return self.maintree[ind]
else:
ind=self.seg2ind(v[0][0],v[0][1])
self.propagate_root(ind)
m=self.maintree[ind]
for vi in v[1:]:
ind=self.seg2ind(vi[0],vi[1])
self.propagate_root(ind)
m=self.func(m,self.maintree[ind])
return m
class LazySegTree_RAQ: #0-index
def __init__(self,init_val,segfunc,ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1<<(n-1).bit_length()
self.tree = [ide_ele]*2*self.num
self.lazy = [0]*2*self.num
for i in range(n):
self.tree[self.num+i] = init_val[i]
for i in range(self.num-1,0,-1):
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1])
def gindex(self,l,r):
l += self.num
r += self.num
lm = l>>(l&-l).bit_length()
rm = r>>(r&-r).bit_length()
while r>l:
if l<=lm:
yield l
if r<=rm:
yield r
r >>= 1
l >>= 1
while l:
yield l
l >>= 1
def propagates(self,*ids):
for i in reversed(ids):
v = self.lazy[i]
if v==0:
continue
self.lazy[i] = 0
self.lazy[2*i] += v
self.lazy[2*i+1] += v
self.tree[2*i] += v
self.tree[2*i+1] += v
def add(self,l,r,x):
ids = self.gindex(l,r)
l += self.num
r += self.num
while l<r:
if l&1:
self.lazy[l] += x
self.tree[l] += x
l += 1
if r&1:
self.lazy[r-1] += x
self.tree[r-1] += x
r >>= 1
l >>= 1
for i in ids:
self.tree[i] = self.segfunc(self.tree[2*i], self.tree[2*i+1]) + self.lazy[i]
def query(self,l,r):
self.propagates(*self.gindex(l,r))
res = self.ide_ele
l += self.num
r += self.num
while l<r:
if l&1:
res = self.segfunc(res,self.tree[l])
l += 1
if r&1:
res = self.segfunc(res,self.tree[r-1])
l >>= 1
r >>= 1
return res
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(N)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
class UnionFind():# 0-index
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())
def z_alg(s):
l=len(s)
d=[0]*(l+1)
d[0]=l
i=1
while i<l:
j=d[i]
while i+j<l and s[i+j]==s[j]:
j+=1
d[i]=j
k=1
while d[k]<j-k:
d[i+k]=d[k]
k+=1
d[i+k]=max(0,j-k)
i+=k
return d
class Bit:# 1-index
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def prime_f(n):
k=2
z=defaultdict(int)
while n>=k**2:
if n%k==0:
z[k]+=1
n//=k
else:
k+=1
if n>1:
z[n]+=1
return z
def pr_fac(n):
counter = Counter()
p=2
while p**2<n:
while n % p == 0:
counter[p] += 1
n //= p
p+=1
if n != 1:
counter[n] += 1
s=[]
for key, value in counter.items():
for i in range(value):
s.append(key)
return s
def base_change(n,nb,ob=10):
n10=int(str(n),ob)
dig="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
q=[]
if n10==0:
return "0"
while n10>0:
q.append(dig[n10%nb])
n10//=nb
return "".join(q[::-1])
mod=998244353
inf=1<<60
lim=3*10**6
fact=[1,1]
inv=[0,1]
factinv=[1,1]
alp="abcdefghijklmnopqrstuvwxyz"
dalp={alp[i]:i for i in range(26)}
def factorial():
for i in range(2,lim):
fact.append((fact[-1]*i)%mod)
inv.append((-(mod//i)*inv[mod%i])%mod)
factinv.append((factinv[-1]*inv[-1])%mod)
return
def binom(a,b):
if 0<=b<=a:
return (fact[a]*factinv[b]*factinv[a-b])%mod
else:
return 0
def cumsum(l):
c=[0]
for li in l:
c.append(c[-1]+li)
return c
#def bfs(edges,cost,vertices,start):# edges are one-way,
# d={i:[] for i in vertices}
# for i in range(len(edges)):
# edges
factorial()
#############
def main(n,a,b):
a=sorted(a)
b=sorted(b)
d=[[] for _ in range(n)]
for i in range(n):
r=bisect.bisect(a,b[i])
d[i]=sorted(range(max(r-3,0),min(r+3,n)),key=lambda x:abs(b[i]-a[x]))[:2]
mx=max([abs(b[i]-a[d[i][0]]) for i in range(n)])
m=[mx]*n
for i in range(n):
m[d[i][0]]=max(m[d[i][0]],abs(b[i]-a[d[i][1]]))
# print(m)
for i in range(n):
yr=bisect.bisect_left(a,b[0]+a[i])
yl=bisect.bisect_right(a,a[i]-b[0])
if (b[0]>=a[i] or ((yl<yr and yl!=i) or yl<yr-1)) and a[i]>m[i]:
print("Alice")
return
print("Bob")
return
t,=map(int,input().split())
# s=list(map(int,input().split()))
# p=list(map(int,input().split()))
# n,m,k=input().split()
# nxy=list(input().split())
# s=[input() for _ in range(h)]
# x=[int(input()) for _ in range(q)]
# s=input()
# t=input()
# cp=[input().split() for __ in range(q)]
# uv=[list(map(int,input().split())) for __ in range(m)]
# c=list(map(int,input().split()))
# main(n,m,s)
for _ in range(t):
n,=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
main(n,a,b)
|
ConDefects/ConDefects/Code/arc170_d/Python/49562273
|
condefects-python_data_979
|
H, W, N, h, w = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(H)]
ans = [[0] * (W - w + 1) for _ in range(H - h + 1)]
dic = {}
for i in range(H):
for j in range(W):
if i >= h or j >= w:
a = A[i][j]
if a in dic:
dic[a] += 1
else:
dic[a] = 1
ans[0][0] = len(dic)
for i in range(H - h + 1):
dic2 = dic.copy()
for j in range(W - w):
for k in range(h):
a = A[i + k][j + w]
dic2[a] -= 1
if dic2[a] == 0:
dic2.pop(a)
a = A[i + k][j]
if a in dic2:
dic2[a] += 1
else:
dic2[a] = 1
ans[i][j + 1] = len(dic2)
if i < H - h:
for k in range(1, w):
a = A[i + h][k]
dic[a] -= 1
if dic[a] == 0:
dic.pop(a)
a = A[i][k]
if a in dic:
dic[a] += 1
else:
dic[a] = 1
ans[i + 1][0] = len(dic)
for i in range(H - h + 1):
print(*ans[i])
H, W, N, h, w = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(H)]
ans = [[0] * (W - w + 1) for _ in range(H - h + 1)]
dic = {}
for i in range(H):
for j in range(W):
if i >= h or j >= w:
a = A[i][j]
if a in dic:
dic[a] += 1
else:
dic[a] = 1
ans[0][0] = len(dic)
for i in range(H - h + 1):
dic2 = dic.copy()
for j in range(W - w):
for k in range(h):
a = A[i + k][j + w]
dic2[a] -= 1
if dic2[a] == 0:
dic2.pop(a)
a = A[i + k][j]
if a in dic2:
dic2[a] += 1
else:
dic2[a] = 1
ans[i][j + 1] = len(dic2)
if i < H - h:
for k in range(w):
a = A[i + h][k]
dic[a] -= 1
if dic[a] == 0:
dic.pop(a)
a = A[i][k]
if a in dic:
dic[a] += 1
else:
dic[a] = 1
ans[i + 1][0] = len(dic)
for i in range(H - h + 1):
print(*ans[i])
|
ConDefects/ConDefects/Code/abc278_e/Python/46190302
|
condefects-python_data_980
|
from itertools import combinations
def solve():
N = int(input())
xs = map(int, input().split())
a = sorted(v for v in xs if v > 0)
b = sorted(v for v in xs if v < 0)
c = a[:3] + a[3:][-3:] + b[:3] + b[3:][-3:]
mx, mi = -float('inf'), float('inf')
for x, y, z in combinations(c, 3):
t = (x+y+z)/(x*y*z)
mi = min(mi, t)
mx = max(mx, t)
print(mi)
print(mx)
solve()
from itertools import combinations
def solve():
N = int(input())
xs = list(map(int, input().split()))
a = sorted(v for v in xs if v > 0)
b = sorted(v for v in xs if v < 0)
c = a[:3] + a[3:][-3:] + b[:3] + b[3:][-3:]
mx, mi = -float('inf'), float('inf')
for x, y, z in combinations(c, 3):
t = (x+y+z)/(x*y*z)
mi = min(mi, t)
mx = max(mx, t)
print(mi)
print(mx)
solve()
|
ConDefects/ConDefects/Code/arc158_b/Python/45744284
|
condefects-python_data_981
|
import os
import sys
from io import BytesIO, IOBase
import bisect
BUFSIZE = 4096
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def I():
return input()
def SI():
return str(input())
def II():
return int(input())
def LII():
return list(map(int, input().split()))
n = II()
a = LII()
neg, pos = [], []
for i in range(n):
x = a[i]
if x > 0:
pos.append(x)
else:
neg.append(x)
neg.sort()
pos.sort()
arr = []
m1 = min(len(neg), 3)
for i in range(m1):
arr.append(neg[i])
m1 = max(m1, len(neg) - 3)
for i in range(m1, len(neg)):
arr.append(a[i])
m2 = min(len(pos), 3)
for i in range(m2):
arr.append(pos[i])
m2 = max(m2, len(pos) - 3)
for i in range(m2, len(pos)):
arr.append(pos[i])
mn, mx = (arr[0] + arr[1] + arr[2]) / (arr[0] * arr[1] * arr[2]), (arr[0] + arr[1] + arr[2]) / (arr[0] * arr[1] * arr[2])
for i, x in enumerate(arr):
for j in range(i + 1, len(arr)):
y = arr[j]
for k in range(j + 1, len(arr)):
z = arr[k]
res = (x + y + z) / (x * y * z)
mn = min(mn, res)
mx = max(mx, res)
print("%.15f" % mn)
print("%.15f" % mx)
import os
import sys
from io import BytesIO, IOBase
import bisect
BUFSIZE = 4096
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)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def I():
return input()
def SI():
return str(input())
def II():
return int(input())
def LII():
return list(map(int, input().split()))
n = II()
a = LII()
neg, pos = [], []
for i in range(n):
x = a[i]
if x > 0:
pos.append(x)
else:
neg.append(x)
neg.sort()
pos.sort()
arr = []
m1 = min(len(neg), 3)
for i in range(m1):
arr.append(neg[i])
m1 = max(m1, len(neg) - 3)
for i in range(m1, len(neg)):
arr.append(neg[i])
m2 = min(len(pos), 3)
for i in range(m2):
arr.append(pos[i])
m2 = max(m2, len(pos) - 3)
for i in range(m2, len(pos)):
arr.append(pos[i])
mn, mx = (arr[0] + arr[1] + arr[2]) / (arr[0] * arr[1] * arr[2]), (arr[0] + arr[1] + arr[2]) / (arr[0] * arr[1] * arr[2])
for i, x in enumerate(arr):
for j in range(i + 1, len(arr)):
y = arr[j]
for k in range(j + 1, len(arr)):
z = arr[k]
res = (x + y + z) / (x * y * z)
mn = min(mn, res)
mx = max(mx, res)
print("%.15f" % mn)
print("%.15f" % mx)
|
ConDefects/ConDefects/Code/arc158_b/Python/45756800
|
condefects-python_data_982
|
import bisect
N=int(input())
x=list(map(int,input().split()))
x.sort()
b=bisect.bisect(x,0)
M=x[:b]
P=x[b:]
C=[]
for i in range(len(M)):
if i<3 or len(M)-3<=i:
C.append(M[i])
for i in range(len(P)):
if i<3 or len(P)-3<=i:
C.append(P[i])
D=[]
for i in range(len(C)-2):
for j in range(i+1,len(C)-1):
for k in range(i+2,len(C)):
D.append((C[i]+C[j]+C[k])/(C[i]*C[j]*C[k]))
D.sort()
print(D[0])
print(D[-1])
import bisect
N=int(input())
x=list(map(int,input().split()))
x.sort()
b=bisect.bisect(x,0)
M=x[:b]
P=x[b:]
C=[]
for i in range(len(M)):
if i<3 or len(M)-3<=i:
C.append(M[i])
for i in range(len(P)):
if i<3 or len(P)-3<=i:
C.append(P[i])
D=[]
for i in range(len(C)-2):
for j in range(i+1,len(C)-1):
for k in range(j+1,len(C)):
D.append((C[i]+C[j]+C[k])/(C[i]*C[j]*C[k]))
D.sort()
print(D[0])
print(D[-1])
|
ConDefects/ConDefects/Code/arc158_b/Python/42045718
|
condefects-python_data_983
|
n = int(input())
x = list(map(int, input().split()))
x.sort()
cand = []
def calc(i, j, k):
a, b, c = x[i], x[j], x[k]
return (a + b + c) / (a * b * c)
cand.append(calc(0, 1, 2))
cand.append(calc(0, 1, -1))
cand.append(calc(0, -1, -2))
cand.append(calc(-1, -2, -3))
print(min(cand))
print(max(cand))
n = int(input())
x = list(map(int, input().split()))
x.sort(key=lambda x: 1 / x)
cand = []
def calc(i, j, k):
a, b, c = x[i], x[j], x[k]
return (a + b + c) / (a * b * c)
cand.append(calc(0, 1, 2))
cand.append(calc(0, 1, -1))
cand.append(calc(0, -1, -2))
cand.append(calc(-1, -2, -3))
print(min(cand))
print(max(cand))
|
ConDefects/ConDefects/Code/arc158_b/Python/45509155
|
condefects-python_data_984
|
from itertools import combinations
N = int(input())
x = list(map(int, input().split()))
x.sort()
inf = float('inf')
mx, mn = -inf, inf
if N >=6:
x = x[:3] + x[-3:]
for xi, xj, xk in combinations(x, 3):
mx = max(mx, (xi+xj+xk)/(xi*xj*xk))
mn = min(mn, (xi+xj+xk)/(xi*xj*xk))
print(mn, mx)
from itertools import combinations
N = int(input())
x = list(map(int, input().split()))
x.sort(key=lambda x: 1/x)
inf = float('inf')
mx, mn = -inf, inf
if N >=6:
x = x[:3] + x[-3:]
for xi, xj, xk in combinations(x, 3):
mx = max(mx, (xi+xj+xk)/(xi*xj*xk))
mn = min(mn, (xi+xj+xk)/(xi*xj*xk))
print(mn, mx)
|
ConDefects/ConDefects/Code/arc158_b/Python/43273469
|
condefects-python_data_985
|
import os,sys,math,random,threading
from copy import deepcopy
from io import BytesIO, IOBase
from types import GeneratorType
from functools import lru_cache, reduce
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
import types
BUFSIZE = 4096
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)
mod = int(1e9 + 7) #998244353
inf = int(1e20)
input = lambda: sys.stdin.readline().rstrip("\r\n")
MI = lambda :map(int,input().split())
li = lambda :list(MI())
ii = lambda :int(input())
py = lambda :print("YES")
pn = lambda :print("NO")
ascii_lowercase='abcdefghijklmnopqrstuvwxyz'
DIRS = [(0, 1), (1, 0), (0, -1), (-1, 0)] # 右下左上
DIRS8 = [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0),(-1, 1)] # →↘↓↙←↖↑↗
class StringHash:
# 字符串哈希，用O(n)时间预处理，用O(1)时间获取段的哈希值
def __init__(self, s):
n = len(s)
self.BASE = BASE = 131313 # 进制 31,131,131313
self.MOD = MOD = 10 ** 13 + 7 # 10**13+37 ,10**13+51 ,10**13+99 ,10**13+129 ,10**13+183
self.h = h = [0] * (n + 1)
self.p = p = [1] * (n + 1)
for i in range(1, n + 1):
p[i] = (p[i - 1] * BASE) % MOD
h[i] = (h[i - 1] * BASE + ord(s[i - 1])) % MOD
# 用O(1)时间获取闭区间[l,r]（即s[l:r]）的哈希值，比切片要快
def get_hash(self, l, r):
return (self.h[r+1] - self.h[l] * self.p[r - l + 1]) % self.MOD
# 获取 s[l1:r1+1] 和 s[l2:r2+1] 拼接的哈希值，要求不能有重叠部分，且有先后顺序
def get_addhash(self, l1, r1, l2, r2):
return (self.get_hash(l1,r1)*self.p[r2-l2+1]+self.get_hash(l2,r2))%self.MOD
from collections import defaultdict
class SuffixArray:
def sa_naive(self, s): #实现了最朴素的后缀数组构建算法，其时间复杂度为 O(n^2 log n)，适用于小规模字符串。
n = len(s)
sa = list(range(n))
sa.sort(key=lambda x: s[x:])
return sa
def sa_doubling(self, s): #实现了倍增算法，其时间复杂度为 O(n log n)，适用于中等规模字符串。
n = len(s)
sa = list(range(n))
rnk = s
t = [0] * n
k = 1
while k < n:
sa.sort(key=lambda x: (rnk[x], rnk[x + k])
if x + k < n else (rnk[x], -1))
t[sa[0]] = 0
for i in range(1, n):
t[sa[i]] = t[sa[i - 1]]
if sa[i - 1] + k < n:
x = (rnk[sa[i - 1]], rnk[sa[i - 1] + k])
else:
x = (rnk[sa[i - 1]], -1)
if sa[i] + k < n:
y = (rnk[sa[i]], rnk[sa[i] + k])
else:
y = (rnk[sa[i]], -1)
if x < y:
t[sa[i]] += 1
k *= 2
t, rnk = rnk, t
return sa
def sa_is(self, s, upper):
#实现了 SA-IS 算法，其时间复杂度为 O(n)，适用于大规模字符串。
#SA-IS 算法基于桶排思想，通过对字符串进行分类和排序，最终得到后缀数组。
#代码中使用了类似于桶排的技巧，通过计算各种类型的后缀数量和前缀相同的子串，将问题转化为子问题，然后递归求解。
n = len(s)
if n == 0:
return []
if n == 1:
return [0]
if n == 2:
if s[0] < s[1]:
return [0, 1]
else:
return [1, 0]
if n < 10:
return self.sa_naive(s)
if n < 50:
return self.sa_doubling(s)
ls = [0] * n
for i in range(n - 2, -1, -1):
ls[i] = ls[i + 1] if s[i] == s[i + 1] else s[i] < s[i + 1]
sum_l = [0] * (upper + 1)
sum_s = [0] * (upper + 1)
for i in range(n):
if ls[i]:
sum_l[s[i] + 1] += 1
else:
sum_s[s[i]] += 1
for i in range(upper):
sum_s[i] += sum_l[i]
if i < upper:
sum_l[i + 1] += sum_s[i]
lms_map = [-1] * (n + 1)
m = 0
for i in range(1, n):
if not ls[i - 1] and ls[i]:
lms_map[i] = m
m += 1
lms = []
for i in range(1, n):
if not ls[i - 1] and ls[i]:
lms.append(i)
sa = [-1] * n
buf = sum_s.copy()
for d in lms:
if d == n:
continue
sa[buf[s[d]]] = d
buf[s[d]] += 1
buf = sum_l.copy()
sa[buf[s[n - 1]]] = n - 1
buf[s[n - 1]] += 1
for i in range(n):
v = sa[i]
if v >= 1 and not ls[v - 1]:
sa[buf[s[v - 1]]] = v - 1
buf[s[v - 1]] += 1
buf = sum_l.copy()
for i in range(n - 1, -1, -1):
v = sa[i]
if v >= 1 and ls[v - 1]:
buf[s[v - 1] + 1] -= 1
sa[buf[s[v - 1] + 1]] = v - 1
if m:
sorted_lms = []
for v in sa:
if lms_map[v] != -1:
sorted_lms.append(v)
rec_s = [0] * m
rec_upper = 0
rec_s[lms_map[sorted_lms[0]]] = 0
for i in range(1, m):
l = sorted_lms[i - 1]
r = sorted_lms[i]
end_l = lms[lms_map[l] + 1] if lms_map[l] + 1 < m else n
end_r = lms[lms_map[r] + 1] if lms_map[r] + 1 < m else n
same = True
if end_l - l != end_r - r:
same = False
else:
while l < end_l:
if s[l] != s[r]:
break
l += 1
r += 1
if l == n or s[l] != s[r]:
same = False
if not same:
rec_upper += 1
rec_s[lms_map[sorted_lms[i]]] = rec_upper
rec_sa = self.sa_is(rec_s, rec_upper)
for i in range(m):
sorted_lms[i] = lms[rec_sa[i]]
sa = [-1] * n
buf = sum_s.copy()
for d in sorted_lms:
if d == n:
continue
sa[buf[s[d]]] = d
buf[s[d]] += 1
buf = sum_l.copy()
sa[buf[s[n - 1]]] = n - 1
buf[s[n - 1]] += 1
for i in range(n):
v = sa[i]
if v >= 1 and not ls[v - 1]:
sa[buf[s[v - 1]]] = v - 1
buf[s[v - 1]] += 1
buf = sum_l.copy()
for i in range(n - 1, -1, -1):
v = sa[i]
if v >= 1 and ls[v - 1]:
buf[s[v - 1] + 1] -= 1
sa[buf[s[v - 1] + 1]] = v - 1
return sa
def suffix_array(self, s, upper=255):
if type(s) is str:
s = [ord(c) for c in s]
return self.sa_is(s, upper)
def _count_sort(self, ls):
c = defaultdict(list)
for i, v in enumerate(ls):
c[v].append(i)
ans = []
for v in sorted(list(c.keys())):
for k in c[v]:
ans.append((k, v))
return ans
def _rk(self, sa):
rk = [0 for _ in sa]
for i in range(len(sa)):
rk[sa[i]] = i
return rk
def _height(self, s):
sa, rk = self.sa, self.rk
ht = [0] * len(sa)
k = 0
for sai in range(0, len(s)):
if k:
k -= 1
while True:
ai, bi = sai + k, sa[rk[sai] - 1] + k
if not (0 <= ai < len(s) and 0 <= bi < len(s)):
break
if max(ai, bi) >= len(s):
break
elif s[ai] == s[bi]:
k += 1
else:
break
ht[rk[sai]] = k
return ht
def __init__(self, s): #下方的i都从1开始，字典序
if type(s) is str: #表示排名第i小的后缀在原字符串中的起始位置为sa[i]
self.sa = self.suffix_array(s)
else:
self.sa = self.suffix_array(s[:])
self.rk = self._rk(self.sa) #字符串中的每个位置i，其对应的后缀在后缀数组中的排名为rk[i]，排名从0开始
self.height = self._height(s) #第i小的后缀与它前一名的后缀的最长公共前缀，其他地方也可能交lcp
self.height[0]=0 #在字符串为单一字符构成时(长度为1也算),heigh[0]会出错成1，按照定义应该为0
n=ii()
s=input()
t=input()
sa=SuffixArray(s+s+"$"+t+t)
res=cnt=0
for i in range(4*n,-1,-1):
if 0<=sa.sa[i]<=n-1:
res+=cnt
elif 2*n+1<=sa.sa[i]<=3*n:
cnt+=1
print(res)
import os,sys,math,random,threading
from copy import deepcopy
from io import BytesIO, IOBase
from types import GeneratorType
from functools import lru_cache, reduce
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from itertools import accumulate, combinations, permutations
from heapq import nsmallest, nlargest, heapify, heappop, heappush
from typing import Generic, Iterable, Iterator, TypeVar, Union, List
import types
BUFSIZE = 4096
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)
mod = int(1e9 + 7) #998244353
inf = int(1e20)
input = lambda: sys.stdin.readline().rstrip("\r\n")
MI = lambda :map(int,input().split())
li = lambda :list(MI())
ii = lambda :int(input())
py = lambda :print("YES")
pn = lambda :print("NO")
ascii_lowercase='abcdefghijklmnopqrstuvwxyz'
DIRS = [(0, 1), (1, 0), (0, -1), (-1, 0)] # 右下左上
DIRS8 = [(0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0),(-1, 1)] # →↘↓↙←↖↑↗
class StringHash:
# 字符串哈希，用O(n)时间预处理，用O(1)时间获取段的哈希值
def __init__(self, s):
n = len(s)
self.BASE = BASE = 131313 # 进制 31,131,131313
self.MOD = MOD = 10 ** 13 + 7 # 10**13+37 ,10**13+51 ,10**13+99 ,10**13+129 ,10**13+183
self.h = h = [0] * (n + 1)
self.p = p = [1] * (n + 1)
for i in range(1, n + 1):
p[i] = (p[i - 1] * BASE) % MOD
h[i] = (h[i - 1] * BASE + ord(s[i - 1])) % MOD
# 用O(1)时间获取闭区间[l,r]（即s[l:r]）的哈希值，比切片要快
def get_hash(self, l, r):
return (self.h[r+1] - self.h[l] * self.p[r - l + 1]) % self.MOD
# 获取 s[l1:r1+1] 和 s[l2:r2+1] 拼接的哈希值，要求不能有重叠部分，且有先后顺序
def get_addhash(self, l1, r1, l2, r2):
return (self.get_hash(l1,r1)*self.p[r2-l2+1]+self.get_hash(l2,r2))%self.MOD
from collections import defaultdict
class SuffixArray:
def sa_naive(self, s): #实现了最朴素的后缀数组构建算法，其时间复杂度为 O(n^2 log n)，适用于小规模字符串。
n = len(s)
sa = list(range(n))
sa.sort(key=lambda x: s[x:])
return sa
def sa_doubling(self, s): #实现了倍增算法，其时间复杂度为 O(n log n)，适用于中等规模字符串。
n = len(s)
sa = list(range(n))
rnk = s
t = [0] * n
k = 1
while k < n:
sa.sort(key=lambda x: (rnk[x], rnk[x + k])
if x + k < n else (rnk[x], -1))
t[sa[0]] = 0
for i in range(1, n):
t[sa[i]] = t[sa[i - 1]]
if sa[i - 1] + k < n:
x = (rnk[sa[i - 1]], rnk[sa[i - 1] + k])
else:
x = (rnk[sa[i - 1]], -1)
if sa[i] + k < n:
y = (rnk[sa[i]], rnk[sa[i] + k])
else:
y = (rnk[sa[i]], -1)
if x < y:
t[sa[i]] += 1
k *= 2
t, rnk = rnk, t
return sa
def sa_is(self, s, upper):
#实现了 SA-IS 算法，其时间复杂度为 O(n)，适用于大规模字符串。
#SA-IS 算法基于桶排思想，通过对字符串进行分类和排序，最终得到后缀数组。
#代码中使用了类似于桶排的技巧，通过计算各种类型的后缀数量和前缀相同的子串，将问题转化为子问题，然后递归求解。
n = len(s)
if n == 0:
return []
if n == 1:
return [0]
if n == 2:
if s[0] < s[1]:
return [0, 1]
else:
return [1, 0]
if n < 10:
return self.sa_naive(s)
if n < 50:
return self.sa_doubling(s)
ls = [0] * n
for i in range(n - 2, -1, -1):
ls[i] = ls[i + 1] if s[i] == s[i + 1] else s[i] < s[i + 1]
sum_l = [0] * (upper + 1)
sum_s = [0] * (upper + 1)
for i in range(n):
if ls[i]:
sum_l[s[i] + 1] += 1
else:
sum_s[s[i]] += 1
for i in range(upper):
sum_s[i] += sum_l[i]
if i < upper:
sum_l[i + 1] += sum_s[i]
lms_map = [-1] * (n + 1)
m = 0
for i in range(1, n):
if not ls[i - 1] and ls[i]:
lms_map[i] = m
m += 1
lms = []
for i in range(1, n):
if not ls[i - 1] and ls[i]:
lms.append(i)
sa = [-1] * n
buf = sum_s.copy()
for d in lms:
if d == n:
continue
sa[buf[s[d]]] = d
buf[s[d]] += 1
buf = sum_l.copy()
sa[buf[s[n - 1]]] = n - 1
buf[s[n - 1]] += 1
for i in range(n):
v = sa[i]
if v >= 1 and not ls[v - 1]:
sa[buf[s[v - 1]]] = v - 1
buf[s[v - 1]] += 1
buf = sum_l.copy()
for i in range(n - 1, -1, -1):
v = sa[i]
if v >= 1 and ls[v - 1]:
buf[s[v - 1] + 1] -= 1
sa[buf[s[v - 1] + 1]] = v - 1
if m:
sorted_lms = []
for v in sa:
if lms_map[v] != -1:
sorted_lms.append(v)
rec_s = [0] * m
rec_upper = 0
rec_s[lms_map[sorted_lms[0]]] = 0
for i in range(1, m):
l = sorted_lms[i - 1]
r = sorted_lms[i]
end_l = lms[lms_map[l] + 1] if lms_map[l] + 1 < m else n
end_r = lms[lms_map[r] + 1] if lms_map[r] + 1 < m else n
same = True
if end_l - l != end_r - r:
same = False
else:
while l < end_l:
if s[l] != s[r]:
break
l += 1
r += 1
if l == n or s[l] != s[r]:
same = False
if not same:
rec_upper += 1
rec_s[lms_map[sorted_lms[i]]] = rec_upper
rec_sa = self.sa_is(rec_s, rec_upper)
for i in range(m):
sorted_lms[i] = lms[rec_sa[i]]
sa = [-1] * n
buf = sum_s.copy()
for d in sorted_lms:
if d == n:
continue
sa[buf[s[d]]] = d
buf[s[d]] += 1
buf = sum_l.copy()
sa[buf[s[n - 1]]] = n - 1
buf[s[n - 1]] += 1
for i in range(n):
v = sa[i]
if v >= 1 and not ls[v - 1]:
sa[buf[s[v - 1]]] = v - 1
buf[s[v - 1]] += 1
buf = sum_l.copy()
for i in range(n - 1, -1, -1):
v = sa[i]
if v >= 1 and ls[v - 1]:
buf[s[v - 1] + 1] -= 1
sa[buf[s[v - 1] + 1]] = v - 1
return sa
def suffix_array(self, s, upper=255):
if type(s) is str:
s = [ord(c) for c in s]
return self.sa_is(s, upper)
def _count_sort(self, ls):
c = defaultdict(list)
for i, v in enumerate(ls):
c[v].append(i)
ans = []
for v in sorted(list(c.keys())):
for k in c[v]:
ans.append((k, v))
return ans
def _rk(self, sa):
rk = [0 for _ in sa]
for i in range(len(sa)):
rk[sa[i]] = i
return rk
def _height(self, s):
sa, rk = self.sa, self.rk
ht = [0] * len(sa)
k = 0
for sai in range(0, len(s)):
if k:
k -= 1
while True:
ai, bi = sai + k, sa[rk[sai] - 1] + k
if not (0 <= ai < len(s) and 0 <= bi < len(s)):
break
if max(ai, bi) >= len(s):
break
elif s[ai] == s[bi]:
k += 1
else:
break
ht[rk[sai]] = k
return ht
def __init__(self, s): #下方的i都从1开始，字典序
if type(s) is str: #表示排名第i小的后缀在原字符串中的起始位置为sa[i]
self.sa = self.suffix_array(s)
else:
self.sa = self.suffix_array(s[:])
self.rk = self._rk(self.sa) #字符串中的每个位置i，其对应的后缀在后缀数组中的排名为rk[i]，排名从0开始
self.height = self._height(s) #第i小的后缀与它前一名的后缀的最长公共前缀，其他地方也可能交lcp
self.height[0]=0 #在字符串为单一字符构成时(长度为1也算),heigh[0]会出错成1，按照定义应该为0
n=ii()
s=input()
t=input()
sa=SuffixArray(s+s+"#"+t+t+"|")
res=cnt=0
for i in range(4*n,-1,-1):
if 0<=sa.sa[i]<=n-1:
res+=cnt
elif 2*n+1<=sa.sa[i]<=3*n:
cnt+=1
print(res)
|
ConDefects/ConDefects/Code/abc272_f/Python/46719819
|
condefects-python_data_986
|
from atcoder.string import*
I=input
n=int(I())
Y=c=0
from atcoder.string import*
I=input
n=int(I())
Y=c=0
for i in suffix_array(I()*2+'`'+I()*2+'{'):c+=i<n;Y+=c*(2*n<i<=3*n)
print(Y)
|
ConDefects/ConDefects/Code/abc272_f/Python/53512226
|
condefects-python_data_987
|
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 11 23:28:42 2024
@author: don
"""
class string:
def sa_is(s,upper):
n=len(s)
if n==0:
return []
if n==1:
return [0]
if n==2:
if (s[0]<s[1]):
return [0,1]
else:
return [1,0]
sa=[0]*n
ls=[0]*n
for i in range(n-2,-1,-1):
ls[i]=ls[i+1] if (s[i]==s[i+1]) else (s[i]<s[i+1])
sum_l=[0]*(upper+1)
sum_s=[0]*(upper+1)
for i in range(n):
if not(ls[i]):
sum_s[s[i]]+=1
else:
sum_l[s[i]+1]+=1
for i in range(upper+1):
sum_s[i]+=sum_l[i]
if i<upper:
sum_l[i+1]+=sum_s[i]
def induce(lms):
for i in range(n):
sa[i]=-1
buf=sum_s[:]
for d in lms:
if d==n:
continue
sa[buf[s[d]]]=d
buf[s[d]]+=1
buf=sum_l[:]
sa[buf[s[n-1]]]=n-1
buf[s[n-1]]+=1
for i in range(n):
v=sa[i]
if v>=1 and not(ls[v-1]):
sa[buf[s[v-1]]]=v-1
buf[s[v-1]]+=1
buf=sum_l[:]
for i in range(n-1,-1,-1):
v=sa[i]
if v>=1 and ls[v-1]:
buf[s[v-1]+1]-=1
sa[buf[s[v-1]+1]]=v-1
lms_map=[-1]*(n+1)
m=0
for i in range(1,n):
if not(ls[i-1]) and ls[i]:
lms_map[i]=m
m+=1
lms=[]
for i in range(1,n):
if not(ls[i-1]) and ls[i]:
lms.append(i)
induce(lms)
if m:
sorted_lms=[]
for v in sa:
if lms_map[v]!=-1:
sorted_lms.append(v)
rec_s=[0]*m
rec_upper=0
rec_s[lms_map[sorted_lms[0]]]=0
for i in range(1,m):
l=sorted_lms[i-1]
r=sorted_lms[i]
end_l=lms[lms_map[l]+1] if (lms_map[l]+1<m) else n
end_r=lms[lms_map[r]+1] if (lms_map[r]+1<m) else n
same=True
if end_l-l!=end_r-r:
same=False
else:
while(l<end_l):
if s[l]!=s[r]:
break
l+=1
r+=1
if (l==n) or (s[l]!=s[r]):
same=False
if not(same):
rec_upper+=1
rec_s[lms_map[sorted_lms[i]]]=rec_upper
rec_sa=string.sa_is(rec_s,rec_upper)
for i in range(m):
sorted_lms[i]=lms[rec_sa[i]]
induce(sorted_lms)
return sa
def suffix_array_upper(s,upper):
assert 0<=upper
for d in s:
assert 0<=d and d<=upper
return string.sa_is(s,upper)
def suffix_array(s):
n=len(s)
if type(s)==str:
s2=[ord(i) for i in s]
return string.sa_is(s2,255)
else:
idx=list(range(n))
idx.sort(key=lambda x:s[x])
s2=[0]*n
now=0
for i in range(n):
if (i& s[idx[i-1]]!=s[idx[i]]):
now+=1
s2[idx[i]]=now
return string.sa_is(s2,now)
def lcp_array(s,sa):
n=len(s)
assert n>=1
rnk=[0]*n
for i in range(n):
rnk[sa[i]]=i
lcp=[0]*(n-1)
h=0
for i in range(n):
if h>0:
h-=1
if rnk[i]==0:
continue
j=sa[rnk[i]-1]
while(j+h<n and i+h<n):
if s[j+h]!=s[i+h]:
break
h+=1
lcp[rnk[i]-1]=h
return lcp
def z_algorithm(s):
n=len(s)
if n==0:
return []
z=[0]*n
i=1;j=0
while(i<n):
z[i]=0 if (j+z[j]<=i) else min(j+z[j]-i,z[i-j])
while((i+z[i]<n) and (s[z[i]]==s[i+z[i]])):
z[i]+=1
if (j+z[j]<i+z[i]):
j=i
i+=1
z[0]=n
return z
N=int(input())
S=input()
T=input()
X=S+S+"a"*N+T+T+"z"*N
#print(X)
li=string.suffix_array(X)
#print(li)
check=[]
from collections import defaultdict
import bisect
D=defaultdict(int)
for ids,i in enumerate(li):
D[i]=ids
if 3*N+1<=i<=4*N:
check.append(ids)
count=0
L=len(check)
for i in range(N):
num=D[i]
index=bisect.bisect_right(check, num)
count+=L-index
print(count)
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 11 23:28:42 2024
@author: don
"""
class string:
def sa_is(s,upper):
n=len(s)
if n==0:
return []
if n==1:
return [0]
if n==2:
if (s[0]<s[1]):
return [0,1]
else:
return [1,0]
sa=[0]*n
ls=[0]*n
for i in range(n-2,-1,-1):
ls[i]=ls[i+1] if (s[i]==s[i+1]) else (s[i]<s[i+1])
sum_l=[0]*(upper+1)
sum_s=[0]*(upper+1)
for i in range(n):
if not(ls[i]):
sum_s[s[i]]+=1
else:
sum_l[s[i]+1]+=1
for i in range(upper+1):
sum_s[i]+=sum_l[i]
if i<upper:
sum_l[i+1]+=sum_s[i]
def induce(lms):
for i in range(n):
sa[i]=-1
buf=sum_s[:]
for d in lms:
if d==n:
continue
sa[buf[s[d]]]=d
buf[s[d]]+=1
buf=sum_l[:]
sa[buf[s[n-1]]]=n-1
buf[s[n-1]]+=1
for i in range(n):
v=sa[i]
if v>=1 and not(ls[v-1]):
sa[buf[s[v-1]]]=v-1
buf[s[v-1]]+=1
buf=sum_l[:]
for i in range(n-1,-1,-1):
v=sa[i]
if v>=1 and ls[v-1]:
buf[s[v-1]+1]-=1
sa[buf[s[v-1]+1]]=v-1
lms_map=[-1]*(n+1)
m=0
for i in range(1,n):
if not(ls[i-1]) and ls[i]:
lms_map[i]=m
m+=1
lms=[]
for i in range(1,n):
if not(ls[i-1]) and ls[i]:
lms.append(i)
induce(lms)
if m:
sorted_lms=[]
for v in sa:
if lms_map[v]!=-1:
sorted_lms.append(v)
rec_s=[0]*m
rec_upper=0
rec_s[lms_map[sorted_lms[0]]]=0
for i in range(1,m):
l=sorted_lms[i-1]
r=sorted_lms[i]
end_l=lms[lms_map[l]+1] if (lms_map[l]+1<m) else n
end_r=lms[lms_map[r]+1] if (lms_map[r]+1<m) else n
same=True
if end_l-l!=end_r-r:
same=False
else:
while(l<end_l):
if s[l]!=s[r]:
break
l+=1
r+=1
if (l==n) or (s[l]!=s[r]):
same=False
if not(same):
rec_upper+=1
rec_s[lms_map[sorted_lms[i]]]=rec_upper
rec_sa=string.sa_is(rec_s,rec_upper)
for i in range(m):
sorted_lms[i]=lms[rec_sa[i]]
induce(sorted_lms)
return sa
def suffix_array_upper(s,upper):
assert 0<=upper
for d in s:
assert 0<=d and d<=upper
return string.sa_is(s,upper)
def suffix_array(s):
n=len(s)
if type(s)==str:
s2=[ord(i) for i in s]
return string.sa_is(s2,255)
else:
idx=list(range(n))
idx.sort(key=lambda x:s[x])
s2=[0]*n
now=0
for i in range(n):
if (i& s[idx[i-1]]!=s[idx[i]]):
now+=1
s2[idx[i]]=now
return string.sa_is(s2,now)
def lcp_array(s,sa):
n=len(s)
assert n>=1
rnk=[0]*n
for i in range(n):
rnk[sa[i]]=i
lcp=[0]*(n-1)
h=0
for i in range(n):
if h>0:
h-=1
if rnk[i]==0:
continue
j=sa[rnk[i]-1]
while(j+h<n and i+h<n):
if s[j+h]!=s[i+h]:
break
h+=1
lcp[rnk[i]-1]=h
return lcp
def z_algorithm(s):
n=len(s)
if n==0:
return []
z=[0]*n
i=1;j=0
while(i<n):
z[i]=0 if (j+z[j]<=i) else min(j+z[j]-i,z[i-j])
while((i+z[i]<n) and (s[z[i]]==s[i+z[i]])):
z[i]+=1
if (j+z[j]<i+z[i]):
j=i
i+=1
z[0]=n
return z
N=int(input())
S=input()
T=input()
X=S+S+"a"*N+T+T+"z"*(N+1)
#print(X)
li=string.suffix_array(X)
#print(li)
check=[]
from collections import defaultdict
import bisect
D=defaultdict(int)
for ids,i in enumerate(li):
D[i]=ids
if 3*N+1<=i<=4*N:
check.append(ids)
count=0
L=len(check)
for i in range(N):
num=D[i]
index=bisect.bisect_right(check, num)
count+=L-index
print(count)
|
ConDefects/ConDefects/Code/abc272_f/Python/49227972
|
condefects-python_data_988
|
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class SuffixArray:
def __init__(self):
return
@staticmethod
def build(s, sig):
# sa: index is rank and value is pos
# rk: index if pos and value is rank
# height: lcp of rank i-th suffix and (i-1)-th suffix
# sum(height): count of same substring of s
# n*(n+1)//2 - sum(height): count of different substring of s
# max(height): can compute the longest duplicate substring,
# which is s[i: i + height[j]] and j = height.index(max(height)) and i = sa[j]
# sig: number of unique rankings which initially is the size of the character set
n = len(s)
sa = list(range(n))
rk = s[:]
ll = 0 # ll is the length that has already been sorted, and now it needs to be sorted by 2ll length
tmp = [0] * n
while True:
p = [i for i in range(n - ll, n)] + [x - ll for i, x in enumerate(sa) if x >= ll]
# for suffixes with a length less than l, their second keyword ranking is definitely
# the smallest because they are all empty
# for suffixes of other lengths, suffixes starting at 'sa [i]' rank i-th, and their
# first ll characters happen to be the second keyword of suffixes starting at 'sa[i] - ll'
# start cardinality sorting, and first perform statistics on the first keyword
# first, count how many values each has
cnt = [0] * sig
for i in range(n):
cnt[rk[i]] += 1
# make a prefix and for easy cardinality sorting
for i in range(1, sig):
cnt[i] += cnt[i - 1]
# then use cardinality sorting to calculate the new sa
for i in range(n - 1, -1, -1):
w = rk[p[i]]
cnt[w] -= 1
sa[cnt[w]] = p[i]
# new_sa to check new_rk
def equal(ii, jj, lll):
if rk[ii] != rk[jj]:
return False
if ii + lll >= n and jj + lll >= n:
return True
if ii + lll < n and jj + lll < n:
return rk[ii + lll] == rk[jj + lll]
return False
sig = -1
for i in range(n):
tmp[i] = 0
for i in range(n):
# compute the lcp
if i == 0 or not equal(sa[i], sa[i - 1], ll):
sig += 1
tmp[sa[i]] = sig
for i in range(n):
rk[i] = tmp[i]
sig += 1
if sig == n:
break
ll = ll << 1 if ll > 0 else 1
# height
k = 0
height = [0] * n
for i in range(n):
if rk[i] > 0:
j = sa[rk[i] - 1]
while i + k < n and j + k < n and s[i + k] == s[j + k]:
k += 1
height[rk[i]] = k
k = 0 if k - 1 < 0 else k - 1
return sa, rk, height
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load]
for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._min_s = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists)
for value in reversed(_list))
def __repr__(self):
"""Return strings representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n = ac.read_int()
s = [ord(w) - ord("a") for w in ac.read_str()]
t = [ord(w) - ord("a") for w in ac.read_str()]
lst = s + s + t + t
sa, rk, height = SuffixArray().build(lst, 26)
ans = 0
ind = SortedList(list(range(2 * n, 3 * n)))
j = 0
for i in range(4 * n):
while j <= i or (j < 4 * n and height[j] >= n):
if 2 * n <= sa[j] < 3 * n:
ind.discard(sa[j])
j += 1
if 0 <= sa[i] < n:
ans += len(ind)
ac.st(ans)
return
Solution().main()
from sys import stdin
class FastIO:
def __init__(self):
self.random_seed = 0
self.flush = False
self.inf = 1 << 32
return
@staticmethod
def read_int():
return int(stdin.readline().rstrip())
@staticmethod
def read_float():
return float(stdin.readline().rstrip())
@staticmethod
def read_list_ints():
return list(map(int, stdin.readline().rstrip().split()))
@staticmethod
def read_list_ints_minus_one():
return list(map(lambda x: int(x) - 1, stdin.readline().rstrip().split()))
@staticmethod
def read_str():
return stdin.readline().rstrip()
@staticmethod
def read_list_strs():
return stdin.readline().rstrip().split()
def get_random_seed(self):
import random
self.random_seed = random.randint(0, 10 ** 9 + 7)
return
def st(self, x):
return print(x, flush=self.flush)
def lst(self, x):
return print(*x, flush=self.flush)
def flatten(self, lst):
self.st("\n".join(str(x) for x in lst))
return
@staticmethod
def max(a, b):
return a if a > b else b
@staticmethod
def min(a, b):
return a if a < b else b
@staticmethod
def ceil(a, b):
return a // b + int(a % b != 0)
@staticmethod
def accumulate(nums):
n = len(nums)
pre = [0] * (n + 1)
for i in range(n):
pre[i + 1] = pre[i] + nums[i]
return pre
class SuffixArray:
def __init__(self):
return
@staticmethod
def build(s, sig):
# sa: index is rank and value is pos
# rk: index if pos and value is rank
# height: lcp of rank i-th suffix and (i-1)-th suffix
# sum(height): count of same substring of s
# n*(n+1)//2 - sum(height): count of different substring of s
# max(height): can compute the longest duplicate substring,
# which is s[i: i + height[j]] and j = height.index(max(height)) and i = sa[j]
# sig: number of unique rankings which initially is the size of the character set
n = len(s)
sa = list(range(n))
rk = s[:]
ll = 0 # ll is the length that has already been sorted, and now it needs to be sorted by 2ll length
tmp = [0] * n
while True:
p = [i for i in range(n - ll, n)] + [x - ll for i, x in enumerate(sa) if x >= ll]
# for suffixes with a length less than l, their second keyword ranking is definitely
# the smallest because they are all empty
# for suffixes of other lengths, suffixes starting at 'sa [i]' rank i-th, and their
# first ll characters happen to be the second keyword of suffixes starting at 'sa[i] - ll'
# start cardinality sorting, and first perform statistics on the first keyword
# first, count how many values each has
cnt = [0] * sig
for i in range(n):
cnt[rk[i]] += 1
# make a prefix and for easy cardinality sorting
for i in range(1, sig):
cnt[i] += cnt[i - 1]
# then use cardinality sorting to calculate the new sa
for i in range(n - 1, -1, -1):
w = rk[p[i]]
cnt[w] -= 1
sa[cnt[w]] = p[i]
# new_sa to check new_rk
def equal(ii, jj, lll):
if rk[ii] != rk[jj]:
return False
if ii + lll >= n and jj + lll >= n:
return True
if ii + lll < n and jj + lll < n:
return rk[ii + lll] == rk[jj + lll]
return False
sig = -1
for i in range(n):
tmp[i] = 0
for i in range(n):
# compute the lcp
if i == 0 or not equal(sa[i], sa[i - 1], ll):
sig += 1
tmp[sa[i]] = sig
for i in range(n):
rk[i] = tmp[i]
sig += 1
if sig == n:
break
ll = ll << 1 if ll > 0 else 1
# height
k = 0
height = [0] * n
for i in range(n):
if rk[i] > 0:
j = sa[rk[i] - 1]
while i + k < n and j + k < n and s[i + k] == s[j + k]:
k += 1
height[rk[i]] = k
k = 0 if k - 1 < 0 else k - 1
return sa, rk, height
class SortedList:
def __init__(self, iterable=None, _load=200):
"""Initialize sorted list instance."""
if iterable is None:
iterable = []
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load]
for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._min_s = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._min_s
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._min_s
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists)
for value in reversed(_list))
def __repr__(self):
"""Return strings representation of sorted list."""
return 'SortedList({0})'.format(list(self))
class Solution:
def __init__(self):
return
@staticmethod
def main(ac=FastIO()):
"""
url: url of the problem
tag: algorithm tag
"""
n = ac.read_int()
s = [ord(w) - ord("a") for w in ac.read_str()]
t = [ord(w) - ord("a") for w in ac.read_str()]
lst = s + s + t + t
sa, rk, height = SuffixArray().build(lst, 26)
ans = 0
ind = SortedList(list(range(2 * n, 3 * n)))
j = 0
for i in range(4 * n):
while j < i and height[i] < n:
if 2 * n <= sa[j] < 3 * n:
ind.discard(sa[j])
j += 1
if 0 <= sa[i] < n:
ans += len(ind)
ac.st(ans)
return
Solution().main()
|
ConDefects/ConDefects/Code/abc272_f/Python/52005290
|
condefects-python_data_989
|
def main():
# write code here.
N = II()
S = IS()
T = IS()
sa = sais(T*2+"z"*N+S*2)
ans=cnt=0
for elm in sa[::-1]:
if 0<=elm<N: cnt+=1
if 4*N-1<=elm<5*N-1: ans+=cnt
print(ans)
from collections import Counter
# SA-IS (O(nlogn))
# s: 文字列
def sais(s):
uniq = list(set(s))
uniq.sort()
return sais_rec(list(map({e: i+1 for i, e in enumerate(uniq)}.__getitem__, s)), len(uniq))
def sais_rec(lst, num):
L = len(lst)
if L < 2:
return lst + [0]
lst = lst + [0]
L += 1
res = [-1] * L
t = [1] * L
for i in range(L-2, -1, -1):
t[i] = 1 if (lst[i] < lst[i+1] or (lst[i] == lst[i+1] and t[i+1])) else 0
isLMS = [t[i-1] < t[i] for i in range(L)]
LMS = [i for i in range(1, L) if t[i-1] < t[i]]
LMSn = len(LMS)
count = Counter(lst)
tmp = 0
cstart = [0]*(num+1)
cend = [0]*(num+1)
for key in range(num+1):
cstart[key] = tmp
cend[key] = tmp = tmp + count[key]
cc_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in reversed(LMS):
res[next(cc_it[lst[e]])] = e
cs_it = [iter(range(s, e)) for s, e in zip(cstart, cend)]
ce_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in res:
if e > 0 and not t[e-1]:
res[next(cs_it[lst[e-1]])] = e-1
for e in reversed(res):
if e > 0 and t[e-1]:
res[next(ce_it[lst[e-1]])] = e-1
name = 0; prev = -1
pLMS = {}
for e in res:
if isLMS[e]:
if prev == -1 or lst[e] != lst[prev]:
name += 1; prev = e
else:
for i in range(1, L):
if lst[e+i] != lst[prev+i]:
name += 1; prev = e
break
if isLMS[e+i] or isLMS[prev+i]:
break
pLMS[e] = name-1
if name < LMSn:
sublst = [pLMS[e] for e in LMS if e < L-1]
ret = sais_rec(sublst, name-1)
LMS = list(map(LMS.__getitem__, reversed(ret)))
else:
LMS = [e for e in reversed(res) if isLMS[e]]
res = [-1] * L
cc_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in LMS:
res[next(cc_it[lst[e]])] = e
cs_it = [iter(range(s, e)) for s, e in zip(cstart, cend)]
ce_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in res:
if e > 0 and not t[e-1]:
res[next(cs_it[lst[e-1]])] = e-1
for e in reversed(res):
if e > 0 and t[e-1]:
res[next(ce_it[lst[e-1]])] = e-1
return res
# Longest Common Prefix
# (文字列s, 文字列長n, Suffix Array)を引数として与える
def LCP(s, n, sa):
lcp = [-1]*(n+1)
rank = [0]*(n+1)
for i in range(n+1): rank[sa[i]] = i
h = 0
lcp[0] = 0
for i in range(n):
j = sa[rank[i] - 1]
if h > 0: h -= 1
while j+h < n and i+h < n and s[j+h]==s[i+h]:
h += 1
lcp[rank[i] - 1] = h
return lcp
def ManberMyers(string):
N = len(string)
#sa = [i for i in range(N+1)]
#rank[i]:i文字目から1文字が何番目に小さいかを圧縮する前.
rank = defaultdict(lambda:-1)
for i,c in enumerate(string):
rank[i] = ord(c)
width = 1
while width < N:
#tmp[i]:i文字目から長さ2*widthの強さ.
tmp = [(rank[i], rank[i+width]) for i in range(N+1)]
comp = {e:i for i,e in enumerate(sorted(tmp))}
rank = defaultdict(lambda:-1)
for i in range(N+1):
rank[i] = comp[tmp[i]]
width *= 2
sa = [0]*(N+1)
for i in range(N+1):
sa[rank[i]] = i
return sa
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(bound_included1, bound_included2, coeff1, coeff0):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mal_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mal_matrix(res, mat, mod)
mat = mal_matrix(mat, mat, mod)
exp //= 2
return res
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class UnionFind:
"""
二次元の時は、初期化時に (H,W) のように二次元配列の高さと幅を入力.
引数一個の root とか size は (r,c) みたいに.
引数二個の unite とか same は ((ra,ca),(rb,cb)) みたいに引数入れる.
"""
def __init__(self,*N):
if not isinstance(N[0],int):
N = N[0]
if len(N)==1:
N=N[0]
elif len(N)==2:
self.H, self.W = N[0], N[1]
N = self.H * self.W
self.par = [ i for i in range(N) ]
self.tree_size = [ 1 for i in range(N) ]
def root(self,*x):
x = self._dimCheck1(x)
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return False
self.par[rx] = ry
self.tree_size[ry] += self.tree_size[rx]
return True
def same(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
return rx == ry
def size(self,*x):
x = self._dimCheck1(x)
rx = self.root(x)
return self.tree_size[rx]
def _dimCheck1(self,x):
if len(x)==1: return x[0]
if len(x)==2: return x[0]*self.W + x[1]
def _dimCheck2(self,xy):
if isinstance(xy[0],int): return xy[0],xy[1]
return xy[0][0]*self.W + xy[0][1], xy[1][0]*self.W + xy[1][1]
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def solve(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main()
def main():
# write code here.
N = II()
S = IS()
T = IS()
sa = sais(T*2+"z"*N+S*2)
ans=cnt=0
for elm in sa[::-1]:
if 0<=elm<N: cnt+=1
if 3*N<=elm<4*N: ans+=cnt
print(ans)
from collections import Counter
# SA-IS (O(nlogn))
# s: 文字列
def sais(s):
uniq = list(set(s))
uniq.sort()
return sais_rec(list(map({e: i+1 for i, e in enumerate(uniq)}.__getitem__, s)), len(uniq))
def sais_rec(lst, num):
L = len(lst)
if L < 2:
return lst + [0]
lst = lst + [0]
L += 1
res = [-1] * L
t = [1] * L
for i in range(L-2, -1, -1):
t[i] = 1 if (lst[i] < lst[i+1] or (lst[i] == lst[i+1] and t[i+1])) else 0
isLMS = [t[i-1] < t[i] for i in range(L)]
LMS = [i for i in range(1, L) if t[i-1] < t[i]]
LMSn = len(LMS)
count = Counter(lst)
tmp = 0
cstart = [0]*(num+1)
cend = [0]*(num+1)
for key in range(num+1):
cstart[key] = tmp
cend[key] = tmp = tmp + count[key]
cc_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in reversed(LMS):
res[next(cc_it[lst[e]])] = e
cs_it = [iter(range(s, e)) for s, e in zip(cstart, cend)]
ce_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in res:
if e > 0 and not t[e-1]:
res[next(cs_it[lst[e-1]])] = e-1
for e in reversed(res):
if e > 0 and t[e-1]:
res[next(ce_it[lst[e-1]])] = e-1
name = 0; prev = -1
pLMS = {}
for e in res:
if isLMS[e]:
if prev == -1 or lst[e] != lst[prev]:
name += 1; prev = e
else:
for i in range(1, L):
if lst[e+i] != lst[prev+i]:
name += 1; prev = e
break
if isLMS[e+i] or isLMS[prev+i]:
break
pLMS[e] = name-1
if name < LMSn:
sublst = [pLMS[e] for e in LMS if e < L-1]
ret = sais_rec(sublst, name-1)
LMS = list(map(LMS.__getitem__, reversed(ret)))
else:
LMS = [e for e in reversed(res) if isLMS[e]]
res = [-1] * L
cc_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in LMS:
res[next(cc_it[lst[e]])] = e
cs_it = [iter(range(s, e)) for s, e in zip(cstart, cend)]
ce_it = [iter(range(e-1, s-1, -1)) for s, e in zip(cstart, cend)]
for e in res:
if e > 0 and not t[e-1]:
res[next(cs_it[lst[e-1]])] = e-1
for e in reversed(res):
if e > 0 and t[e-1]:
res[next(ce_it[lst[e-1]])] = e-1
return res
# Longest Common Prefix
# (文字列s, 文字列長n, Suffix Array)を引数として与える
def LCP(s, n, sa):
lcp = [-1]*(n+1)
rank = [0]*(n+1)
for i in range(n+1): rank[sa[i]] = i
h = 0
lcp[0] = 0
for i in range(n):
j = sa[rank[i] - 1]
if h > 0: h -= 1
while j+h < n and i+h < n and s[j+h]==s[i+h]:
h += 1
lcp[rank[i] - 1] = h
return lcp
def ManberMyers(string):
N = len(string)
#sa = [i for i in range(N+1)]
#rank[i]:i文字目から1文字が何番目に小さいかを圧縮する前.
rank = defaultdict(lambda:-1)
for i,c in enumerate(string):
rank[i] = ord(c)
width = 1
while width < N:
#tmp[i]:i文字目から長さ2*widthの強さ.
tmp = [(rank[i], rank[i+width]) for i in range(N+1)]
comp = {e:i for i,e in enumerate(sorted(tmp))}
rank = defaultdict(lambda:-1)
for i in range(N+1):
rank[i] = comp[tmp[i]]
width *= 2
sa = [0]*(N+1)
for i in range(N+1):
sa[rank[i]] = i
return sa
# user config
############
DEBUG_MODE=1
############
# import
import sys
import itertools
import bisect
import math
from collections import *
from pprint import pprint
from functools import cache
import heapq
# alias
DD = defaultdict
BSL = bisect.bisect_left
BSR = bisect.bisect_right
# config
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
# input template
def II(): return int(input())
def IS(): return input()[:-1]
def MI(): return map(int,input().split())
def LM(): return list(MI())
def LL(n): return [LM() for _ in range(n)]
def INPUT_TABLE_LIST(n,remove_br=True): return [list(input())[:-1] if remove_br else list(input()) for _ in range(n)]
def INPUT_TABLE_STRING(n): return [IS() for _ in range(n)]
def ALPHABET_TO_NUM(string, upper=False): return list(map(lambda elm:ord(elm)-ord("A") if upper else ord(elm)-ord("a"), string))
def MI_1(): return map(lambda x:int(x)-1,input().split())
def LM_1(): return list(MI_1())
def LL_1(n): return [LM_1() for _ in range(n)]
# functions
def bit_count(num):
length = num.bit_length()
res = 0
for i in range(length):
if num >> i & 1:
res += 1
return res
def DB(*args,**kwargs):
global DEBUG_MODE
if not DEBUG_MODE:
return
if args:
print(*args)
return
for name, value in kwargs.items():
print(f"{name} : {value}")
def argmax(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(max(lst))
def argmin(*args):
if len(args) == 1 and hasattr(args[0], '__iter__'):
lst = args[0]
else:
lst = args
return lst.index(min(lst))
def expand_table(table, h_mag, w_mag):
#引数の二次元配列などをタイルのように繰り替えしたものを返す.
res = []
for row in table:
res.append(row*w_mag)
return res*h_mag
def safe_sqrt(N):
#[平方根]の誤差が怖いとき用.
rough = int(N**0.5)
left = rough - 10
right = rough + 10
while left != right:
mid = (left+right+1)//2
if mid**2 <= N:
left = mid
else:
right = mid - 1
return left
def sigma_LinearFunc(bound_included1, bound_included2, coeff1, coeff0):
"""
coeff1*x + coeff0
の x = [left, right] の和を求める.
"""
left = min(bound_included1, bound_included2)
right = max(bound_included1, bound_included2)
return coeff0*(right-left+1) + coeff1*(left+right)*(right-left+1)//2
def find_divisors(n):
divisors_small = []
divisors_big = []
i = 1
while i * i <= n:
if n % i == 0:
divisors_small.append(i)
# iと一致しない場合、n/iも約数
if i != n // i:
divisors_big.append(n // i)
i += 1
return divisors_small + divisors_big[::-1]
def prime_factorization(n):
n_intact = n
ret = []
i = 2
while i * i <= n_intact:
if n % i == 0:
cnt = 0
while n % i == 0:
n //= i
cnt += 1
ret.append((i,cnt))
i += 1
if n != 1: ret.append((n,1))
return ret
def makeTableBit(table, letter1="#", rev=False):
H,W = len(table), len(table[0])
res = []
for h in range(H):
rowBit = 0
for w in range(W):
if rev:
if table[h][w] == letter1:
rowBit += 2**w
else:
if table[h][W-w-1] == letter1:
rowBit += 2**w
res.append(rowBit)
return res
def rot(S):return list(zip(*S))[::-1]
def topological_sort(G, indegree=None):
N = len(G)
if indegree is None:
indegree = [0]*N
for v in range(N):
for adj in G[v]:
indegree[adj] += 1
deq = deque()
for v in range(N):
if indegree[v] == 0:
deq.append(v)
res = []
while deq:
v = deq.popleft()
res.append(v)
for adj in G[v]:
indegree[adj] -= 1
if indegree[adj] == 0:
deq.append(adj)
return res
def mal_matrix(A, B, mod):
N = len(A)
K = len(A[0])
M = len(B[0])
res = [[0 for _ in range(M)] for _ in range(N)]
for i in range(N) :
for j in range(K) :
for k in range(M) :
res[i][k] += A[i][j] * B[j][k]
res[i][k] %= mod
return res
def pow_matrix(mat, exp, mod):
N = len(mat)
res = [[1 if i == j else 0 for i in range(N)] for j in range(N)]
while exp > 0 :
if exp%2 == 1 :
res = mal_matrix(res, mat, mod)
mat = mal_matrix(mat, mat, mod)
exp //= 2
return res
#classes
"""
・使い方
s=SortedSet() : 引数にイテラブル渡せる.
s.a: SortedSetの中身を返す。
len(s), x in s, x not in s: リストと同じ要領で使える。
s.add(x): xを追加してTrueを返す。ただしxがすでにs内にある場合、xは追加せずにFalseを返す。
s.discard(x): xを削除してTrueを返す。ただしxがs内にない場合、何もせずにFalseを返す。
s.lt(x): xより小さい最大の要素を返す。もし存在しないなら、Noneを返す。
s.le(x): x 以下の 最大の要素を返す。もし存在しないなら、Noneを返す。
s.gt(x): xより大きい最小の要素を返す。もし存在しないなら、Noneを返す。
s.ge(x): x 以上の 最小の要素を返す。もし存在しないなら、Noneを返す。
s.index(x): xより小さい要素の数を返す。
s.index_right(x): x以下の要素の数を返す。
"""
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, List, Tuple, TypeVar, Optional
T = TypeVar('T')
class SortedSet(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
if any(a[i] >= a[i + 1] for i in range(n - 1)):
a, b = [], a
for x in b:
if not a or a[-1] != x:
a.append(x)
bucket_size = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // bucket_size : n * (i + 1) // bucket_size] for i in range(bucket_size)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedSet" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def add(self, x: T) -> bool:
"Add an element and return True if added. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return True
a, b, i = self._position(x)
if i != len(a) and a[i] == x: return False
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
return True
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
"""
(num, cnt)を要素としたSSを管理してMultiset化したいとき用.
"""
def exist(self, x):
ret = self.gt((x,0))
if ret is None:
return False
elif ret[0] == x:
return True
else:
return False
def increment(self, x):
if not self.exist(x):
self.add((x,1))
else:
num, cnt = self.gt((x,0))
self.discard((x,cnt))
self.add((x,cnt+1))
def decrement(self, x):
num, cnt = self.gt((x,0))
if cnt == 1:
self.discard((x,cnt))
else:
self.discard((x,cnt))
self.add((x,cnt-1))
# https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py
T = TypeVar('T')
class SortedMultiset(Generic[T]):
BUCKET_RATIO = 16
SPLIT_RATIO = 24
def __init__(self, a: Iterable[T] = []) -> None:
"Make a new SortedMultiset from iterable. / O(N) if sorted / O(N log N)"
a = list(a)
n = self.size = len(a)
if any(a[i] > a[i + 1] for i in range(n - 1)):
a.sort()
num_bucket = int(math.ceil(math.sqrt(n / self.BUCKET_RATIO)))
self.a = [a[n * i // num_bucket : n * (i + 1) // num_bucket] for i in range(num_bucket)]
def __iter__(self) -> Iterator[T]:
for i in self.a:
for j in i: yield j
def __reversed__(self) -> Iterator[T]:
for i in reversed(self.a):
for j in reversed(i): yield j
def __eq__(self, other) -> bool:
return list(self) == list(other)
def __len__(self) -> int:
return self.size
def __repr__(self) -> str:
return "SortedMultiset" + str(self.a)
def __str__(self) -> str:
s = str(list(self))
return "{" + s[1 : len(s) - 1] + "}"
def _position(self, x: T) -> Tuple[List[T], int, int]:
"return the bucket, index of the bucket and position in which x should be. self must not be empty."
for i, a in enumerate(self.a):
if x <= a[-1]: break
return (a, i, bisect_left(a, x))
def __contains__(self, x: T) -> bool:
if self.size == 0: return False
a, _, i = self._position(x)
return i != len(a) and a[i] == x
def count(self, x: T) -> int:
"Count the number of x."
return self.index_right(x) - self.index(x)
def add(self, x: T) -> None:
"Add an element. / O(√N)"
if self.size == 0:
self.a = [[x]]
self.size = 1
return
a, b, i = self._position(x)
a.insert(i, x)
self.size += 1
if len(a) > len(self.a) * self.SPLIT_RATIO:
mid = len(a) >> 1
self.a[b:b+1] = [a[:mid], a[mid:]]
def _pop(self, a: List[T], b: int, i: int) -> T:
ans = a.pop(i)
self.size -= 1
if not a: del self.a[b]
return ans
def discard(self, x: T) -> bool:
"Remove an element and return True if removed. / O(√N)"
if self.size == 0: return False
a, b, i = self._position(x)
if i == len(a) or a[i] != x: return False
self._pop(a, b, i)
return True
def lt(self, x: T) -> Optional[T]:
"Find the largest element < x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] < x:
return a[bisect_left(a, x) - 1]
def le(self, x: T) -> Optional[T]:
"Find the largest element <= x, or None if it doesn't exist."
for a in reversed(self.a):
if a[0] <= x:
return a[bisect_right(a, x) - 1]
def gt(self, x: T) -> Optional[T]:
"Find the smallest element > x, or None if it doesn't exist."
for a in self.a:
if a[-1] > x:
return a[bisect_right(a, x)]
def ge(self, x: T) -> Optional[T]:
"Find the smallest element >= x, or None if it doesn't exist."
for a in self.a:
if a[-1] >= x:
return a[bisect_left(a, x)]
def __getitem__(self, i: int) -> T:
"Return the i-th element."
if i < 0:
for a in reversed(self.a):
i += len(a)
if i >= 0: return a[i]
else:
for a in self.a:
if i < len(a): return a[i]
i -= len(a)
raise IndexError
def pop(self, i: int = -1) -> T:
"Pop and return the i-th element."
if i < 0:
for b, a in enumerate(reversed(self.a)):
i += len(a)
if i >= 0: return self._pop(a, ~b, i)
else:
for b, a in enumerate(self.a):
if i < len(a): return self._pop(a, b, i)
i -= len(a)
raise IndexError
def index(self, x: T) -> int:
"Count the number of elements < x."
ans = 0
for a in self.a:
if a[-1] >= x:
return ans + bisect_left(a, x)
ans += len(a)
return ans
def index_right(self, x: T) -> int:
"Count the number of elements <= x."
ans = 0
for a in self.a:
if a[-1] > x:
return ans + bisect_right(a, x)
ans += len(a)
return ans
class UnionFind:
"""
二次元の時は、初期化時に (H,W) のように二次元配列の高さと幅を入力.
引数一個の root とか size は (r,c) みたいに.
引数二個の unite とか same は ((ra,ca),(rb,cb)) みたいに引数入れる.
"""
def __init__(self,*N):
if not isinstance(N[0],int):
N = N[0]
if len(N)==1:
N=N[0]
elif len(N)==2:
self.H, self.W = N[0], N[1]
N = self.H * self.W
self.par = [ i for i in range(N) ]
self.tree_size = [ 1 for i in range(N) ]
def root(self,*x):
x = self._dimCheck1(x)
if self.par[x] == x:
return x
self.par[x] = self.root(self.par[x])
return self.par[x]
def unite(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
if rx == ry:
return False
self.par[rx] = ry
self.tree_size[ry] += self.tree_size[rx]
return True
def same(self,*xy):
x,y = self._dimCheck2(xy)
rx = self.root(x)
ry = self.root(y)
return rx == ry
def size(self,*x):
x = self._dimCheck1(x)
rx = self.root(x)
return self.tree_size[rx]
def _dimCheck1(self,x):
if len(x)==1: return x[0]
if len(x)==2: return x[0]*self.W + x[1]
def _dimCheck2(self,xy):
if isinstance(xy[0],int): return xy[0],xy[1]
return xy[0][0]*self.W + xy[0][1], xy[1][0]*self.W + xy[1][1]
class Comb:
def __init__(self,table_len,MOD):
"""
MODが素数の場合しか使用できない.
table_len に指定した数まで法MODでのコンビネーションの計算が可能になる.
"""
self.fac = [1,1]
self.inv = [1,1]
self.finv = [1,1]
self.MOD = MOD
for i in range(2,table_len+1):
self.fac.append(self.fac[i-1]*i%MOD)
self.inv.append(-self.inv[MOD%i]*(MOD//i)%MOD)
self.finv.append(self.finv[i-1]*self.inv[i]%MOD)
def comb(self,a,b):
return self.fac[a]*self.finv[b]*self.finv[a-b]%MOD
class RollingHash:
def __init__(self, string, base, mod):
self.mod = mod
l = len(string)
self.hash = [0]*(l+1)
for i in range(1,l+1):
self.hash[i] = ( self.hash[i-1] * base + ord(string[i-1]) ) % mod
self.pw = [1]*(l+1)
for i in range(1,l+1):
self.pw[i] = self.pw[i-1] * base % mod
def get(self, l, r):
return (self.hash[r] - self.hash[l] * self.pw[r-l]) % self.mod
class GridBFS:
def __init__(self, table):
#二次元配列や文字列の配列を受け取る.
self.table = table
self.H = len(table)
self.W = len(table[0])
self.wall = "#"
def find(self, c):
#table から引数の文字を探しインデックスを返す. 無い時、None.
for h in range(self.H):
for w in range(self.W):
if self.table[h][w] == c:
return (h,w)
return None
def set_wall_string(self, string):
#壁として扱う文字を "#!^" の様に文字列リテラルで格納. 初期値は、"#"
self.wall = string
def solve(self, start, goal=None, transition = [[-1,0],[0,1],[1,0],[0,-1]]):
#goal指定したら、goalまでの最短距離を、指定しなければdist配列を返す. 到達不可能は -1.
#二次元配列上での遷移方法を transition で指定できる. 初期値は上下左右.
H, W = self.H, self.W
deq = deque()
deq.append(start)
dist = [[-1]*W for _ in range(H)]
dist[start[0]][start[1]] = 0
while deq:
h,w = deq.popleft()
for dh, dw in transition:
nh = h+dh
nw = w+dw
if (not 0<=nh<H) or (not 0<=nw<W):
continue
if goal and (nh,nw)==goal:
return dist[h][w] + 1
if self.table[nh][nw] in self.wall:
continue
if dist[nh][nw] == -1:
dist[nh][nw] = dist[h][w] + 1
deq.append((nh,nw))
if goal:
return -1
return dist
class DisjointSparseTable:
def __init__(self, op, v):
"""
静的な半群列の区間積を<O(NlogN),O(1)>で.
結合則満たして閉じていれば良い.
"""
self._op = op
self._n = len(v)
self._log = (self._n - 1).bit_length()
self._d = [[0]*self._n for _ in range(self._log)]
for j in range(self._n):
self._d[0][j] = v[j]
for i in range(self._log):
width = 1 << i+1
half_width = 1 << i
k = 0
while k*width + half_width < self._n:
piv = k*width + half_width
self._d[i][piv-1] = v[piv-1]
for j in range(1, half_width):
self._d[i][piv-1-j] = self._op(v[piv-1-j], self._d[i][piv-j])
self._d[i][piv] = v[piv]
for j in range(1, min(half_width, self._n-piv)):
self._d[i][piv+j] = self._op(v[piv+j], self._d[i][piv+j-1])
k += 1
def prod(self, left, right):
"""
入力は開区間.
left == right の時の挙動未定義(単位元が無いため)
必要なら適宜追記.
"""
if left == right:
...
right -= 1
assert 0 <= left <= right < self._n
if left == right:
return self._d[0][left]
layer = (left ^ right).bit_length() - 1
return self._op(self._d[layer][left], self._d[layer][right])
global DIRECTION_4, DIRECTION_8, DIRECTION_DIAGONAL, DIRECTION_URDL_TABLE, DIRECTION_URDL_COORD_PLANE, MOD, INF, LOWER_ALPS, UPPER_ALPS, ALL_ALPS
# well-used const
# clockwise from top.
DIRECTION_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIRECTION_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIRECTION_DIAGONAL = [[-1,1],[1,1],[1,-1],[-1,-1]]
DIRECTION_URDL_TABLE = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIRECTION_URDL_COORD_PLANE = {'U':(0,1), 'R':(1,0), 'D':(0,-1), 'L':(-1,0)}
MOD = 998244353
INF = float("inf")
LOWER_ALPS = "abcdefghijklmnopqrstuvwxyz"
UPPER_ALPS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
ALL_ALPS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
main()
|
ConDefects/ConDefects/Code/abc272_f/Python/52456403
|
condefects-python_data_990
|
N,Q=map(int,input().split())
sosuu=[]
v=[0]*(10**6+1)
for i in range(2,10**6):
if v[i]==1:
continue
for j in range(2,10**6):
if i*j>10**6:
break
v[i*j]=1
for x in range(2,10**6+1):
if v[x]==0:
sosuu.append(x)
G=[[] for i in range(10**6+1)]
for x in sosuu:
for j in range(1,10**6):
if x*j>10**6:
break
count=0
n=x*j
while n%x==0:
n//=x
count+=1
count%=3
if count>0:
G[x*j].append((x,count))
v=[0]*(N+1)
v2=[0]*(N+1)
mod=998244353
x10=[1]*(10**6+1)
y59=[1]*(10**6+1)
mody=978902437
for i in range(1,N+1):
x10[i]=x10[i-1]*10
x10[i]%=mod
y59[i]=y59[i-1]*59
y59[i]%=mod
u=[0]*(10**6+1)
A=list(map(int,input().split()))
ans=0
ans2=0
for i in range(N):
x=A[i]
for B in G[x]:
y,count=B[:]
r=(u[y]+count)%3
ans+=r*x10[y]
ans-=u[y]*x10[y]
ans%=mod
ans2+=r*y59[y]
ans2-=u[y]*y59[y]
u[y]=r
v[i+1]=ans
v2[i+1]=ans2
for i in range(Q):
l,r=map(int,input().split())
ans1=v[l-1]
ans2=v[r]
ans3=v2[l-1]
ans4=v2[r]
if ans1==ans2 and ans3==ans4:
print('Yes')
else:
print('No')
N,Q=map(int,input().split())
sosuu=[]
v=[0]*(10**6+1)
for i in range(2,10**6):
if v[i]==1:
continue
for j in range(2,10**6):
if i*j>10**6:
break
v[i*j]=1
for x in range(2,10**6+1):
if v[x]==0:
sosuu.append(x)
G=[[] for i in range(10**6+1)]
for x in sosuu:
for j in range(1,10**6):
if x*j>10**6:
break
count=0
n=x*j
while n%x==0:
n//=x
count+=1
count%=3
if count>0:
G[x*j].append((x,count))
v=[0]*(N+1)
v2=[0]*(N+1)
mod=998244353
x10=[1]*(10**6+1)
y59=[1]*(10**6+1)
mody=978902437
for i in range(1,10**6+1):
x10[i]=x10[i-1]*10
x10[i]%=mod
y59[i]=y59[i-1]*59
y59[i]%=mod
u=[0]*(10**6+1)
A=list(map(int,input().split()))
ans=0
ans2=0
for i in range(N):
x=A[i]
for B in G[x]:
y,count=B[:]
r=(u[y]+count)%3
ans+=r*x10[y]
ans-=u[y]*x10[y]
ans%=mod
ans2+=r*y59[y]
ans2-=u[y]*y59[y]
u[y]=r
v[i+1]=ans
v2[i+1]=ans2
for i in range(Q):
l,r=map(int,input().split())
ans1=v[l-1]
ans2=v[r]
ans3=v2[l-1]
ans4=v2[r]
if ans1==ans2 and ans3==ans4:
print('Yes')
else:
print('No')
|
ConDefects/ConDefects/Code/abc238_g/Python/44443541
|
condefects-python_data_991
|
n=int(input())
for i in range(n):
print(n-1)
print(0)
n=int(input())
for i in range(n):
print(n-i)
print(0)
|
ConDefects/ConDefects/Code/abc281_a/Python/45998040
|
condefects-python_data_992
|
n = input()
n = int(n)
for i in range(10,-1,-1):
print(i)
n = input()
n = int(n)
for i in range(n,-1,-1):
print(i)
|
ConDefects/ConDefects/Code/abc281_a/Python/45244769
|
condefects-python_data_993
|
from collections import Counter
N,M=map(int,input().split())
S=list(map(int,input().split()))
X=list(map(int,input().split()))
C=Counter()
A=[-10**10]
for i in range(M):
C[abs(A[0]-X[i])]+=1
for i in range(N-1):
A.append(S[i]-A[i])
for j in range(M):
C[abs(A[i+1]-X[j])]+=1
ans=0
for key,value in C.items():
ans=max(ans,value)
print(ans)
from collections import Counter
N,M=map(int,input().split())
S=list(map(int,input().split()))
X=list(map(int,input().split()))
C=Counter()
A=[-10**18]
for i in range(M):
C[abs(A[0]-X[i])]+=1
for i in range(N-1):
A.append(S[i]-A[i])
for j in range(M):
C[abs(A[i+1]-X[j])]+=1
ans=0
for key,value in C.items():
ans=max(ans,value)
print(ans)
|
ConDefects/ConDefects/Code/abc255_e/Python/45097288
|
condefects-python_data_994
|
from collections import defaultdict
n, m = map(int, input().split())
s = list(map(int, input().split()))
scc = [s[0]]
for i in range(1, n-1):
scc.append(scc[-1]+ (-1)**(i)*s[i])
x = list(map(int, input().split()))
x = set(x)
d = defaultdict(int)
for i in range(1, n):
for j in x:
tmp = scc[i-1] + (-1)**(i)*j
d[tmp] += 1
ans = 0
for k, v in d.items():
ans = max(ans, v+v*(k in x))
print(ans)
from collections import defaultdict
n, m = map(int, input().split())
s = list(map(int, input().split()))
scc = [s[0]]
for i in range(1, n-1):
scc.append(scc[-1]+ (-1)**(i)*s[i])
x = list(map(int, input().split()))
x = set(x)
d = defaultdict(int)
for i in range(1, n):
for j in x:
tmp = scc[i-1] + (-1)**(i)*j
d[tmp] += 1
ans = 0
for k, v in d.items():
ans = max(ans, v+(k in x))
print(ans)
|
ConDefects/ConDefects/Code/abc255_e/Python/45923403
|
condefects-python_data_995
|
N = int(input())
time = [0] * (N+1)
need = [[] for _ in range(N+1)]
for i in range(1, N+1):
t, k, *A = list(map(int, input().split()))
time[i] = t
need[i] = A
ans = 0
got = set()
stack = [N]
while stack:
node = stack.pop()
got.add(node)
ans += time[node]
for n in need[node]:
if n in got:
continue
stack.append(n)
print(ans)
N = int(input())
time = [0] * (N+1)
need = [[] for _ in range(N+1)]
for i in range(1, N+1):
t, k, *A = list(map(int, input().split()))
time[i] = t
need[i] = A
ans = 0
got = set()
stack = [N]
while stack:
node = stack.pop()
if node in got:
continue
got.add(node)
ans += time[node]
for n in need[node]:
if n in got:
continue
stack.append(n)
print(ans)
|
ConDefects/ConDefects/Code/abc226_c/Python/45490771
|
condefects-python_data_996
|
import sys
sys.setrecursionlimit(10**8)
inf = float("INF")
from collections import deque, defaultdict, Counter
from itertools import product, combinations, permutations
from heapq import heapify, heappop, heappush
def I(): return input()
def II(): return int(input())
def IS(): return input().split()
def MII(): return map(int, input().split())
def LI(): return list(input())
def LII(): return list(map(int, input().split()))
def SII(): return set(map(int, input().split()))
def LSI(): return list(map(str, input().split()))
N = II()
T = []
A = [list() for _ in range(N)]
for i in range(N):
t, k, *a = MII() # 技i 習得には Ti時間必要、事前に k個の技を習得しておく必要あり
T.append(t)
for num in a:
A[i].append(num-1)
stack = list()
visited = [False]*N
stack.append(N-1)
ans = T[N-1]
while stack:
now = stack.pop()
for nex in A[now]:
if visited[nex] == False:
stack.append(nex)
visited[nex]
ans += T[nex]
print(ans)
import sys
sys.setrecursionlimit(10**8)
inf = float("INF")
from collections import deque, defaultdict, Counter
from itertools import product, combinations, permutations
from heapq import heapify, heappop, heappush
def I(): return input()
def II(): return int(input())
def IS(): return input().split()
def MII(): return map(int, input().split())
def LI(): return list(input())
def LII(): return list(map(int, input().split()))
def SII(): return set(map(int, input().split()))
def LSI(): return list(map(str, input().split()))
N = II()
T = []
A = [list() for _ in range(N)]
for i in range(N):
t, k, *a = MII() # 技i 習得には Ti時間必要、事前に k個の技を習得しておく必要あり
T.append(t)
for num in a:
A[i].append(num-1)
stack = list()
visited = [False]*N
stack.append(N-1)
ans = T[N-1]
while stack:
now = stack.pop()
for nex in A[now]:
if visited[nex] == False:
stack.append(nex)
visited[nex] = True
ans += T[nex]
print(ans)
|
ConDefects/ConDefects/Code/abc226_c/Python/45711710
|
condefects-python_data_997
|
N = int(input())
skill = []
for _ in range(N):
skill.append(list(map(int, input().split())))
need = [False] * N
need[N-1] = True
for i in range(N-1, -1, -1):
if need[i]:
for j in skill[i][2:]:
need[j] = True
ans = 0
for i in range(N):
if need[i]:
ans += skill[i][0]
print(ans)
N = int(input())
skill = []
for _ in range(N):
skill.append(list(map(int, input().split())))
need = [False] * N
need[N-1] = True
for i in range(N-1, -1, -1):
if need[i]:
for j in skill[i][2:]:
need[j-1] = True
ans = 0
for i in range(N):
if need[i]:
ans += skill[i][0]
print(ans)
|
ConDefects/ConDefects/Code/abc226_c/Python/45527659
|
condefects-python_data_998
|
from sys import stdin
def input():
return stdin.readline().rstrip("\n")
def solve():
s = int(input())
if s in [1, 2, 3, 5, 7]:
print("No")
return
print("Yes")
a = (s + 1) // 2
if s % 2 == 0:
print(0, 0, a, a, a - 2, a)
else:
print(0, 0, a, a - 1, a - 1, a - 4)
case_t = 1
case_t = int(input())
for _ in [None] * case_t:
solve()
from sys import stdin
def input():
return stdin.readline().rstrip("\n")
def solve():
s = int(input())
if s in [1, 2, 3, 5, 7]:
print("No")
return
print("Yes")
a = s // 2
if s % 2 == 0:
print(0, 0, a, a, a - 2, a)
else:
print(0, 0, a, a - 1, a - 1, a - 4)
case_t = 1
case_t = int(input())
for _ in [None] * case_t:
solve()
|
ConDefects/ConDefects/Code/arc167_e/Python/46643252
|
condefects-python_data_999
|
def One_Square_in_a_Triangle():
S = int(input())
if S in [1, 2, 3, 5, 7]:
return "NO"
if S == 4:
return "YES" + "\n" + "1 " + "1 " + "1 " + "3 " + "3 " + "3"
else:
a = S // 2
if S % 2 == 0:
return "YES" + "\n" + "0 " + "0 " + str(a) + " " + str(a) + " 0 "+ str(a)
else:
return "YES" + "\n" + "0 " + "0 " + str(a) + " " + str(a-1) + " " + str(a-1) + " " +str(a-4)
T = int(input())
for t in range(1, T+1):
print(str(One_Square_in_a_Triangle()))
def One_Square_in_a_Triangle():
S = int(input())
if S in [1, 2, 3, 5, 7]:
return "NO"
if S == 4:
return "YES" + "\n" + "1 " + "1 " + "1 " + "3 " + "3 " + "3"
else:
a = S // 2
if S % 2 == 0:
return "YES" + "\n" + "0 " + "0 " + str(a) + " " + str(a) + " "+ str(a-2) + " " + str(a)
else:
return "YES" + "\n" + "0 " + "0 " + str(a) + " " + str(a-1) + " " + str(a-1) + " " +str(a-4)
T = int(input())
for t in range(1, T+1):
print(str(One_Square_in_a_Triangle()))
|
ConDefects/ConDefects/Code/arc167_e/Python/46646029
|
condefects-python_data_1000
|
s=input()
a,b=map(int,input().split())
print(s[:a-1]+s[b-1]+s[a:b-2]+s[a-1]+s[b:])
s=input()
a,b=map(int,input().split())
print(s[:a-1]+s[b-1]+s[a:b-1]+s[a-1]+s[b:])
|
ConDefects/ConDefects/Code/abc236_a/Python/45439657
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.