input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, A = list(map(int, input().split())) # N枚数のカード, 平均をAにしたい
X = tuple(map(int, input().split())) # N枚のカードの中身
dp = [[[0]*(50*N+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1 # 0枚の中から0枚選んで合計が0になる選び方が1通りある
for i in range(N):
for j in range(N+1):
for k in range(50*N+1):
if dp[i][j][k]: # そのパターン数が0になっている場所からの遷移はありえない！！！
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for i in range(1, N+1):
ans += dp[N][i][i*A]
print(ans)
| N, A = list(map(int, input().split())) # N枚数のカード, 平均をAにしたい
X = tuple(map(int, input().split())) # N枚のカードの中身
dp = [[[0]*(50*N+2) for _ in range(N+2)] for _ in range(N+2)]
dp[0][0][0] = 1 # 0枚の中から0枚選んで合計が0になる選び方が1通りある
for i in range(N):
for j in range(N+1):
for k in range(50*N+1):
if dp[i][j][k]: # ここの分岐が分からん
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for i in range(1, N+1):
ans += dp[N][i][i*A]
print(ans)
| p04013 |
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
s = [{} for i in range(N+1)]
s[0][0] = 1
for i in range(N):
cur = X[i]
for j in range(N, 0, -1):
for k, v in list(s[j-1].items()):
s[j][cur + k] = s[j].get(cur + k, 0) + v
ans = 0
for i in range(1, N+1):
ans += s[i].get(i*A, 0)
print(ans) | N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
d = {0: 1}
for cur in X:
for k, v in list(d.items()):
d[cur + k] = d.get(cur + k, 0) + v
print((d[0]-1)) | p04013 |
n,a = (int(i) for i in input().split())
x = [int(i) for i in input().split()]
m,answer = max(max(x),a),0
dp = [[[0]*(n*m+1) for i in range(n+1)] for i in range(n+1)]
dp[0][0][0] = 1
for i in range(n+1):
for j in range(n+1):
for k in range(n*m+1):
if i>=1 and k<x[i-1]: dp[i][j][k] = dp[i-1][j][k]
elif i>=1 and j>=1 and k>=x[i-1]: dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i-1]]
for j in range(1,n+1):
answer += dp[n][j][j*a]
print(answer) | n,a = (int(i) for i in input().split())
x = [int(i)-a for i in input().split()]
x = [0]+x
y = max(max(x)+a,a)
dp = [[0 for i in range(2*n*y+1)] for i in range(n+1)]
dp[0][n*y] = 1
for i in range(n+1):
for j in range(2*n*y+1):
if i>0 and (j-x[i]<0 or j-x[i]>2*n*y): dp[i][j]=dp[i-1][j]
elif i>0 and 0<=j-x[i]<=2*n*y: dp[i][j]=dp[i-1][j]+dp[i-1][j-x[i]]
else: pass
print((dp[n][n*y]-1)) | p04013 |
from functools import lru_cache
N, A = list(map(int, input().split()))
X = [int(x) for x in input().split()]
@lru_cache(1000000000, False)
def solve(i, n, s):
if s < 0:
return -1
if N-i+1 < n:
return -1
if n == 0:
if s == 0:
return 1
else:
return -1
if i == N:
return -1
s1 = solve(i+1, n-1,s-X[i])
s2 = solve(i+1, n, s)
if s1 == -1 and s2 == -1:
return -1
if s1 == -1:
return s2
if s2 == -1:
return s1
return s1 + s2
answer = 0
for n in range(1, N+1):
s = solve(0, n, n*A)
if s != -1:
#print(n, s)
answer += s
print(answer)
def test():
import itertools
for a in itertools.combinations(X,3):
if sum(a) == A*3:
print(a) | from functools import lru_cache
N, A = list(map(int, input().split()))
X = [int(x) for x in input().split()]
#with open("9", "w") as f:
# print(50, 1, file=f)
# print(*([1]*50), file=f)
assert len(X) == N
def solve0(i, n, s):
if s < 0:
return -1
if N-i+1 < n:
return -1
if n == 0:
if s == 0:
return 1
else:
return -1
if i == N:
return -1
s1 = solve(i+1, n-1,s-X[i])
s2 = solve(i+1, n, s)
if s1 == -1 and s2 == -1:
return -1
if s1 == -1:
return s2
if s2 == -1:
return s1
return s1 + s2
cache = {}
def solve(i, n, s):
key = (i, n, s)
a = cache.get(key, None)
if a is None:
a = solve0(i, n, s)
cache[key] = a
return a
answer = 0
for n in range(1, N+1):
s = solve(0, n, n*A)
if s != -1:
answer += s
print(answer) | p04013 |
from itertools import combinations, starmap
N, A = list(map(int, input().split()))
x_list = list(map(int, input().split()))
coefficient = 1 # Aの係数
result = 0
while coefficient <= N:
for r in range(1, N+1):
multiple_of_a = coefficient * A
combis_sums = list(map(sum, combinations(x_list, r)))
for combi_sum in combis_sums:
if combi_sum == multiple_of_a:
result += 1
coefficient += 1
print(result) | N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
max_of_a = N * A
# dp[i][j][k] := i枚目までからj枚取って、合計をkにする通り数
dp = [[[0] * (max_of_a + 1) for _ in range(N+1)]for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N+1):
for j in range(N+1):
for k in range(max_of_a + 1):
if i >= 1 and x[i-1] > k:
dp[i][j][k] = dp[i-1][j][k]
elif i >= 1 and j >= 1 and x[i-1] <= k:
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - x[i-1]]
ans = 0
for j in range(1, N+1):
# N枚(カード総数)の中から1枚以上取った時の、j枚取って合計がj*Aの所 の合計
ans += dp[N][j][j*A]
print(ans) | p04013 |
from collections import Counter
from copy import copy
N,A = list(map(int,input().split()))
src = list(map(int,input().split()))
dp = [Counter()]
dp[0][0] = 1
for i,a in enumerate(src):
dp.append(Counter())
for j in reversed(list(range(i+1))):
for k,v in list(dp[j].items()):
dp[j+1][k+a] += v
ans = 0
for i in range(1,N+1):
ans += dp[i][A*i]
print(ans)
| from collections import Counter
N,A = list(map(int,input().split()))
src = list(map(int,input().split()))
dp = [Counter({0:1})]
for i,a in enumerate(src):
dp.append(Counter())
for j in reversed(list(range(i+1))):
for k,v in list(dp[j].items()):
dp[j+1][k+a] += v
ans = 0
for i,ctr in enumerate(dp):
if i==0: continue
ans += ctr[i*A]
print(ans) | p04013 |
n,a=list(map(int,input().split()))
lists=list(map(int,input().split()))
x=max(lists)
dp=[[[0 for i in range(2602)] for j in range(51)] for _ in range(51)]
dp[0][0][0]=1
#dp[i][j][k] で0からi番目のカードまでのうちで ｊ枚を選択して、その時に選んだ数の合計がsとなるような方法の総数を刺すことにする
for i in range(n+1):
for j in range(n+1):
for k in range(n*x+1):
if i>=j and i>=1 and k<lists[i-1]:
dp[i][j][k]=dp[i-1][j][k]
elif i>=j and j>=1and k>=lists[i-1]:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-lists[i-1]]
ans=0
for i in range(1,n+1):
ans+=dp[n][i][a*i]
print(ans)
| n,a=list(map(int,input().split()))
lists=list(map(int,input().split()))
for i in range(n):
lists[i]-=a
answer=0
dp=[[0 for i in range(5001)] for _ in range(51)]
#dp[i][j]で0からi枚目まで好きなように選択してそのそうわがｊ-2500となるような撮り方の総数
#最終的に求めるのはdp[i][0]である
for i in range(n+1):
for j in range(4951):
if i>=1 and j>=lists[i-1]:
dp[i][j]=dp[i-1][j-lists[i-1]]+dp[i-1][j]
if i>=1 and j<lists[i-1]:
dp[i][j]=dp[i-1][j]
else:
if j==2500 and i==0:
dp[i][j]=1
elif j!=2500 and i==0:
dp[i][j]=0
print((dp[n][2500]-1))
| p04013 |
N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
maxn = max(max(X), A)
dp = [[0 for _ in range(2 * N * maxn + 1)] for _ in range(N + 1)]
dp[0][N * maxn] = 1
for i in range(N):
for k in range(2 * N * maxn + 1):
dp[i + 1][k] = dp[i][k]
if 0 <= k - X[i] <= 2 * N * maxn:
dp[i + 1][k] += dp[i][k - X[i]]
print((dp[N][N * maxn] - 1))
| N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
maxn = max(max(X), A)
dp = [[0] * (2 * N * maxn + 1) for _ in range(N + 1)]
dp[0][N * maxn] = 1
for i in range(N):
for k in range(2 * N * maxn + 1):
dp[i + 1][k] = dp[i][k]
if 0 <= k - X[i] <= 2 * N * maxn:
dp[i + 1][k] += dp[i][k - X[i]]
print((dp[N][N * maxn] - 1))
| p04013 |
from collections import deque
n,a=list(map(int,input().split()))
cards=list(map(int,input().split()))
noz=[x-a for x in cards].count(0)
pl=[x-a for x in cards if x-a>0]
nl=[a-x for x in cards if x-a<0]
sl=[pl,nl][len(nl)<=len(pl)]
ll=[pl,nl][len(pl)<len(nl)]
sl.sort()
ll.sort()
sumfunc = lambda n, l: sum([l[x]*((n>>x)&1) for x in range(len(l))])
sumsl=[0 for _ in range(sum(sl))]
sumll=[0 for _ in range(sum(ll))]
for i in range(1,2**len(sl)):
sumsl[sumfunc(i,sl)-1]+=1
for i in range(1,2**len(ll)):
sumll[sumfunc(i,ll)-1]+=1
count=sum([x*y for x,y in zip(sumsl, sumll)])
# count=0
# p=sum([not sumsl[-1]<sumfunc(2**i,ll) for i in range(1,len(ll)+1)])
# q=sum([sumsl[0]>=sumfunc(2**i-1,ll) for i in range(1,len(ll)+1)])
# count=[sumfunc(j,ll) in sumsl for j in range(2**q-1,2**p)].count(True)
print(((count+1)*(2**noz)-1))
| import sys
n,a=list(map(int, input().split()))
cards=list(map(int, input().split()))
integers=[x-a for x in cards]
cards.append(a)
f=max(cards)*n
dp=[[0 for i in range(n+1)] for j in range(2*f+1) ]
for y in range(n+1):
for x in range(2*f+1):
if y==0 and x==f:
dp[x][y]=1
elif y>0 and (x-integers[y-1]<0 or x-integers[y-1]>2*f):
dp[x][y]=dp[x][y-1]
elif y>0 and x-integers[y-1]>=0 and x-integers[y-1]<=2*f:
dp[x][y]=dp[x-integers[y-1]][y-1]+dp[x][y-1]
else:
dp[x][y]=0
print((dp[f][n]-1))
| p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]
dp[0][0][0] = 1
for i in range(n):
for use in range(n):
for total in range(n * a):
dp[i + 1][use][total] += dp[i][use][total]
dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]
ans = 0
for i in range(1, n + 1):
ans += dp[n][i][a * i]
print(ans)
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [[[0] * (50 * (n + 10)) for _ in range(n + 10)] for _ in range(n + 10)]
dp[0][0][0] = 1
for i in range(n):
for use in range(n):
for total in range(n * a):
if dp[i][use][total]:
dp[i + 1][use][total] += dp[i][use][total]
dp[i + 1][use + 1][total + x[i]] += dp[i][use][total]
ans = 0
for i in range(1, n + 1):
ans += dp[n][i][a * i]
print(ans)
| p04013 |
from collections import Counter
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
for i in range(n):
x[i]-=a
left=x[:n//2]
l=len(left)
right=x[n//2:]
r=len(right)
data_left=Counter()
data_right=Counter()
for i in range(1,2**l):
num=0
for j in range(l):
if (i>>j)&1==1:
num+=left[j]
data_left[-num]+=1
for i in range(1,2**r):
num=0
for j in range(r):
if (i>>j)&1==1:
num+=right[j]
data_right[num]+=1
ans=data_left[0]+data_right[0]
for u,v in list(data_left.items()):
ans+=data_right[u]*v
print(ans) | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
for i in range(n):
x[i]-=a
dp=[0]*(2*n*50+2)
dp[0]=1
for i in range(n):
h=dp[:]
for j in range(-(n-1)*50,(n-1)*50+1):
h[j]+=dp[j-x[i]]
dp=h
print((dp[0]-1)) | p04013 |
import itertools as itr
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
#print(n,a)
#print(x)
cnt=0
for i in range(1,n+1):
for y in itr.combinations(x,i):
#print(y)
if sum(y) == i*a:
cnt += 1
print(cnt) | # -*- coding: utf-8 -*-
"""
Created on Sun Aug 5 12:20:16 2018
ABC44C
@author: maezawa
"""
def f(i, j):
global xa
global dp
if i==0:
cnt = 0
if j==0:
cnt += 1
if j==xa[0]:
cnt += 1
return cnt
if (i, j) in dp:
return dp[(i,j)]
else:
dp[(i,j)] = f(i-1,j-xa[i]) + f(i-1,j)
#print(i,j, dp[(i,j)])
return dp[(i,j)]
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
xa = [x[i]-a for i in range(n)]
dp = dict([])
print((f(n-1, 0)-1))
| p04013 |
from collections import Counter
n,a = list(map(int,input().split()))
x = [int(i)-a for i in input().split()]
dp = [Counter()]
# [何個使ったか][sum]
dp[0][0] = 1
for i,j in enumerate(x):
dp.append(Counter())
for k in reversed(list(range(i+1))):
for m,n in list(dp[k].items()):
dp[k+1][m+j] += n
res = 0
for l in dp:
res += l[0]
print((res-1)) | from collections import Counter
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
dp = [Counter()]
# [何個使ったか][sum]
dp[0][0] = 1
for i,j in enumerate(x):
dp.append(Counter())
for k in reversed(list(range(i+1))):
for m,p in list(dp[k].items()):
dp[k+1][m+j] += p
res = 0
for i in range(1,n+1):
res += dp[i][i*a]
print(res) | p04013 |
from collections import defaultdict
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = [x - k for x in arr]
arr.sort()
arr_minus = [-x for x in arr if x < 0]
arr_zero = sum(x==0 for x in arr)
arr_plus = [x for x in arr if x > 0]
minus_nums = defaultdict(int)
for i in range(1, 2 ** len(arr_minus)):
bin_minus = "{:050b}".format(i)[::-1]
item = sum(x for idx, x in enumerate(arr_minus) if bin_minus[idx] == "1")
minus_nums[item] += 1
cnt = 0
for i in range(1, 2 ** len(arr_plus)):
bin_plus = "{:050b}".format(i)[::-1]
item = sum(x for idx, x in enumerate(arr_plus) if bin_plus[idx] == "1")
cnt += minus_nums[item]
print(((1 + cnt) * 2 ** arr_zero - 1)) | from collections import defaultdict
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr = [x - k for x in arr]
dct = defaultdict(int)
dct[0] = 1
for x in arr:
for k, v in list(dct.items()):
dct[k + x] += v
print((dct[0] - 1))
| p04013 |
N, A = [int(_) for _ in input().split()]
X = [int(_) - A for _ in input().split()]
dp = [0] * 3000 + [1] + [0] * 3000
for x in X:
dp_old = dp.copy()
for i in range(max(-x, 0), min(6001, 6001 - x)):
dp[i + x] += dp_old[i]
print((dp[3000] - 1))
| N, A = [int(_) for _ in input().split()]
X = [int(_) - A for _ in input().split()]
M = max(X + [A])
dp = [0] * (2 * N * M + 1)
dp[N * M] = 1
for x in X:
dp_old = dp.copy()
for i in range(max(-x, 0), min(2 * N * M + 1, 2 * N * M + 1 - x)):
dp[i + x] += dp_old[i]
print((dp[N * M] - 1))
| p04013 |
N, A = [int(_) for _ in input().split()]
X = [int(_) - A for _ in input().split()]
X_plus = [_ for _ in X if _ > 0]
X_minus = [-_ for _ in X if _ < 0]
l_plus = len(X_plus)
l_minus = len(X_minus)
l_zero = len(X) - l_plus - l_minus
s_plus = sum(X_plus)
s_minus = sum(X_minus)
dp_plus = [1] + [0] * s_plus
dp_minus = [1] + [0] * s_minus
for i in range(l_plus):
dp_plus_old = dp_plus.copy()
for j in range(s_plus + 1 - X_plus[i]):
dp_plus[j + X_plus[i]] += dp_plus_old[j]
for i in range(l_minus):
dp_minus_old = dp_minus.copy()
for j in range(s_minus + 1 - X_minus[i]):
dp_minus[j + X_minus[i]] += dp_minus_old[j]
c_zero = 2 ** l_zero
ans = c_zero - 1
for j in range(1, min(s_plus, s_minus) + 1):
ans += c_zero * dp_plus[j] * dp_minus[j]
print(ans)
| N, A = [int(_) for _ in input().split()]
X = [int(_) - A for _ in input().split()]
X_plus = [_ for _ in X if _ > 0]
X_minus = [-_ for _ in X if _ < 0]
l_zero = len(X) - len(X_plus) - len(X_minus)
s_plus = sum(X_plus)
s_minus = sum(X_minus)
dp_plus = {0: 1}
dp_minus = {0: 1}
for p in X_plus:
dp_plus_old = dp_plus.copy()
for k, v in list(dp_plus_old.items()):
dp_plus[k + p] = dp_plus_old.get(k, 0) + dp_plus_old.get(k + p, 0)
for m in X_minus:
dp_minus_old = dp_minus.copy()
for k, v in list(dp_minus_old.items()):
dp_minus[k + m] = dp_minus_old.get(k, 0) + dp_minus_old.get(k + m, 0)
c_zero = 2 ** l_zero
ans = c_zero - 1
for j in range(1, min(s_plus, s_minus) + 1):
ans += c_zero * dp_plus.get(j, 0) * dp_minus.get(j, 0)
print(ans)
| p04013 |
import collections
import itertools
import functools
@functools.lru_cache(maxsize=100000000)
def sigma(s):
return sum(k * v for k, v in s)
def main():
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
d = collections.defaultdict(int)
d[0] = 1
for c in x:
current = list(d.items())
for diff, count in current:
delta = diff + c - a
d[delta] = d[delta] + count
print((d[0] - 1))
if __name__ == '__main__':
main()
| import collections
def main():
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
d = collections.defaultdict(int)
d[0] = 1
for c in x:
current = list(d.items())
for diff, count in current:
delta = diff + c - a
d[delta] = d[delta] + count
print((d[0] - 1))
if __name__ == '__main__':
main()
| p04013 |
from collections import defaultdict
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [defaultdict(int) for _ in range(n+1)]
dp[0][a] += 1
for i, x_i in enumerate(x):
for p in list(dp[i].keys()):
pk = p + a - x_i
dp[i+1][pk] += dp[i][p]
dp[i+1][p] += dp[i][p]
print((dp[n][a] - 1)) | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
x = [i - a for i in x]
# print(x)
D = {0 : 1}
for i in x:
for j, k in list(D.items()):
D[i+j] = D.get(i+j, 0) + k
# print(D)
print((D[0] - 1))
| p04013 |
N,A = list(map(int,input().split()))
L = list(map(int,input().split()))
#for i in range(N) :
# L[i] -= A
#L = sorted(L)
ans = 0
for bit in range(1 << N) :
calc = 0
ctr = 0
for k in range(N) :
if bit & (1 << k) :
calc += L[k]
ctr += 1
if calc == 0 :
continue
if calc == A*ctr :
ans += 1
print(ans)
| N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
ma = max(X)
dp = [[[0 for s in range(ma*N+1)] for k in range(N+1)] for i in range(N+1)]
dp[0][0][0] = 1
for i in range(1,N+1) :
for k in range(i+1) :
for s in range(ma*N+1) :
if (k >= 1) and (s >= X[i-1]) :
dp[i][k][s] = dp[i-1][k][s] + dp[i-1][k-1][s-X[i-1]]
else :
dp[i][k][s] = dp[i-1][k][s]
ans = 0
for k in range(1,N+1) :
if k*A > ma*N :
break
ans += dp[N][k][k*A]
print(ans)
| p04013 |
iN,iA =[int(x) for x in input().split()]
#aX = [int(x) - iA for x in input().split()]
aX = [int(x) for x in input().split()]
#解法1
#すげーな動的計画法
iMX = max(aX + [iA])
dp = [[[0]*(iN*iMX + 1) for _ in range(iN+1)] for _ in range(iN + 1)]
dp[0][0][0] = 1
for j in range(1,iN+1):
for k in range(0,iN+1):
for s in range(0,iN*iMX + 1):
if s < aX[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif k >= 1 and s >= aX[j-1]:
dp[j][k][s] = dp[j-1][k][s]+dp[j-1][k-1][s- aX[j-1]]
else:
dp[j][k][s] = 0
iRet = 0
for k in range(1,iN+1):
iRet += dp[iN][k][k*iA]
print(iRet)
| iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
#解法2
iMX = max(aX + [iA])
dp = [[0]*(2 * iN*iMX + 1) for _ in range(iN+1)]
for j in range(0,iN+1):
for t in range(0,2*iN*iMX):
if j == 0 and t == iN * iMX :
dp[j][t] = 1
elif j >= 0 and ( t - aX[j-1] < 0 or t - aX[j-1] > 2*iN*iMX):
dp[j][t] = dp[j-1][t]
elif j >= 0 and ( 0 <= t - aX[j-1] <= 2*iN*iMX):
dp[j][t] = dp[j-1][t] + dp[j-1][t-aX[j-1]]
else:
dp[j][t] = 0
print((dp[iN][iN*iMX] -1 ))
| p04013 |
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
#解法2
iMX = max(aX + [iA])
dp = [[0]*(2 * iN*iMX + 1) for _ in range(iN+1)]
for j in range(0,iN+1):
for t in range(0,2*iN*iMX):
if j == 0 and t == iN * iMX :
dp[j][t] = 1
elif j >= 0 and ( t - aX[j-1] < 0 or t - aX[j-1] > 2*iN*iMX):
dp[j][t] = dp[j-1][t]
elif j >= 0 and ( 0 <= t - aX[j-1] <= 2*iN*iMX):
dp[j][t] = dp[j-1][t] + dp[j-1][t-aX[j-1]]
else:
dp[j][t] = 0
print((dp[iN][iN*iMX] -1 ))
| iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
#解法2そのまま
iMX = max(aX + [iA])
iULim = iN*iMX
iULim2 = 2*iULim
#y0..yjから0枚以上選んだ合計をt-iN*iMXにするような選び方の総数
dp = [[0]*(iULim2 + 1) for _ in range(iN+1)]
for j in range(0,iN+1):
for t in range(0,iULim2):
if j == 0 and t == iULim :
dp[j][t] = 1
elif t - aX[j-1] < 0 or t - aX[j-1] > iULim2:
dp[j][t] = dp[j-1][t]
elif 0 <= t - aX[j-1] <= iULim2:
dp[j][t] = dp[j-1][t] + dp[j-1][t-aX[j-1]]
else:
dp[j][t] = 0
print((dp[iN][iN*iMX] -1 ))
| p04013 |
iN,iA =[int(x) for x in input().split()]
#aX = [int(x) - iA for x in input().split()]
aX = [int(x) for x in input().split()]
#解法1
iMX = max(aX + [iA])
dp = [[[0]*(iN*iMX + 1) for _ in range(iN+1)] for _ in range(iN + 1)]
dp[0][0][0] = 1
for j in range(1,iN+1):
# for k in range(0,iN+1):
for k in range(0,j+1):
# for s in range(0,iN*iMX + 1):
for s in range(0,j*iMX + 1):
if s < aX[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif k >= 1 and s >= aX[j-1]:
dp[j][k][s] = dp[j-1][k][s]+dp[j-1][k-1][s- aX[j-1]]
else:
dp[j][k][s] = 0
iRet = 0
for k in range(1,iN+1):
iRet += dp[iN][k][k*iA]
print(iRet)
| #分割してみた。これで通るかな？
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
aPlus = [x for x in aX if 0 < x ]
aMinus = [-1 * x for x in aX if x < 0 ]
iLenPlus = len(aPlus)
iLenMinus = len(aMinus)
iLen0 = iN - iLenPlus - iLenMinus
def fnCr(iN,iR):
if iN - iR < iR :
iR = iN - iR
if iN == 0 :
return 0
elif iR == 0:
return 1
elif iR == 1:
return iN
return iN / iR * fnCr(iN-1,iR-1)
aFr = [1]*(iN+1)
for i in range(1,iN+1):
aFr[i] = aFr[i-1] * i
iCZero = 2**iLen0 - 1 #sum(k=1..N){nCk} = 2^n -1
iRet = 0
iRet += iCZero
iCZero += 1 #0の場合を追加
iSumPlus = sum(aPlus)
iSumMinus = sum(aMinus)
iUlim = min(iSumPlus , iSumMinus)
iOlim = max(iSumPlus , iSumMinus)
if 0 < iUlim:
dp1 = [[0]*(iOlim +1) for _ in range(iLenPlus)]
dp1[0][0] = 1
dp1[0][aPlus[0]]=1
for j in range(1,iLenPlus):
for k in range(iUlim + 1):
if k < aPlus[j] :
dp1[j][k] = dp1[j-1][k]
else:
dp1[j][k] = dp1[j-1][k] + dp1[j-1][k-aPlus[j]]
dp2 = [[0]*(iOlim +1) for _ in range(iLenMinus)]
dp2[0][0] = 1
dp2[0][aMinus[0]]=1
for j in range(1,iLenMinus):
for k in range(iUlim + 1):
if k < aMinus[j] :
dp2[j][k] = dp2[j-1][k]
else:
dp2[j][k] = dp2[j-1][k] + dp2[j-1][k-aMinus[j]]
for i in range(1,iUlim+1):
iRet += iCZero * dp1[-1][i] * dp2[-1][i]
print(iRet)
| p04013 |
#人のすなるCounterなるものを我も書いてみんとてするなり
from collections import Counter
#方針 マイナスとプラスでDPを分割
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
aPlus = [x for x in aX if 0 < x ]
aMinus = [-1 * x for x in aX if x < 0 ]
iLenPlus = len(aPlus)
iLenMinus = len(aMinus)
iLen0 = iN - iLenPlus - iLenMinus
#0の場合はnCkの累積和なので別に計算する
#知ってたわけではなく解析しててみつけた
iCZero = 2**iLen0 - 1 #sum(k=1..N){nCk} = 2^n -1
iRet = 0
iRet += iCZero
iCZero += 1 #0の場合を追加
iUlim = min(sum(aPlus) , sum(aMinus))
if 0 < iUlim:
dp1 = Counter([0,aPlus[0]])
for i in range(1,iLenPlus):
iThisX = aPlus[i]
tmp = {}
for k, v in list(dp1.items()):
tmp[iThisX + k] = v
dp1 += tmp
dp2 = Counter([0,aMinus[0]])
for i in range(1,iLenMinus):
iThisX = aMinus[i]
tmp = {}
for k, v in list(dp2.items()):
tmp[iThisX + k] = v
dp2 += tmp
for i in range(1,iUlim+1):
iRet += iCZero * dp1[i] * dp2[i]
print(iRet)
| def 解():
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
aPlus = [x for x in aX if 0 < x ]
aMinus = [-1 * x for x in aX if x < 0 ]
iLenPlus = len(aPlus)
iLenMinus = len(aMinus)
iLen0 = iN - iLenPlus - iLenMinus
iCZero = 2**iLen0 - 1 #sum(k=1..N){nCk} = 2^n -1
iRet = 0
iRet += iCZero
iCZero += 1 #0の場合を追加
iSumPlus = sum(aPlus)
iSumMinus = sum(aMinus)
iUlim = min(iSumPlus , iSumMinus)
iOlim = max(iSumPlus , iSumMinus)
if 0 < iUlim:
dp1 = [[0]*(iOlim +1) for _ in range(iLenPlus)]
dp1[0][0] = 1
dp1[0][aPlus[0]]=1
for j in range(1,iLenPlus):
for k in range(iUlim + 1):
if k < aPlus[j] :
dp1[j][k] = dp1[j-1][k]
else:
dp1[j][k] = dp1[j-1][k] + dp1[j-1][k-aPlus[j]]
dp2 = [[0]*(iOlim +1) for _ in range(iLenMinus)]
dp2[0][0] = 1
dp2[0][aMinus[0]]=1
for j in range(1,iLenMinus):
for k in range(iUlim + 1):
if k < aMinus[j] :
dp2[j][k] = dp2[j-1][k]
else:
dp2[j][k] = dp2[j-1][k] + dp2[j-1][k-aMinus[j]]
for i in range(1,iUlim+1):
iRet += iCZero * dp1[-1][i] * dp2[-1][i]
print(iRet)
解()
| p04013 |
def 解():
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
aPlus = [x for x in aX if 0 < x ]
aMinus = [-1 * x for x in aX if x < 0 ]
iLenPlus = len(aPlus)
iLenMinus = len(aMinus)
iLen0 = iN - iLenPlus - iLenMinus
iCZero = 2**iLen0 - 1 #sum(k=1..N){nCk} = 2^n -1
iRet = 0
iRet += iCZero
iCZero += 1 #0の場合を追加
iSumPlus = sum(aPlus)
iSumMinus = sum(aMinus)
iUlim = min(iSumPlus , iSumMinus)
iOlim = max(iSumPlus , iSumMinus)
if 0 < iUlim:
dp1 = [[0]*(iOlim +1) for _ in range(iLenPlus)]
dp1[0][0] = 1
dp1[0][aPlus[0]]=1
for j in range(1,iLenPlus):
for k in range(iUlim + 1):
if k < aPlus[j] :
dp1[j][k] = dp1[j-1][k]
else:
dp1[j][k] = dp1[j-1][k] + dp1[j-1][k-aPlus[j]]
dp2 = [[0]*(iOlim +1) for _ in range(iLenMinus)]
dp2[0][0] = 1
dp2[0][aMinus[0]]=1
for j in range(1,iLenMinus):
for k in range(iUlim + 1):
if k < aMinus[j] :
dp2[j][k] = dp2[j-1][k]
else:
dp2[j][k] = dp2[j-1][k] + dp2[j-1][k-aMinus[j]]
for i in range(1,iUlim+1):
iRet += iCZero * dp1[-1][i] * dp2[-1][i]
print(iRet)
解()
| #正負で分割
#dpの作り方はARCの方の人のロジックを参考にした。
#こんなんでええんや...
def 解():
iN,iA =[int(x) for x in input().split()]
aX = [int(x) - iA for x in input().split()]
aPlus = [x for x in aX if 0 < x ]
aMinus = [-1 * x for x in aX if x < 0 ]
iLenPlus = len(aPlus)
iLenMinus = len(aMinus)
iLen0 = iN - iLenPlus - iLenMinus
iCZero = 2**iLen0 - 1 #sum(k=1..N){nCk} = 2^n -1
iRet = 0
iRet += iCZero
iCZero += 1 #0の場合を追加
iUlim = min(sum(aPlus) , sum(aMinus))
if 0 < iUlim:
dp1 = {0:1}
for iX in aPlus:
for k,v in list(dp1.copy().items()):
dp1[k+iX] = dp1.get(k+iX,0)+v
dp2 = {0:1}
for iX in aMinus:
for k,v in list(dp2.copy().items()):
dp2[k+iX] = dp2.get(k+iX,0)+v
for i in range(1,iUlim+1):
if i in dp1 and i in dp2:
iRet += iCZero * dp1[i] * dp2[i]
print(iRet)
解()
| p04013 |
# C - 高橋君とカード / Tak and Cards
#import numpy as np
import math
N, A = list(map(int, input().split()))
#x = np.array(list(map(int, input().split())))
x = list(map(int, input().split()))
# 数列aと整数Aを与えると、aからいくつか取って合計Aにするパターンが何通りあるかを返す関数
def partial_sum(a,A):
n = len(a)
dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数
dp[0][0] = 1
for i in range(n):
for j in range(A+1):
if j >= a[i]:
dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]
else:
dp[i+1][j] = dp[i][j]
return dp[n][A]
#x_diff = x - np.array(A) # ここから合計0になるように取る。負の数列についてpartial_sumが動かないことに注意
x_diff = [a - A for a in x]
x_diff_negative = [-a for a in x_diff if a < 0]
x_diff_positive = [a for a in x_diff if a > 0]
ans = 0
for i in range(1, sum(x)):
ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)
# 0の選び方
n_pattern_0 = 0
#n_0 = np.count_nonzero(x_diff == 0)
n_0 = x_diff.count(0)
if n_0 > 0:
for i in range(1, n_0+1):
n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))
# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある
# 0単体で選ぶ方法もある
ans += (ans+1) * n_pattern_0
print(ans) | # C - 高橋君とカード / Tak and Cards
#import numpy as np
import math
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
# 数列aと整数Aを与えると、aからいくつか取って合計Aにするパターンが何通りあるかを返す関数
def partial_sum(a,A):
n = len(a)
dp = [[0]*(A+2) for _ in range(n+2)] # dp[i+1][j] a[i]までの数からいくつか選んで総和をjにするパターンの数
dp[0][0] = 1
for i in range(n):
for j in range(A+1):
if j >= a[i]:
dp[i+1][j] = dp[i][j-a[i]] + dp[i][j]
else:
dp[i+1][j] = dp[i][j]
return dp[n][A]
x_diff = [a - A for a in x] # ここから合計0になるように取る。負の数列についてpartial_sumが動かないことに注意
x_diff_negative = [-a for a in x_diff if a < 0]
x_diff_positive = [a for a in x_diff if a > 0]
ans = 0
for i in range(1, min(sum(x_diff_negative), sum(x_diff_positive)) + 1):
ans += partial_sum(x_diff_negative,i) * partial_sum(x_diff_positive,i)
# 0の選び方
n_pattern_0 = 0
n_0 = x_diff.count(0)
if n_0 > 0:
for i in range(1, n_0+1):
n_pattern_0 += math.factorial(n_0) // (math.factorial(n_0-i) * math.factorial(i))
# ここまで数えた全てのパターンそれぞれについて、x_diff中の0をいくつか含めた別パターンがある
# 0単体で選ぶ方法もある
ans += (ans+1) * n_pattern_0
print(ans) | p04013 |
import sys
input = sys.stdin.readline
def main():
n, a = list(map(int, input().split()))
x = tuple(map(int, input().split()))
sm_mx = sum(x)
dp = [[[0] * (sm_mx + 1) for i in range(n + 1)] for j in range(n + 1)]
dp[0][0][0] = 1
for i, e in enumerate(x, 1):
for j in range(n + 1):
for sm in range(sm_mx + 1):
if sm < e:
dp[i][j][sm] = dp[i-1][j][sm]
elif j >= 1 and sm >= e:
dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]
ans = 0
for i in range(1, n + 1):
if i > sm_mx / a:
break
ans += dp[n][i][i*a]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
n, a = list(map(int, input().split()))
x = tuple(map(int, input().split()))
sm_mx = sum(x)
dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i, e in enumerate(x, 1):
for j in range(n + 1):
for sm in range(sum(x[:i]) + 1):
if sm < e:
dp[i][j][sm] = dp[i-1][j][sm]
elif j >= 1 and sm >= e:
dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]
ans = 0
for i in range(1, n + 1):
if i > sm_mx / a:
break
ans += dp[n][i][i*a]
print(ans)
if __name__ == "__main__":
main()
| p04013 |
import sys
input = sys.stdin.readline
def main():
n, a = list(map(int, input().split()))
x = tuple(map(int, input().split()))
sm_mx = sum(x)
dp = [[[0] * (sm_mx + 1) for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i, e in enumerate(x, 1):
for j in range(n + 1):
for sm in range(sum(x[:i]) + 1):
if sm < e:
dp[i][j][sm] = dp[i-1][j][sm]
elif j >= 1 and sm >= e:
dp[i][j][sm] = dp[i-1][j][sm] + dp[i-1][j-1][sm-e]
ans = 0
for i in range(1, n + 1):
if i > sm_mx / a:
break
ans += dp[n][i][i*a]
print(ans)
if __name__ == "__main__":
main()
| def main():
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
mx = max(x + [a])
for i in range(n):
x[i] -= a
sm = 2 * n * mx
dp = [[0] * (sm + 1) for _ in range(n + 1)]
dp[0][n*mx] = 1
for i, e in enumerate(x, 1):
for j in range(sm + 1):
if 0 <= j - e <= sm:
dp[i][j] = dp[i-1][j] + dp[i-1][j-e]
else:
dp[i][j] = dp[i-1][j]
ans = dp[n][n*mx] - 1
print(ans)
if __name__ == "__main__":
main()
| p04013 |
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
x = list([y-a for y in x])
ans = -1
for i in range(2**n):
tmp = 0
for j in range(n):
if (i >> j) & 1:
tmp += x[j]
if tmp == 0:
ans += 1
print(ans) | n,a = list(map(int,input().split()))
x = sorted(list([int(y)-a for y in input().split()]))
sx = max(abs(x[0]),abs(x[-1]))*n
dp = [[0 for _ in range(2*sx+2)] for _ in range(n+1)]
dp[0][0] = 1
for j in range(n):
for t in range(-sx-1,sx+1):
if -sx <= t-x[j] and t-x[j] <= sx:
dp[j+1][t] = dp[j][t] + dp[j][t-x[j]]
else:
dp[j+1][t] = dp[j][t]
print((dp[n][0]-1)) | p04013 |
N,A = (int(T) for T in input().split())
X = [int(T) for T in input().split()]
DP = [[[0]*(N+1) for TS in range(0,50*N+1)] for TI in range(0,N+1)]
DP[0][0][0] = 1
for TI in range(0,N):
for TS in range(0,50*N+1):
for TK in range(0,N+1):
if DP[TI][TS][TK]!=0:
DP[TI+1][TS][TK] += DP[TI][TS][TK]
DP[TI+1][TS+X[TI]][TK+1] += DP[TI][TS][TK]
print((sum(DP[N][A*TA][TA] for TA in range(1,N+1)))) | N,A = (int(T) for T in input().split())
X = [int(T)-A for T in input().split()]
DP = [[0]*(2*(50*N)+1) for TI in range(0,N+1)]
DP[0][50*N] = 1
for TI in range(0,N):
for TS in range(0,2*50*N+1):
if DP[TI][TS]!=0:
DP[TI+1][TS] += DP[TI][TS]
DP[TI+1][TS+X[TI]] += DP[TI][TS]
print((DP[N][50*N]-1)) | p04013 |
import sys
input=sys.stdin.readline
n,a=list(map(int,input().split()))
x=[0]+list(map(int,input().split()))
su=sum(x)
dp=[[[0 for k in range(su+1)] for j in range(51)] for i in range(51)]
dp[0][0][0]=1
for i in range(1,n+1):
for j in range(i+1):
for k in range(su+1):
if k<x[i]:
dp[i][j][k]=dp[i-1][j][k]
if k>=x[i] and j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]
ans=0
for t in range(1,n+1):
if a*t<=su:
ans+=dp[n][t][a*t]
else:
break
print(ans)
| import sys
input=sys.stdin.readline
n,a=list(map(int,input().split()))
x=[0]+list(map(int,input().split()))
su=sum(x)
maxi=max(x)
dp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]
dp[0][0][0]=1
for i in range(1,n+1):
for j in range(i+1):
for k in range(maxi*j+1):
if k<x[i]:
dp[i][j][k]=dp[i-1][j][k]
if k>=x[i] and j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]
ans=0
for t in range(1,n+1):
if a*t<=su:
ans+=dp[n][t][a*t]
else:
break
print(ans)
| p04013 |
import sys
input=sys.stdin.readline
n,a=list(map(int,input().split()))
x=[0]+list(map(int,input().split()))
su=sum(x)
maxi=max(x)
dp=[[[0 for k in range(maxi*n+1)] for j in range(51)] for i in range(51)]
dp[0][0][0]=1
for i in range(1,n+1):
for j in range(i+1):
for k in range(maxi*j+1):
if k<x[i]:
dp[i][j][k]=dp[i-1][j][k]
if k>=x[i] and j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i]]
ans=0
for t in range(1,n+1):
if a*t<=su:
ans+=dp[n][t][a*t]
else:
break
print(ans)
| from collections import Counter
n,a=list(map(int,input().split()))
X=sorted(list([int(x)-a for x in input().split()]))
ans=Counter([0])
for x in X:
tmp=Counter()
for i,j in list(ans.items()):
tmp[i+x]+=j
ans+=tmp
print((ans[0]-1))
| p04013 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
M = sum(X)
dp = [[0] * (M + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, 0, -1):
for k in range(X[i], M + 1):
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
if A * j > M:
break
ans += dp[j][A * j]
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
M = sum(X)
dp = [[0] * (M + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, 0, -1):
for k in range(X[i], M + 1):
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, min(N, M // A) + 1):
ans += dp[j][A * j]
print(ans)
return
if __name__ == '__main__':
main()
| p04013 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
X = [x - A for x in X]
base = 2500
dp = [[0] * 5001 for _ in range(N + 1)]
dp[0][base] = 1
for i in range(N):
for s in range(5001):
dp[i + 1][s] = dp[i][s]
if 0 <= s - X[i] <= 5000:
dp[i + 1][s] += dp[i][s - X[i]]
print((dp[N][base] - 1))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
X = [x - A for x in X]
neg = pos = 0
for x in X:
if x > 0:
pos += x
else:
neg += x
M = pos - neg
base = -neg
dp = [[0] * (M + 1) for _ in range(N + 1)]
dp[0][base] = 1
for i in range(N):
for s in range(M + 1):
dp[i + 1][s] = dp[i][s]
if 0 <= s - X[i] <= M:
dp[i + 1][s] += dp[i][s - X[i]]
print((dp[N][base] - 1))
return
if __name__ == '__main__':
main()
| p04013 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
X = [x - A for x in X]
base = 2500
dp = [[0] * 5001 for _ in range(N + 1)]
dp[0][base] = 1
for i in range(N):
for j in range(-2500, 2501):
if -2500 <= j - X[i] <= 2500:
dp[i + 1][j + base] = dp[i][j + base] + dp[i][j - X[i] + base]
else:
dp[i + 1][j + base] = dp[i][j + base]
print((dp[N][base] - 1))
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, A, *X = list(map(int, read().split()))
X = [x - A for x in X]
base = 2500
dp = [0] * 5001
dp[base] = 1
for i in range(N):
dp, dp_prev = dp[:], dp
for j in range(5001):
if 0 <= j - X[i] <= 5000:
dp[j] += dp_prev[j - X[i]]
print((dp[base] - 1))
return
if __name__ == '__main__':
main()
| p04013 |
import sys
readline = sys.stdin.readline
from collections import Counter
def main():
N, A = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
X = [x-A for x in X]
ans = 0
X1 = X[:N//2]
X2 = X[N//2:]
X1_sum = [0]
for i in range(1, 2**len(X1)):
b = bin(i)[2:].zfill(len(X1))
su = sum([X1[i] for i, e in enumerate(b) if e == '1'])
X1_sum.append(su)
X2_sum = [0]
for i in range(1, 2**len(X2)):
b = bin(i)[2:].zfill(len(X2))
su = sum([X2[i] for i, e in enumerate(b) if e == '1'])
X2_sum.append(su)
c = Counter(X2_sum)
c_keys = list(c.keys())
for x1 in X1_sum:
if -x1 in c_keys:
ans += c[-x1]
print((ans - 1))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
def main():
N, A = list(map(int, readline().rstrip().split()))
X = list(map(int, readline().rstrip().split()))
lim = max(X) * N
X = [x-A for x in X]
dp = [[0]*(2*lim) for _ in range(N+1)]
dp[0][lim] = 1
for i in range(1, N+1):
x = X[i-1]
for j in range(2*lim):
if 0 <= j - x < 2 * lim:
dp[i][j] = dp[i-1][j] + dp[i-1][j-x]
else:
dp[i][j] = dp[i-1][j]
print((dp[N][lim] - 1))
if __name__ == '__main__':
main() | p04013 |
# 配るDP
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[[0 for _ in range(3010)] for __ in range(N+1)] for ___ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(2500+1):
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for n in range(1, N+1):
ans += dp[N][n][n*A]
print(ans)
| # 配るDP
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[[0 for _ in range(3010)] for __ in range(N+1)] for ___ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(N):
for k in range(2500+1):
if dp[i][j][k]:
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for n in range(1, N+1):
ans += dp[N][n][n*A]
print(ans)
| p04013 |
N, A = list(map(int, input().split()))
lst = [int(x) for x in input().split()]
ret = 0
for i in range(2 ** N):
n = 0
cnt = 0
for j in range(N):
if i >> j & 1:
n += lst[j]
cnt += 1
if cnt > 0 and n / cnt == A:
ret += 1
print(ret)
| N, A = list(map(int, input().split()))
lst = [int(x) - A for x in input().split()]
dp = [[0] * (100 * N + 1) for _ in range(N + 1)]
dp[0][50 * N] = 1
for i in range(N):
for j in range(50, 100 * N + 1 - 50):
dp[i + 1][j] = dp[i][j] + dp[i][j - lst[i]]
print((dp[N][50 * N] - 1))
| p04013 |
NMAX = 55
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[[0] * NMAX for s in range(3000)] for i in range(NMAX)]
dp[0][0][0] = 1 # dp[i][s][k]: i個からk個選ぶとき、総和がsのものの個数
for i in range(N): # N-1時点でNが更新されるのでここまでで十分
for s in range(3000):
for k in range(N+1):
if dp[i][s][k] == 0:
continue
dp[i+1][s][k] += dp[i][s][k]
dp[i+1][s+X[i]][k+1] += dp[i][s][k]
ans = 0
for k in range(1, N+1):
ans += dp[N][A*k][k]
print(ans)
|
NMAX = 55
T = 2500
N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
dp = [[0]*5001 for i in range(NMAX)] # i時点で総和がSになるものの個数
dp[0][T] = 1
for i in range(N):
for s in range(5001):
if s+X[i] > 5001 or dp[i][s] == 0:
continue
dp[i+1][s] += dp[i][s]
dp[i+1][s+X[i]] += dp[i][s]
print((dp[N][T]-1))
| p04013 |
while True:
things = {}
count = eval(input())
if count == 0: break
for i in range(count):
fuga = input().split()
things[fuga[0]] = int(fuga[1])
for i in range(eval(input())):
fuga = input().split()
money =0
for j in range(int(fuga[1])):
hoge = things[fuga[j+2]] if fuga[j+2] in things else 0
money+= hoge
things[fuga[0]] = things[fuga[0]] if money > things[fuga[0]] else money
ans = input()
fin = things[ans] if ans in things else 0
print(fin) | while True:
things = {}
count = eval(input())
if count == 0: break
for i in range(count):
fuga = input().split()
things[fuga[0]] = int(fuga[1])
for i in range(eval(input())):
fuga = input().split()
money =0
for j in range(int(fuga[1])):
hoge = things[fuga[j+2]] if fuga[j+2] in things else 0
money+= hoge
things[fuga[0]] = things[fuga[0]] if money > things[fuga[0]] else money
ans = input()
print("%s"%(things[ans] if ans in things else "0")) | p00201 |
n,a,b,k=list(map(int,input().split()))
p=998244353
def getinv(n):
inv=[0]*(n+1)
for i in range(1,n+1):
inv[i]=pow(i,p-2,p)
return inv
def getnCr(n):
inv=getinv(n)
nCr=[0]*(n+1)
nCr[0]=1
for i in range(1,n+1):
nCr[i]=(nCr[i-1]*(n-i+1)*inv[i])%p
return nCr
def solve(n,a,b,k):
ans=0
nCr=getnCr(n)
for i in range(n+1):
if (k-a*i)<0 or (k-a*i)%b!=0:
continue
j=(k-a*i)//b
if a*i+b*j==k and 0<=j<=n:
ans+= nCr[i]*nCr[j]
ans%=p
return ans
print((solve(n,a,b,k))) | p=998244353
def getinv(n):
inv = [0]*(n+1)
#フェルマーの小定理より、i=1の時は1であることが分かる
inv[1] = 1
for i in range(2,n+1):
#そのまま計算すると負になってしまうので、最後にmod pを取ることで正に戻す
inv[i] = (-(p//i)*inv[p%i])%p
return inv
def getCmb(n):
#逆元を取得
inv = getinv(n)
#0 <= r <= n に対してnCrを求める
nCr = [0]*(n+1)
#r=0の時は、r-1が存在しないので与えておく
nCr[0] = 1
for i in range(1,n+1):
#iで割る代わりにinv[i]をかけ、mod pを求める
nCr[i] = (nCr[i-1]*(n-i+1)*inv[i])%p
return nCr
def solve(n,a,b,k):
nCr = getCmb(n)
ans=0
for i in range(n+1):
#割り切れない時もあるが、その時は次の条件a*i+b*j==kで弾かれるので問題ない
j = (k-a*i)//b
#条件に一致するものを選ぶ。jの範囲に注意
if a*i + b*j == k and 0<=j<=n:
ans+= (nCr[i]*nCr[j])%p
ans%= p
return ans
n,a,b,k=list(map(int,input().split()))
print((solve(n,a,b,k))) | p03332 |
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 16 15:50:39 2019
@author: Yamazaki Kenichi
"""
N,A,B,K = list(map(int,input().split()))
mod = 998244353
T = []
R = K//A
for i in range(R+1):
if i == 0:
if K%B == 0 and K//B <= N:
T.append([0,0,K//B,N-K%B])
continue
if (K - (A*i)) % B == 0:
r = i
b = (K - (A*i)) // B
g = min(r,b)
r,b = r-g, b-g
while r+g+b <=N and g>=0:
T.append([r,g,b,N-(r+g+b)])
r,g,b = r+1,g-1,b+1
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
ans = 0
for c in T:
ans += g1[N]*g2[c[0]]*g2[c[1]]*g2[c[2]]*g2[c[3]]%mod
print((ans%mod))
| # -*- coding: utf-8 -*-
"""
Created on Sat Mar 16 18:32:20 2019
@author: Yamazaki Kenichi
"""
N,A,B,K = list(map(int,input().split()))
mod = 998244353
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
def a(r,g,b):
return g1[N]*g2[r]*g2[g]*g2[b]*g2[N-r-g-b]%mod
ans = 0
R = K//A
for i in range(R+1):
if i == 0:
if K%B == 0 and K//B <= N:
ans += a(0,0,K//B)
continue
if (K - (A*i)) % B == 0:
r = i
b = (K - (A*i)) // B
g = min(r,b)
r,b = r-g, b-g
while r+g+b <=N and g>=0:
ans += a(r,g,b)
r,g,b = r+1,g-1,b+1
print((ans%mod))
| p03332 |
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 16 18:32:20 2019
@author: Yamazaki Kenichi
"""
N,A,B,K = list(map(int,input().split()))
mod = 998244353
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
def a(r,g,b):
return g1[N]*g2[r]*g2[g]*g2[b]*g2[N-r-g-b]%mod
ans = 0
R = K//A
for i in range(R+1):
if i == 0:
if K%B == 0 and K//B <= N:
ans += a(0,0,K//B)
continue
if (K - (A*i)) % B == 0:
r = i
b = (K - (A*i)) // B
g = min(r,b)
r,b = r-g, b-g
while r+g+b <=N and g>=0:
ans += a(r,g,b)
r,g,b = r+1,g-1,b+1
print((ans%mod))
| # -*- coding: utf-8 -*-
"""
Created on Sat Mar 16 18:40:19 2019
@author: Yamazaki Kenichi
"""
N,A,B,K = list(map(int,input().split()))
mod = 998244353
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
g1 = [1, 1] # 元テーブル
g2 = [1, 1] # 逆元テーブル
inv = [0, 1] # 逆元テーブル計算用テーブル
for i in range(2, N+1):
g1.append((g1[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod//i)) % mod)
g2.append((g2[-1] * inv[-1]) % mod)
def a(r,b):
return cmb(N,r,mod)*cmb(N,b,mod)
ans = 0
R = K//A
for i in range(R+1):
if (K-A*i)%B == 0:
ans += a(i,(K-A*i)//B) % mod
print((ans%mod)) | p03332 |
N, A, B, K = list(map(int, input().split()))
maxAB = max(A, B)
minAB = min(A, B)
ans = 0
def cmb(n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
mod = 998244353 # 問題によって変える、ここは素数でないとうまく動かない
N_cmb = 0
N_cmb += N # 入力の制約によって変えるところ、nCrの計算で欲しいnの最大値
fac = [1, 1] # 階乗テーブル
finv = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for ZZZ in range(2, N_cmb + 1):
fac.append((fac[-1] * ZZZ) % mod)
inverse.append(mod-inverse[mod % ZZZ]*(mod//ZZZ) % mod)
finv.append((finv[-1] * inverse[-1]) % mod)
for i in range(N+1):
j = (K - maxAB * i) // minAB
if (K - maxAB * i) % minAB == 0 and 0 <= j <= N:
#print(i, j)
for h in range(min(i, j)+1):
if i + j - h <= N:
#print(cmb(N, h), cmb(N - h, i - h), cmb(N - i, j - h))
ans += ((cmb(N, h) * cmb(N - h, i - h)) %
mod) * cmb(N - i, j - h)
ans %= mod
print(ans)
| N, A, B, K = list(map(int, input().split()))
maxAB = max(A, B)
minAB = min(A, B)
ans = 0
def cmb(n, r):
if (r < 0 or r > n):
return 0
r = min(r, n-r)
return fac[n] * finv[r] * finv[n-r] % mod
mod = 998244353 # 問題によって変える、ここは素数でないとうまく動かない
N_cmb = 0
N_cmb += N # 入力の制約によって変えるところ、nCrの計算で欲しいnの最大値
fac = [1, 1] # 階乗テーブル
finv = [1, 1] # 逆元テーブル
inverse = [0, 1] # 逆元テーブル計算用テーブル
for ZZZ in range(2, N_cmb + 1):
fac.append((fac[-1] * ZZZ) % mod)
inverse.append(mod-inverse[mod % ZZZ]*(mod//ZZZ) % mod)
finv.append((finv[-1] * inverse[-1]) % mod)
for i in range(min(N+1, K//maxAB+1)):
j = (K - maxAB * i) // minAB
if (K - maxAB * i) % minAB == 0 and 0 <= j <= N:
#print(i, j)
ans += cmb(N, i) * cmb(N, j) % mod
ans %= mod
print(ans)
| p03332 |
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 998244353
def ddprint(x):
if DBG:
print(x)
def modinv2(x,r):
return pow(x,r-2,r)
def comb(n,a,R):
return (fact[n]*modinv2(fact[n-a]*fact[a],R))
def factinit(n,R):
global fact
fact = [1]*(n+1)
for i in range(2,n+1):
fact[i] = (fact[i-1]*i)%R
n,a,b,k = inm()
sm = 0
factinit(n,R)
for pq in range(n+1):
if (k-a*pq)%b>0:
continue
qr = (k-a*pq)//b
if qr>n:
continue
q1 = max(0,pq+qr-n)
q2 = min(pq,qr)
for q in range(q1,q2+1):
p = pq-q
r = qr-q
s = n-p-q-r
sor = ((fact[p]*fact[q]%R)*(fact[r]*fact[s]%R))%R
sm = (sm+fact[n]*modinv2(sor,R))%R
print(sm)
| #from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 998244353
def ddprint(x):
if DBG:
print(x)
def modinv2(x,r):
return pow(x,r-2,r)
def comb(n,a,R):
return (fact[n]*modinv2(fact[n-a]*fact[a],R))
def factinit(n,R):
global fact
fact = [1]*(n+1)
for i in range(2,n+1):
fact[i] = (fact[i-1]*i)%R
n,a,b,k = inm()
sm = 0
factinit(n,R)
for pq in range(n+1):
if k<a*pq or (k-a*pq)%b>0:
continue
qr = (k-a*pq)//b
if qr>n:
continue
sm = (sm+comb(n,pq,R)*comb(n,qr,R))%R
print(sm)
| p03332 |
MOD = 998244353
MAX = int(3e5 + 1)
def div(a, b):
return a * pow(b, MOD-2, MOD) % MOD
FACT = [1] * (MAX+1)
for i in range(1, MAX+1):
FACT[i] = (i * FACT[i-1]) % MOD
INV = [1] * (MAX+1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i-1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N+1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N-x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N-y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| MOD = 998244353
MAX = int(3e5 + 10)
def div(a, b):
return a * pow(b, MOD-2, MOD) % MOD
FACT = [1] * (MAX+1)
for i in range(1, MAX+1):
FACT[i] = (i * FACT[i-1]) % MOD
INV = [1] * (MAX+1)
INV[MAX] = div(1, FACT[MAX])
for i in range(MAX, 0, -1):
INV[i-1] = (INV[i] * i) % MOD
def main():
N, A, B, K = list(map(int, input().split()))
ans = 0
# solve Ax + By = K
for x in range(N+1):
By = K - x * A
if By >= 0 and By % B == 0 and By <= B * N:
y = By // B
tmp1 = FACT[N] * INV[x] * INV[N-x] % MOD
tmp2 = FACT[N] * INV[y] * INV[N-y] % MOD
ans = (ans + tmp1 * tmp2) % MOD
print(ans)
if __name__ == "__main__":
main()
| p03332 |
import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().rstrip().split()))
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
# template
# BEGIN CUT HERE
# MOD = 10**9 + 7
MOD = 998244353 # AGC025_B
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int): Modintの初期値
MOD=10**9+7 (int): 余りを計算するMOD。素数である必要がある。
'''
def __init__(self, n, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n, self.mod)
def __str__(self):
return str(self.n)
def __int__(self):
return int(self.n)
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return pow(self.n, self.mod - 2, self.mod)
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __add__(self, other):
self += other
return self
def __sub__(self, other):
self -= other
return self
def __mul__(self, other):
self *= other
return self
def __floordiv__(self, other):
self //= other
return self
def comb(self, n: int, k: int):
'''
コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
'''
if n < k or k < 0:
return Modint(0)
res = Modint(1)
for i in range(int(k)):
res *= Modint(n - i)
res //= Modint(i + 1)
return res
def H(self, n: int, k: int):
if n < 0 or k < 0:
return Modint(0)
elif n == 0 and k == 0:
return Modint(1)
else:
return self.comb(n + k - 1, n)
class Combination():
def __init__(self, sz):
'''
前処理にO(N)，それぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [0] * (sz + 1)
self._rfact = [0] * (sz + 1)
self._fact[0] = 1
self._rfact[sz] = 1
for i in range(1, sz + 1):
self._fact[i] = int(self._fact[i - 1] * Modint(i))
self._rfact[sz] = Modint(self._fact[sz]).inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = int(self._rfact[i + 1] * Modint(i + 1))
def fact(self, k: int) -> int:
return self._fact[k]
def rfact(self, k: int) -> int:
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int): nPkのn(0<=n<=N)
k (int): nPkのk（0<=k<=n）
Returns
----------
Modint: nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return 0
return Modint(self._fact[n] * self._rfact[n - k])
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int): nCkのn(0<=n<=N)
k (int): nCkのk（0<=k<=n）
Returns
----------
Modint: nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return 0
return Modint(self._fact[n] * self._rfact[k] * self._rfact[n - k])
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int): nHkのn(0<=n<=N)
k (int): nHkのk（0<=k<=n）
Returns
----------
Modint: nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return 0
elif k == 0:
return 1
return self.C(n + k - 1, n)
# END CUT HERE
def ABC132_D():
N, K = mi()
res = Combination(N)
for i in range(1, K + 1):
print((res.C(K - 1, i - 1) * res.H(N - K - i + 1, i + 1)))
# verified on 2019/07/01
# https://atcoder.jp/contests/abc132/tasks/abc132_d
# Python3: 32ms https://atcoder.jp/contests/abc132/submissions/6200580
def AGC025_B():
N, A, B, K = mi()
res = Combination(N)
ans = Modint(0)
for a in range(K // A + 1):
b = (K - a * A) // B
if A * a + B * b == K and a >= 0 and b >= 0:
ans += res.C(N, a) * res.C(N, b)
print(ans)
# verified on 2019/07/01
# https://atcoder.jp/contests/agc025/tasks/agc025_b
# Python3:
if __name__ == '__main__':
# ABC132_D()
AGC025_B()
| import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(eval(input()))
def mi(): return list(map(int, input().rstrip().split()))
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
# template
# BEGIN CUT HERE
# MOD = 10**9 + 7
MOD = 998244353 # AGC025_B
class Modint():
'''
自動でMODで割った余りを計算してくれる整数。MODは素数である必要があり，デフォルトは10**9+7。
Parameters
----------
n (int): Modintの初期値
MOD=10**9+7 (int): 余りを計算するMOD。素数である必要がある。
'''
def __init__(self, n, mod=MOD):
if n >= 0:
self.n = n % mod
else:
self.n = (mod - (-n) % mod) % mod
self.mod = mod
def __eq__(self, other):
return self.n == int(other)
def __ne__(self, other):
return not self == other
def __neg__(self):
return self.__class__(-self.n, self.mod)
def __str__(self):
return str(self.n)
def __int__(self):
return int(self.n)
def __iadd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __radd__(self, other):
self.n += int(other)
self.n %= self.mod
return self
def __isub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __rsub__(self, other):
self.n -= int(other)
self.n %= self.mod
return self
def __imul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def __rmul__(self, other):
self.n = self.n * int(other) % self.mod
return self
def inverse(self):
'''
フェルマーの小定理を考えると，MOD-2乗することでMODでの逆元を求めることができる。これは組み込み関数のpowを使うと十分に早い（O(log MOD)）。
'''
return pow(self.n, self.mod - 2, self.mod)
def __ifloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __rfloordiv__(self, other):
self *= pow(int(other), self.mod - 2, self.mod)
return self
def __add__(self, other):
self += other
return self
def __sub__(self, other):
self -= other
return self
def __mul__(self, other):
self *= other
return self
def __floordiv__(self, other):
self //= other
return self
# def comb(self, n: int, k: int):
# '''
# コンビネーション絡みの定義。comb(n,k):特に前処理をせずnCkを求める
# 毎回O(N)かかるので死ぬ覚悟でO(N^2)を投げるくらいしか無理
# ちなみにですが，これでABC132_D()を出すとPyPy3で1932msくらいですれすれセーフ
# '''
# if n < k or k < 0:
# return Modint(0)
# res = Modint(1)
# for i in range(int(k)):
# res *= Modint(n - i)
# res //= Modint(i + 1)
# return res
# def H(self, n: int, k: int):
# if n < 0 or k < 0:
# return Modint(0)
# elif n == 0 and k == 0:
# return Modint(1)
# else:
# return self.comb(n + k - 1, n)
class Combination():
def __init__(self, sz):
'''
Nまでの階乗とその逆元（割り算用）を計算しておく。前処理にO(N)，P, C, Hそれぞれの計算はO(1)。N = 200000なら割と余裕で通る。
'''
self._fact = [0] * (sz + 1)
self._rfact = [0] * (sz + 1)
self._fact[0] = 1
self._rfact[sz] = 1
for i in range(1, sz + 1):
self._fact[i] = int(self._fact[i - 1] * Modint(i))
self._rfact[sz] = Modint(self._fact[sz]).inverse()
for i in range(sz - 1, -1, -1):
self._rfact[i] = int(self._rfact[i + 1] * Modint(i + 1))
def fact(self, k: int) -> int:
return self._fact[k]
def rfact(self, k: int) -> int:
return self._rfact[k]
def P(self, n: int, k: int) -> Modint:
'''
nPkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int): nPkのn (0<=n<=N)
k (int): nPkのk （0<=k<=n）
Returns
----------
Modint: nPkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return 0
return Modint(self._fact[n] * self._rfact[n - k])
def C(self, n: int, k: int) -> Modint:
'''
nCkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
Parameters
----------
n (int): nCkのn(0<=n<=N)
k (int): nCkのk（0<=k<=n）
Returns
----------
Modint: nCkをModint型で返す。Modintに依存。
'''
if k < 0 or n < k:
return 0
return Modint(self._fact[n] * self._rfact[k] * self._rfact[n - k])
def H(self, n: int, k: int) -> Modint:
'''
nHkの値を返す。nはあらかじめ前処理されたN以下でないとダメ
ちなみにnHkはn個の区別できないものをk個の箱に分けるパターンの数で，結局n+k-1Cnになる。
Parameters
----------
n (int): nHkのn(0<=n<=N)
k (int): nHkのk（0<=k<=n）
Returns
----------
Modint: nHkをModint型で返す。Modintに依存。
'''
if n < 0 or k < 0:
return 0
elif k == 0:
return 1
return self.C(n + k - 1, n)
# END CUT HERE
def ABC132_D():
N, K = mi()
res = Combination(N)
for i in range(1, K + 1):
print((res.C(K - 1, i - 1) * res.H(N - K - i + 1, i + 1)))
# verified on 2019/07/01
# https://atcoder.jp/contests/abc132/tasks/abc132_d
# Python3: 32ms https://atcoder.jp/contests/abc132/submissions/6200580
# PyPy3だとオーバヘッドが大きいのか240msくらいかかるけど，基本はPyPyで良いと思う。
def AGC025_B():
N, A, B, K = mi()
res = Combination(N)
ans = Modint(0)
for a in range(min(K // A + 1, N + 1)):
b = (K - a * A) // B
if A * a + B * b == K and a >= 0 and b >= 0:
ans += res.C(N, a) * res.C(N, b)
print(ans)
# verified on 2019/07/01
# https://atcoder.jp/contests/agc025/tasks/agc025_b
# PyPy3: https://atcoder.jp/contests/agc025/submissions/6200598
# Python3だとTLE
if __name__ == '__main__':
# ABC132_D()
AGC025_B()
| p03332 |
def cmb1(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
n, a, b, k = list(map(int, input().split()))
mod = 998244353
ans = 0
for i in range(n+1):
if k - a*i >= 0 and (k - a*i)%b == 0:
j = (k - a*i)//b
ans += cmb1(n, i, mod)*cmb1(n, j, mod)
ans %= mod
print(ans) | n, a, b, k = list(map(int, input().split()))
def cmb1(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
ans = 0
for i in range(n+1):
x = a*i
y = k-x
if y < 0:
continue
if y%b == 0:
j = y//b
ans += cmb1(n, i, mod)*cmb1(n, j, mod)
print((ans%mod))
| p03332 |
N, A, B, K = tuple(map(int, (input().split())))
mod = 998244353
def ab(n):
ab = []
a = n // A
while (n - A * a) % B != 0:
a -= 1
b = (n - A * a) // B
ab.append((a, b))
while a > 0:
a, b = a - B // gcd(A, B), b + A // gcd(A, B)
if a < 0:
break
ab.append((a, b))
return ab
def gcd(a, b):
if a < b:
a, b = b, a
if a % b == 0:
return b
return gcd(b, a - b * (a // b))
def mpow(x, n):
ans = 1
while n != 0:
if n & 1:
ans = ans * x % mod
x = x * x % mod
n = n >> 1
return ans
factorial = [1 for i in range(N + 1)]
inverse = [1 for i in range(N + 1)]
for i in range(1, N + 1):
factorial[i] = (factorial[i - 1] * i) % mod
inverse[i] = mpow(factorial[i], mod - 2) % mod
com = [((factorial[N] * inverse[r] % mod) * inverse[N - r] % mod) for r in range(0, N + 1)]
ans = 0
for a, b in ab(K):
if a > N or b > N:
continue
ans += com[a] * com[b]
print((ans % mod)) | N, A, B, K = tuple(map(int, (input().split())))
mod = 998244353
factorial = [1 for i in range(N + 1)]
inverse = [1 for i in range(N + 1)]
for i in range(1, N + 1):
factorial[i] = (factorial[i - 1] * i) % mod
inverse[i] = inverse[i - 1] * pow(i, mod - 2, mod) % mod
com = [1 for i in range(N + 1)]
for i in range(1, N + 1):
com[i] = (factorial[N] * inverse[i] % mod) * inverse[N - i] % mod
ans = 0
for x in range(N + 1):
d = K - A * x
if 0 <= d and d % B == 0:
y = d // B
if y <= N:
ans += com[x] * com[y]
print((ans % mod)) | p03332 |
# 拡張ユークリッド互除法
# gcd(a,b) と ax + by = gcd(a,b) の最小整数解を返す
def extgcd(a, b):
if a == 0:
return b, 0, 1
else:
g, y, x = extgcd(b % a, a)
return g, x - (b // a) * y, y
# aの逆元(mod m)を求める。(aとmは互いに素であることが前提)
def mod_inv(a,m):
gcd, x, y = extgcd(a,m)
return (m+x%m)%m
N, A, B, K = list(map(int, input().split()))
mod = 998244353
ans = 0
for a in range(N+1):
if (K - A*a) % B == 0 and A*a <= K:
b = (K- A*a) // B
res_a = 1
for i in range(1,N+1):
res_a = res_a*i%mod
for i in range(1,a+1):
res_a = res_a*mod_inv(i,mod)%mod
for i in range(1,(N-a)+1):
res_a = res_a*mod_inv(i,mod)%mod
res_b = 1
for i in range(1,N+1):
res_b = res_b*i%mod
for i in range(1,b+1):
res_b = res_b*mod_inv(i,mod)%mod
for i in range(1,(N-b)+1):
res_b = res_b*mod_inv(i,mod)%mod
ans += res_a*res_b%mod
print((ans%mod))
| def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
N, A, B, K = list(map(int, input().split()))
p = 998244353
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
ans = 0
for a in range(N+1):
if (K - A*a) % B == 0 and A*a <= K:
b = (K- A*a) // B
ans += cmb(N, a, p)*cmb(N, b, p)%p
print((ans%p))
| p03332 |
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
N, A, B, K = list(map(int, input().split()))
MOD = 998244353
c = Factorial(N + 1, MOD).comb
def calc(a, b):
return (c(N, a) * c(N, b)) % MOD
ans = 0
for a in range(N + 1):
b = (K - (A * a)) // B
if A * a + B * b == K and 0 <= b <= N:
ans += calc(a, b)
ans %= MOD
print (ans)
| def main():
class Factorial:
def __init__(self, n, mod):
self.f = [1]
self.mod = mod
for j in range(1, n + 1):
self.f.append(self.f[-1] * j % mod)
self.i = [pow(self.f[-1], mod - 2, mod)]
for j in range(n, 0, -1):
self.i.append(self.i[-1] * j % mod)
self.i.reverse()
def factorial(self, j):
return self.f[j]
def ifactorial(self, j):
return self.i[j]
def comb(self, n, k):
return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0
N, A, B, K = list(map(int, input().split()))
MOD = 998244353
c = Factorial(N + 1, MOD).comb
ans = 0
for a in range(N + 1):
b = (K - (A * a)) // B
if A * a + B * b == K and 0 <= b <= N:
ans += (c(N, a) * c(N, b)) % MOD
ans %= MOD
print (ans)
if __name__ == '__main__':
main() | p03332 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product
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()
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
def nCr(n, r):
r = min(r, n - r)
numerator = 1
for i in range(n, n - r, -1):
numerator *= i
denominator = 1
for i in range(r, 1, -1):
denominator *= i
return numerator // denominator
@mt
def slv(N, A, B, K):
ans = 0
for i in range(K // A + 1):
if (K - i * A) % B == 0 and i <= N and (K - i * A) // B <= N:
error_print(i, (K - i * A) // B)
ans += nCr(N, i) * nCr(N, (K - i * A) // B) % 998244353
return ans
def main():
N, A, B, K = read_int_n()
print(slv(N, A, B, K))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product
sys.setrecursionlimit(10000)
MOD = 998244353
def mul_mod(a, b):
return (a % MOD) * (b % MOD) % MOD
def add_mod(a, b):
return (a + b) % MOD
def sub_mod(a, b):
return (a - b) % MOD
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()
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
def prepare(n):
f = 1
for m in range(1, n + 1):
f *= m
f %= MOD
fn = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return fn, invs
@mt
def slv(N, A, B, K):
ans = 0
FN, invs = prepare(N)
for i in range(K // A + 1):
if (K - i * A) % B == 0 and i <= N and (K - i * A) // B <= N:
j = (K - i * A) // B
error_print(i, j)
ans = add_mod(ans,
mul_mod(FN * invs[i] * invs[N - i] % MOD,
FN * invs[j] * invs[N - j] % MOD))
return ans
def main():
N, A, B, K = read_int_n()
print(slv(N, A, B, K))
if __name__ == '__main__':
main()
| p03332 |
n, a, b, k = list(map(int, input().split()))
M = 998244353
fact_n = [None for m in range(n+1)]
fact_inv = [None for m in range(n+1)]
def combination(n, r):
if n == 0 and r == 0:
return 1
elif n < r or n < 0:
return 0
c = fact_inv[r] * fact_inv[n-r] % M
return fact_n[n] * c % M
def main():
fact_n[0] = fact_inv[0] = 1
for i in range(1, n+1):
fact_n[i] = fact_n[i-1] * i % M
fact_inv[i] = fact_inv[i-1] * pow(i, M-2, M) % M
com = 0
for i in range(n+1):
if (k-a*i) % b == 0 and k - a * i >= 0:
j = (k-a*i) // b
com += combination(n, i) * combination(n, j) % M
print((com % M))
if __name__ == '__main__':
main()
| n, a, b, k = list(map(int, input().split()))
M = 998244353
fact_n = [0 for m in range(n+1)]
fact_inv = [0 for m in range(n+1)]
def combination(n, r):
if n == 0 and r == 0:
return 1
elif n < r or n < 0:
return 0
c = fact_inv[r] * fact_inv[n-r] % M
return fact_n[n] * c % M
def main():
fact_n[0] = fact_inv[0] = 1
for i in range(1, n+1):
fact_n[i] = fact_n[i-1] * i % M
fact_inv[i] = pow(fact_n[i], M-2, M)
com = 0
for i in range(n+1):
if (k-a*i) % b == 0 and k - a * i >= 0:
j = (k-a*i) // b
com += combination(n, i) * combination(n, j) % M
print((com % M))
if __name__ == '__main__':
main()
| p03332 |
n, a, b, k = list(map(int, input().split()))
M = 998244353
fact_n = [0 for m in range(n+1)]
fact_inv = [0 for m in range(n+1)]
def combination(n, r):
if n == 0 and r == 0:
return 1
elif n < r or n < 0:
return 0
c = fact_inv[r] * fact_inv[n-r] % M
return fact_n[n] * c % M
def main():
fact_n[0] = fact_inv[0] = 1
for i in range(1, n+1):
fact_n[i] = fact_n[i-1] * i % M
fact_inv[i] = pow(fact_n[i], M-2, M)
com = 0
for i in range(n+1):
if (k-a*i) % b == 0 and k - a * i >= 0:
j = (k-a*i) // b
com += combination(n, i) * combination(n, j) % M
print((com % M))
if __name__ == '__main__':
main()
| n, a, b, k = list(map(int, input().split()))
M = 998244353
fact_n = [0 for m in range(n+1)]
fact_inv = [0 for m in range(n+1)]
def mod_pow(a, n):
x = 1
while n > 0:
if n & 1:
x = x * a % M
a = a * a % M
n >>= 1
return x
def combination(n, r):
if n == 0 and r == 0:
return 1
elif n < r or n < 0:
return 0
return fact_n[n] * fact_inv[r] * fact_inv[n-r] % M
def main():
fact_n[0] = fact_inv[0] = 1
for i in range(1, n+1):
fact_n[i] = fact_n[i-1] * i % M
fact_inv[n] = pow(fact_n[n], M-2, M)
for i in range(n-1, 0, -1):
fact_inv[i] = fact_inv[i+1] * (i+1) % M
com = 0
for i in range(n+1):
if (k-a*i) % b == 0 and k - a * i >= 0:
j = (k-a*i) // b
com += combination(n, i) * combination(n, j) % M
print((com % M))
if __name__ == '__main__':
main()
| p03332 |
n,a,b,k = list(map(int,input().split()))
mod = 998244353
fact = [1,1]
finv = [1,1]
inv = [0,1]
for i in range(2,n+5):
fact.append((fact[-1]*i)%mod)
inv.append((inv[mod%i]*(mod-mod//i))%mod)
finv.append((finv[-1]*inv[-1])%mod)
def nCr(n,r,mod):
if r > n:
return 0
else:
return fact[n]*finv[r]*finv[n-r]%mod
def nPr(n,r,mod):
if r > n:
return 0
else:
return fact[n]*finv[n-r]%mod
ans = 0
for i in range(n+1):
d = k-a*i
if d < 0:
break
if d%b:
continue
x = d//b
v = nCr(n,i,mod)
for j in range(x+1):
if i+j > n:
break
ans += v*nCr(i,x-j,mod)%mod*nCr(n-i,j,mod)%mod
ans %= mod
print(ans) | n,a,b,k = list(map(int,input().split()))
mod = 998244353
fact = [1,1]
finv = [1,1]
inv = [0,1]
for i in range(2,n+5):
fact.append((fact[-1]*i)%mod)
inv.append((inv[mod%i]*(mod-mod//i))%mod)
finv.append((finv[-1]*inv[-1])%mod)
def nCr(n,r,mod):
if r > n:
return 0
else:
return fact[n]*finv[r]*finv[n-r]%mod
def nPr(n,r,mod):
if r > n:
return 0
else:
return fact[n]*finv[n-r]%mod
ans = 0
for i in range(n+1):
if i*a > k:
break
d = k-i*a
if d%b or d//b > n:
continue
ans += nCr(n,i,mod)*nCr(n,d//b,mod)%mod
ans %= mod
print(ans) | p03332 |
mod=998244353
N,A,B,K=list(map(int,input().split()))
#繰り返し二乗法
def great_power(x, y):
if y == 0:
return 1
elif y == 1:
return x % mod
elif y % 2 == 0:
return great_power(x, y//2)**2 % mod
else:
return great_power(x, y//2)**2 * x % mod
#階乗計算
factorial=[1]
for i in range(1,N+1):
factorial.append(factorial[i-1]*i %mod)
#逆元計算
inverse=[0]*(N+1)
inverse[N] = great_power(factorial[N], mod-2)
for i in range(N-1, -1, -1):
inverse[i] = inverse[i+1] * (i+1) % mod
#combination計算
def nCr(n,r):
if n==r or n<r:
return 1
return factorial[n] * inverse[r] * inverse[n-r] % mod
def solve(a,b,c):
res=nCr(N,a+b+c)
res2=factorial[a+b+c] * inverse[a]*inverse[b]*inverse[c]
return (res*res2)%mod
ans=[]
for i in range(N+1):
if (K-A*i)%B==0:
ans.append((i,(K-A*i)//B))
out=0
for x,y in ans:
for i in range(min(x,y)+1):
red,green,blue=x-i,i,y-i
if red+green+blue <=N:
out+=solve(red,green,blue)
print((out%mod))
| mod=998244353
N,A,B,K=list(map(int,input().split()))
#繰り返し二乗法
def great_power(x, y):
if y == 0:
return 1
elif y == 1:
return x % mod
elif y % 2 == 0:
return great_power(x, y//2)**2 % mod
else:
return great_power(x, y//2)**2 * x % mod
#階乗計算
factorial=[1]
for i in range(1,N+1):
factorial.append(factorial[i-1]*i %mod)
#逆元計算
inverse=[0]*(N+1)
inverse[N] = great_power(factorial[N], mod-2)
for i in range(N-1, -1, -1):
inverse[i] = inverse[i+1] * (i+1) % mod
#combination計算
def nCr(n,r):
if n==r or n<r or r==0:
return 1
return factorial[n] * inverse[r] * inverse[n-r] % mod
ans=0
for i in range(N+1):
if (K-A*i)%B==0 and (K-A*i)>=0:
j=(K-A*i)//B
if j <= N:
ans+=( nCr(N,i) * nCr(N,j) ) %mod
ans %= mod
print(ans)
| p03332 |
N, A, B, K = list(map(int, input().split()))
mod = 998244353
F = [1]
RF = []
def inv(x):
res = 1
k = mod - 2
y = x
while k:
if k & 1:
res = (res * y) % mod
y = (y * y) % mod
k //= 2
return res
def init():
for i in range(N):
F.append((F[i] * (i + 1)) % mod)
for i in F:
RF.append(inv(i))
def comb(x, y):
if y < 0 or x < y:
return 0
return (F[x] * ((inv(F[x - y]) * inv(F[y])) % mod)) % mod
ans = 0
init()
for a in range(N):
b = (K - a * A) / B
if b < 0:
break
if b.is_integer():
ans += (comb(N, a) * (comb(N, int(b)))) % mod
print((ans % mod))
| N, A, B, K = list(map(int, input().split()))
mod = 998244353
fact = [1] * (N + 1)
ifact = [1] * (N + 1)
def init():
for i in range(N):
fact[i + 1] = fact[i] * (i + 1) % mod
ifact[i + 1] = pow(fact[i + 1], mod - 2, mod)
def comb(x, y):
if y < 0 or y > x:
return 0
return (fact[x] * ifact[x - y] * ifact[y]) % mod
ans = 0
init()
for a in range(N + 1):
n = K - a * A
if n < 0:
break
if n % B == 0:
ans += (comb(N, a) * (comb(N, n // B))) % mod
print((ans % mod))
| p03332 |
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N, A, B, K = list(map(int, input().split()))
ans = 0
for i in range(N+1):
m = K-A*i
if m%B!=0:
continue
ans += cmb(N,i,mod)*cmb(N,m//B,mod)
ans %= mod
print(ans) | def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 998244353 #出力の制限
N = 10**6
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,A,B,K = list(map(int, input().split()))
ans = 0
for i in range(N+1):
if (K-A*i)%B!=0:
continue
j = (K-A*i)//B
m = cmb(N,i,mod)*cmb(N,j,mod)%mod
ans += m
ans %= mod
print(ans) | p03332 |
def read():
return int(eval(input()))
def reads():
return [int(x) for x in input().split()]
P = 998244353
N, A, B, K = reads()
fact = [1]
for i in range(1, N+1):
fact.append(fact[i-1] * i % P)
def egcd(a, b):
if b == 0:
return a, 1, 0
else:
q, r = divmod(a, b)
g, x, y = egcd(b, r)
return g, y, x - q * y
def inv(n):
g, x, _ = egcd(n, P)
# assert g == 1
return x
invfact = [inv(fact[i]) for i in range(N+1)]
def comb(n, k):
# assert 0 <= k <= n
return fact[n] * invfact[k] * invfact[n-k] % P
result = 0
for x in range(N+1):
y, r = divmod(K - A * x, B)
if r == 0 and 0 <= y <= N:
result = result + comb(N, x) * comb(N, y) % P
print((result % P)) | def read():
return int(eval(input()))
def reads():
return [int(x) for x in input().split()]
P = 998244353
N, A, B, K = reads()
def inv(n):
return pow(n, P-2, P)
fact = [1] * (N+1)
for i in range(1, N+1):
fact[i] = fact[i-1] * i % P
invfact = [inv(fact[N])] * (N+1)
for i in range(N, 0, -1):
invfact[i-1] = invfact[i] * i % P
def comb(n, k):
# assert 0 <= k <= n
return fact[n] * invfact[k] * invfact[n-k] % P
result = 0
for x in range(N+1):
y, r = divmod(K - A * x, B)
if r == 0 and 0 <= y <= N:
result = result + comb(N, x) * comb(N, y) % P
print((result % P)) | p03332 |
import math
L = input().split()
sp = 998244353
# approx 10**9
N = int(L[0])
A = int(L[1])
B = int(L[2])
K = int(L[3])
def binom(n,m):
if n == m:
return 1
elif m == 1:
return n
elif m > n:
return 0
else:
a = math.factorial(n)
b = math.factorial(m)
c = math.factorial(n - m)
return a // (b*c)
# max is A*N + B*N
sum = 0
for i in range(0,N):
if (K - A*i) % B == 0:
j = (K-A*i)//B
sum += (binom(N,i) * binom(N,j)) % sp
print(sum)
| N,A,B,K = list(map(int,input().split()))
sprime = 998244353 # approx 10**9
A,B = sorted((A,B))
if (A+B) * N < K:
print((0))
exit()
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
memo = [0] * (N+1)
memo[0] = memo[N] = 1
for i in range(1,N//2+1):
v = memo[i-1] * (N-i+1) * modinv(i,sprime)
v = v % sprime
memo[i] = memo[N-i] = v
# max is A*N + B*N
sum = 0
for b in range(N+1):
a = (K-b*B)//A
if 0 <= a <= N and a*A+b*B == K:
sum += memo[a]*memo[b]
sum %= sprime
print(sum) | p03332 |
N, A, B, K = list(map(int, input().split()))
mod = 998244353
fac = [1]
inv = [1]
for i in range(1, N + 1) :
fac.append(fac[-1] * i % mod)
inv.append(pow(fac[-1], mod - 2, mod))
ret = 0
for na in range(N + 1) :
if (K - na * A) % B != 0 :
continue
nb = (K - na * A) // B
for ng in range(max(0, na + nb - N), min(na, nb) + 1) :
ret += fac[N] * inv[na-ng] * inv[nb-ng] * inv[ng] * inv[N-na-nb+ng] % mod
ret %= mod
print(ret)
| N, A, B, K = list(map(int, input().split()))
mod = 998244353
fac = [1]
inv = [1]
for i in range(1, N + 1) :
fac.append(fac[-1] * i % mod)
inv.append(pow(fac[-1], mod - 2, mod))
ret = 0
for na in range(N + 1) :
if (K - na * A) % B != 0 :
continue
nb = (K - na * A) // B
if 0 <= na <= N and 0 <= nb <= N :
ret += fac[N] * inv[N-na] * inv[na] * fac[N] * inv[N-nb] * inv[nb]
ret %= mod
print(ret)
| p03332 |
from math import factorial as fac
def cc(n,r):
def fac2(n,r):
m = 1
for i in range(n-r+1,n+1):
m*=i
return m
r = min(r,n-r)
return fac2(n,r)//fac(r)
n, a, b, k = list(map(int, input().split()))
mod = 998244353
ans = 0
for i in range(min(k//a+1,n+1)):
jof = k-a*i
if jof%b==0 and jof<=n*b:
j = jof//b
ans += cc(n,i)*cc(n,j)
ans %= mod
print(ans) | n,a,b,k = list(map(int,input().split()))
mod = 998244353
fun = [1]*(n+1)
for i in range(1,n+1):
fun[i] = fun[i-1]*i%mod
rev = [1]*(n+1)
rev[n] = pow(fun[n],mod-2,mod)
for i in range(n-1,0,-1):
rev[i] = rev[i+1]*(i+1)%mod
def nCr(n,r):
if r > n:
return 0
return fun[n]*rev[r]%mod*rev[n-r]%mod
ans = 0
for i in range(min(n,k//a)+1):
j = (k-a*i)//b
if i*a+j*b == k and 0<=j<=n:
ans += nCr(n,i)*nCr(n,j)
ans %= mod
print(ans) | p03332 |
n, a, b, k = list(map(int, input().split()))
MOD = 998244353
a_max = min(k // a, n) + 1
pair = []
for i in range(a_max):
if (k - a * i) % b == 0:
j = (k - a * i) // b
if j <= n:
pair.append([i % MOD,j % MOD])
inv = [0] * (n + 1)
inv[1] = 1
for i in range(2, n + 1):
inv[i] = (-(MOD // i) * inv[MOD % i]) % MOD
nCr = [0] * (n + 1)
nCr[0] = 1
for r in range(1, n + 1):
nCr[r] = (nCr[r - 1] * (n - r + 1) * inv[r]) % MOD
result = 0
for p in pair:
result += (nCr[p[0]] % MOD) * (nCr[p[1]] % MOD)
if result == 0:
print((1))
else:
print((result % MOD)) | # coding: utf-8
# Your code here!
n, a, b, k = list(map(int, input().split()))
MOD = 998244353
inv = [0] * ( n + 1)
inv[1] = 1
for i in range(2, n + 1):
inv[i] = (-(MOD // i) * inv[MOD % i]) % MOD
nCr = [0] * ( n + 1)
nCr[0] = 1
for i in range(1, n+1):
nCr[i] = (nCr[i-1] * (n - i + 1) * inv[i]) % MOD
result = 0
maxA = min(n, k//a)
for i in range(maxA + 1):
if ( k - a * i) % b == 0:
j = ( k - a * i) // b
if j <= n:
result += (nCr[i] * nCr[j]) % MOD
if result == 0:
print((1))
else:
print((result % MOD)) | p03332 |
N,A,B,K=list(map(int,input().split()))
P=998244353
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def inv(x):
return egcd(x,P)[0]
Fact=[0 for i in range(N+1)]
Finv=[0 for i in range(N+1)]
Fact[0]=1
Finv[0]=1
for i in range(1,N+1):
Fact[i]=(i*Fact[i-1])%P
Finv[i]=(Finv[i-1]*inv(i))%P
def NC(k):
tmp=(Finv[k]*Finv[N-k])%P
return (Fact[N]*tmp)%P
ans=0
for s in range(N+1):
t=(K-s*A)//B
if s*A+t*B==K and 0<=t<=N:
ans+=(NC(s)*NC(t))%P
print((ans%P))
| N,A,B,K=list(map(int,input().split()))
P=998244353
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def inv(x):
return egcd(x,P)[0]
Fact=[0 for i in range(N+1)]
Finv=[0 for i in range(N+1)]
Fact[0]=1
Finv[0]=1
for i in range(1,N+1):
Fact[i]=(i*Fact[i-1])%P
Finv[i]=(Finv[i-1]*inv(i))%P
ans=0
def NC(k):
tmp=(Finv[k]*Finv[N-k])%P
return (Fact[N]*tmp)%P
for x in range(N+1):
y=(K-x*A)//B
if x*A+y*B==K and 0<=y<=N:
ans+=(NC(x)*NC(y))%P
print((ans%P))
| p03332 |
P=998244353
MAX_N=3*10**5+1
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def inv(x):
return egcd(x,P)[0]
Fact=[0 for i in range(MAX_N+1)]
Finv=[0 for i in range(MAX_N+1)]
Fact[0]=1
Finv[0]=1
for i in range(MAX_N):
Fact[i+1]=(Fact[i]*(i+1))%P
Finv[i+1]=inv(Fact[i+1])%P
def C(n,k):
return (Fact[n]*(Finv[k]*Finv[n-k])%P)%P
N,A,B,K=list(map(int,input().split()))
L=[]
for i in range(K//A+1):
if (K-A*i)%B==0:
j=(K-A*i)//B
if 0<=i<=N and 0<=j<=N:
L.append((i,j))
ans=0
for x,y in L:
ans+=C(N,x)*C(N,y)
ans%=P
print(ans)
| N,A,B,K=list(map(int,input().split()))
P=998244353
def egcd(a, b):
(x, lastx) = (0, 1)
(y, lasty) = (1, 0)
while b != 0:
q = a // b
(a, b) = (b, a % b)
(x, lastx) = (lastx - q * x, x)
(y, lasty) = (lasty - q * y, y)
return (lastx, lasty, a)
def inv(x):
return egcd(x,P)[0]
Fact=[0 for i in range(N+1)]
Finv=[0 for i in range(N+1)]
Fact[0]=1
Finv[0]=1
for i in range(1,N+1):
Fact[i]=(i*Fact[i-1])%P
Finv[i]=(Finv[i-1]*inv(i))%P
def NC(k):
tmp=(Finv[k]*Finv[N-k])%P
return (Fact[N]*tmp)%P
ans=0
for s in range(N+1):
t=(K-s*A)//B
if s*A+t*B==K and 0<=t<=N:
ans+=(NC(s)*NC(t))%P
print((ans%P))
| p03332 |
import sys
input = sys.stdin.buffer.readline
import copy
def main():
N,A,B,K = list(map(int,input().split()))
MOD = 998244353
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
inv = copy.deepcopy(fac)
invfac = copy.deepcopy(fac)
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
inv[i] = MOD-(MOD//i)*inv[MOD%i]%MOD
invfac[i] = (invfac[i-1]*inv[i])%MOD
def coef(x,y):
num = (((fac[x]*invfac[y])%MOD)*invfac[x-y]%MOD)
return num
ans = 0
for i in range(min(K//max(A,B),N)+1):
rest = K-i*max(A,B)
if rest%min(A,B) == 0:
j = rest//min(A,B)
if j <= N:
ans += coef(N,i)*coef(N,j)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.buffer.readline
import copy
def main():
N,A,B,K = list(map(int,input().split()))
MOD = 998244353
fac = [0 for _ in range(N+1)]
fac[0],fac[1] = 1,1
invfac = copy.deepcopy(fac)
for i in range(2,N+1):
fac[i] = (fac[i-1]*i)%MOD
invfac[-1] = pow(fac[-1],MOD-2,MOD)
for i in range(N,0,-1):
invfac[i-1] = (invfac[i]*i)%MOD
def coef(x,y):
num = (((fac[x]*invfac[y])%MOD)*invfac[x-y]%MOD)
return num
ans = 0
for i in range(min(K//max(A,B),N)+1):
rest = K-i*max(A,B)
if rest%min(A,B) == 0:
j = rest//min(A,B)
if j <= N:
ans += coef(N,i)*coef(N,j)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| p03332 |
from math import factorial as fa
f=lambda a,b:fa(a)//(fa(a-b)*fa(b))
n,a,b,k=list(map(int,input().split()))
v=998244353
l=[]
for i in range(n+1):
if not (k-a*i)%b:
j=(k-a*i)//b
if 0<=j<=n+1:
l.extend([(i,j)])
s=0
for (i,j) in l:
s+=(f(n,i)*f(n,j))%v
print(s) | n,a,b,k=list(map(int,input().split()))
mod=998244353
s=0
fac=[1]*(n+1)
rev=[1]*(n+1)
for i in range(1,n+1):
fac[i]=i*fac[i-1]%mod
rev[i]=pow(fac[i],mod-2,mod)
f=lambda a,b:(fac[a]*rev[a-b]*rev[b])%mod
for i in range(n+1):
j,r=divmod((k-a*i),b)
if r==0 and 0<=j<=n:
s+=(f(n,i)*f(n,j))%mod
print((s%mod))
| p03332 |
def comb(n,k,p):
from math import factorial
if n<0 or k<0 or n<k: return 0
if n==0 or k==0: return 1
a,b,c = factorial(n)%p,factorial(k)%p,factorial(n-k)%p
return (a*pf(b,p-2,p)*pf(c,p-2,p))%p
def pf(a,b,p):
if b==0: return 1
if b%2==0:
d = pf(a,b//2,p)
return d**2%p
if b%2==1: return (a*pf(a,b-1,p))%p
n,a,b,k = (int(i) for i in input().split())
mod,ans = 998244353,0
for i in range(n+1):
if (k-a*i)%b==0:
j = (k-a*i)//b
ans = (ans+comb(n,i,mod)*comb(n,j,mod))%mod
print(ans) | n,a,b,k = (int(i) for i in input().split())
mod,ans = 998244353,0
fn,fk = [1]*n,[1]*n
for i in range(n-1): fn[i+1] = (fn[i]*(i+2))%mod
def power(n,k):
if k==1: return n
elif k%2==0: return power((n**2)%mod,k//2)
else: return (n*power(n,k-1))%mod
def comb(n,k):
if n==0 or k==0 or n==k: return 1
else: return (((fn[n-1]*fk[n-k-1])%mod)*fk[k-1])%mod
fk[-1] = power(fn[-1],mod-2)
for i in range(2,n+1): fk[-i] = (fk[-i+1]*(n+2-i))%mod
for i in range(n+1):
if (k-a*i)%b==0 and k-a*i>=0 and (k-a*i)//b<=n:
j = (k-a*i)//b
ans = (ans+(comb(n,i)*comb(n,j))%mod)%mod
print(ans) | p03332 |
M=998244353;n,A,B,K=list(map(int,input().split()));F=[1];a=0
for i in range(n):F+=[F[-1]*(n-i)*pow(i+1,M-2,M)%M]
for i in range(n+1):
r=K-i*A;q=r//B
if(r%B==0)&(0<=q<=n):a+=F[i]*F[q]
print((a%M)) | M=998244353;n,A,B,K=list(map(int,input().split()));F=[1];a=0
for i in range(n):F+=[F[-1]*(n-i)*pow(i+1,M-2,M)%M]
for i in range(n+1):
r=K-i*A
if r%B==0and 0<=r//B<=n:a+=F[i]*F[r//B]
print((a%M)) | p03332 |
N,A,B,K = list(map(int,input().split()))
if A<B: A,B = B,A
MOD = 998244353
def mul(a,b):
return (a*b) % MOD
def pow(a,n): # a^n
ret = 1
mag = a
while n > 0:
if n & 1:
ret = mul(ret, mag)
mag = mul(mag, mag)
n >>= 1
return ret
def inv(a):
return pow(a, MOD-2)
fac = [1]
#fac_inv = [1]
for n in range (1,N+10):
f = mul(fac[n-1], n)
fac.append(f)
# fac_inv.append(inv(f))
mem = {}
def ncr(n,r):
if (n,r) in mem:
return mem[(n,r)]
else:
ret = mul(mul(fac[n], inv(fac[n-r])), inv(fac[r]))
if len(mem) <= 10**5:
mem[(n,r)] = ret
return ret
ans = 0
for a in range(N+1):
if a*A > K: break
rem = K-a*A
if rem%B: continue
b = rem//B
for green in range(min(a,b) + 1):
red = a - green
blue = b - green
if red + green + blue > N: continue
tmp = 1
tmp = mul(tmp, ncr(N, red+green+blue))
tmp = mul(tmp, ncr(red+green+blue, green+blue))
tmp = mul(tmp, ncr(green+blue, blue))
ans += tmp
print((ans % MOD))
| N,A,B,K = list(map(int,input().split()))
if A<B: A,B = B,A
MOD = 998244353
def mul(a,b):
return (a*b) % MOD
def pow(a,n): # a^n
ret = 1
mag = a
while n > 0:
if n & 1:
ret = mul(ret, mag)
mag = mul(mag, mag)
n >>= 1
return ret
def inv(a):
return pow(a, MOD-2)
fac = [1]
fac_inv = [1]
for n in range (1,N+10):
f = mul(fac[n-1], n)
fac.append(f)
fac_inv.append(inv(f))
mem = [0] * (N+1)
def ncr(n,r):
if mem[r] > 0:
return mem[r]
else:
ret = mul(mul(fac[n], fac_inv[n-r]), fac_inv[r])
mem[r] = ret
return ret
ans = 0
for a in range(N+1):
if a*A > K: break
rem = K-a*A
if rem%B: continue
b = rem//B
if b > N: continue
ans += mul(ncr(N,a), ncr(N,b))
print((ans % MOD))
| p03332 |
N,A,B,K = list(map(int,input().split()))
MOD = 998244353
fac = [1,1] + [0]*N
finv = [1,1] + [0]*N
inv = [0,1] + [0]*N
for i in range(2,N+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for a in range(N+1):
if a*A > K: break
rem = K-a*A
if rem%B: continue
b = rem//B
for green in range(min(a,b) + 1):
red = a - green
blue = b - green
if red + green + blue > N: continue
tmp = 1
tmp *= ncr(N, red+green+blue)
tmp *= ncr(red+green+blue, green+blue)
tmp *= ncr(green+blue, blue)
ans += tmp % MOD
print((ans % MOD)) | N,A,B,K = list(map(int,input().split()))
MOD = 998244353
if (A+B)*N < K:
print((0))
exit()
M = N+5
fac = [1,1] + [0]*M
finv = [1,1] + [0]*M
inv = [0,1] + [0]*M
for i in range(2,M+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for a in range(N+1):
rem = K - a*A
if rem < 0: break
b,m = divmod(rem, B)
if m: continue
ans += ncr(N,a) * ncr(N,b)
ans %= MOD
print(ans) | p03332 |
N,A,B,K = list(map(int,input().split()))
MOD = 998244353
if (A+B)*N < K:
print((0))
exit()
M = N+5
fac = [1,1] + [0]*M
finv = [1,1] + [0]*M
inv = [0,1] + [0]*M
for i in range(2,M+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def ncr(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for a in range(N+1):
rem = K - a*A
if rem < 0: break
b,m = divmod(rem, B)
if m: continue
ans += ncr(N,a) * ncr(N,b)
ans %= MOD
print(ans) | N,A,B,K = list(map(int,input().split()))
MOD = 998244353
MAXN = N+5
fac = [1,1] + [0]*MAXN
finv = [1,1] + [0]*MAXN
inv = [0,1] + [0]*MAXN
for i in range(2,MAXN+2):
fac[i] = fac[i-1] * i % MOD
inv[i] = -inv[MOD%i] * (MOD // i) % MOD
finv[i] = finv[i-1] * inv[i] % MOD
def comb(n,r):
if n < r: return 0
if n < 0 or r < 0: return 0
return fac[n] * (finv[r] * finv[n-r] % MOD) % MOD
ans = 0
for a in range(N+1):
if (K-a*A)%B: continue
b = (K-a*A)//B
ans += comb(N,a) * comb(N,b)
ans %= MOD
print(ans) | p03332 |
N, A, B, K = [int(_) for _ in input().split()]
def gcd(a, b):
if a < b:
a, b = b, a
while b:
a, b = b, a % b
return a
L = 300000+1
M = 998244353
Fm = {}
inverseFm = {}
x = 1
for i in range(L):
Fm[i] = x
x = x * (i + 1) % M
def inverseFm(x, cache={}):
if x in cache:
return cache[x]
result = pow(Fm[x], M - 2, M)
cache[x] = result
return result
def C(n, r):
result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
return result
def solve(N, A, B, K):
g = gcd(gcd(A, B), K)
A, B, K = A//g, B//g, K//g
if A > B:
A, B = B, A
l = A * B // gcd(A, B)
x = K
for i in range(min(N + 1, l)):
if x % B == 0:
break
x -= A
else:
return 0
result = 0
for a in range(i, N + 1, B):
b = (K - A * a) // B
for x in range(max(0, a-b), min(N-b+1, a+1)):
y = a - x
z = b - y
d = Fm[N] * inverseFm(x) * inverseFm(y) * inverseFm(z) * inverseFm(N - x - y - z) % M
# print("s", x, y, z)
result = (result + d) % M
return result
def solve0(N, A, B, K):
result = 0
for x in range(0, N + 1):
for y in range(0, N + 1 - x):
for z in range(0, N + 1 - x - y):
if A * x + (A + B) * y + B * z == K:
# print("s0", x, y, z)
d = Fm[N] * inverseFm(x) * inverseFm(y) * inverseFm(z) * inverseFm(N - x - y - z) % M
result = (result + d) % M
return result
def check():
import random
for i in range(100):
N = random.randint(1, 20)
A = random.randint(1, 20)
B = random.randint(1, 20)
K = random.randint(1, 20)
r = solve(N, A, B, K)
r0 = solve0(N, A, B, K)
if r != r0:
print((N, A, B, K, r, r0))
#check()
print((solve(N, A, B, K)))
#print(solve0(N, A, B, K))
| N, A, B, K = [int(_) for _ in input().split()]
L = 300000+1
M = 998244353
Fm = {}
inverseFm = {}
x = 1
for i in range(L):
Fm[i] = x
x = x * (i + 1) % M
def inverseFm(x, cache={}):
if x in cache:
return cache[x]
result = pow(Fm[x], M - 2, M)
cache[x] = result
return result
def C(n, r):
result = Fm[n] * inverseFm(r) * inverseFm(n - r) % M
return result
def solve(N, A, B, K):
result = 0
for a in range(0, N+1):
b, m = divmod(K - A * a, B)
if m == 0 and 0 <= b <= N:
result += C(N, a) * C(N, b) % M
return result % M
print((solve(N, A, B, K)))
| p03332 |
import sys
def input():
return sys.stdin.readline().strip()
N, A, B, K = list(map(int, input().split()))
mod = 998244353
fact_list = [1]
for i in range(1, N + 1):
fact_list.append((fact_list[-1]*i) % mod)
def pow(x, y, mod=1000000007):
pow_list = [x]
i = 1
while 2**i <= y:
a = pow_list[-1]**2
if mod != 0:
a = a % mod
pow_list.append(a)
i += 1
ans = 1
for bit in range(len(pow_list)):
if (2**bit) & y != 0:
ans *= pow_list[bit]
if mod != 0:
ans = ans % mod
return ans
def fact(n, mod=1000000007):
return fact_list[n]
rev_list = [1]
for i in range(N):
rev_list.append(pow(fact(i + 1, mod), mod - 2, mod))
def mod_rev(x, mod):
"""
関数powが必要
"""
return rev_list[x]
def comb(a, b, mod=1000000007):
"""
関数mod_rev, fact, powが必要
"""
if a < b or b < 0:
return 0
a_fact = fact(a, mod)
b_fact = fact(b, mod)
a_b_fact = fact(a - b, mod)
if mod != 0:
return (a_fact * mod_rev(b, mod) * mod_rev(a - b, mod))%mod
else:
return a_fact//(b_fact*a_b_fact)
ans = 0
for r in range(N + 1):
rest = K - r * A
if rest % B == 0 and rest // B >= 0 and rest // B <= N:
b = rest // B
ans += comb(N, r, mod)*comb(N, b, mod)
ans %= mod
print(ans) |
import sys
def input():
return sys.stdin.readline().strip()
N, A, B, K = list(map(int, input().split()))
mod = 998244353
fact_list = [1]
for i in range(1, N + 1):
fact_list.append((fact_list[-1]*i) % mod)
def pow(x, y, mod=1000000007):
pow_list = [x]
i = 1
while 2**i <= y:
a = pow_list[-1]**2
if mod != 0:
a = a % mod
pow_list.append(a)
i += 1
ans = 1
for bit in range(len(pow_list)):
if (2**bit) & y != 0:
ans *= pow_list[bit]
if mod != 0:
ans = ans % mod
return ans
def fact(n, mod=1000000007):
return fact_list[n]
inv_t = [0] + [1]
for i in range(2,N + 1):
inv_t += [inv_t[mod % i] * (mod - int(mod / i)) % mod]
def mod_rev(x, mod):
"""
関数powが必要
"""
return inv_t[x]
inv_fact = [1] + [1]
for i in range(2, N + 1):
inv_fact.append((inv_fact[-1] * inv_t[i]) % mod)
def comb(a, b, mod=1000000007):
"""
関数mod_rev, fact, powが必要
"""
if a < b or b < 0:
return 0
if a == b or b == 0:
return 1
a_fact = fact(a, mod)
b_fact = fact(b, mod)
a_b_fact = fact(a - b, mod)
if mod != 0:
return (a_fact * inv_fact[b] * inv_fact[a - b])%mod
else:
return a_fact//(b_fact*a_b_fact)
ans = 0
times = 0
for r in range(N + 1):
rest = K - r * A
if rest % B == 0 and rest // B >= 0 and rest // B <= N:
b = rest // B
ans += comb(N, r, mod)*comb(N, b, mod)
ans %= mod
times += 1
print(ans) | p03332 |
# coding: utf-8
# Your code here!
import array
SIZE=300000; MOD= 998244353
#inv = array.array('q',[0]*(SIZE+1))# inv[j] = j^{-1} mod M
#fac = array.array('q',[0]*(SIZE+1))# inv[j] = j! mod M
#finv = array.array('q',[0]*(SIZE+1))# inv[j] = (j!)^{-1} mod M
inv = [0]*(SIZE+1)# inv[j] = j^{-1} mod M
fac = [0]*(SIZE+1)# inv[j] = j! mod M
finv = [0]*(SIZE+1)# inv[j] = (j!)^{-1} mod M
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE+1):
inv[i] = MOD -(MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if r < 0 or r > n:
return 0
else:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
n,a,b,k = [int(i) for i in input().split()]
ans=0
for i in range(n+1):
if (k-i*a)%b == 0:
ans = (ans + choose(n,i)*choose(n,(k-i*a)//b)%MOD)%MOD
print(ans)
| SIZE=300000; MOD=998244353 #ここを変更する
inv = [0]*(SIZE+1)# inv[j] = j^{-1} mod MOD
fac = [0]*(SIZE+1)# inv[j] = j! mod MOD
finv = [0]*(SIZE+1)# inv[j] = (j!)^{-1} mod MOD
inv[1] = 1
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
for i in range(2,SIZE+1):
inv[i] = MOD -(MOD//i)*inv[MOD%i]%MOD
fac[i] = fac[i-1]*i%MOD
finv[i]= finv[i-1]*inv[i]%MOD
def choose(n,r): # nCk mod MOD の計算
if r < 0 or r > n or n < 0:
return 0
else:
return (fac[n]*finv[r]%MOD)*finv[n-r]%MOD
n,a,b,k = [int(i) for i in input().split()]
ans=0
for i in range(n+1):
if (k-i*a)%b == 0:
ans = (ans + choose(n,i)*choose(n,(k-i*a)//b)%MOD)%MOD
print(ans)
| p03332 |
n,a,b,k=[int(i) for i in input().split()]
c=a+b
mod=998244353
ans=0
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2,300003):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
#以下のcom関数を用いて組み合わせを計算
def com(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
for i in range(n+1):
if (k-b*i)%a==0 and k-b*i>=0:
n_a=(k-b*i)//a
n_b=i
n_c=min(n_a,n_b)
n_a, n_b=n_a-min(n_a,n_b), n_b-min(n_a,n_b)
count=0
while n_a + n_b + n_c <=n and n_c>=0 and n_b>=0 and n_a>=0:
ans+=com(n, n_c, mod) * com(n-n_c, n_b, mod) * com(n-n_c-n_b, n_a, mod) %mod
n_c-=1
n_b+=1
n_a+=1
print((ans%mod)) | n,a,b,k=[int(i) for i in input().split()]
c=a+b
mod=998244353
ans=0
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range(2,300003):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
#以下のcom関数を用いて組み合わせを計算
def com(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
for i in range(n+1):
if (k-b*i)%a==0 and k-b*i>=0:
n_a=(k-b*i)//a
n_b=i
if max(n_a, n_b) <=n:
ans+=com(n, n_a, mod) * com(n, n_b, mod) %mod
print((ans%mod))
| p03332 |
from copy import deepcopy
dx=[0,0,1,-1]
dy=[1,-1,0,0]
def dfs(y,x,cnt):
Ice_cp[y][x]=0
cnt+=1
for i in range(4):
mx=x+dx[i]
my=y+dy[i]
if 0<=mx<m and 0<=my<n and Ice_cp[my][mx]==1:
return dfs(my,mx,cnt)
return cnt
while True:
m=eval(input())
n=eval(input())
if n==m==0:break
maxInt=0
Ice=[list(map(int,input().split())) for i in range(n)]
for i in range(n):
for j in range(m):
cnt=0
Ice_cp=deepcopy(Ice)
if Ice_cp[i][j]==1:
maxInt=max(maxInt,dfs(i,j,cnt))
print(maxInt) | dx=[0,0,1,-1]
dy=[1,-1,0,0]
def dfs(y,x,cnt):
global maxInt
maxInt=max(maxInt,cnt)
Ice[y][x]=0
for i in range(4):
mx=x+dx[i]
my=y+dy[i]
if mx<0 or m<=mx or my<0 or n<=my:
continue
if Ice[my][mx]==1:
dfs(my,mx,cnt+1)
Ice[my][mx]=1
while True:
m=eval(input())
n=eval(input())
if n==m==0:break
maxInt=0
Ice=[list(map(int,input().split())) for i in range(n)]
for y in range(n):
for x in range(m):
if Ice[y][x]==1:
dfs(y,x,1)
Ice[y][x]=1
print(maxInt) | p00458 |
def b(M,x,y,n=1):
M[x][y]='0';t=[]
if'1'==M[x-1][y]:t+=[b(M,x-1,y,n+1)]
if'1'==M[x][y-1]:t+=[b(M,x,y-1,n+1)]
if'1'==M[x+1][y]:t+=[b(M,x+1,y,n+1)]
if'1'==M[x][y+1]:t+=[b(M,x,y+1,n+1)]
M[x][y]='1'
return max([n]+t)
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[['0']*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=input().split()
print((max(b(P,i,j)for i in range(1,m+1)for j in range(1,n+1)if'1'==P[i][j])))
| def b(M,x,y,n=1):
M[x][y]=0;t=[]
if M[x-1][y]:t+=[b(M,x-1,y,n+1)]
if M[x][y-1]:t+=[b(M,x,y-1,n+1)]
if M[x+1][y]:t+=[b(M,x+1,y,n+1)]
if M[x][y+1]:t+=[b(M,x,y+1,n+1)]
M[x][y]=1
return max([n]+t)
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max(b(P,i,j)for i in range(1,m+1)for j in range(1,n+1)if P[i][j])))
| p00458 |
def s():
def b(M,x,y,n=0):
if M[x][y]==0:return n
M[x][y]=0
a=max(b(M,x-1,y,n+1),b(M,x,y-1,n+1),b(M,x+1,y,n+1),b(M,x,y+1,n+1))
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max(b(P,i,j)for i in range(1,m+1)for j in range(1,n+1))))
if'__main__'==__name__:s()
| def s():
def b(M,x,y,n):
M[x][y]=0;a=n
if M[x-1][y]:a=max(a,b(M,x-1,y,n+1))
if M[x][y-1]:a=max(a,b(M,x,y-1,n+1))
if M[x+1][y]:a=max(a,b(M,x+1,y,n+1))
if M[x][y+1]:a=max(a,b(M,x,y+1,n+1))
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max(b(P,i,j,1)for i in range(1,m+1)for j in range(1,n+1)if P[i][j])))
if'__main__'==__name__:s()
| p00458 |
def s():
def b(M,x,y,n=1):
M[x][y]=0;a=n
if M[x-1][y]:a=max(a,b(M,x-1,y,n+1))
if M[x][y-1]:a=max(a,b(M,x,y-1,n+1))
if M[x+1][y]:a=max(a,b(M,x+1,y,n+1))
if M[x][y+1]:a=max(a,b(M,x,y+1,n+1))
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max({b(P,i,j)for i in range(1,m+1)for j in range(1,n+1)if P[i][j]})))
if'__main__'==__name__:s()
| def s():
def b(M,x,y,n=1):
M[x][y]=0;a=n
if M[x-1][y]:
t=b(M,x-1,y,n+1)
if a<t:a=t
if M[x][y-1]:
t=b(M,x,y-1,n+1)
if a<t:a=t
if M[x+1][y]:
t=b(M,x+1,y,n+1)
if a<t:a=t
if M[x][y+1]:
t=b(M,x,y+1,n+1)
if a<t:a=t
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max(b(P,i,j)for i in range(1,m+1)for j in range(1,n+1)if P[i][j])))
if'__main__'==__name__:s()
| p00458 |
def s():
def b(M,x,y,n=1):
M[x][y]=0;a=n
for p,q in[(-1,0),(0,-1),(1,0),(0,1)]:
if M[x+p][y+q]:
t=b(M,x+p,y+q,n+1)
if a<t:a=t
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
print((max(b(P,i,j)for i in range(1,m+1)for j in range(1,n+1)if P[i][j])))
if'__main__'==__name__:s()
| def s():
def b(M,x,y,n=1):
M[x][y]=0;a=n
if M[x-1][y]:
t=b(M,x-1,y,n+1)
if a<t:a=t
if M[x][y-1]:
t=b(M,x,y-1,n+1)
if a<t:a=t
if M[x+1][y]:
t=b(M,x+1,y,n+1)
if a<t:a=t
if M[x][y+1]:
t=b(M,x,y+1,n+1)
if a<t:a=t
M[x][y]=1
return a
for e in iter(input,'0'):
n,m=int(e),int(eval(input()))
P=[[0]*(n+2)for _ in[0]*(m+2)]
for i in range(m):P[i+1][1:-1]=list(map(int,input().split()))
a=0
for i in range(1,m+1):
for j in range(1,n+1):
if P[i][j]:
t=b(P,i,j)
if a<t:a=t
print(a)
if'__main__'==__name__:s()
| p00458 |
def solve():
while True:
m, n = int(eval(input())), int(eval(input()))
if not m:
break
ices = [[0] + list(map(int,input().split())) + [0] for _ in range(n)]
ices.insert(0, [0] * (m + 2),)
ices.append([0] * (m + 2))
score = [[0] * (m + 2) for _ in range(n + 2)]
for x in range(1, n + 1):
for y in range(1, m + 1):
if ices[x][y]:
score[x - 1][y] += 1
score[x + 1][y] += 1
score[x][y - 1] += 1
score[x][y + 1] += 1
def search(x, y, imap, acc):
imap[x][y] = 0
acc += 1
a = b = c = d = 0
if imap[x - 1][y]:
a = search(x - 1, y, imap, acc)
if imap[x + 1][y]:
b = search(x + 1, y, imap, acc)
if imap[x][y - 1]:
c = search(x, y - 1, imap, acc)
if imap[x][y + 1]:
d = search(x, y + 1, imap, acc)
imap[x][y] = 1
return max(acc, a, b, c, d)
ans = 0
for x in range(1, n + 1):
for y in range(1, m + 1):
if score[x][y] in [1, 2] and ices[x][y]:
a = search(x, y, ices, 0)
if ans < a:
ans = a
print(ans)
solve()
| def solve():
while True:
m, n = int(eval(input())), int(eval(input()))
if not m:
break
ices = [[0] + list(map(int,input().split())) + [0] for _ in range(n)]
ices.insert(0, [0] * (m + 2),)
ices.append([0] * (m + 2))
score = [[0] * (m + 2) for _ in range(n + 2)]
for x in range(1, n + 1):
for y in range(1, m + 1):
score[x][y] = ices[x - 1][y] + ices[x + 1][y] + ices[x][y - 1] + ices[x][y + 1]
def search(x, y, imap, acc):
imap[x][y] = 0
acc += 1
a = b = c = d = 0
if imap[x - 1][y]:
a = search(x - 1, y, imap, acc)
if imap[x + 1][y]:
b = search(x + 1, y, imap, acc)
if imap[x][y - 1]:
c = search(x, y - 1, imap, acc)
if imap[x][y + 1]:
d = search(x, y + 1, imap, acc)
imap[x][y] = 1
return max(acc, a, b, c, d)
ans = 0
for x in range(1, n + 1):
for y in range(1, m + 1):
if score[x][y] in [1, 2] and ices[x][y]:
a = search(x, y, ices, 0)
if ans < a:
ans = a
print(ans)
solve()
| p00458 |
def solve():
while True:
m, n = int(eval(input())), int(eval(input()))
if not m:
break
ices = [[0] + list(map(int,input().split())) + [0] for _ in range(n)]
ices.insert(0, [0] * (m + 2),)
ices.append([0] * (m + 2))
score = [[0] * (m + 2) for _ in range(n + 2)]
for x in range(1, n + 1):
for y in range(1, m + 1):
score[x][y] = ices[x - 1][y] + ices[x + 1][y] + ices[x][y - 1] + ices[x][y + 1]
def search(x, y, imap, acc):
imap[x][y] = 0
acc += 1
a = b = c = d = 0
if imap[x - 1][y]:
a = search(x - 1, y, imap, acc)
if imap[x + 1][y]:
b = search(x + 1, y, imap, acc)
if imap[x][y - 1]:
c = search(x, y - 1, imap, acc)
if imap[x][y + 1]:
d = search(x, y + 1, imap, acc)
imap[x][y] = 1
return max(acc, a, b, c, d)
ans = 0
for x in range(1, n + 1):
for y in range(1, m + 1):
if score[x][y] in [1, 2] and ices[x][y]:
a = search(x, y, ices, 0)
if ans < a:
ans = a
print(ans)
solve()
| def solve():
while True:
m, n = int(eval(input())), int(eval(input()))
if not m:
break
ices = [[0] + list(map(int,input().split())) + [0] for _ in range(n)]
ices.insert(0, [0] * (m + 2),)
ices.append([0] * (m + 2))
score = [[0] * (m + 2) for _ in range(n + 2)]
for x in range(1, n + 1):
for y in range(1, m + 1):
score[x][y] = ices[x - 1][y] + ices[x + 1][y] + ices[x][y - 1] + ices[x][y + 1]
def search(x, y, imap, acc):
imap[x][y] = 0
acc += 1
ret = acc
a = b = c = d = 0
if imap[x - 1][y]:
a = search(x - 1, y, imap, acc)
if ret < a:
ret = a
if imap[x + 1][y]:
b = search(x + 1, y, imap, acc)
if ret < b:
ret = b
if imap[x][y - 1]:
c = search(x, y - 1, imap, acc)
if ret < c:
ret = c
if imap[x][y + 1]:
d = search(x, y + 1, imap, acc)
if ret < d:
ret = d
imap[x][y] = 1
return ret
ans = 0
for x in range(1, n + 1):
for y in range(1, m + 1):
if score[x][y] in [1, 2] and ices[x][y]:
a = search(x, y, ices, 0)
if ans < a:
ans = a
print(ans)
solve()
| p00458 |
from copy import deepcopy
from array import array
while True:
m = int(input())
n = int(input())
if m == 0 and n == 0:
break
begin = [array('b', [False] * m) for y in range(n)]
for y in range(n):
line = list(map(int, input().split(' ')))
for x in range(m):
if line[x] == 1:
begin[y][x] = True
# (stage, current position(x, y), current point)
que = []
for x in range(m):
for y in range(n):
if begin[y][x]:
stage = deepcopy(begin)
stage[y][x] = False
que.append((stage, (x, y), 1))
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
ans = 0
while que:
stage = que.pop()
for i in range(4):
nx = dx[i] + stage[1][0]
ny = dy[i] + stage[1][1]
if 0 <= nx < m and 0 <= ny < n and stage[0][ny][nx]:
field = deepcopy(stage[0])
field[ny][nx] = False
ans = max(ans, stage[2] + 1)
que.append((field, (nx, ny), stage[2] + 1))
print(ans) | from copy import deepcopy
while True:
m = int(input())
n = int(input())
if m == 0 and n == 0:
break
field = [[False] * m for y in range(n)]
for y in range(n):
line = list(map(int, input().split(' ')))
for x in range(m):
if line[x] == 1:
field[y][x] = True
ans = 0
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
def search(x, y, d):
global ans
if d > ans:
ans = d
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if 0 <= nx < m and 0 <= ny < n and field[ny][nx]:
field[ny][nx] = False
search(nx, ny, d + 1)
field[ny][nx] = True
for x in range(m):
for y in range(n):
if field[y][x]:
field[y][x] = False
search(x, y, 1)
field[y][x] = True
print(ans) | p00458 |
from collections import deque
while 1:
c = eval(input())
r = eval(input())
if c == 0: break
l = [list(map(int, input().split())) for i in range(r)]
ans = 0
d = [(-1,0),(0,-1),(1,0),(0,1)]
for i in range(c):
for j in range(r):
q = deque()
a = [[0]*c for x in range(r)]
if l[j][i] == 0: continue
a[j][i] = 1
q.append((j,i))
while len(q) != 0:
cy, cx = q.popleft()
for x, y in d:
dx = x + cx; dy = y + cy;
if 0<=dx<c and 0<=dy<r and a[dy][dx] == 0 and l[dy][dx] == 1:
q.append((dy, dx))
a[dy][dx] = a[cy][cx] + 1
for i in range(c):
for j in range(r):
ans = max(ans, a[j][i])
print(ans) | while 1:
c = eval(input())
r = eval(input())
if c == 0: break
l = [list(map(int, input().split())) for i in range(r)]
ans = 0
d = [(-1,0),(0,-1),(1,0),(0,1)]
def dfs(j, i, cnt):
global ans
ans = max(ans, cnt)
for x, y in d:
dx = x + i; dy = y + j
if 0<=dx<c and 0<=dy<r and l[dy][dx]:
l[dy][dx] = False
dfs(dy, dx, cnt+1)
l[dy][dx] = True
for i in range(c):
for j in range(r):
if l[j][i]:
l[j][i] = False
dfs(j,i,1)
l[j][i] = True
print(ans) | p00458 |
def check(p):
for i in range(1, 9):
if p[i] != p[0]:
return False
for i in range(10, 12):
if p[i] != p[9]:
return False
for i in range(13, 15):
if p[i] != p[12]:
return False
for i in range(16, 18):
if p[i] != p[15]:
return False
for i in range(19, 21):
if p[i] != p[18]:
return False
for i in range(22, 30):
if p[i] != p[21]:
return False
return True
def turn1(p):
p[6], p[21] = p[21], p[6]
p[7], p[22] = p[22], p[7]
p[8], p[23] = p[23], p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
def turn2(p):
p[0], p[27] = p[27], p[0]
p[1], p[28] = p[28], p[1]
p[2], p[29] = p[29], p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
def turn3(p):
p[0], p[23] = p[23], p[0]
p[3], p[26] = p[26], p[3]
p[6], p[29] = p[29], p[6]
p[20], p[9] = p[9], p[20]
p[17], p[15] = p[15], p[17]
def turn4(p):
p[2], p[21] = p[21], p[2]
p[5], p[24] = p[24], p[5]
p[8], p[27] = p[27], p[8]
p[18], p[11] = p[11], p[18]
p[14], p[12] = p[12], p[14]
def search(p, cnt):
if cnt > 8:
return 99
if check(p):
return cnt
r = 100
turn1(p)
r = min(r, search(p, cnt+1))
turn1(p)
turn2(p)
r = min(r, search(p, cnt+1))
turn2(p)
turn3(p)
r = min(r, search(p, cnt+1))
turn3(p)
turn4(p)
r = min(r, search(p, cnt+1))
turn4(p)
return r
N = int(eval(input()))
for l in range(N):
p = [int(i) for i in input().split()]
print((search(p, 0)))
|
def check(p):
for i in range(1, 9):
if p[i] != p[0]:
return False
for i in range(10, 12):
if p[i] != p[9]:
return False
for i in range(13, 15):
if p[i] != p[12]:
return False
for i in range(16, 18):
if p[i] != p[15]:
return False
for i in range(19, 21):
if p[i] != p[18]:
return False
for i in range(22, 30):
if p[i] != p[21]:
return False
return True
def turn1(p):
p[6], p[21] = p[21], p[6]
p[7], p[22] = p[22], p[7]
p[8], p[23] = p[23], p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
def turn2(p):
p[0], p[27] = p[27], p[0]
p[1], p[28] = p[28], p[1]
p[2], p[29] = p[29], p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
def turn3(p):
p[0], p[23] = p[23], p[0]
p[3], p[26] = p[26], p[3]
p[6], p[29] = p[29], p[6]
p[20], p[9] = p[9], p[20]
p[17], p[15] = p[15], p[17]
def turn4(p):
p[2], p[21] = p[21], p[2]
p[5], p[24] = p[24], p[5]
p[8], p[27] = p[27], p[8]
p[18], p[11] = p[11], p[18]
p[14], p[12] = p[12], p[14]
def search(p, cnt):
if cnt == 8:
return cnt
if check(p):
return cnt
r = 100
turn1(p)
r = min(r, search(p, cnt+1))
turn1(p)
turn2(p)
r = min(r, search(p, cnt+1))
turn2(p)
turn3(p)
r = min(r, search(p, cnt+1))
turn3(p)
turn4(p)
r = min(r, search(p, cnt+1))
turn4(p)
return r
N = int(eval(input()))
for l in range(N):
p = [int(i) for i in input().split()]
print((search(p, 0)))
| p00295 |
def rotate(p, comm):
if comm==0:
p[0],p[1],p[2], p[27],p[28],p[29] = p[27],p[28],p[29], p[0],p[1],p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
elif comm==1:
p[2],p[5],p[8], p[21],p[24],p[27] = p[21],p[24],p[27], p[2],p[5],p[8]
p[11], p[18] = p[18], p[11]
p[12], p[14] = p[14], p[12]
elif comm==2:
p[6],p[7],p[8], p[21],p[22],p[23] = p[21],p[22],p[23], p[6],p[7],p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
elif comm==3:
p[0],p[3],p[6], p[23],p[26],p[29] = p[23],p[26],p[29], p[0],p[3],p[6]
p[9], p[20] = p[20], p[9]
p[15], p[17] = p[17], p[15]
def all_eq(A, left, right):
return all(A[i]==A[left] for i in range(left, right))
def is_correct(p):
return all_eq(p, 9, 12) and all_eq(p, 12, 15) and all_eq(p, 15, 18) and all_eq(p, 18, 21) and all_eq(p, 0, 9) and all_eq(p, 21, 30)
def dfs(p, cnt, f):
ret = 9
if cnt==9:
return 9
if is_correct(p):
return cnt
for k in range(4):
if k==f:
continue
rotate(p, k)
ret = min(ret, dfs(p, cnt+1, k))
rotate(p, k)
return ret
n = eval(input())
for _ in range(n):
p = list(map(int, input().split()))
print(dfs(p, 0, -1)) | def rotate(p, comm):
if comm==0:
p[0],p[1],p[2], p[27],p[28],p[29] = p[27],p[28],p[29], p[0],p[1],p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
elif comm==1:
p[2],p[5],p[8], p[21],p[24],p[27] = p[21],p[24],p[27], p[2],p[5],p[8]
p[11], p[18] = p[18], p[11]
p[12], p[14] = p[14], p[12]
elif comm==2:
p[6],p[7],p[8], p[21],p[22],p[23] = p[21],p[22],p[23], p[6],p[7],p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
elif comm==3:
p[0],p[3],p[6], p[23],p[26],p[29] = p[23],p[26],p[29], p[0],p[3],p[6]
p[9], p[20] = p[20], p[9]
p[15], p[17] = p[17], p[15]
def all_eq(A, left, right):
return all(A[i]==A[left] for i in range(left, right))
def is_correct(p):
return all_eq(p, 9, 12) and all_eq(p, 12, 15) and all_eq(p, 15, 18) and all_eq(p, 18, 21) and all_eq(p, 0, 9) and all_eq(p, 21, 30)
ans = 8
def dfs(p, cnt, f):
global ans
if cnt>ans:
return
if is_correct(p):
ans = cnt
return
for k in range(4):
if k==f:
continue
rotate(p, k)
dfs(p, cnt+1, k)
rotate(p, k)
n = eval(input())
for _ in range(n):
p = list(map(int, input().split()))
ans = 8
dfs(p, 0, -1)
print(ans) | p00295 |
def rotate(p, comm):
if comm==0:
p[0],p[1],p[2], p[27],p[28],p[29] = p[27],p[28],p[29], p[0],p[1],p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
elif comm==1:
p[2],p[5],p[8], p[21],p[24],p[27] = p[21],p[24],p[27], p[2],p[5],p[8]
p[11], p[18] = p[18], p[11]
p[12], p[14] = p[14], p[12]
elif comm==2:
p[6],p[7],p[8], p[21],p[22],p[23] = p[21],p[22],p[23], p[6],p[7],p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
elif comm==3:
p[0],p[3],p[6], p[23],p[26],p[29] = p[23],p[26],p[29], p[0],p[3],p[6]
p[9], p[20] = p[20], p[9]
p[15], p[17] = p[17], p[15]
def all_eq(A, left, right):
return all(A[i]==A[left] for i in range(left, right))
def is_correct(p):
return all_eq(p, 9, 12) and all_eq(p, 12, 15) and all_eq(p, 15, 18) and all_eq(p, 18, 21) and all_eq(p, 0, 9) and all_eq(p, 21, 30)
ans = 8
def dfs(p, cnt, f):
global ans
if cnt>ans:
return
if is_correct(p):
ans = cnt
return
for k in range(4):
if k==f:
continue
rotate(p, k)
dfs(p, cnt+1, k)
rotate(p, k)
n = eval(input())
for _ in range(n):
p = list(map(int, input().split()))
ans = 8
dfs(p, 0, -1)
print(ans) | def rotate(p, comm):
if comm==0:
p[0],p[1],p[2], p[27],p[28],p[29] = p[27],p[28],p[29], p[0],p[1],p[2]
p[14], p[15] = p[15], p[14]
p[18], p[20] = p[20], p[18]
elif comm==1:
p[2],p[5],p[8], p[21],p[24],p[27] = p[21],p[24],p[27], p[2],p[5],p[8]
p[11], p[18] = p[18], p[11]
p[12], p[14] = p[14], p[12]
elif comm==2:
p[6],p[7],p[8], p[21],p[22],p[23] = p[21],p[22],p[23], p[6],p[7],p[8]
p[12], p[17] = p[17], p[12]
p[9], p[11] = p[11], p[9]
elif comm==3:
p[0],p[3],p[6], p[23],p[26],p[29] = p[23],p[26],p[29], p[0],p[3],p[6]
p[9], p[20] = p[20], p[9]
p[15], p[17] = p[17], p[15]
def all_eq(A, left, right):
return all(A[i]==A[left] for i in range(left, right))
def is_correct(p):
return all_eq(p, 9, 12) and all_eq(p, 12, 15) and all_eq(p, 15, 18) and all_eq(p, 18, 21) and all_eq(p, 0, 9) and all_eq(p, 21, 30)
ans = 8
def dfs(p, cnt, f):
global ans
if ans<=cnt:
return
if is_correct(p):
ans = cnt
return
for k in range(4):
if ans<=cnt+1:
break
if k==f:
continue
rotate(p, k)
dfs(p, cnt+1, k)
rotate(p, k)
n = eval(input())
for _ in range(n):
p = list(map(int, input().split()))
ans = 8
dfs(p, 0, -1)
print(ans) | p00295 |
def op1 (p) :
q = [i for i in p]
q[12] = p[17]
q[17] = p[12]
q[6] = p[21]
q[7] = p[22]
q[8] = p[23]
q[21] = p[6]
q[22] = p[7]
q[23] = p[8]
q[9] = p[11]
q[11] = p[9]
return q
def op2 (p) :
q = [i for i in p]
q[14] = p[15]
q[15] = p[14]
q[0] = p[27]
q[1] = p[28]
q[2] = p[29]
q[27] = p[0]
q[28] = p[1]
q[29] = p[2]
q[18] = p[20]
q[20] = p[18]
return q
def op3 (p) :
q = [i for i in p]
q[9] = p[20]
q[20] = p[9]
q[0] = p[23]
q[3] = p[26]
q[6] = p[29]
q[23] = p[0]
q[26] = p[3]
q[29] = p[6]
q[15] = p[17]
q[17] = p[15]
return q
def op4 (p) :
q = [i for i in p]
q[11] = p[18]
q[18] = p[11]
q[2] = p[21]
q[5] = p[24]
q[8] = p[27]
q[21] = p[2]
q[24] = p[5]
q[27] = p[8]
q[14] = p[12]
q[12] = p[14]
return q
def valid (p) :
for i in range(1, 9) :
if (p[0] != p[i]) :
return False
for i in range(10, 12) :
if (p[9] != p[i]) :
return False
for i in range(13, 15) :
if (p[12] != p[i]) :
return False
for i in range(16, 18) :
if (p[15] != p[i]) :
return False
for i in range(19, 21) :
if (p[18] != p[i]) :
return False
for i in range(22, 30) :
if (p[21] != p[i]) :
return False
return True
def solve (n, p) :
if (n > 8) :
return 100
if (valid(p)) :
return 0
s = [solve(n + 1, op1(p)), solve(n + 1, op2(p)), solve(n + 1, op3(p)), solve(n + 1, op4(p))]
s.sort()
return s[0] + 1
N = int(eval(input()))
for i in range(0, N) :
p = [int(term) - 1 for term in input().split()]
print((solve(0, p))) | def op1 (p) :
return (
p[ 0],p[ 1],p[ 2],p[ 3],p[ 4],p[ 5],p[21],p[22],p[23],p[11],p[10],p[9],p[17],p[13],p[14],
p[15],p[16],p[12],p[18],p[19],p[20],p[ 6],p[ 7],p[ 8],p[24],p[25],p[26],p[27],p[28],p[29]
)
def op2 (p) :
return (
p[27],p[28],p[29],p[ 3],p[ 4],p[ 5],p[ 6],p[ 7],p[ 8],p[ 9],p[10],p[11],p[12],p[13],p[15],
p[14],p[16],p[17],p[20],p[19],p[18],p[21],p[22],p[23],p[24],p[25],p[26],p[ 0],p[ 1],p [2]
)
q = [i for i in p]
q[14] = p[15]
q[15] = p[14]
q[0] = p[27]
q[1] = p[28]
q[2] = p[29]
q[27] = p[0]
q[28] = p[1]
q[29] = p[2]
q[18] = p[20]
q[20] = p[18]
return q
def op3 (p) :
return (
p[23],p[ 1],p[ 2],p[26],p[ 4],p[ 5],p[29],p[ 7],p[ 8],p[20],p[10],p[11],p[12],p[13],p[14],
p[15],p[16],p[17],p[18],p[19],p[ 9],p[21],p[22],p[ 0],p[24],p[25],p[ 3],p[27],p[28],p[ 6]
)
def op4 (p) :
return (
p[ 0],p[ 1],p[21],p[ 3],p[ 4],p[24],p[ 6],p[ 7],p[27],p[ 9],p[10],p[18],p[14],p[13],p[12],
p[15],p[16],p[17],p[11],p[19],p[20],p[ 2],p[22],p[23],p[ 5],p[25],p[26],p[ 8],p[28],p[29]
)
def valid (p) :
for i in range(1, 9) :
if (p[0] != p[i]) :
return False
for i in range(10, 12) :
if (p[9] != p[i]) :
return False
for i in range(13, 15) :
if (p[12] != p[i]) :
return False
for i in range(16, 18) :
if (p[15] != p[i]) :
return False
for i in range(19, 21) :
if (p[18] != p[i]) :
return False
for i in range(22, 30) :
if (p[21] != p[i]) :
return False
return True
def solve (n, p) :
if (n > 8) :
return 100
if (valid(p)) :
return 0
s = [solve(n + 1, op1(p)), solve(n + 1, op2(p)), solve(n + 1, op3(p)), solve(n + 1, op4(p))]
s.sort()
return s[0] + 1
N = int(eval(input()))
for i in range(0, N) :
p = tuple([int(term) - 1 for term in input().split()])
print((solve(0, p))) | p00295 |
def op1 (p) :
return (
p[ 0],p[ 1],p[ 2],p[ 3],p[ 4],p[ 5],p[21],p[22],p[23],p[11],p[10],p[9],p[17],p[13],p[14],
p[15],p[16],p[12],p[18],p[19],p[20],p[ 6],p[ 7],p[ 8],p[24],p[25],p[26],p[27],p[28],p[29]
)
def op2 (p) :
return (
p[27],p[28],p[29],p[ 3],p[ 4],p[ 5],p[ 6],p[ 7],p[ 8],p[ 9],p[10],p[11],p[12],p[13],p[15],
p[14],p[16],p[17],p[20],p[19],p[18],p[21],p[22],p[23],p[24],p[25],p[26],p[ 0],p[ 1],p [2]
)
def op3 (p) :
return (
p[23],p[ 1],p[ 2],p[26],p[ 4],p[ 5],p[29],p[ 7],p[ 8],p[20],p[10],p[11],p[12],p[13],p[14],
p[15],p[16],p[17],p[18],p[19],p[ 9],p[21],p[22],p[ 0],p[24],p[25],p[ 3],p[27],p[28],p[ 6]
)
def op4 (p) :
return (
p[ 0],p[ 1],p[21],p[ 3],p[ 4],p[24],p[ 6],p[ 7],p[27],p[ 9],p[10],p[18],p[14],p[13],p[12],
p[15],p[16],p[17],p[11],p[19],p[20],p[ 2],p[22],p[23],p[ 5],p[25],p[26],p[ 8],p[28],p[29]
)
def valid (p) :
for i in range(1, 9) :
if (p[0] != p[i]) :
return False
for i in range(10, 12) :
if (p[9] != p[i]) :
return False
for i in range(13, 15) :
if (p[12] != p[i]) :
return False
for i in range(16, 18) :
if (p[15] != p[i]) :
return False
for i in range(19, 21) :
if (p[18] != p[i]) :
return False
for i in range(22, 30) :
if (p[21] != p[i]) :
return False
return True
def solve (n, p) :
if (n > 8) :
return 100
if (valid(p)) :
return 0
s = [solve(n + 1, op1(p)), solve(n + 1, op2(p)), solve(n + 1, op3(p)), solve(n + 1, op4(p))]
s.sort()
return s[0] + 1
N = int(eval(input()))
for i in range(0, N) :
p = tuple([int(term) - 1 for term in input().split()])
print((solve(0, p))) | def op1 (p) :
return (
p[ 0],p[ 1],p[ 2],p[ 3],p[ 4],p[ 5],p[21],p[22],p[23],p[11],p[10],p[ 9],p[17],p[13],p[14],
p[15],p[16],p[12],p[18],p[19],p[20],p[ 6],p[ 7],p[ 8],p[24],p[25],p[26],p[27],p[28],p[29]
)
def op2 (p) :
return (
p[27],p[28],p[29],p[ 3],p[ 4],p[ 5],p[ 6],p[ 7],p[ 8],p[ 9],p[10],p[11],p[12],p[13],p[15],
p[14],p[16],p[17],p[20],p[19],p[18],p[21],p[22],p[23],p[24],p[25],p[26],p[ 0],p[ 1],p [2]
)
def op3 (p) :
return (
p[23],p[ 1],p[ 2],p[26],p[ 4],p[ 5],p[29],p[ 7],p[ 8],p[20],p[10],p[11],p[12],p[13],p[14],
p[17],p[16],p[15],p[18],p[19],p[ 9],p[21],p[22],p[ 0],p[24],p[25],p[ 3],p[27],p[28],p[ 6]
)
def op4 (p) :
return (
p[ 0],p[ 1],p[21],p[ 3],p[ 4],p[24],p[ 6],p[ 7],p[27],p[ 9],p[10],p[18],p[14],p[13],p[12],
p[15],p[16],p[17],p[11],p[19],p[20],p[ 2],p[22],p[23],p[ 5],p[25],p[26],p[ 8],p[28],p[29]
)
def op (p, i) :
if (i == 1) :
return op1(p)
elif (i == 2) :
return op2(p)
elif (i == 3) :
return op3(p)
elif (i == 4) :
return op4(p)
def valid (p) :
for i in range(1, 9) :
if (p[0] != p[i]) :
return False
for i in range(22, 30) :
if (p[21] != p[i]) :
return False
for i in range(10, 12) :
if (p[9] != p[i]) :
return False
for i in range(13, 15) :
if (p[12] != p[i]) :
return False
for i in range(16, 18) :
if (p[15] != p[i]) :
return False
for i in range(19, 21) :
if (p[18] != p[i]) :
return False
q = (p[0], p[9], p[12], p[15], p[18], p[21])
if (q == (0, 1, 3, 5, 4, 2)) :
return True
if (q == (0, 3, 5, 4, 1, 2)) :
return True
if (q == (0, 5, 4, 1, 3, 2)) :
return True
if (q == (0, 4, 1, 3, 5, 2)) :
return True
if (q == (2, 1, 5, 3, 4, 0)) :
return True
if (q == (2, 5, 3, 4, 1, 0)) :
return True
if (q == (2, 3, 4, 1, 5, 0)) :
return True
if (q == (2, 4, 1, 5, 3, 0)) :
return True
return False
def solve (n, p, i) :
global minimum
if (n > 9) :
return
if (n >= minimum) :
return
if (valid(p)) :
minimum = min(minimum, n)
return
for j in range(1, 5) :
if (i != j) :
solve(n + 1, op(p, j), j)
return
minimum = 100
N = int(eval(input()))
for kk in range(0, N) :
minimum = 100
p = tuple([int(term) - 1 for term in input().split()])
if (valid(p)) :
print((0))
continue
for i in range(1, 5) :
solve(1, op(p, i), i)
print(minimum) | p00295 |
while 1:
n=int(eval(input()))
if n==0:break
a=0
for i in range(1,n//2):a+=(n+2*i-1)//(2*i)-1
print((8*(2*n-1+a))) | while 1:
n=int(eval(input()))
if n==0:break
a=0;i=1;b=n//2
while i*i<b:a+=((b-1)//i+1)-i-1;i+=1
a=(a+b-1)*2+i
print((8*(a+n))) | p00612 |
x, t = (int(x) for x in input().split())
if x > t:
ans = x-t
else:
ans = 0
print(ans) | x, t = list(map(int, input().split()))
f = lambda x: x if x > 0 else 0
print((f(x-t))) | p03609 |
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
X,t = MI()
print((max(0,X-t)))
| import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
X,t = MI()
print((max(0,X-t)))
| p03609 |
a,b=list(map(int,input().split()));print((max(0,a-b))) | x,t=list(map(int,input().split()))
print((max(0,x-t))) | p03609 |
import sys
x, t = (int(i) for i in sys.stdin.readline().split())
print((x - t if x > t else 0)) | import sys
def main():
X, t = list(map(int, sys.stdin.readline().split()))
ans = max(0, X - t)
print(ans)
if __name__ == '__main__':
main() | p03609 |
a,b = list(map(int,input().split()))
print((max(a-b,0))) | def main():
x,t = list(map(int,input().split()))
print((max(0,x-t)))
if __name__ == '__main__':
main()
| p03609 |
X, t = list(map(int, input().split()))
print((max(X - t, 0))) | X, t = list(map(int, input().split()))
print((max(0, X - t))) | p03609 |
x,t=list(map(int, input().split()))
if x-t>0:
print((int(x-t)))
else:
print((int(0))) | x,t=list(map(int, input().split()))
A=x-t
if A>=0:
print(A)
else:
print((0)) | p03609 |
X, t = list(map(int, input().split()))
print((max(X - t, 0))) | X, t = list(map(int, input().split()))
if X > t:
print((X -t))
else:
print((0)) | p03609 |
x,t=list(map(int,input().split()))
print(("0" if x-t<0 else x-t)) | print((max(eval(input().replace(" ","-")),0))) | p03609 |
print((max(0,eval(input().replace(' ','-'))))) | print((max(eval(input().replace(*' -')),0))) | p03609 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.