input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, M = (list(map(int, input().split())))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = 1
A.sort(reverse=True)
B.sort(reverse=True)
aloop = 0
bloop = 0
if len(set(A)) != len(A) or len(set(B)) != len(B):
C = 0
else:
for k in range(N * M, 0, -1):
if C == 0:
break
if k in A and k in B:
continue
elif (k in A and k not in B):
C *= len([x for x in B if x > k])
elif (k not in A and k in B):
C *= len([x for x in A if x > k])
else:
C *= (len([x for x in A if x > k]) *
len([x for x in B if x > k]) - (N * M - k))
C %= (10**9+7)
print(C) | N, M = (list(map(int, input().split())))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = 1
A.sort(reverse=True)
B.sort(reverse=True)
aloop = 0
bloop = 0
if len(set(A)) != len(A) or len(set(B)) != len(B):
C = 0
else:
for k in range(N * M, 0, -1):
if aloop < N and bloop < M and k == A[aloop] and k == B[bloop]:
aloop += 1
bloop += 1
elif aloop < N and k == A[aloop]:
C *= bloop
aloop += 1
elif bloop < M and k == B[bloop]:
C *= aloop
bloop += 1
else:
C *= (aloop * bloop - (N * M - k))
C = C % (10**9+7)
print(C)
| p03152 |
N,M=list(map(int,input().split()))
Y=[0]*N*M
X=[0]*N*M
z=1
for a in map(int,input().split()):
if Y[-a]:z=0
Y[-a]=1
for b in map(int,input().split()):
if X[-b]:z=0
X[-b]=1
h=w=0
MD=10**9+7
for i in range(N*M):
z*=[h*w-i,h,w,1][Y[i]*2+X[i]]
z%=MD
h+=Y[i]
w+=X[i]
print(z)
| s,a,b=[set(map(int,input().split()))for j in[0]*3];c=1;N=M=0;k=x=max(a)
while k:A=k in a;B=k in b;N+=A;M+=B;c*=[M*N-x+k,N,M,1][A*2+B];c%=10**9+7;k-=1
print(c) | p03152 |
N,M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10**9+7
a = 0
b = 0
ans = 1
for i in range(N*M,0,-1):
#print(i,a,b,ans)
if i in A and i in B:
ans = ans
a += 1
b += 1
elif i in A: # i not in B
ans *= b
ans %= mod
a+=1
elif i in B:
ans *= a
ans %= mod
b+=1
else:
if a*b - (N*M - i) <= 0:
print((0))
break
else:
ans *= a*b - (N*M - i)
ans %= mod
else:
print(ans)
| N,M = list(map(int, input().split()))
A = set(list(map(int, input().split())))
B = set(list(map(int, input().split())))
mod = 10**9+7
a = 0
b = 0
ans = 1
for i in range(N*M,0,-1):
#print(i,a,b,ans)
if i in A and i in B:
ans = ans
a += 1
b += 1
elif i in A: # i not in B
ans *= b
ans %= mod
a+=1
elif i in B:
ans *= a
ans %= mod
b+=1
else:
if a*b - (N*M - i) <= 0:
print((0))
break
else:
ans *= a*b - (N*M - i)
ans %= mod
else:
print(ans)
| p03152 |
def double_landscape(N: int, M: int, A: list, B: list) -> int:
if not (is_unique(A) and is_unique(B)):
return 0
count = 1
for x in range(N * M + 1, 0, -1):
availables = 0
if x in A and x in B:
availables = 1
elif x in A:
availables = sum(b > x for b in B)
elif x in B:
availables = sum(a > x for a in A)
else:
used = (N * M - x)
availables = sum(a > x and b > x for a in A for b in B)
availables -= used
if availables == 0:
return 0
count *= availables
count %= 10**9 + 7
return count
def is_unique(l: list) -> bool:
return len(l) == len(set(l))
if __name__ == "__main__":
N, M = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
B = [int(s) for s in input().split()]
print((double_landscape(N, M, A, B)))
| def double_landscape(N: int, M: int, A: list, B: list) -> int:
if not (is_unique(A) and is_unique(B)):
return 0
A = sorted(A, reverse=True)
B = sorted(B, reverse=True)
i_a, i_b = 0, 0
count = 1
NM = N*M
for x in range(NM, 0, -1):
availables = 0
if i_a < N and i_b < M and x == A[i_a] and x == B[i_b]:
availables = 1
i_a += 1
i_b += 1
elif i_a < N and x == A[i_a]:
availables = i_b
i_a += 1
elif i_b < M and x == B[i_b]:
availables = i_a
i_b += 1
else:
availables = i_a * i_b - (NM - x)
if availables <= 0:
return 0
count *= availables
count %= 10**9 + 7
return count
def is_unique(l: list) -> bool:
return len(l) == len(set(l))
if __name__ == "__main__":
N, M = [int(s) for s in input().split()]
A = [int(s) for s in input().split()]
B = [int(s) for s in input().split()]
print((double_landscape(N, M, A, B)))
| p03152 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, A, B):
mod = 10**9 + 7
if len(A) != len(set(A)):
return 0
if len(B) != len(set(B)):
return 0
A.sort()
B.sort()
ans = 1
NM = N*M
for i in range(N*M, 0, -1):
if i in A and i in B:
pass
elif i in A:
j = len(B) - bisect.bisect_right(B, i)
ans = (ans * j) % mod
elif i in B:
j = len(A) - bisect.bisect_right(A, i)
ans = (ans * j) % mod
else:
j = len(A) - bisect.bisect_right(A, i)
k = len(B) - bisect.bisect_right(B, i)
ans = (ans * (j*k-(NM-i))) % mod
return ans
def main():
N, M = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, A, B))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, M, A, B):
mod = 10**9 + 7
if len(A) != len(set(A)):
return 0
if len(B) != len(set(B)):
return 0
A.sort()
B.sort()
As = set(A)
Bs = set(B)
ans = 1
NM = N*M
for i in range(N*M, 0, -1):
if i in As and i in Bs:
pass
elif i in As:
j = M - bisect.bisect_right(B, i)
ans = (ans * j) % mod
elif i in Bs:
j = N - bisect.bisect_right(A, i)
ans = (ans * j) % mod
else:
j = N - bisect.bisect_right(A, i)
k = M - bisect.bisect_right(B, i)
ans = (ans * (j*k-(NM-i))) % mod
return ans
def main():
N, M = read_int_n()
A = read_int_n()
B = read_int_n()
print(slv(N, M, A, B))
if __name__ == '__main__':
main()
| p03152 |
N, M = list(map(int, input().split()))
a_list = tuple(map(int, input().split()))
b_list = tuple(map(int, input().split()))
mod = 10 ** 9 + 7
a_list = sorted(a_list, reverse=True)
b_list = sorted(b_list, reverse=True)
a_list.append(-1)
b_list.append(-1)
ans = 1
a_i = 0
b_i = 0
for i in range(N*M, 0, -1):
if i == a_list[a_i] and i == b_list[b_i]:
a_i += 1
b_i += 1
elif i == a_list[a_i]:
a_i += 1
ans *= b_i
elif i == b_list[b_i]:
b_i += 1
ans *= a_i
else:
ans *= (a_i*b_i - (N * M - i))
print((ans % mod))
| N, M = list(map(int, input().split()))
a_list = tuple(map(int, input().split()))
b_list = tuple(map(int, input().split()))
mod = 10 ** 9 + 7
a_list = sorted(a_list, reverse=True)
b_list = sorted(b_list, reverse=True)
a_list.append(-1)
b_list.append(-1)
ans = 1
a_i = 0
b_i = 0
for i in range(N*M, 0, -1):
if i == a_list[a_i] and i == b_list[b_i]:
a_i += 1
b_i += 1
elif i == a_list[a_i]:
a_i += 1
ans *= b_i
ans %= mod
elif i == b_list[b_i]:
b_i += 1
ans *= a_i
ans %= mod
else:
ans *= (a_i*b_i - (N * M - i))
ans %= mod
print((ans % mod))
| p03152 |
import sys
from bisect import bisect_left
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
if len(A) != len(set(A)) or len(B) != len(set(B)):
print((0))
exit()
A.sort()
B.sort()
As = set(A)
Bs = set(B)
res = 1
for x in reversed(list(range(1, n * m + 1))):
if x in As and x in Bs:
continue
elif x in A:
res *= m - bisect_left(B, x)
elif x in B:
res *= n - bisect_left(A, x)
else:
s = m - bisect_left(B, x)
t = n - bisect_left(A, x)
res *= s * t - (n * m - x)
res %= mod
print(res)
if __name__ == '__main__':
resolve()
| import sys
from bisect import bisect_left
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
if len(A) != len(set(A)) or len(B) != len(set(B)):
print((0))
exit()
A.sort()
B.sort()
As = set(A)
Bs = set(B)
res = 1
for x in reversed(list(range(1, n * m + 1))):
if x in As and x in Bs:
continue
elif x in As:
res *= m - bisect_left(B, x)
elif x in Bs:
res *= n - bisect_left(A, x)
else:
s = m - bisect_left(B, x)
t = n - bisect_left(A, x)
res *= s * t - (n * m - x)
res %= mod
print(res)
if __name__ == '__main__':
resolve()
| p03152 |
from collections import Counter
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())),reverse=True)
B = sorted(list(map(int,input().split())),reverse=True)
mod = pow(10,9)+7
n,m = 0,0
ans = 1
def istwo(L):
if len(list([x for x in list(Counter(L).values()) if x>1]))>0:
return True
else:
return False
if istwo(A) or istwo(B):
print((0))
else:
for i in range(1,(N*M)+1)[::-1]:
if n<N and i<=A[n]:n+=1
if m<M and i<=B[m]:m+=1
if i in A and i in B:
ans = ans%mod
elif i in A:
ans = (ans*(m))%mod
elif i in B:
ans = (ans*(n))%mod
else:
ans = (ans*(n*m-(N*M-i)))%mod
#print(i,n,m,ans)
print(ans) | from collections import Counter
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())),reverse=True)
B = sorted(list(map(int,input().split())),reverse=True)
mod = pow(10,9)+7
n,m = 0,0
ans = 1
def istwo(L):
if len(list([x for x in list(Counter(L).values()) if x>1]))>0:
return True
else:
return False
if istwo(A) or istwo(B):
print((0))
else:
for i in range(1,(N*M)+1)[::-1]:
if n<N and i<=A[n]:n+=1
if m<M and i<=B[m]:m+=1
if n>0 and m>0 and i == A[n-1] and i == B[m-1]:
ans = ans%mod
elif n>0 and i == A[n-1]:
ans = (ans*(m))%mod
elif m>0 and i == B[m-1]:
ans = (ans*(n))%mod
else:
ans = (ans*(n*m-(N*M-i)))%mod
#print(i,n,A[n-1],m,B[m-1],ans)
print(ans) | p03152 |
import bisect
MOD = 10**9+7
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
B = sorted(list(map(int,input().split())))
a = set(A)
b = set(B)
check = True
if len(a) != N or len(b) != M:
check = False
ans = 1
for num in range(N*M,0,-1):
tmp = 0
if num in A and num in B: continue
elif num in A:
tmp = M - bisect.bisect_left(B,num)
elif num in B:
tmp = N - bisect.bisect_left(A,num)
else:
x = bisect.bisect_left(A,num)
y = bisect.bisect_left(B,num)
tmp = (N-x)*(M-y) - (M*N-num)
if tmp < 0 or check == False:
check = False
break
ans *= tmp
ans %= MOD
print((ans if check else 0)) | import bisect
MOD = 10**9+7
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
B = sorted(list(map(int,input().split())))
a = set(A)
b = set(B)
check = True
if len(a) != N or len(b) != M:
check = False
ans = 1
for num in range(N*M,0,-1):
tmp = 0
if num in a and num in b: continue
elif num in a:
tmp = M - bisect.bisect_left(B,num)
elif num in b:
tmp = N - bisect.bisect_left(A,num)
else:
x = bisect.bisect_left(A,num)
y = bisect.bisect_left(B,num)
tmp = (N-x)*(M-y) - (M*N-num)
if tmp < 0 or check == False:
check = False
break
ans *= tmp
ans %= MOD
print((ans if check else 0)) | p03152 |
N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
a = [0 for i in range(N*M+1)]
b = [0 for i in range(N*M+1)]
da = [0 for i in range(N*M+1)]
db = [0 for i in range(N*M+1)]
mod = 10**9+7
for i in range(N):
a[A[i]] += 1
if da[A[i]] == 1:
print((0))
quit()
da[A[i]] += 1
for i in range(M):
b[B[i]] += 1
if db[B[i]] == 1:
print((0))
quit()
db[B[i]] += 1
for i in range(1,N*M+1):
a[-i-1] += a[-i]
b[-i-1] += b[-i]
ans = 1
for i in range(N*M):
f = 0
g = 0
x = N*M - i
y = i
if da[x] == 1:
f = 1
if db[x] == 1:
g = 1
z = 1
if f == 0:
z *= a[x]
if g == 0:
z *= b[x]
if f+g == 0:
z -= i
if z <= 0:
print((0))
quit()
else:
ans *= z%mod
print((ans%mod)) | N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
a = [0 for i in range(N*M+1)]
b = [0 for i in range(N*M+1)]
da = [0 for i in range(N*M+1)]
db = [0 for i in range(N*M+1)]
mod = 10**9+7
for i in range(N):
a[A[i]] += 1
if da[A[i]] == 1:
print((0))
quit()
da[A[i]] += 1
for i in range(M):
b[B[i]] += 1
if db[B[i]] == 1:
print((0))
quit()
db[B[i]] += 1
for i in range(1,N*M+1):
a[-i-1] += a[-i]
b[-i-1] += b[-i]
ans = 1
for i in range(N*M):
f = 0
g = 0
x = N*M - i
y = i
if da[x] == 1:
f = 1
if db[x] == 1:
g = 1
z = 1
if f == 0:
z = z*a[x]%mod
if g == 0:
z = z*b[x]%mod
if f+g == 0:
z -= i
if z <= 0:
print((0))
quit()
else:
ans = ans*z%mod
print((ans%mod))
| p03152 |
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
ans = 1
cnta = 0
cntb = 0
mod = 10**9+7
for num in range(n*m,0,-1):
if num in a and num in b:
cnta += 1
cntb += 1
cnta%=mod
cntb%=mod
elif num in a:
ans *= cntb
ans %= mod
cnta += 1
elif num in b:
ans *= cnta
ans %= mod
cntb += 1
else:
ans *= (cnta*cntb - (n*m - num))%mod
ans %= mod
print(ans) | n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
A=set(a);B=set(b)
ans = 1
cnta = 0
cntb = 0
mod = 10**9+7
for num in range(n*m,0,-1):
if num in A and num in B:
cnta += 1
cntb += 1
elif num in A:
ans *= cntb
cnta += 1
elif num in B:
ans *= cnta
cntb += 1
else:
ans *= (cnta*cntb - (n*m - num))%mod
ans %= mod
print(ans) | p03152 |
import sys
# %%
n, m = list(map(int, sys.stdin.readline().split()))
ary = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
bry = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
mod = 10 ** 9 + 7
# %%
if len(set(ary)) != len(ary) or len(set(bry)) != len(bry):
print((0))
else:
ary.append(0)
bry.append(0)
cnt = 1
i = 0
j = 0
for num in range(n * m, 0, -1):
if (num == ary[i]) & (num == bry[j]):
i += 1
j += 1
elif (num == ary[i]) ^ (num == bry[j]):
if num == ary[i]:
cnt *= len(bry[:j])
i += 1
else:
cnt *= len(ary[:i])
j += 1
else:
na = len(ary[:i])
nb = len(bry[:j])
cnt *= (na * nb - (n * m - num))
cnt = cnt % mod
print((cnt % mod))
| import sys
# %%
n, m = list(map(int, sys.stdin.readline().split()))
ary = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
bry = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
mod = 10 ** 9 + 7
# %%
if len(set(ary)) != len(ary) or len(set(bry)) != len(bry):
print((0))
else:
ary.append(0)
bry.append(0)
cnt = 1
i = 0
j = 0
for num in range(n * m, 0, -1):
if (num == ary[i]) and (num == bry[j]):
i += 1
j += 1
elif (num == ary[i]) or (num == bry[j]):
if num == ary[i]:
cnt *= len(bry[:j])
i += 1
else:
cnt *= len(ary[:i])
j += 1
else:
# na = len(ary[:i])
# nb = len(bry[:j])
cnt *= (i * j - (n * m - num))
cnt = cnt % mod
print(cnt)
| p03152 |
import sys
# %%
n, m = list(map(int, sys.stdin.readline().split()))
ary = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
bry = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
mod = 10 ** 9 + 7
# %%
if len(set(ary)) != len(ary) or len(set(bry)) != len(bry):
print((0))
else:
ary.append(0)
bry.append(0)
cnt = 1
i = 0
j = 0
for num in range(n * m, 0, -1):
if (num == ary[i]) & (num == bry[j]):
i += 1
j += 1
elif (num == ary[i]) ^ (num == bry[j]):
if num == ary[i]:
cnt *= len(bry[:j])
i += 1
else:
cnt *= len(ary[:i])
j += 1
else:
na = len(ary[:i])
nb = len(bry[:j])
cnt *= (na * nb - (n * m - num))
cnt = cnt % mod
print(cnt)
| import sys
# %%
n, m = list(map(int, sys.stdin.readline().split()))
ary = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
bry = sorted(list(map(int, sys.stdin.readline().split())), reverse=True)
mod = 10 ** 9 + 7
# %%
if len(set(ary)) != len(ary) or len(set(bry)) != len(bry):
print((0))
else:
ary.append(0)
bry.append(0)
cnt = 1
i = 0
j = 0
for num in range(n * m, 0, -1):
if (num == ary[i]) & (num == bry[j]):
i += 1
j += 1
elif (num == ary[i]) ^ (num == bry[j]):
if num == ary[i]:
cnt *= j
i += 1
else:
cnt *= i
j += 1
else:
cnt *= (i * j - (n * m - num))
cnt = cnt % mod
print(cnt)
| p03152 |
# -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/keyence2019/editorial.pdf
"""
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, M = MAP()
# 二分探索用にソートしておく
# (どの行に何が来るかの具体的な位置は今回必要ないのでソートしていい)
A = sorted(LIST())
B = sorted(LIST())
MAX = N * M
# 同じリストに同じ値がいたら論外
# (各値1回ずつしか使えないのに、違う行で最大値が同じとか不可能)
if len(A) != len(set(A)) or len(B) != len(set(B)):
print((0))
exit()
# 1: Aにある, 2: Bにある, 3: 両方にある, 0: どちらにもない
flags = [0] * (MAX+1)
for i in range(N):
flags[A[i]] += 1
for i in range(M):
flags[B[i]] += 2
ans = 1
for i in range(MAX, 0, -1):
tmp = 1
# どちらにもない
if flags[i] == 0:
# Aで自分以上の数 * Bで自分以上の数 - 自分以上の数
tmp = (N-bisect_left(A, i)) * (M-bisect_left(B, i)) - (N*M-i)
if tmp <= 0:
print((0))
exit()
# Aにある
elif flags[i] == 1:
# 自分の行が決まっているので、列を調べに行く
tmp = (M-bisect_left(B, i))
# Bにある
elif flags[i] == 2:
tmp = (N-bisect_left(A, i))
ans = (ans * tmp) % MOD
print(ans)
| # -*- coding: utf-8 -*-
import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7
N, M = MAP()
# あとで大きい値から数えたいので降順ソートしておく
A = sorted(LIST(), reverse=True)
B = sorted(LIST(), reverse=True)
MAX = N * M
# 同じリストに同じ値がいたら論外
# (各値1回ずつしか使えないのに、違う行で最大値が同じとか不可能)
if len(A) != len(set(A)) or len(B) != len(set(B)):
print((0))
exit()
# 1: Aにある, 2: Bにある, 3: 両方にある, 0: どちらにもない
flags = [0] * (MAX+1)
for i in range(N):
flags[A[i]] += 1
for i in range(M):
flags[B[i]] += 2
ans = 1
j = k = biga = bigb = 0
for i in range(MAX, 0, -1):
# リスト内の、自分iより大きい値の数を数えながら進める
if j != N and A[j] >= i:
biga += 1
j += 1
if k != M and B[k] >= i:
bigb += 1
k += 1
tmp = 1
# どちらにもない
if flags[i] == 0:
# Aで自分以上の数 * Bで自分以上の数 - 自分以上の数
tmp = biga * bigb - (N*M-i)
if tmp <= 0:
print((0))
exit()
# Aにある
elif flags[i] == 1:
# 自分の行が決まっているので、列を調べに行く
tmp = bigb
# Bにある
elif flags[i] == 2:
tmp = biga
ans = (ans * tmp) % MOD
print(ans)
| p03152 |
H,W=list(map(int,input().split()))
hlen = list(map(int,input().split()))
wlen = list(map(int,input().split()))
hlen.sort(reverse=True)
wlen.sort(reverse=True)
hhlen =[0 for _ in range(H*W+1)]
wwlen =[0 for _ in range(H*W+1)]
for x,xx in zip([hlen,wlen],[hhlen,wwlen]):
c = 1
for y in x:
if xx[y] != 0:
print((0))
exit()
else:
xx[y] = c
def Count(x,l):
ret = 0
while l[ret] > x :
ret += 1
if ret == len(l):
break
return ret
m = max(hlen[0],wlen[0])
count = 1
for num in range(1,H*W+1)[::-1]:
if hhlen[num] and wwlen[num]:
count *= 1
elif hhlen[num]:
count *= Count(num,wlen)
elif wwlen[num]:
count *= Count(num,hlen)
else:
count *= Count(num,hlen)*Count(num,wlen) - (m-num)
#print(num,flagh,flagw,count)
count %= (10**9+7)
print((count % (10**9+7))) | H,W=list(map(int,input().split()))
hlen = list(map(int,input().split()))
wlen = list(map(int,input().split()))
hlen.sort(reverse=True)
wlen.sort(reverse=True)
hlen.append(0)
wlen.append(0)
m = H*W
count = 1
h=0
w=0
for num in range(1,H*W+1)[::-1]:
if hlen[h] == num and wlen[w] == num:
count *= 1
h += 1
w += 1
elif hlen[h] == num:
count *= w
h += 1
elif wlen[w] == num:
count *= h
w += 1
else:
count *= h*w - (m-num)
#print(num,flagh,flagw,count)
count %= (10**9+7)
print(count) | p03152 |
N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
ret = 1
MOD = 10 ** 9 + 7
from collections import Counter
import sys
ca = Counter(A)
cb = Counter(B)
if ca.most_common(1)[0][1] >= 2 or cb.most_common(1)[0][1] >= 2:
print((0))
sys.exit(0)
A.sort()
B.sort()
import bisect
def index(a, x):
'Locate the leftmost value exactly equal to x'
i = bisect.bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
return -1
for n in range(N * M, 0, -1):
a = index(A, n)
b = index(B, n)
cntA = len(A) - bisect.bisect_right(A, n)
cntB = len(B) - bisect.bisect_right(B, n)
# 両方みつけた
if a != -1 and b != -1:
pass
# Bの方だけ見つけた
elif a == -1 and b != -1:
ret *= cntA
# Aの方だけ見つけた
elif a != -1 and b == -1:
ret *= cntB
# 両方なかった
else:
ret *= (cntA * cntB - (N * M - n))
ret = ret % MOD
print(ret)
| N, M = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
B = [int(x) for x in input().split()]
ret = 1
MOD = 10 ** 9 + 7
A.sort(reverse=True)
B.sort(reverse=True)
aidx = bidx = 0
for n in range(N * M, 0, -1):
# 両方みつけた
if aidx < N and bidx < M and n == A[aidx] and n == B[bidx] and A[aidx] == B[bidx]:
aidx += 1
bidx += 1
# Bの方だけ見つけた
elif bidx < M and n == B[bidx]:
ret *= aidx
bidx += 1
# Aの方だけ見つけた
elif aidx < N and n == A[aidx]:
ret *= bidx
aidx += 1
# 両方なかった
else:
ret *= (aidx * bidx - (N * M - n))
ret = ret % MOD
print(ret)
| p03152 |
import math
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
mod = 10 ** 9 + 7
ans = 1
a.sort(reverse = True)
b.sort(reverse = True)
counta = 0
countb = 0
count = 0
for i in range(n*m,0,-1):
if a and b:
if a[0] == i and b[0] == i:
a_tmp = a.pop(0)
b_tmp = b.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
if b:
if b[0] == b_tmp:
print((0))
exit()
counta += 1
countb += 1
elif a[0] == i:
a_tmp = a.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
counta += 1
ans *= countb
ans %= mod
elif b[0] == i:
b_tmp = b.pop(0)
if b:
if b[0] == b_tmp:
print((0))
exit()
countb += 1
ans *= counta
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
elif a:
if a[0] == i:
a_tmp = a.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
counta += 1
ans *= countb
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
elif b:
if b[0] == i:
b_tmp = b.pop(0)
if b:
if b[0] == b_tmp:
print((0))
exit()
countb += 1
ans *= counta
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
count += 1
if not a and not b:
idx = i
break
print((ans * math.factorial(idx-1) % mod))
| import math
n,m = list(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
mod = 10 ** 9 + 7
ans = 1
a.sort(reverse = True)
b.sort(reverse = True)
counta = 0
countb = 0
count = 0
for i in range(n*m,0,-1):
if a and b:
if a[0] == i and b[0] == i:
a_tmp = a.pop(0)
b_tmp = b.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
if b:
if b[0] == b_tmp:
print((0))
exit()
counta += 1
countb += 1
elif a[0] == i:
a_tmp = a.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
counta += 1
ans *= countb
ans %= mod
elif b[0] == i:
b_tmp = b.pop(0)
if b:
if b[0] == b_tmp:
print((0))
exit()
countb += 1
ans *= counta
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
elif a:
if a[0] == i:
a_tmp = a.pop(0)
if a:
if a[0] == a_tmp:
print((0))
exit()
counta += 1
ans *= countb
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
elif b:
if b[0] == i:
b_tmp = b.pop(0)
if b:
if b[0] == b_tmp:
print((0))
exit()
countb += 1
ans *= counta
ans %= mod
else:
ans *= (counta * countb - count)
ans %= mod
count += 1
if not a and not b:
idx = i
break
for i in range(1,idx):
ans *= i
ans %= mod
print(ans)
| p03152 |
from bisect import bisect
n, m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
a.sort()
b.sort()
ia = 0
ib = 0
cnt = 1
for i in range(1,n*m+1)[::-1]:
if i in a:
if i in b:
cnt *= 1
ia += 1
ib += 1
else:
cnt *= ib
cnt %= 1000000007
ia += 1
else:
if i in b:
cnt *= ia
cnt %= 1000000007
ib += 1
else:
cnt *= ia*ib - (n*m - i)
cnt %= 1000000007
if len(a) != len(set(a)) or len(b) != len(set(b)) :
cnt = 0
print(cnt)
| from bisect import bisect
n, m = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = [int(i) for i in input().split()]
a.append(0)
b.append(0)
a.sort()
b.sort()
ia = 0
ib = 0
cnt = 1
for i in range(1,n*m+1)[::-1]:
if i == a[-1]:
if i == b[-1]:
cnt *= 1
a.pop(-1)
b.pop(-1)
ia += 1
ib += 1
else:
cnt *= ib
a.pop(-1)
cnt %= 1000000007
ia += 1
else:
if i == b[-1]:
cnt *= ia
b.pop(-1)
cnt %= 1000000007
ib += 1
else:
cnt *= ia*ib - (n*m - i)
cnt %= 1000000007
print(cnt)
| p03152 |
from collections import Counter
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in range(N):
for j in range(M):
if A[i]==B[j]:
if A[i] in used:
print((0))
return
else:
used.add(A[i])
c[min(A[i], B[j])] += 1
cd = 0
ans = 1
bef = 0
for i, j in sorted(c.items()):
cd += (i - bef)
if i in used:
# print(cd, j)
cd -= 1
for k in range(j-1):
ans *= (cd-k)
ans %= MOD
cd -= j-1
else:
# print(cd, j)
ans *= j
cd -= 1
for k in range(j-1):
ans *= (cd-k)
ans %= MOD
cd -= j-1
bef = i
print((ans%MOD))
solve() | from collections import Counter
import sys
input=sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in range(N):
for j in range(M):
if A[i]==B[j]:
if A[i] in used:
print((0))
return
else:
used.add(A[i])
c[min(A[i], B[j])] += 1
cd = 0
ans = 1
bef = 0
for i, j in sorted(c.items()):
cd += (i - bef)
if i not in used:
ans *= j
cd -= 1
for k in range(j-1):
ans *= (cd-k)
ans %= MOD
cd -= j-1
bef = i
print((ans%MOD))
if __name__ == "__main__":
solve()
| p03152 |
from collections import Counter
import sys
input=sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in range(N):
for j in range(M):
if A[i]==B[j]:
if A[i] in used:
print((0))
return
else:
used.add(A[i])
c[min(A[i], B[j])] += 1
cd = 0
ans = 1
bef = 0
for i, j in sorted(c.items()):
cd += (i - bef)
if i not in used:
ans *= j
cd -= 1
for k in range(j-1):
ans *= (cd-k)
ans %= MOD
cd -= j-1
bef = i
print((ans%MOD))
if __name__ == "__main__":
solve()
| from collections import Counter
import sys
input=sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in A:
for j in B:
if i==j:
if i in used:
print((0))
return
else:
used.add(i)
c[min(i, j)] += 1
v, ans, bef = 0, 1, 0
for i, j in sorted(c.items()):
ans *= 1 if i in used else j
v += i-bef-1
for k in range(j-1):
ans *= v-k
ans %= MOD
v -= j-1
bef = i
print(ans)
if __name__ == "__main__":
solve()
| p03152 |
# coding:utf-8
import sys
import bisect
# from collections import Counter, defaultdict
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
N, M = LI()
A = LI()
B = LI()
A.sort()
B.sort()
SA = set(A)
SB = set(B)
if N != len(SA) or M != len(SB):
print((0))
exit()
ans = 1
num = 0
aa = N
bb = M
for i in range(1, N * M + 1)[::-1]:
if i in SA and i in SB:
pass
elif i in SB:
while aa != 0 and 0 < i <= A[aa - 1]:
aa -= 1
ans *= N - aa
ans %= MOD
elif i in SA:
while bb != 0 and 0 < i <= B[bb - 1]:
bb -= 1
ans *= M - bb
ans %= MOD
else:
while aa != 0 and 0 < i <= A[aa - 1]:
aa -= 1
while bb != 0 and 0 < i <= B[bb - 1]:
bb -= 1
ans *= (M - bb) * (N - aa) - num
ans %= MOD
num += 1
# print(i, ans, num)
print(ans)
| # coding:utf-8
import sys
INF = float('inf')
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
def main():
h, w = LI()
A = LI()
A.sort()
B = LI()
B.sort()
# A, B内では同じ値は存在できない
if len(A) != len(set(A)) or len(B) != len(set(B)):
return 0
a_i, b_i = h - 1, w - 1
if h * w > A[a_i] or h * w > B[b_i]:
return 0
res = 1
for n in range(1, h * w + 1)[::-1]:
while a_i > 0 and A[a_i - 1] >= n:
a_i -= 1
while b_i > 0 and B[b_i - 1] >= n:
b_i -= 1
if n == A[a_i] and n == B[b_i]:
res *= 1
elif n == A[a_i]:
res *= w - b_i
elif n == B[b_i]:
res *= h - a_i
else:
res *= (h - a_i) * (w - b_i) - (h * w - n)
res %= MOD
return res
print((main()))
| p03152 |
import bisect
N,M = list(map(int,input().split()))
A = sorted(list(map(int,input().split())))
B = sorted(list(map(int,input().split())))
sa = set(A)
sb = set(B)
MOD = 10**9+7
if len(sa) != N or len(sb) != M:
print((0))
exit()
ans = 1
for n in range(N*M, 0, -1):
if n in sa and n in sb: continue
if n in sa:
vacant = M - bisect.bisect(B,n)
elif n in sb:
vacant = N - bisect.bisect(A,n)
else:
i = N - bisect.bisect(A,n)
j = M - bisect.bisect(B,n)
vacant = i*j - (N*M-n)
if vacant <= 0:
print((0))
exit()
ans *= vacant
ans %= MOD
print(ans) | N,M = list(map(int,input().split()))
A = list(map(int,input().split()))
B = list(map(int,input().split()))
A.sort()
B.sort()
sa = set(A)
sb = set(B)
if len(sa)!=N or len(sb)!=M:
print((0))
exit()
MOD = 10**9+7
ans = 1
w = h = 0
for v in range(N*M,0,-1):
if v in sa and v in sb:
w += 1
h += 1
elif v in sa:
ans *= w
ans %= MOD
h += 1
elif v in sb:
ans *= h
ans %= MOD
w += 1
else:
free = w*h - (N*M - v)
if free <= 0:
print((0))
exit()
ans *= free
ans %= MOD
print(ans) | p03152 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 7
def main():
result = 1
i = -1
j = -1
used_area = 0
A.sort(reverse=True)
B.sort(reverse=True)
for x in range(N * M, 0, -1):
while i < N-1:
if A[i+1] >= x:
i += 1
else:
break
while j < M-1:
if B[j+1] >= x:
j += 1
else:
break
marked_row = False
marked_col = False
count_row = A[0:i+1].count(x)
if count_row > 1:
return(0)
if count_row == 1:
usable_row = 1
marked_row = True
else:
usable_row = i+1
count_col = B[0:j+1].count(x)
if count_col > 1:
return(0)
if count_col == 1:
usable_col = 1
marked_col = True
else:
usable_col = j+1
if marked_row or marked_col:
usable_area = usable_row * usable_col
else:
usable_area = usable_row * usable_col - used_area
if usable_area <= 0:
return(0)
result = result * usable_area % mod
used_area += 1
return(result)
if __name__ == '__main__':
print((main()))
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
mod = 10 ** 9 + 7
def main():
result = 1
i = -1
j = -1
used_area = 0
A.sort(reverse=True)
B.sort(reverse=True)
for x in range(N * M, 0, -1):
expanded_row = 0
expanded_col = 0
while i < N-1:
if A[i+1] >= x:
i += 1
expanded_row += 1
else:
break
while j < M-1:
if B[j+1] >= x:
j += 1
expanded_col += 1
else:
break
marked_row = False
marked_col = False
if expanded_row > 1:
return(0)
if expanded_row == 1:
usable_row = 1
marked_row = True
else:
usable_row = i+1
if expanded_col > 1:
return(0)
if expanded_col == 1:
usable_col = 1
marked_col = True
else:
usable_col = j+1
if marked_row or marked_col:
usable_area = usable_row * usable_col
else:
usable_area = usable_row * usable_col - used_area
# print('x:', x)
# print('usable_row:', A[0:i+1])
# print('usable_col:', B[0:j+1])
# print('usable_area:', usable_area)
if usable_area <= 0:
return(0)
result = result * usable_area % mod
used_area += 1
return(result)
if __name__ == '__main__':
print((main()))
| p03152 |
def solve():
MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
A = set(map(int, input().split()))
B = set(map(int, input().split()))
row, columun = 0, 0
ans = 1
for i in range(N * M, 0, -1):
in_A = i in A
in_B = i in B
if in_A and in_B:
row += 1
columun += 1
elif in_A:
row += 1
ans *= columun
elif in_B:
columun += 1
ans *= row
else:
ans *= row * columun - (N * M - i)
print((ans % MOD))
if __name__ == '__main__':
solve()
| def solve():
MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
A = set(map(int, input().split()))
B = set(map(int, input().split()))
row, columun = 0, 0
ans = 1
for i in range(N * M, 0, -1):
in_A = i in A
in_B = i in B
if in_A and in_B:
row += 1
columun += 1
elif in_A:
row += 1
ans *= columun
elif in_B:
columun += 1
ans *= row
else:
ans *= row * columun - (N * M - i)
ans %= MOD
print(ans)
if __name__ == '__main__':
solve()
| p03152 |
from collections import defaultdict
def main():
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = defaultdict(list)
t = defaultdict(list)
for i, x in enumerate(a):
s[x].append(i)
for i, x in enumerate(b):
t[x].append(i)
N = n * m
w = 0
ans = 1
u = [[1] * m for _ in range(n)]
for i in range(N, 0, -1):
if len(s[i]) > 1 or len(t[i]) > 1:
print(0)
return
if len(s[i]) == 1 and len(t[i]) == 1:
x = s[i][0]
y = t[i][0]
for j in range(m):
if b[j] > i:
w += u[x][j]
u[x][j] = 0
for j in range(n):
if a[j] > i:
w += u[j][y]
u[j][y] = 0
elif len(s[i]) == 1:
x = s[i][0]
c = sum(b[j] > i for j in range(m))
ans = ans * c % 1000000007
w -= 1
for j in range(m):
if b[j] > i:
w += u[x][j]
u[x][j] = 0
elif len(t[i]) == 1:
y = t[i][0]
c = sum(a[j] > i for j in range(n))
ans = ans * c % 1000000007
w -= 1
for j in range(n):
if a[j] > i:
w += u[j][y]
u[j][y] = 0
else:
if w <= 0:
print(0)
return
ans = ans * w % 1000000007
w -= 1
print(ans)
main()
| from collections import defaultdict
def main():
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = defaultdict(list)
t = defaultdict(list)
for i, x in enumerate(a):
s[x].append(i)
for i, x in enumerate(b):
t[x].append(i)
N = n * m
w = 0
ans = 1
u = [[1] * m for _ in range(n)]
for i in range(N, 0, -1):
if len(s[i]) > 1 or len(t[i]) > 1:
print(0)
return
if len(s[i]) == 1 and len(t[i]) == 1:
x = s[i][0]
y = t[i][0]
for j in range(m):
if b[j] > i:
w += u[x][j]
u[x][j] = 0
for j in range(n):
if a[j] > i:
w += u[j][y]
u[j][y] = 0
elif len(s[i]) == 1:
x = s[i][0]
c = 0
for j in range(m):
if b[j] > i:
c += 1
w += u[x][j]
u[x][j] = 0
w -= 1
ans = ans * c % 1000000007
elif len(t[i]) == 1:
y = t[i][0]
c = 0
for j in range(n):
if a[j] > i:
c += 1
w += u[j][y]
u[j][y] = 0
w -= 1
ans = ans * c % 1000000007
else:
if w <= 0:
print(0)
return
ans = ans * w % 1000000007
w -= 1
print(ans)
main()
| p03152 |
def d_double_landxcape(N, M, A, B):
"""
N行M列のグリッドに1からNMまでの整数を重複なく書き込む。このとき、以下の条件を満たす。
・i行目に書き込まれている値のうち、最大の値はA_i
・j行目に書き込まれている値のうち、最大の値はA_j
書き込み方の総数を10**9+7で割った余りを求めよ。
"""
# Aの各要素、またはBの各要素の中で、同じ値があるならば解は0
# (異なる行/列に同じ数字を書き込むことは不可能)。
# グリッドの中のxが書かれうる場所について、xが大きな順に考える。
# 1. xがA_iとB_jの両方に現れる場合
# xの場所は一意に定まる。
# 2. xがA_iとB_jの片方に現れる場合
# xがA_iに現れている場合、xの場所としてありうるものの個数は、
# (B_j >= x となるjの個数) である。
# xはA_i行にしか書き込めないし、B_j < x となる列に書き込むと
# 矛盾してしまうため。
# 3. xがAにもBにも現れない場合
# xの場所としてありうるものの個数は、
# (A_i >= x となるiの個数) * (B_j >= x となるjの個数) である。
# ただし、そのうち NM - x 個はxより大きな値が書き込まれている。
# 以上の値の総乗が解である。
from bisect import bisect_left
a = sorted(A)
b = sorted(B)
a_set = set(A)
b_set = set(B)
if len(a) != len(a_set) or len(b) != len(b_set):
return 0 # 重複する要素があった。矛盾する。
ans = 1
for k in range(N * M, 0, -1):
cond1 = k in a_set
cond2 = k in b_set
# 順に、上にコメントした、条件1. 2. 3. を満たす場合
if cond1 and cond2:
continue
elif cond1:
idx = bisect_left(b, k)
ans *= (M - idx)
elif cond2:
idx = bisect_left(a, k)
ans *= (N - idx)
else:
idx_a = bisect_left(a, k)
idx_b = bisect_left(b, k)
ans *= (N - idx_a) * (M - idx_b) - (N * M - k)
return ans % (10**9 + 7)
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
print((d_double_landxcape(N, M, A, B))) | def d_double_landxcape(N, M, A, B):
"""
N行M列のグリッドに1からNMまでの整数を重複なく書き込む。このとき、以下の条件を満たす。
・i行目に書き込まれている値のうち、最大の値はA_i
・j行目に書き込まれている値のうち、最大の値はA_j
書き込み方の総数を10**9+7で割った余りを求めよ。
"""
# Aの各要素、またはBの各要素の中で、同じ値があるならば解は0
# (異なる行/列に同じ数字を書き込むことは不可能)。
# グリッドの中のxが書かれうる場所について、xが大きな順に考える。
# 1. xがA_iとB_jの両方に現れる場合
# xの場所は一意に定まる。
# 2. xがA_iとB_jの片方に現れる場合
# xがA_iに現れている場合、xの場所としてありうるものの個数は、
# (B_j >= x となるjの個数) である。
# xはA_i行にしか書き込めないし、B_j < x となる列に書き込むと
# 矛盾してしまうため。
# 3. xがAにもBにも現れない場合
# xの場所としてありうるものの個数は、
# (A_i >= x となるiの個数) * (B_j >= x となるjの個数) である。
# ただし、そのうち NM - x 個はxより大きな値が書き込まれている。
# 以上の値の総乗が解である。
from bisect import bisect_left
MOD = 10**9 + 7
a = sorted(A)
b = sorted(B)
a_set = set(A)
b_set = set(B)
if len(a) != len(a_set) or len(b) != len(b_set):
return 0 # 重複する要素があった。矛盾する。
ans = 1
for k in range(N * M, 0, -1):
cond1 = k in a_set
cond2 = k in b_set
# 順に、上にコメントした、条件1. 2. 3. を満たす場合
if cond1 and cond2:
continue
elif cond1:
idx = bisect_left(b, k)
ans *= (M - idx)
elif cond2:
idx = bisect_left(a, k)
ans *= (N - idx)
else:
idx_a = bisect_left(a, k)
idx_b = bisect_left(b, k)
ans *= (N - idx_a) * (M - idx_b) - (N * M - k)
ans %= MOD
return ans % MOD
N, M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
B = [int(i) for i in input().split()]
print((d_double_landxcape(N, M, A, B))) | p03152 |
N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
# A.sort(reverse=True)
# B.sort(reverse=True)
rowrange = 0
colrange = 0
ans = 1
for i in reversed(list(range(1, N * M + 1))):
r = i in A
c = i in B
if r is True and c is True:
rowrange += 1
colrange += 1
elif r is True and c is False:
rowrange += 1
ans = (colrange * ans) % (10 ** 9 + 7)
elif r is False and c is True:
colrange += 1
ans = (rowrange * ans) % (10 ** 9 + 7)
else:
ans = ((rowrange * colrange - (N * M - i)) * ans) % (10 ** 9 + 7)
print(ans)
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
# A.sort(reverse=True)
# B.sort(reverse=True)
rowrange = 0
colrange = 0
ans = 1
for i in reversed(list(range(1, N * M + 1))):
r = i in A
c = i in B
if r is True and c is True:
rowrange += 1
colrange += 1
A.remove(i)
B.remove(i)
elif r is True and c is False:
rowrange += 1
ans = (colrange * ans) % (10 ** 9 + 7)
A.remove(i)
elif r is False and c is True:
colrange += 1
ans = (rowrange * ans) % (10 ** 9 + 7)
B.remove(i)
else:
ans = ((rowrange * colrange - (N * M - i)) * ans) % (10 ** 9 + 7)
print(ans)
| p03152 |
from math import ceil
def main():
l = [int(eval(input())) for _ in range(6)]
n, a, b, c, d, e = l
group = ceil(n / min(a, b, c, d, e))
print((4 + group))
if __name__ == '__main__':
main()
| from math import ceil
def main():
n = int(eval(input()))
required_times = [int(eval(input())) for _ in range(5)]
groups = ceil(n / min(required_times))
print((groups + 4))
if __name__ == '__main__':
main()
| p03077 |
n = int(eval(input()))
move = [int(eval(input())) for i in range(5)]
div,mod = divmod(n,min(move))
if mod == 0:
print((div + 4))
else:print((div + 5)) | import math
n = int(eval(input()))
move = [int(eval(input())) for i in range(5)]
print((math.ceil(n / min(move)) + 4)) | p03077 |
import math
N=int(eval(input()))
A=[int(eval(input())) for _ in range(5)]
n=min(A)
for i in range(5):
if n==A[i]:
p=i
break
k=math.ceil(N/n)
print((k+4)) | import math
N=int(eval(input()))
A=[int(eval(input())) for _ in range(5)]
print((math.ceil(N/min(A))+4))
| p03077 |
N = int(eval(input()))
A = [int(eval(input())) for i in range(5)] #A[i]:amount of people able to be carried at once from i to i+1
B = [0] * 6 #B[i]:amount of people at i now
cnt = 0
#max people able to be transported in m minutes
P = [0] * 9
B[0] = 10**15
for m in range(9):
for i in range(5,0,-1):
B[i] += min(A[i-1],B[i-1])
B[i-1] -= min(A[i-1],B[i-1])
P[m] = B[5]
cnt += 1
#print(P)
x = N // P[-1]
y = N % P[-1]
if y == 0:
print((5*x+4))
exit(0)
for j in range(7,2,-1):
if P[j]<y:
time = 5 * x + j + 2
print(time)
exit(0)
| import math
N = int(eval(input()))
A = [int(eval(input())) for i in range(5)]
print((math.ceil(N/min(A))+4)) | p03077 |
n = int(eval(input()))
L = [int(eval(input())) for i in range(5)]
ans = 5
max_ = -1
for l in L:
if n <= l:
continue
else:
q, r = divmod(n, l)
if r == 0:
max_ = max(max_, q-1)
else:
max_ = max(max_, q)
if max_ != -1:
ans += max_
print(ans)
| n = int(eval(input()))
L = [int(eval(input())) for _ in range(5)]
ans = 5
if n%min(L) == 0:
ans += n//min(L)-1
else:
ans += n//min(L)+1-1
print(ans)
| p03077 |
#!/usr/bin/env python3
import re
n = int(eval(input()))
p = []
min = 1000000000000000
for i in range(5):
x = int(eval(input()))
p.append(x)
if(min > x):
min = x
if(n%min == 0):
print((int(n/min) + 4))
else:
print((int(n/min) + 5))
| #!/usr/bin/env python3
#ABC123 C
import math
L = [int(eval(input())) for _ in range(6)]
N = L[0]
L.remove(L[0])
L.sort()
min = L[0]
print((math.ceil(N/L[0]) + 4)) | p03077 |
n,*a=list(map(int,open(0).read().split()));a=min(a);print((4+(n+a-1)//a)) | n, *a = list(map(int, open(0).read().split()))
b = min(a)
print((4 + (n+b-1)//b)) | p03077 |
import math
n = int(eval(input()))
l = [int(eval(input())) for i in range(5)]
print((math.ceil(n/min(l))+4))
| import math
n = int(eval(input()))
ls = [int(eval(input())) for _ in range(5)]
print((math.ceil(n/min(ls))+4))
| p03077 |
from math import ceil
n = int(eval(input()))
A = [int(eval(input())) for i in range(5)]
print((ceil(n/min(A))+4))
| from math import ceil
n = int(eval(input()))
t = [int(eval(input())) for i in range(5)]
print((4+ceil(n/min(t)))) | p03077 |
import math
n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
time = min(a, b, c, d, e)
if n < time:
print((5))
else:
print((math.ceil(n / time) + 4))
| import math
N = int(eval(input()))
carry = [int(eval(input())) for _ in range(5)]
print((math.ceil(N / min(carry))+4)) | p03077 |
def main():
N = int(eval(input()))
T = [int(eval(input())) for i in range(5)]
minT = min(T)
bo = (N + minT - 1)//minT
print((4+bo))
if __name__ == '__main__':
main()
| def main():
N = int(eval(input()))
A = [int(eval(input())) for i in range(5)]
print((0--N//min(A) + 4))
if __name__ == '__main__':
main()
| p03077 |
def ii2ss(n):
ss = []
for i in range(n):
ss.append(eval(input()))
return ss
def sp2nn(sp, sep=' '):
return [int(s) for s in sp.split(sep)]
def ss2nn(ss):
return [int(s) for s in list(ss)]
import math
def main(ss):
N, A, B, C, D, E = ss2nn(ss)
m = min(A, B, C, D, E)
return math.ceil(N / m) + 4
ss = ii2ss(6)
print((main(ss))) | # AtCoder Beginner Contest 123
# https://atcoder.jp/contests/abc123
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))
import math
def main():
N = i2n()
ABCDE = ii2nn(5)
m = min(ABCDE)
n = int(math.ceil(N / m)) + 4
print(n)
main() | p03077 |
import sys
import math
ns = [int(i) for i in sys.stdin.read().strip().split('\n')]
n = ns[0]
ns = ns[1:]
m = min(ns)
ans = math.ceil(n / m) + 4
print(ans)
| import math
import sys
n, *ns = [int(i) for i in sys.stdin.read().strip().split('\n')]
m = min(ns)
ans = math.ceil(n / m) + 4
print(ans)
| p03077 |
import math
N = int(eval(input()))
d = [int(eval(input())) for i in range(5)]
mi = d[0]
Ans = math.ceil(N / mi)
for i in d[1:]:
Ans += 1
if i < mi:
x = math.ceil(N / i) - math.ceil(N / mi)
Ans += x
mi = i
print(Ans) | N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
x = min(A, B, C, D, E)
ans = 4 + N // x
if N % x != 0:
ans += 1
print(ans) | p03077 |
N = int(eval(input()))
L = [0 for i in range(5)]
for i in range(5):
L[i] = int(eval(input()))
time = [0 for i in range(5)]
time[0] = (N-1)//L[0] + 1
for i in range(4):
if L[i] <= L[i+1]:
time[i+1] = time[i]
else:
time[i+1] = (N-1)//L[i+1] + 1
ans = max(time) + 4
print(ans) | N = int(eval(input()))
L = [int(eval(input())) for _ in range(5)]
n = min(L)
ans = (N+n-1) // n + 4
print(ans) | p03077 |
n=int(eval(input()))
m=10**15+1
mi=0
for i in range(5):
a=int(eval(input()))
if a<m:
m=a
mi=i
print(((n-1)//m+1+5-1)) | n=int(eval(input()))
m=10**15+1
a=[int(eval(input())) for _ in range(5)]
print(((n-1)//min(a)+5)) | p03077 |
import sys
import math
stdin = sys.stdin
mod = 10**9 + 7
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]
n = ni()
a = []
for _ in range(5):
a.append(ni())
print((math.ceil(n/min(a))+4))
| import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
n = ni()
a = []
for _ in range(5):
a.append(ni())
amin = min(a)
ans = (n-1)//min(a) + 1 + 4
print(ans)
| p03077 |
n=int(eval(input()))
a=int(eval(input()))
b=int(eval(input()))
c=int(eval(input()))
d=int(eval(input()))
e=int(eval(input()))
m = min(a,b,c,d,e)
cnt = (n-1)//m + 1
print((cnt+4)) | n = int(eval(input()))
m = min([int(eval(input())) for _ in range(5)])
cnt = (n-1)//m + 1
print((cnt + 4))
| p03077 |
N = int(eval(input()))
MIN = float("inf")
for _ in range(5):
MIN = min(MIN, int(eval(input())))
from math import ceil
print((ceil(N / MIN) + 4)) | N = int(eval(input()))
MIN = float("inf")
for _ in range(5):
MIN = min(MIN, int(eval(input())))
print(((N + MIN - 1) // MIN + 4)) | p03077 |
from math import ceil
N = int(eval(input()))
v = [int(eval(input())) for _ in range(5)]
print((ceil(N / min(v)) + 4)) | from math import ceil
n = int(eval(input()))
a = [int(eval(input())) for _ in range(5)]
print((ceil(n / min(a)) + 4))
| p03077 |
#coding: utf-8
from math import ceil
N = int(eval(input()))
l = []
for i in range(5):
l.append(int(eval(input())))
print((ceil(N / min(l) + 4))) | #coding: utf-8
N = int(eval(input()))
l = []
for i in range(5):
l.append(int(eval(input())))
if N % min(l) != 0:
print((N // min(l) + 5))
else:
print((N // min(l) + 4)) | p03077 |
N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
dp = [0] * 6
dp[0] = N
T = [A,B,C,D,E]
ans = 0
ans = -(-N//min(T)) + 4
# while dp[5] < N:
# for i in range(4, -1, -1):
# if dp[i] == 0:
# continue
# dp[i+1] += min(dp[i],T[i])
# dp[i] -= min(dp[i],T[i])
# ans += 1
print(ans)
| # coding: utf-8
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = [0] * 5
for i in range(5):
A[i] = ir()
mi = min(A)
plus = -(-N//mi)
answer = 4 + plus
print(answer)
| p03077 |
import math
N = int(eval(input()))
A = [0] * 5
human_in_city = [0]*6
human_in_city[0] = N
moving_human = [0]*5
for i in range(5):
A[i] = int(eval(input()))
# count = 0
# while human_in_city[-1] != N:
# count += 1
# for i in range(5):
# if human_in_city[i] >= A[i]:
# moving_human[i] = A[i]
# else:
# moving_human[i] = human_in_city[i]
# for i in range(5):
# human_in_city[i+1] += moving_human[i]
# human_in_city[i] -= moving_human[i]
min_A = min(A)
count = 5 + math.ceil(N / min_A) -1
print(count) | N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
min_p = min(A, B, C, D, E)
import math
min_p = math.ceil(N / min_p)
print((min_p+4)) | p03077 |
from math import ceil
N = int(eval(input()))
L = [int(eval(input())) for k in range(5)]
ans = 5
for k in range(5):
ans = max(ans,4+ceil(N/L[k]))
print(ans)
| from math import ceil
N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
L = [A,B,C,D,E]
m = min(L)
print((4+ceil(N/m)))
| p03077 |
N = int(eval(input()))
A = [int(eval(input())) for _ in range(5)]
a = min(A)
n = N//a
k = N%a
ans = 0
if n>0:
ans = 5+(n-1)
if k>0:
ans += 1
else:
if k>0:
ans = 5
print(ans) | N = int(eval(input()))
A = [int(eval(input())) for _ in range(5)]
a = min(A)
n = N//a
b = N%a
if b==0:
print((5+n-1))
else:
print((5+n)) | p03077 |
n = int(eval(input()))
lis = [int(eval(input())) for i in range(5)]
key = 0
if n % min(lis) == 0:key = 1
print((5 + n//min(lis)-key)) | n = int(eval(input()))
nu = min([int(eval(input())) for i in range(5)])
print((4 + bool(n%nu) + n//nu)) | p03077 |
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
original = [a,b,c,d,e]
print((math.ceil(n / min(original))+4)) | import math
def main():
n = int(eval(input()))
# n, m = map(int, input().split())
# a = list(map(int, input().split()))
# s = input()
# h = [int(input()) for _ in rane(n)]
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
print((math.ceil(n / min(a, b, c, d, e)) + 4))
if __name__ == '__main__':
main()
| p03077 |
import copy
N = int(eval(input()))
A, B, C, D, E = [int(eval(input())) for i in range(5)]
Xs = [N, 0, 0, 0, 0, 0]
Fs = [A, B, C, D, E]
Fmin = min(Fs)
c = 0
while True:
#print(Xs)
nXs = copy.copy(Xs)
for i in range(len(Fs)):
if Xs[i] - Fs[i] > 0:
nXs[i] -= Fs[i]
nXs[i+1] += Fs[i]
else:
nXs[i] -= Xs[i]
nXs[i+1] += Xs[i]
#print(nXs)
Xs = nXs
c+=1
if max(Xs[1:5]) == Fmin:
c+=Xs[0]//Fmin
Xs[0]%=Fmin
if sum(Xs[0:5]) == 0:
break
print(c) | N = int(eval(input()))
min_ = min([int(eval(input())) for i in range(5)])
suf = 1 if N%min_ != 0 else 0
print((N//min_+4+suf)) | p03077 |
import math
n = int(eval(input()))
m = 10 ** 15 + 1
for _ in range(5):
m = min(m, int(eval(input())))
print((math.ceil(n / m) + 5 - 1)) | import math
n = int(eval(input()))
m = min([int(eval(input())) for _ in range(5)])
print((math.ceil(n/m) + 4)) | p03077 |
n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
dic ={0:n,1:0,2:0,3:0,4:0,5:0}
time =0
if n == 10000000007:
print((5000000008))
exit()
while sum(dic)>0:
if dic[5] == n:
print(time)
exit()
if dic[4] > e:
dic[4] -= e
dic[5] += e
else:
dic[5] += dic[4]
dic[4] = 0
if dic[3] > d:
dic[3] -= d
dic[4] += d
else:
dic[4] += dic[3]
dic[3] = 0
if dic[2] > c:
dic[2] -= c
dic[3] += c
else:
dic[3] += dic[2]
dic[2] = 0
if dic[1] > b:
dic[1] -= b
dic[2] += b
else:
dic[2] += dic[1]
dic[1] = 0
if dic[0] > a:
dic[0] -= a
dic[1] += a
else:
dic[1] += dic[0]
dic[0] = 0
time += 1 | n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
time =0
amin = min(a,b,c,d,e)
time=(n//amin+1 if n%amin != 0 else n/amin)+4
print((int(time))) | p03077 |
import math
N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
X = min([A,B,C,D,E])
t=math.ceil(N/X)
print((t+4)) | N = int(eval(input()))
ls = [int(eval(input())) for _ in range(5)]
X = min(ls)
print(((N+X-1)//X+4)) | p03077 |
import math
N = int(eval(input()))
A = int(eval(input()))
B = int(eval(input()))
C = int(eval(input()))
D = int(eval(input()))
E = int(eval(input()))
bottleneck = min([A, B, C, D, E])
n_addition = math.ceil(N / bottleneck) - 1
print((5 + n_addition))
| import math
n_paths = 5
N = int(eval(input()))
ABCDE = [int(eval(input())) for _ in range(n_paths)]
bottleneck = min(ABCDE)
n_addition = math.ceil(N / bottleneck) - 1
print((n_paths + n_addition))
| p03077 |
n = int(eval(input()))
a = int(eval(input()))
b = int(eval(input()))
c = int(eval(input()))
d = int(eval(input()))
e = int(eval(input()))
ans = 0 - -n//min(a, b, c, d, e) + 4
print(ans) | n = int(eval(input()))
l = [int(eval(input())) for _ in range(5)]
ans = 0 - -n//min(l) + 4
print(ans) | p03077 |
import sys
f = sys.stdin
board = [[0 for i in range(11)] for j in range(11)]
for i, line in enumerate(f):
for j, c in enumerate(line.strip()):
board[i + 1][1 + (i + 1) % 2 + j * 2] = int(c)
step = {(-1, 0 ):'L',(0, -1 ):'U',(1, 0 ):'R',(0, 1):'D'}
start = pre_loc = 1 + 1j
loc = 3 + 1j
print('R',end='')
while loc != start:
for direct in [(pre_loc - loc) / 2 * 1j ** (i + 1) for i in range(3)]:
if board[int(loc.imag + direct.imag)][int(loc.real + direct.real)]:
pre_loc = loc
loc += direct * 2
print(step[(direct.real,direct.imag)],end='')
break
print()
| import sys
f = sys.stdin
board = [[0 for i in range(11)] for j in range(11)]
for i, line in enumerate(f):
for j, c in enumerate(line.strip()):
board[i + 1][1 + (i + 1) % 2 + j * 2] = int(c)
step = {(-1, 0 ):'L',(0, -1 ):'U',(1, 0 ):'R',(0, 1):'D'}
start = pre_loc = 1 + 1j
loc = 3 + 1j
print('R',end='')
while loc != start:
for direct in [(pre_loc - loc) / 2 * 1j ** (i + 1) for i in range(4)]:
if board[int(loc.imag + direct.imag)][int(loc.real + direct.real)]:
pre_loc = loc
loc += direct * 2
print(step[(direct.real,direct.imag)],end='')
break
print()
| p00037 |
wx=[]
wy=[]
def readdata():
z=[]
try:
while True:
z.append(input())
except: return z
def nextpath(p, dir0):
for e in [3,0,1,2]:
dp = ispath(p, (dir0+e)%4)
if dp!=[]: break
return dp
def ispath(p, dir1):
y,x = p
dp = []
if dir1==0 and y>0 and wy[y-1][x]=="1": dp= 0
elif dir1==1 and x<len(wx[0]) and wx[y][x] =="1": dp = 1
elif dir1==2 and y<len(wy[0])-1 and wy[y][x] =="1": dp = 2
elif dir1==3 and x>0 and wx[y][x-1]=="1": dp = 3
return dp
def f0037():
p =[0,0]
dp = 1
msg = []
while True:
dp = nextpath(p, dp)
p[0]+=[-1,0,1,0][dp]
p[1]+=[0,1,0,-1][dp]
msg.append("URDL"[dp])
if p==[0,0]: break
return msg
z = readdata()
wx = z[0::2]
wy = z[1::2]
msg = f0037()
print("".join(msg)) | wx=[]
wy=[]
def readdata():
z=[]
try:
while True:
z.append(input())
except: return z
def nextpath(p,dir0):
for e in [3,0,1,2]:
d = (dir0+e)%4
if ispath(p,d): return d
return None
def ispath(p,d):
y,x = p
f=""
try:
if d==0 and y>0: f = wy[y-1][x]
elif d==1 and x<len(wy): f = wx[y][x]
elif d==2 and y<len(wx): f = wy[y][x]
elif d==3 and x>0: f = wx[y][x-1]
except: pass
return f=="1"
def f0037():
p =[0,0]
dp = 1
msg = []
while True:
dp = nextpath(p, dp)
p[0] += [-1,0,1,0][dp]
p[1] += [0,1,0,-1][dp]
msg.append("URDL"[dp])
if p==[0,0]: break
return "".join(msg)
z = readdata()
wx = z[0::2]
wy = z[1::2]
print(f0037()) | p00037 |
D, L = list(map(int, input().split()))
print((sum(divmod(D, L)))) | D, L = list(map(int, input().split()))
print((D//L + D%L)) | p00312 |
l=list(map(int,input().split()))
c=0
if 1 in l:c+=1
if 9 in l:c+=1
if 7 in l:c+=1
if 4 in l:c+=1
if c==4:print('YES')
else:print('NO') | l=list(map(int,input().split()))
if 1 in l and 9 in l and 7 in l and 4 in l:print('YES')
else:print('NO') | p03149 |
def resolve():
l=list(map(int, input().split()))
a=l.count(1)
b=l.count(9)
c=l.count(7)
d=l.count(4)
if a==b==c==d==1:
print('YES')
else:
print('NO')
resolve() | def resolve():
l=list(map(int, input().split()))
l.sort()
if l==[1,4,7,9]:
print('YES')
else:
print('NO')
resolve()
| p03149 |
l = set([int(e) for e in input().split()])
set_1974 = set([1,9,7,4])
if l == set_1974:
print("YES")
else:
print("NO") | l = {int(e) for e in input().split()}
set_1974 = {1,9,7,4}
if l == set_1974:
print("YES")
else:
print("NO") | p03149 |
N = [int(_) for _ in input().split()]
if 1 in N and 9 in N and 7 in N and 4 in N:
print("YES")
else:
print("NO") | N = [int(_) for _ in input().split()]
N.sort()
if N == [1, 4, 7, 9]:
print("YES")
else:
print("NO")
| p03149 |
def slove():
import sys
input = sys.stdin.readline
a = list(map(str, str(input().rstrip('\n')).split()))
a.sort()
print(("YES" if "".join(a) == "1479" else "NO"))
if __name__ == '__main__':
slove()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n = sorted(list(map(str, readline().rstrip().decode('utf-8').split())))
print(("YES" if n == sorted("1974") else "NO"))
if __name__ == '__main__':
solve()
| p03149 |
n = list(map(int,input().split()))
n.sort()
if(n[0]==1 and n[1]==4 and n[2]==7 and n[3]==9):
print("YES")
else:
print("NO") | li = list(map(int,input().split()))
if 1 in li and 4 in li and 7 in li and 9 in li:
print("YES")
else:
print("NO") | p03149 |
n = list(map(int,input().split()))
n.sort()
if n == [1,4,7,9]:
print("YES")
else:
print("NO") | print(("YES" if sorted(map(int,input().split())) == [1,4,7,9] else "NO")) | p03149 |
#!/usr/bin/python
import sys
def solve(s):
count = 0
len_s = len(s)
l = len_s // 2
for i in range(l):
if s[i] != s[len_s -1 -i]:
count += 1
print(count)
if __name__ == '__main__':
s = sys.stdin.readline().strip()
solve(s) | import sys
S = sys.stdin.readline().strip()
ls = len(S)
ans = 0
h = ls // 2
for i in range(h):
if S[i] != S[ls - 1 - i]:
ans += 1
print(ans) | p02836 |
import sys
import math
def resolve():
S=list(input().rstrip())
c=0
for i in range(math.floor(len(S)/2)):
if(S[i]!=S[len(S)-i-1]):
c+=1
print(c)
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """redcoder"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """vvvvvv"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """abcdabc"""
output = """2"""
self.assertIO(input, output)
if __name__ == "__main__":
#unittest.main()
resolve() |
import sys
import math
def resolve():
S=input().rstrip()
c=0
for i in range((len(S)//2)):
if(S[i]!=S[-i-1]):
c+=1
print(c)
from io import StringIO
import unittest
class TestClass(unittest.TestCase):
def assertIO(self, input, output):
stdout, stdin = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(input)
resolve()
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, stdin
self.assertEqual(out, output)
def test_入力例_1(self):
input = """redcoder"""
output = """1"""
self.assertIO(input, output)
def test_入力例_2(self):
input = """vvvvvv"""
output = """0"""
self.assertIO(input, output)
def test_入力例_3(self):
input = """abcdabc"""
output = """2"""
self.assertIO(input, output)
if __name__ == "__main__":
#unittest.main()
resolve() | p02836 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32
def solve(S: str):
sl = list(S)
rs = sl[::-1]
from math import ceil
print((ceil([sl[i] != rs[i] for i in range(len(S))].count(True)/2)))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
solve(S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10000000)
INF = 1<<32
def solve(S: str):
print(([S[i] != S[::-1][i] for i in range(len(S))].count(True)//2))
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
solve(S)
if __name__ == '__main__':
main()
| p02836 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
s = input().rstrip()
r = len(s)
res = 0
for i in range(r//2):
if s[i] != s[-(i+1)]:
res += 1
print(res)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
s = input().rstrip()
res = 0
ss = s[::-1]
for i in range(len(s)):
if s[i] != ss[i]:
res += 1
print((res//2))
if __name__ == '__main__':
main() | p02836 |
#参考
#https://atcoder.jp/contests/aising2019/submissions/3995168
import bisect
N,Q=list(map(int,input().split()))
A=list(map(int,input().split()))
Asum=[0]*N
Asum2=[0]*N
total=0
for i in range(N):
total+=A[i]
Asum[i]=total
if i>1:
Asum2[i]=A[i]+Asum2[i-2]
else:
Asum2[i]=A[i]
X=[]
for i in range(Q):
X.append((int(eval(input())),i))
X.sort(key=lambda x :x[0])
#yで高橋くんと青木くんの取りたいカードが初めて衝突すると考える。
#このようなyは半分より小さい所にはないので初期値を半分のところとする。
#yがNまで来た時は最初から交互に取る
#Xを小さい順から計算することで、yの値が単調増加になる
y=N//2-1
ans=[0]*Q
for x,i in X:
while y<=N-1 and x>A[y]:
y+=1
while y<=N-1:
takahashi=N-y
aoki=y+1-bisect.bisect_left(A,x-(A[y]-x))
if takahashi>aoki:
y+=1
else:
break
#右端からA[y]までは全て高橋くんが取る
ans[i]+=Asum[N-1]-Asum[y-1]
#青木くんはyからN-y個取っているので、その下のところから交互に取る
if y-(N-y)-1<0:
continue
ans[i]+=Asum2[y-(N-y)-1]
for i in range(Q):
print((ans[i])) | #参考
#https://atcoder.jp/contests/aising2019/submissions/3995168
import bisect
N,Q=list(map(int,input().split()))
A=list(map(int,input().split()))
Asum=[0]*N
Asum2=[0]*N
total=0
for i in range(N):
total+=A[i]
Asum[i]=total
if i>1:
Asum2[i]=A[i]+Asum2[i-2]
else:
Asum2[i]=A[i]
X=[]
for i in range(Q):
X.append((int(eval(input())),i))
X.sort(key=lambda x :x[0])
#yで高橋くんと青木くんの取りたいカードが初めて衝突すると考える。
#このようなyは半分より小さい所にはないので初期値を半分のところとする。
#yがNまで来た時は最初から交互に取る
#Xを小さい順から計算することで、yの値が単調増加になる
y=N//2-1
ans=[0]*Q
for x,i in X:
#条件式はy<=N-1を最初に持ってこないとA[y]の参照でエラーの可能性
while y<=N-1 and x>A[y]:
y+=1
while y<=N-1:
takahashi=N-y
aoki=y+1-bisect.bisect_left(A,x-(A[y]-x))
if takahashi>aoki:
y+=1
else:
break
#右端からA[y]までは全て高橋くんが取る
ans[i]+=Asum[N-1]-Asum[y-1]
#青木くんはyからN-y個取っているので、その下のところから交互に取る
if y-(N-y)-1<0:
continue
ans[i]+=Asum2[y-(N-y)-1]
for i in range(Q):
print((ans[i])) | p03158 |
import sys
input = sys.stdin.readline
from collections import *
from bisect import *
def judge(x):
tak = N-x
aoki = x-bisect_left(A, 2*X-A[x])+1
return tak<=aoki
def binary_search():
l, r = mark, N-1
while l<=r:
m = (l+r)//2
if judge(m):
r = m-1
else:
l = m+1
return l
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
acc = [0]
acc_e = [0]
for i in range(N):
acc.append(acc[-1]+A[i])
acc_e.append(acc_e[-1]+(A[i] if i%2==0 else 0))
for _ in range(Q):
X = int(eval(input()))
mark = bisect_left(A, X)
border = binary_search()
ans = acc[-1]-acc[border]
c = N-border
if 2*c>=N:
print(ans)
continue
if (N-2*c-1)%2==0:
ans += acc_e[N-2*c]
else:
ans += acc[N-2*c]-acc_e[N-2*c]
print(ans) | import sys
input = sys.stdin.readline
from collections import *
from bisect import *
def judge(x):
aoki = N-x-bisect_left(A, 2*X-A[N-x])+1
return x<=aoki
def binary_search():
l, r = 1, N-bisect_left(A, X)
while l<=r:
m = (l+r)//2
if judge(m):
l = m+1
else:
r = m-1
return r
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
acc = [0]
acco = [0]
for i in range(N):
acc.append(acc[-1]+A[i])
if i%2==1:
acco.append(acco[-1]+A[i])
else:
acco.append(acco[-1])
for _ in range(Q):
X = int(eval(input()))
x = binary_search()
ans = acc[N]-acc[N-x]
if N-2*x>0:
if (N-2*x)%2==0:
ans += acco[N-2*x]
else:
ans += acc[N-2*x]-acco[N-2*x]
print(ans) | p03158 |
import bisect
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
big = bisect.bisect_left(a, x)
small = big - 1
if (x - a[small]) ** 2 <= (x - a[big]) ** 2:
l = small
else:
l = big
r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
taka = n - m
aoki = n - taka - (bisect.bisect_left(a, x - rng))
if taka <= aoki + 1:
r = m
else:
l = m
rng = abs(x - a[r])
taka = n - r
aoki = n - taka - (bisect.bisect_left(a, x - rng))
taka_sum = sum_all[n] - sum_all[n - taka]
aoki_sum = sum_all[r] - sum_all[r - taka]
rest = n - taka * 2
if rest > 0:
if rest % 2 == 0:
taka_sum += sum_even[rest]
aoki_sum += sum_odd[rest]
else:
taka_sum += sum_odd[rest]
aoki_sum += sum_even[rest]
print(taka_sum) | import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
big = bisect.bisect_left(a, x)
small = big - 1
if (x - a[small]) ** 2 <= (x - a[big]) ** 2:
l = small
else:
l = big
r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
taka = n - m
aoki = n - taka - (bisect.bisect_left(a, x - rng))
if taka <= aoki + 1:
r = m
else:
l = m
rng = abs(x - a[r])
taka = n - r
aoki = n - taka - (bisect.bisect_left(a, x - rng))
taka_sum = sum_all[n] - sum_all[n - taka]
aoki_sum = sum_all[r] - sum_all[r - taka]
rest = n - taka * 2
if rest > 0:
if rest % 2 == 0:
taka_sum += sum_even[rest]
aoki_sum += sum_odd[rest]
else:
taka_sum += sum_odd[rest]
aoki_sum += sum_even[rest]
ans.append(taka_sum)
print(("\n".join([str(item) for item in ans]))) | p03158 |
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
big = bisect.bisect_left(a, x)
small = big - 1
if (x - a[small]) ** 2 <= (x - a[big]) ** 2:
l = small
else:
l = big
r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
taka = n - m
aoki = n - taka - (bisect.bisect_left(a, x - rng))
if taka <= aoki + 1:
r = m
else:
l = m
rng = abs(x - a[r])
taka = n - r
aoki = n - taka - (bisect.bisect_left(a, x - rng))
taka_sum = sum_all[n] - sum_all[n - taka]
aoki_sum = sum_all[r] - sum_all[r - taka]
rest = n - taka * 2
if rest > 0:
if rest % 2 == 0:
taka_sum += sum_even[rest]
aoki_sum += sum_odd[rest]
else:
taka_sum += sum_odd[rest]
aoki_sum += sum_even[rest]
ans.append(taka_sum)
print(("\n".join([str(item) for item in ans]))) | import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
l = 0
r = n - 1
# l: aoki takes, r: takahashi takes
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans]))) | p03158 |
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
l = 0
r = n - 1
# l: aoki takes, r: takahashi takes
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans]))) | import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
x = int(eval(input()))
# Get div of aoki - takahashi
# l: aoki takes, r: takahashi takes
l = 0; r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans]))) | p03158 |
from bisect import *
n,q = list(map(int,input().split()))
A = list(map(int,input().split()))
every2 = [[0]*(n//2 + 2) for _ in range(2)]
right = [0]*(n+1)
for i in range(n):
odd = i&1
every2[odd][i//2 + 1] = every2[odd][i//2] + A[i]
right[i+1] = right[i] + A[-i-1]
# ans = [0]*q
def ok(y,x):
M = A[-y]
if M <= x:return False
d = M - x
m = x - d
return bisect_left(A,m)+2*y-1 <= n
for i in range(q):
X = int(eval(input()))
W = bisect_right(A,X)
top = n - W + 1
bottom = 1
while top - bottom > 1:
mid = (top + bottom)//2
if ok(mid,X):
bottom = mid
else:
top = mid
ans = right[bottom] + every2[1 - (n&1)][(n-1)//2 + 1 - bottom]
print(ans)
# print('\n'.join(ans))
| from bisect import *
import sys
input = sys.stdin.readline
n,q = list(map(int,input().split()))
A = list(map(int,input().split()))
every2 = [[0]*(n//2 + 2) for _ in range(2)]
right = [0]*(n+1)
for i in range(n):
odd = i&1
every2[odd][i//2 + 1] = every2[odd][i//2] + A[i]
right[i+1] = right[i] + A[-i-1]
# ans = [0]*q
def ok(y,x):
M = A[-y]
if M <= x:return False
d = M - x
m = x - d
return bisect_left(A,m)+2*y-1 <= n
for i in range(q):
X = int(eval(input()))
W = bisect_right(A,X)
top = n - W + 1
bottom = 1
while top - bottom > 1:
mid = (top + bottom)//2
if ok(mid,X):
bottom = mid
else:
top = mid
ans = right[bottom] + every2[1 - (n&1)][(n-1)//2 + 1 - bottom]
print(ans)
# print('\n'.join(ans))
| p03158 |
from itertools import accumulate,zip_longest
from functools import reduce
import bisect
import sys
input = sys.stdin.readline
N,Q = list(map(int,input().split()))
A = list(map(int,input().split()))
X = [int(eval(input())) for i in range(Q)]
B = [2*a+1 for a in A] # right
A = [2*a for a in A] # left
X = [2*x for x in X]
S = list(accumulate(A))
T0 = accumulate(A[::2])
T1 = accumulate(A[1::2])
T = list(reduce(lambda x,y : x+y, zip_longest(T0,T1)))
if T[-1] is None:
T.pop()
maxhigh = 10**16
for x in X:
if x > (A[-1]+A[-2])//2:
print((T[-1]//2))
continue
NG = maxhigh
OK = 0
R = OK
ans = 0
while True:
l = x - R
r = x + R
li = bisect.bisect_left(A,l)
ri = bisect.bisect_right(B,r)
#print(l,r,li,ri)
M = ri-li
if ri == N-M:
if li > 0:
ans += T[li-1]
break
if ri == N-M-1:
#print("HER",li,ri)
li -= 1
if li > 0:
ans += T[li-1]
break
if ri < N-M:
OK = R
R = (R + NG)//2
if N-M < ri:
NG = R
R = (R + OK)//2
#print(l,x,r,li,ri,OK,"R",R,NG)
#print(l,x,r,li,ri,OK,R,NG)
if ri > 0:
ans += S[N-1] - S[ri-1]
else:
ans += S[N-1]
print((ans//2))
| from itertools import accumulate,zip_longest
from functools import reduce
import bisect
import sys
input = sys.stdin.readline
N,Q = list(map(int,input().split()))
A = list(map(int,input().split()))
X = [int(eval(input())) for i in range(Q)]
B = [2*a+1 for a in A] # right
A = [2*a for a in A] # left
X = [2*x for x in X]
S = list(accumulate(A))
T0 = accumulate(A[::2])
T1 = accumulate(A[1::2])
T = []
for s,t in zip_longest(T0,T1):
T.append(s)
T.append(t)
if T[-1] is None:
T.pop()
maxhigh = 10**16
for x in X:
if x > (A[-1]+A[-2])//2:
print((T[-1]//2))
continue
NG = maxhigh
OK = 0
R = OK
ans = 0
while True:
l = x - R
r = x + R
li = bisect.bisect_left(A,l)
ri = bisect.bisect_right(B,r)
M = ri-li
if ri == N-M:
if li > 0:
ans += T[li-1]
break
if ri == N-M-1:
li -= 1
if li > 0:
ans += T[li-1]
break
if ri < N-M:
OK = R
R = (R + NG)//2
if N-M < ri:
NG = R
R = (R + OK)//2
if ri > 0:
ans += S[N-1] - S[ri-1]
else:
ans += S[N-1]
print((ans//2))
| p03158 |
import bisect
n,q = list(map(int, input().split()))
aList = list(map(int, input().split()))
sumList=[]
sep2SumList=[]
for i in range(n):
if i==0:
sumList.append(aList[i])
else:
sumList.append(sumList[-1]+aList[i])
if n%2==0:
if i%2==1:
if i==1:
sep2SumList.append(aList[i])
else:
sep2SumList.append(sep2SumList[-1]+aList[i])
else:
if i%2==0:
if i==0:
sep2SumList.append(aList[i])
else:
sep2SumList.append(sep2SumList[-1]+aList[i])
sakaime=[]
anskazu=(n+1)//2
for i in range(anskazu):
sakaime.append((aList[n-(i+1+1)]+aList[n-((i+1+1)*2-1)])//2)
sakaime.reverse()
sakaime=sakaime[1:]
def kotae(x):
bisect.bisect_left(sakaime,x)
num=len(sakaime)+1-bisect.bisect_left(sakaime,x)
if num==len(sakaime)+1:
ans=sumList[-1]-sumList[-1-num]
else:
ans=sumList[-1]-sumList[-1-num]+sep2SumList[(n-num*2+1)//2-1]
return ans
for i in range(q):
x=int(eval(input()))
print((kotae(x))) | import bisect
n,q = list(map(int, input().split()))
aList = list(map(int, input().split()))
sumList=[]
sep2SumList=[]
for i in range(n):
if i==0:
sumList.append(aList[i])
else:
sumList.append(sumList[-1]+aList[i])
if n%2==0:
if i%2==1:
if i==1:
sep2SumList.append(aList[i])
else:
sep2SumList.append(sep2SumList[-1]+aList[i])
else:
if i%2==0:
if i==0:
sep2SumList.append(aList[i])
else:
sep2SumList.append(sep2SumList[-1]+aList[i])
sakaime=[]
anskazu=(n+1)//2
for i in range(anskazu):
sakaime.append((aList[n-(i+1+1)]+aList[n-((i+1+1)*2-1)])//2)
sakaime.reverse()
sakaime=sakaime[1:]
def kotae(x):
bisect.bisect_left(sakaime,x)
num=len(sakaime)+1-bisect.bisect_left(sakaime,x)
if num==len(sakaime)+1:
ans=sumList[-1]-sumList[-1-num]
else:
ans=sumList[-1]-sumList[-1-num]+sep2SumList[(n-num*2+1)//2-1] #+1することで奇数を吸収
return ans
for i in range(q):
x=int(eval(input()))
print((kotae(x))) | p03158 |
import itertools
def inpl(): return [int(i) for i in input().split()]
def f(y):
return abs(x-A[y])
N, Q = inpl()
A = inpl()
SA = list(itertools.accumulate(A))
if N%2 :
B = [v for i, v in enumerate(A) if not i%2]
B = [0] + list(itertools.accumulate(B))
else:
B = [v for i, v in enumerate(A) if i%2]
B = [0] + list(itertools.accumulate(B))
for _ in range(Q):
x = int(eval(input()))
lo = 1
hi = -(-N//2) + 1
while hi - lo >1:
mid = (lo+hi)//2
if mid == 1:
continue
if max(f(N-mid-1), f(N-2*mid+1)) <= f(N-mid):
lo = mid
else:
hi = mid
print((SA[N-1] - SA[N-lo-1] + B[-((2*lo-N)//2)]))
| import itertools
import sys
def input(): return sys.stdin.readline()
def inpl(): return [int(i) for i in input().split()]
def f(y):
return abs(x-A[y])
N, Q = inpl()
A = inpl()
SA = list(itertools.accumulate(A))
if N%2 :
B = [v for i, v in enumerate(A) if not i%2]
B = [0] + list(itertools.accumulate(B))
else:
B = [v for i, v in enumerate(A) if i%2]
B = [0] + list(itertools.accumulate(B))
for _ in range(Q):
x = int(eval(input()))
lo = 1
hi = -(-N//2) + 1
while hi - lo >1:
mid = (lo+hi)//2
if mid == 1:
continue
if max(f(N-mid-1), f(N-2*mid+1)) <= f(N-mid):
lo = mid
else:
hi = mid
print((SA[N-1] - SA[N-lo-1] + B[-((2*lo-N)//2)]))
| p03158 |
import bisect
n,q = list(map(int,input().split()))
A = list(map(int,input().split()))
dic = {}
w = [A[0]]
for i in range(1,n):
w.append(w[-1]+A[i])
w1 = [A[0],0]
w2 = [0,A[1]]
for i in range(2,n):
if i%2 == 0:
w1.append(w1[-2]+A[i])
w2.append(0)
else:
w2.append(w2[-2]+A[i])
w1.append(0)
def solve(x):
if x in dic:
print((dic[x]))
return
if x >= A[-1]:
count = max(w1[-1],w2[-1])
dic[x] = count
print(count)
return
l = 0
r = 10**10
while r > l+1:
m = (r+l)//2
li = bisect.bisect_left(A,x-m)
ri = bisect.bisect_right(A,x+m)
if n-ri == ri-li:
count = w[-1]-w[ri-1]
li -= 1
if li>= 0:
if li%2 == 0:
count += w1[li]
else:
count += w2[li]
dic[x] = count
print(count)
return 0
if n-ri == ri-li+1:
count = w[-1]-w[ri-1]
li -= 2
if li>= 0:
if li%2 == 0:
count += w1[li]
else:
count += w2[li]
dic[x] = count
print(count)
return 0
if A[ri-1] == x+m:
ri2 = ri-1
if n-ri2 == ri2-li:
count = w[-1]-w[ri2-1]
li -= 1
if li>= 0:
if li%2 == 0:
count += w1[li]
else:
count += w2[li]
dic[x] = count
print(count)
return 0
elif n-ri2 == ri2-li+1:
count = w[-1]-w[ri2-1]
li -= 2
if li>= 0:
if li%2 == 0:
count += w1[li]
else:
count += w2[li]
dic[x] = count
print(count)
return 0
if 2*ri > n+li:
r = m
else:
l = m
count = max(w1[-1],w2[-1])
dic[x] = count
print(count)
return
for _ in range(q):
x = int(eval(input()))
solve(x)
| n,q = list(map(int,input().split()))
A = list(map(int,input().split()))
w = [A[0]]
for i in range(1,n):
w.append(w[-1]+A[i])
w1 = [0]*n
for i in range(n):
if (n-1-i)%2 == 0:
w1[i] = A[i]
if i > 0:
w1[i] += w1[i-1]
def solve(x):
l = 0
r = n+1
while r-l > 1:
m = (r+l)//2
if A[n-m] <= x:
r = m
else:
if 2*m-1 > n:
r = m
else:
if A[n-m]-x >= x-A[n-2*m+1]:
l = m
else:
r = m
ans = w[-1]-w[n-l-1]
if n-2*l-1 >= 0:
ans += w1[n-2*l-1]
print(ans)
for _ in range(q):
solve(int(eval(input()))) | p03158 |
n, q = list(map(int, input().split()))
a = list(map(int, input().split()))
x = [int(eval(input())) for _ in range(q)]
sort_x = sorted(x)
ans = {}
if n%2== 1:
small_position = 0
border_position = int((n-1)/2)
sum_all = sum(a[border_position:])
a.append(1000000000)
a.append(1000000000)
for x_i in sort_x:
for compare in a[border_position:]:
if x_i - a[small_position] > compare-x_i:
sum_all = sum_all + a[small_position] - compare
small_position += 2
border_position += 1
ans[x_i] = sum_all
else:
ans[x_i] = sum_all
break
else:
small_position = 1
border_position = int(n/2)
sum_all = sum(a[border_position:])
a.append(1000000000)
a.append(1000000000)
for x_i in sort_x:
for compare in a[border_position:]:
if x_i - a[small_position] > compare-x_i:
sum_all = sum_all + a[small_position] - compare
small_position += 2
border_position += 1
ans[x_i] = sum_all
else:
ans[x_i] = sum_all
break
for x_i in x:
print((ans[x_i]))
| n, q = list(map(int, input().split()))
a = list(map(int, input().split()))
x = [int(eval(input())) for _ in range(q)]
sort_x = sorted(x)
ans = {}
if n%2== 1:
small_position = 0
border_position = int((n-1)/2)
else:
small_position = 1
border_position = int(n/2)
sum_all = sum(a[border_position:])
a.append(10000000000)
a.append(10000000000)
x_index = 0
flag = False
for compare in a[border_position:]:
compare_x = sort_x[x_index]
small_a = a[small_position]
while 2*sort_x[x_index] - small_a <= compare:
ans[sort_x[x_index]] = sum_all
x_index += 1
if x_index == q:
flag = True
break
sum_all = sum_all + small_a - compare
small_position += 2
if flag:
break
for x_i in x:
print((ans[x_i]))
| p03158 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from bisect import bisect_left as bl, bisect_right as br
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(x, i):
# i番目を取れるかどうか
v = a[i]
target = x - (v-x)
num = i - bl(a, target-0.1)
return num+1 >= n - i
anss = [None] * q
cumsum1 = [0] * n
cumsum0 = [0] * n
for i in range(n):
if i%2:
cumsum1[i] = cumsum1[i-1] + a[i]
cumsum0[i] = cumsum0[i-1]
else:
cumsum0[i] = cumsum0[i-1] + a[i]
cumsum1[i] = cumsum1[i-1]
for j in range(q):
x = int(eval(input()))
l = 0
r = n-1
while l<r-1:
m = (r+l)//2
if sub(x, m):
r = m
else:
l = m
# rまではxより大きくて取れる
# print("r", r)
ans = sum(a[r:])
ii = r-2 - (n-r-1)
if ii>=0:
if ii%2:
ans += cumsum1[ii]
else:
ans += cumsum0[ii]
anss[j] = ans
write("\n".join(map(str, anss))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from bisect import bisect_left as bl, bisect_right as br
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(x, i):
# i番目を取れるかどうか
v = a[i]
target = x - (v-x)
num = i - bl(a, target-0.1)
return num+1 >= n - i
anss = [None] * q
cumsum1 = [0] * n
cumsum0 = [0] * n
cumsum = [0] * n
for i in range(n):
if i%2:
cumsum1[i] = cumsum1[i-1] + a[i]
cumsum0[i] = cumsum0[i-1]
else:
cumsum0[i] = cumsum0[i-1] + a[i]
cumsum1[i] = cumsum1[i-1]
cumsum[i] = cumsum[i-1] + a[i]
for j in range(q):
x = int(eval(input()))
l = 0
r = n-1
while l<r-1:
m = (r+l)//2
if sub(x, m):
r = m
else:
l = m
# rまではxより大きくて取れる
# ans = sum(a[r:])
ans = cumsum[-1] - cumsum[r-1]
ii = r-2 - (n-r-1)
if ii>=0:
if ii%2:
ans += cumsum1[ii]
else:
ans += cumsum0[ii]
anss[j] = ans
write("\n".join(map(str, anss))) | p03158 |
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from bisect import bisect_left as bl, bisect_right as br
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(x, i):
# i番目を取れるかどうか
v = a[i]
target = x - (v-x)
num = i - bl(a, target-0.1)
return num+1 >= n - i
anss = [None] * q
cumsum1 = [0] * n
cumsum0 = [0] * n
cumsum = [0] * n
for i in range(n):
if i%2:
cumsum1[i] = cumsum1[i-1] + a[i]
cumsum0[i] = cumsum0[i-1]
else:
cumsum0[i] = cumsum0[i-1] + a[i]
cumsum1[i] = cumsum1[i-1]
cumsum[i] = cumsum[i-1] + a[i]
for j in range(q):
x = int(eval(input()))
l = 0
r = n-1
while l<r-1:
m = (r+l)//2
if sub(x, m):
r = m
else:
l = m
# rまではxより大きくて取れる
# ans = sum(a[r:])
ans = cumsum[-1] - cumsum[r-1]
ii = r-2 - (n-r-1)
if ii>=0:
if ii%2:
ans += cumsum1[ii]
else:
ans += cumsum0[ii]
anss[j] = ans
write("\n".join(map(str, anss))) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
from bisect import bisect_left as bl, bisect_right as br
n,q = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
def sub(x, i):
# i番目を取れるかどうか
v = a[i]
target = x - (v-x)
num = i - bl(a, target)
return num+1 >= n - i
anss = [None] * q
cumsum1 = [0] * n
cumsum0 = [0] * n
cumsum = [0] * n
for i in range(n):
if i%2:
cumsum1[i] = cumsum1[i-1] + a[i]
cumsum0[i] = cumsum0[i-1]
else:
cumsum0[i] = cumsum0[i-1] + a[i]
cumsum1[i] = cumsum1[i-1]
cumsum[i] = cumsum[i-1] + a[i]
for j in range(q):
x = int(eval(input()))
l = 0
r = n-1
while l<r-1:
m = (r+l)//2
if sub(x, m):
r = m
else:
l = m
# rまではxより大きくて取れる
# ans = sum(a[r:])
ans = cumsum[-1] - cumsum[r-1]
ii = r-2 - (n-r-1)
if ii>=0:
if ii%2:
ans += cumsum1[ii]
else:
ans += cumsum0[ii]
anss[j] = ans
write("\n".join(map(str, anss))) | p03158 |
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
# aとbの最大公約数
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
# aとbの最小公倍数
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve(A, Q):
N = len(A)
A = A[::-1]
s, es = [0] * (N + 1), [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + A[i]
es[i + 1] = es[i] + (A[i] if i % 2 == 0 else 0)
ths, vals = [], []
for i in range((N - 1) // 2):
th = (A[i + 1] + A[i * 2 + 2]) // 2 + 1
val = (s[i + 1] - s[0]) + (es[N] - es[i * 2 + 2])
ths.append(th)
vals.append(val)
ths = ths[::-1]
vals = vals[::-1]
for _ in range(Q):
x = int(eval(input()))
p = bisect_right(ths, x)
if p == 0:
print((s[(N + 1) // 2] - s[0]))
else:
print((vals[p - 1]))
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
solve(A, Q)
if __name__ == '__main__':
main()
| from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
# aとbの最大公約数
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
# aとbの最小公倍数
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve(A, Q):
N = len(A)
A = A[::-1]
s, es = [0] * (N + 1), [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + A[i]
es[i + 1] = es[i] + (A[i] if i % 2 == 0 else 0)
x_list, sum_t_list = [], []
for n in range((N - 1) // 2):
x = (A[n + 1] + A[n * 2 + 2]) // 2 + 1
sum_t = s[n + 1] + (es[N] - es[n * 2 + 2])
x_list.append(x)
sum_t_list.append(sum_t)
x_list = x_list[::-1]
sum_t_list = sum_t_list[::-1]
for _ in range(Q):
x = int(eval(input()))
p = bisect_right(x_list, x)
if p == 0:
print((s[(N + 1) // 2]))
else:
print((sum_t_list[p - 1]))
def main():
N, Q = list(map(int, input().split()))
A = list(map(int, input().split()))
solve(A, Q)
if __name__ == '__main__':
main()
| p03158 |
from math import ceil
N, Q = list(map(int, input().split()))
A = [int(a) for a in input().split()]
AltTake = [0 for a in range(N)]
GetAll = [0 for a in range(N)]
AltTake[0], AltTake[1] = A[0], A[1]
GetAll[-1] = A[-1]
BlockList = [0 for i in range(ceil(N/2))]
maxBlock = ceil(N/2)
for i in range(2, N):
AltTake[i] = A[i] + AltTake[i-2]
for i in reversed(list(range(N-1))):
GetAll[i] = GetAll[i+1] + A[i]
for i in range(ceil(N/2) - 1):
BlockList[-i-1] = (A[-i-2] + A[-2*i - 3]) // 2 + 1
def BSearch(x, L):
left, right = 0, len(L)
while right - left > 1:
mid = (right + left)//2
if L[mid] > x:
right = mid
else:
left = mid
return left
for _ in range(Q):
block = maxBlock - BSearch(int(eval(input())), BlockList)
if block == maxBlock: print((GetAll[-block]))
else: print((GetAll[-block] + AltTake[N - block * 2 -1])) | import sys
from bisect import bisect_left
def solve():
input = sys.stdin.readline
N, Q = map(int, input().split())
A = [int(a) for a in input().split()]
X = [int(input()) for _ in range(Q)]
cont = [0] * N
cont[N-1] = A[N-1]
for i in reversed(range(N-1)): cont[i] = cont[i+1] + A[i]
change = [0] * N
change[0] = A[0]
change[1] = A[1]
for i in range(2, N): change[i] = change[i-2] + A[i]
upperBound = [-1] * N
for i in range((N + 1)// 2): #上からi+1個連続でとれるxの最大値
target = A[N-i-1]
lower = A[(N-i-1) - i]
upperBound[N-i-1] = (target + lower) // 2
upperBound[N-1] = 10 ** 10
Ans = [0] * Q
for i, x in enumerate(X):
pos = bisect_left(upperBound, x)
Ans[i] += cont[pos] #連続で取れる数
if N - (N - pos) * 2 - 1 >= 0: Ans[i] += change[N - (N - pos) * 2 - 1]
print(*Ans, sep="\n")
return 0
if __name__ == "__main__":
solve()
| p03158 |
import copy
N,Q = list(map(int,input().split()))
A = list(map(int,input().split()))
X = [0]*Q
for i in range(Q):
X[i] = int(eval(input()))
#初期値
j= -1
Takahashi = 0
Aoki = 0
B = copy.deepcopy(A)
flag =0
for k in range(N):
if flag == 0: #高橋くんの行動
Takahashi += B[-1]
del B[-1]
flag = 1
elif flag ==1: #青木くんの行動
#j-1番目のカード値B[j-1] <= 青木くんが決めた整数X[i] < j番目のカード値B[j]
#となるようにjの値を決める
#ただしX[i]がいずれのBの要素よりも大きい場合はi=N-k-1とする
if j == -1:
for l in range(N-k):
if X[i] < B[l]:
j = l
break
if j == -1:
j = N-k-1
if len(B) == j:
j = len(B)-1
#j=0（青木くんが決めた整数は残りカードのいずれよりも小さい）の場合、B[0]を取る
if j == 0:
Aoki +=B[0]
del B[0]
flag =0
#j=0（青木くんが決めた整数は残りカードのいずれよりも小さい）の場合、B[0]を取る
#j番目のカードB[j]を取る
elif abs(X[i]-B[j]) < abs(X[i]-B[j-1]):
Aoki += B[j]
del B[j]
flag =0
if len(B) == j:
j=j-1
#j番目のカードB[j-1]を取る
else:
Aoki += B[j-1]
del B[j-1]
flag = 0
j = j-1
print(Takahashi) | n,q = list(map(int,input().split()))
a = list(map(int,input().split()))
query = [int(eval(input())) for i in range(q)]
a = sorted(a)
ruiseki = [0]*(n+1)
for i in range(n):
ruiseki[i+1] = ruiseki[i] + a[i]
ruiseki2 = [0]*(n+1)
if n % 2 == 1:
for i in range(n):
if i % 2 == 0:
ruiseki2[i+1] = ruiseki2[i] + a[i]
else:
ruiseki2[i+1] = ruiseki2[i]
if n % 2 == 0:
for i in range(n):
if i % 2 == 1:
ruiseki2[i+1] = ruiseki2[i] + a[i]
else:
ruiseki2[i+1] = ruiseki2[i]
def solve(mid, num):
r = -((-mid) // 2)
l = mid
r_pos = n - r
l_pos = n - l
if abs(a[l_pos] - num) <= abs(a[r_pos] - num):
return True
else:
return False
for i in range(q):
num = query[i]
ok = 1
ng = n + 1
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if solve(mid, num):
ok = mid
else:
ng = mid
ans = 0
ans += ruiseki[n] - ruiseki[n-(ok+1)//2]
nokori = n - ok
ans += ruiseki2[nokori]
print(ans) | p03158 |
read = input
n,k = list(map(int, read().split()))
a = read()
a = '1' + a + '1'
# -1 if use 0, -1 if use len(a) -1
pstart = 0
pcnt = 0
ptype = '1'
b = []
# (start, end, cnt)
for tp in enumerate(a):
i, c = tp
if ptype == c:
pcnt = pcnt + 1
else :
b.append((pstart, i-1, pcnt))
pstart = i
ptype = c
pcnt = 1
b.append((pstart, i, pcnt))
# print(b)
if k >= len(b)//2:
print((sum([tp[2] for tp in b]) - 2))
else :
start = 0
end = k * 2
ans = 0
while(end <= len(b) - 1):
tmp = sum([tp[2] for tp in b[start:(end+1)]])
if b[start][0] == 0:
tmp = tmp - 1
if b[end][1] == len(a)-1:
tmp = tmp -1
# print(start, end ,tmp)
ans = max(ans, tmp)
start = start + 2
end = end + 2
print(ans) | read = input
n,k = list(map(int, read().split()))
a = read()
a = '1' + a + '1'
# -1 if use 0, -1 if use len(a) -1
pstart = 0
pcnt = 0
ptype = '1'
b = []
# (start, end, cnt)
for tp in enumerate(a):
i, c = tp
if ptype == c:
pcnt = pcnt + 1
else :
b.append((pstart, i-1, pcnt))
pstart = i
ptype = c
pcnt = 1
b.append((pstart, i, pcnt))
# print(b)
if k >= len(b)//2:
print((sum([tp[2] for tp in b]) - 2))
else :
start = 0
end = k * 2
ans = 0
S = [0 for i in range(len(b)+10)]
S[0] = b[0][2]
for i in range(1, len(b)):
S[i] = S[i-1] + b[i][2]
while(end <= len(b) - 1):
tmp = S[end] - (S[start - 1] if start - 1>=0 else 0)
if b[start][0] == 0:
tmp = tmp - 1
if b[end][1] == len(a)-1:
tmp = tmp -1
# print(start, end ,tmp)
ans = max(ans, tmp)
start = start + 2
end = end + 2
print(ans) | p03074 |
import sys
input=sys.stdin.readline
n,k= list(map(int, input().split()))
s = input().strip()
s.strip()
p = [0]
for i in range(n):
if s[i] != s[p[-1]]:
p.append(i)
p.append(n)
X = []
for i in range(len(p)-1):
if s[p[i]] == "1":
li = i
ri = i + 2 * k + 1
if ri >= len(p)-1:
ri = len(p)-1
x = p[ri] - p[li]
else:
li = i-1
if li < 0:
li = 0
ri = i + 2 * (k-1) + 1
if ri >= len(p)-1:
x = n - p[li]
else:
x = p[ri] - p[li] + 1
X.append(x)
print((max(X)))
| import sys
input=sys.stdin.readline
n,k= list(map(int, input().split()))
s = input().strip()
s.strip()
p = [0]
for i in range(n):
if s[i] != s[p[-1]]:
p.append(i)
X = []
for i in range(len(p)):
if s[p[i]] == "1":
li = i
ri = i + 2 * k + 1
else:
li = i-1
if li < 0:
li = 0
ri = i + 2 * k
if ri > len(p)-1:
x = n - p[li]
else:
x = p[ri] - p[li]
X.append(x)
print((max(X)))
| p03074 |
import sys
# import bisect
# import math
# import itertools
# import numpy as np
# import collections
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e, p = range, enumerate, print
ip = IP()
id = Idea()
mod = 10 ** 9 + 7
"""この下から書いてね"""
n, k = ip.IL()
s = input()
zeros = []
ones = [0]
prev = "1"
for x in s:
if x == "1":
if prev == "0":
ones += [1]
else:
ones[-1] += 1
else:
if prev == "1":
zeros += [1]
else:
zeros[-1] += 1
prev = x
ones += [0]
tmp = sum(zeros[0:k]) + sum(ones[0:k+1])
ans = tmp
for i in r(0, len(zeros) - k):
tmp += zeros[i+k] - zeros[i] + ones[i+k+1] - ones[i]
ans = max(tmp, ans)
p(ans)
main()
| import sys
# import bisect
# import math
# import itertools
# import numpy as np
# import collections
"""Template"""
class IP:
"""
入力を取得するクラス
"""
def __init__(self):
self.input = sys.stdin.readline
def I(self):
"""
1文字の取得に使います
:return: int
"""
return int(self.input())
def S(self):
"""
1文字の取得(str
:return: str
"""
return self.input()
def IL(self):
"""
1行を空白で区切りリストにします(int
:return: リスト
"""
return list(map(int, self.input().split()))
def SL(self):
"""
1行の文字列を空白区切りでリストにします
:return: リスト
"""
return list(map(str, self.input().split()))
def ILS(self, n):
"""
1列丸々取得します(int
:param n: 行数
:return: リスト
"""
return [int(self.input()) for _ in range(n)]
def SLS(self, n):
"""
1列丸々取得します（str
:param n: 行数
:return: リスト
"""
return [self.input() for _ in range(n)]
def SILS(self, n):
"""
Some Int LineS
横に複数、縦にも複数
:param n: 行数
:return: list
"""
return [self.IL() for _ in range(n)]
def SSLS(self, n):
"""
Some String LineS
:param n: 行数
:return: list
"""
return [self.SL() for _ in range(n)]
class Idea:
def __init__(self):
pass
def HF(self, p):
"""
Half enumeration
半分全列挙です
pの要素の和の組み合わせを作ります。
ソート、重複削除行います
:param p: list : 元となるリスト
:return: list : 組み合わせられた和のリスト
"""
return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
def Bfs2(self, a):
"""
bit_full_search2
bit全探索の改良版
全探索させたら2進数のリストと10進数のリストを返す
:return: list２つ : １個目 2進数(16桁) 2個目 10進数
"""
# 参考
# https://blog.rossywhite.com/2018/08/06/bit-search/
# https://atcoder.jp/contests/abc105/submissions/4088632
value = []
for i in range(1 << len(a)):
output = []
for j in range(len(a)):
if self.bit_o(i, j):
"""右からj+1番目のiが1かどうか判定"""
# output.append(a[j])
output.append(a[j])
value.append([format(i, 'b').zfill(16), sum(output)])
value.sort(key=lambda x: x[1])
bin = [value[k][0] for k in range(len(value))]
val = [value[k][1] for k in range(len(value))]
return bin, val
def S(self, s, r=0, m=-1):
"""
ソート関係行います。色々な設定あります。
:param s: 元となるリスト
:param r: reversするかどうか 0=False 1=True
:param m: （2次元配列）何番目のインデックスのソートなのか
:return: None
"""
r = bool(r)
if m == -1:
s.sort(reverse=r)
else:
s.sort(reverse=r, key=lambda x: x[m])
def bit_n(self, a, b):
"""
bit探索で使います。0以上のときにTrue出します
自然数だからn
:param a: int
:param b: int
:return: bool
"""
return bool((a >> b & 1) > 0)
def bit_o(self, a, b):
"""
bit探索で使います。1のときにTrue出すよ
oneで1
:param a: int
:param b: int
:return: bool
"""
return bool(((a >> b) & 1) == 1)
def ceil(self, x, y):
"""
Round up
小数点切り上げ割り算
:param x: int
:param y: int
:return: int
"""
return -(-x // y)
def ave(self, a):
"""
平均を求めます
:param a: list
:return: int
"""
return sum(a) / len(a)
def gcd(self, x, y):
if y == 0:
return x
else:
return self.gcd(y, x % y)
"""ここからメインコード"""
def main():
# 1文字に省略
r, e, p = range, enumerate, print
ip = IP()
id = Idea()
mod = 10 ** 9 + 7
"""この下から書いてね"""
n, k = ip.IL()
s = input() + "2"
zeros = []
ones = []
cnt = 0
start = 1
for x in s:
if start == 1 and x != "1":
ones += [cnt]
cnt = 1
start = 0
elif start == 0 and x != "0":
zeros += [cnt]
cnt = 1
start = 1
else:
cnt += 1
if len(zeros) == len(ones):
ones += [0]
ones += [0]
ans = sum(ones[:k+1]) + sum(zeros[:k])
n_ans = ans
for i in r(len(zeros) - k):
n_ans = n_ans + ones[k+1+i] + zeros[k+i] - ones[i] - zeros[i]
ans = max(ans, n_ans)
p(ans)
main()
| p03074 |
#!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, K: int, S: str):
d = [] # type: List[int]
i = 0
while True:
r = 0
while i < N and S[i] == "1":
r += 1
i += 1
d.append(r)
if i >= N:
break
s = 0
while i < N and S[i] == "0":
s += 1
i += 1
d.append(s)
c = 2 * K + 1
if c > len(d):
print((sum(d)))
return
print((max(sum(d[dl:dl + c]) for dl in range(0, len(d) - c + 1, 2))))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, K, S)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, K: int, S: str):
d = [] # type: List[int]
i = 0
while True:
r = 0
while i < N and S[i] == "1":
r += 1
i += 1
d.append(r)
if i >= N:
break
s = 0
while i < N and S[i] == "0":
s += 1
i += 1
d.append(s)
c = 2 * K + 1
if c > len(d):
print((sum(d)))
return
dl = 0
acc = sum(d[:c])
ans = acc
while dl + c + 2 <= len(d):
acc += d[dl + c] + d[dl + c + 1] - d[dl] - d[dl + 1]
ans = max(ans, acc)
dl += 2
print(ans)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
S = next(tokens) # type: str
solve(N, K, S)
if __name__ == '__main__':
main()
| p03074 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, K, S):
s1 = list(map(lambda x: len(x), filter(lambda x: x != '', S.split('0'))))
s0 = list(map(lambda x: len(x), filter(lambda x: x != '', S.split('1'))))
if len(s0) <= K:
return N
# error_print(N, K)
# error_print(S)
# error_print(s1)
# error_print(s0)
ans = 0
s0_top = None
if S[0] == '0':
s0_top = s0.pop(0)
ans = s0_top + sum(s1[:K]) + sum(s0[:K-1])
l1o = 1
l0o = 0
l1 = sum(s1[:K+l1o])
l0 = sum(s0[:K+l0o])
k = 0
while True:
tmp = l1 + l0
# if k == 0 and S[0] == '0':
# tmp -= s1[K]
ans = max(ans, tmp)
if k+K < len(s1) and k+K < len(s0):
l1 -= s1[k]
if k+K+l1o < len(s1):
l1 += s1[k+K+l1o]
l0 -= s0[k]
if k+K+l0o < len(s0):
l0 += s0[k+K+l0o]
else:
break
k += 1
return ans
def main():
N, K = read_int_n()
S = read_str()
rS = ''.join(['0' if c == '1' else '1' for c in S])
print(max(slv(N, K, S), slv(N, K-1, rS)))
# N = 20
# K = random.randint(1, 10)
# S = ''.join(random.choices('01', k=N))
# rS = ''.join(['0' if c == '1' else '1' for c in S])
# print(max(slv(N, K, S), slv(N, K-1, rS)))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input().strip()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, K, S):
s1 = list(map(lambda x: len(x), filter(lambda x: x != '', S.split('0'))))
s0 = list(map(lambda x: len(x), filter(lambda x: x != '', S.split('1'))))
if len(s0) <= K:
return N
if S[0] == '0':
s1.insert(0, 0)
if S[-1] == '0':
s1.append(0)
s = []
i = 0
for i in range(len(s0)):
s.append(s1[i])
s.append(s0[i])
s.extend(s1[i+1:])
sa = [0]
for v in s:
sa.append(sa[-1]+v)
ans = 0
for i in range(0, len(sa), 2):
if i+2*K+1 < len(sa):
ans = max(ans, sa[i+2*K+1]-sa[i])
elif i+2*K < len(sa):
ans = max(ans, sa[i+2*K]-sa[i])
else:
break
return ans
def main():
N, K = read_int_n()
S = read_str()
rS = ''.join(['0' if c == '1' else '1' for c in S])
print(max(slv(N, K, S), slv(N, K-1, rS)))
# N = 20
# K = random.randint(1, 10)
# S = ''.join(random.choices('01', k=N))
# rS = ''.join(['0' if c == '1' else '1' for c in S])
# print(max(slv(N, K, S), slv(N, K-1, rS)))
if __name__ == '__main__':
main()
| p03074 |
import copy
def main():
n, k = list(map(int, input().rstrip().split(' ')))
s = [c == '1' for c in input().rstrip()]
candidates = []
windows = Windows()
current_window = None
for i, c in enumerate(s):
if not c:
if current_window == None:
current_window = Window(False)
elif current_window.one:
windows.windows.append(current_window)
if windows.count_zero_windows() == k:
"""we have k zero windows. shifting one to see new candiate"""
candidates.append(windows)
windows = windows.slide()
current_window = Window(False)
current_window.count += 1
else:
if current_window == None:
current_window = Window(True)
elif not current_window.one:
windows.windows.append(current_window)
current_window = Window(True)
current_window.count += 1
windows.windows.append(current_window)
candidates.append(windows)
print((max([w.count_ones() for w in candidates])))
class Window:
def __init__(self, one_or_zero):
self.one = one_or_zero
self.count = 0
class Windows:
def __init__(self):
self.windows = []
def slide(self):
"""Remove leftmost zero window and returns new windows"""
next = Windows()
if not self.windows[0].one:
next.windows = copy.deepcopy(self.windows[1:])
else:
next.windows = copy.deepcopy(self.windows[2:])
return next
def count_zero_windows(self):
if len(self.windows) % 2 == 0 or self.windows[0].one:
return len(self.windows) // 2
else:
return len(self.windows) // 2 + 1
def count_ones(self):
return sum([w.count for w in self.windows])
if __name__ == '__main__':
main() | import copy
def main():
n, k = list(map(int, input().rstrip().split(' ')))
s = [c == '1' for c in input().rstrip()]
windows = []
current_window = None
for i, c in enumerate(s):
if not c:
if current_window == None:
current_window = Window(False)
elif current_window.one:
windows.append(current_window)
current_window = Window(False)
current_window.count += 1
else:
if current_window == None:
current_window = Window(True)
elif not current_window.one:
windows.append(current_window)
current_window = Window(True)
current_window.count += 1
windows.append(current_window)
counts = []
count = 0
zero_window_count = 0
for i, w in enumerate(windows):
if not w.one:
zero_window_count += 1
if zero_window_count > k:
counts.append(count)
leftmost = i - (2 * k) - 1
if leftmost >= 0:
count -= windows[leftmost].count #1s, if exist
count -= windows[leftmost + 1].count #0s
count += w.count
counts.append(count)
print((max(counts)))
class Window:
def __init__(self, one_or_zero):
self.one = one_or_zero
self.count = 0
def __repr__(self):
return ("1" if self.one else "0") + " " + str(self.count)
if __name__ == '__main__':
main() | p03074 |
import sys,re,copy
input = sys.stdin.readline
N,K=[int(x) for x in input().strip().split()]
S=input().strip()
Z=[len(x) for x in re.split(r'1+',S)]
O=[len(x) for x in re.split(r'0+',S)]
m=0
i=0
if S[0]=='1':
Z.pop(0)
l1=len(O)
l0=len(Z)
while True:
c=sum(O[i:i+K+1])+sum(Z[i:i+K])
if c > m:
m = c
i+=1
if i+K>l1 or i+K>l0:
break
print(m) | import sys,re,copy
input = sys.stdin.readline
N,K=[int(x) for x in input().strip().split()]
f=1
cnt=0
S=[]
r=0
for s in input().strip():
s=int(s)
if s==f:
cnt+=1
else:
r+=cnt
S.append(r)
cnt=1
f=1-f
else:
r+=cnt
S.append(r)
if len(S)%2==0:
S.append(r)
Max=0
i=0
if len(S)==1:
Max=S[0]
else:
while True:
if i >=len(S):
break
r=i+2*K
cnt=S[min(r,len(S)-1)]-S[max(i-1,0)]
if cnt > Max:
Max = cnt
i+=2
print(Max) | p03074 |
import sys
def main():
if 'get_ipython' not in globals():
# For Subsession
N,K = list(map(int, input().split()))
S = sys.stdin.readline()
else:
# For Test
# N = 5
# K = 1
# S = "00010"
N = 14
K = 2
S = "11101010110011"
# N = 1
# K = 1
# S = "1"
SC = []
i = 0
if S[0] == "0":SC.append(0)
while i < N :
if S[i] == "0":
j = S.find("1",i)
else:
j = S.find("0",i)
if j == -1: j = N
cnt = j - i
i = j
SC.append(cnt)
if 'get_ipython' in globals(): print(SC)
i = 0
lenSC = len(SC) - 1
ans = 0
for i in range(0,lenSC+1,2):
#while i <= lenSC:
cnt = 0
k = i + K * 2
if k > lenSC:
k = lenSC
k += 1
cnt = sum(SC[i:k])
if ans < cnt:
ans = cnt
# i += 2
print(ans)
main() | import sys
def main():
if 'get_ipython' not in globals():
# For Subsession
N,K = list(map(int, input().split()))
S = sys.stdin.readline()
else:
# For Test
# N = 5
# K = 1
# S = "00010"
# N = 14
# K = 2
# S = "11101010110011"
# N = 1
# K = 1
# S = "1"
N = 5
K = 1
S = "11111"
SC = []
i = 0
if S[0] == "0":SC.append(0)
while i < N :
if S[i] == "0":
j = S.find("1",i)
else:
j = S.find("0",i)
if j == -1: j = N
cnt = j - i
i = j
SC.append(cnt)
if 'get_ipython' in globals(): print(SC)
SH = []
cnt = 0
for i in range(len(SC)):
cnt += SC[i]
SH.append(cnt)
if 'get_ipython' in globals(): print(SH)
lenSC = len(SC) - 1
ans = 0
for i in range(0,lenSC+1,2):
k = i + K * 2
if k > lenSC:
k = lenSC
if i != 0:
cnt = SH[k] - SH[i-1]
elif k == i:
cnt = SH[k]
else:
cnt = SH[k] - SH[i]
if ans < cnt: ans = cnt
print(ans)
main() | p03074 |
n, k = list(map(int, input().split()))
k += 1
s = "01" + input().rstrip()
n += 2
ans = 0
i = 0
left = 2
right = 1
while i < n:
if k > 0:
pos = s.find('01', i)
if pos == -1:
i = n
right = n - 1
else:
pos = s.find('10', pos + 1)
if pos == -1:
i = n
right = n - 1
else:
right = pos
i = pos + 1
k = k - 1
ans = max(ans, right - left + 1)
else:
pos = s.find('01', left)
left = pos + 1
k = k + 1
print(ans)
| n, k = list(map(int, input().split()))
s = input().rstrip()
ans = 1
i = 0
left = 0
right = 1
while i < n:
if k > 0:
pos = s.find('01', i)
if pos == -1:
i = n
right = n - 1
else:
pos = s.find('10', pos + 1)
if pos == -1:
i = n
right = n - 1
else:
right = pos
i = pos + 1
k = k - 1
ans = max(ans, right - left + 1)
else:
pos = s.find('01', left)
left = pos + 1
k = k + 1
print(ans) | p03074 |
from itertools import accumulate
def resolve():
N, K = map(int, input().split())
S = input()
# even:1
# odd:0
# 1-0-1-0-1 の配列にする. 両端は1にする
L = []
pre = "1"
cnt = 0
for i in range(N):
if pre == S[i]:
cnt += 1
else:
L.append(cnt)
cnt = 1
pre = S[i]
L.append(cnt)
# 最後が0で終わっていたら、仮の1を付け足す。(値が0なので影響ない)
if pre == "0":
L.append(0)
# 1-0-1-0-1の配列を作成し、K＝2だとする。
# 0を2個含めた個数は, 1＝3、0＝2の長さが作成できる
length = 2 * K + 1
# 0をすべて変換できる
if len(L) <= length:
return print(N)
acc = [0] + list(accumulate(L))
ans = 0
for i in range(0, len(L) - length + 1, 2):
ans = max(ans, acc[i + length] - acc[i])
print(ans)
if __name__ == "__main__":
resolve()
|
from itertools import accumulate
def resolve():
N, K = map(int, input().split())
S = input()
# even:1
# odd:0
# 1-0-1-0-1 の配列にする. 両端は1にする
L = []
pre = "1"
cnt = 0
for i in range(N):
if pre == S[i]:
cnt += 1
else:
L.append(cnt)
cnt = 1
pre = S[i]
L.append(cnt)
# 最後が0で終わっていたら、仮の1を付け足す。(値が0なので影響ない)
if pre == "0":
L.append(0)
# 1-0-1-0-1の配列を作成し、K＝2だとする。
# 0を2個含めた個数は, 1＝3、0＝2の長さが作成できる
length = 2 * K + 1
# 0をすべて変換できる
if len(L) <= length:
return print(N)
acc = [0] + list(accumulate(L))
ans = 0
# 1-0-1-0-1の配列なので間に0を含んだ数え上げ
# なので偶数とびに1を起点に数え上げ
for i in range(0, len(L) - length + 1, 2):
ans = max(ans, acc[i + length] - acc[i])
print(ans)
if __name__ == "__main__":
resolve()
| p03074 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.