input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
ans = 0
capa = 0
dept = -1
for t in sorted(T):
if t > dept or capa == 0:
ans += 1
dept = t+K
capa = C-1
else:
capa -= 1
print(ans) | N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
cap = C-1
dep = T[0] + K
ans = 1
for t in T[1:]:
if cap and t <= dep:
cap -= 1
else:
cap = C-1
dep = t + K
ans += 1
print(ans) | p03785 |
N, C, K = list(map(int, input().split()))
Tlist = sorted([int(eval(input())) for _ in range(N)])
ans = 0
count = 0
for i in range(N):
now = Tlist[i]
if count == 0:
rl = now + K
count += 1
continue
else:
if now <= rl <= now + K and count < C:
count += 1
else:
ans += 1
rl = now + K
count = 1
print((ans + 1))
| N, C, K = list(map(int, input().split()))
Tlist = sorted([int(eval(input())) for _ in range(N)])
ans = 0
now = 1
start = Tlist[0]
for t in Tlist[1:]:
if now == C:
ans += 1
start = t
now = 1
else:
if t - start <= K:
now += 1
else:
ans += 1
start = t
now = 1
print((ans+1))
| p03785 |
n,c,k=list(map(int,input().split()))
t=[int(eval(input())) for x in range(n)]
t.sort()
i=0
cnt=0
while i<n:
departure=t[i]+k
p=0
for j in range(i,n):
if t[j] > departure or p==c:
break
p+=1
i+=p
cnt+=1
print(cnt) | import sys
n,c,k,*t = list(map(int, sys.stdin.read().split()))
t.sort()
i=0
cnt=0
while i<n:
departure=t[i]+k
p=0
for j in range(i,n):
if t[j] > departure or p==c:
break
p+=1
i+=p
cnt+=1
print(cnt)
| p03785 |
n, c, k = list(map(int, input().split()))
t = sorted([int(eval(input())) for _ in range(n)])
bus = []
ans = 0
while len(t) != 0:
temp = t.pop(0)
if len(bus) == 0:
bus.append(temp)
else:
if temp < bus[0] + k:
bus.append(temp)
if len(bus) == c:
ans += 1
bus = []
else:
ans += 1
bus = []
print((ans+1)) | n, c, k = list(map(int,input().split()))
t = sorted([int(eval(input())) for _ in range(n)])
ans = 0
bus = []
for i in range(n):
if len(bus) == c:
ans += 1
bus = [t[i]]
elif bus != [] and bus[0] + k < t[i]:
ans += 1
bus = [t[i]]
else:
bus.append(t[i])
print((ans+1)) | p03785 |
import sys
input = sys.stdin.readline
n, c, k = [int(w) for w in input().split()]
la = [int(eval(input())) for _ in range(n)]
la.sort()
lak = [a + k for a in la]
ind = 0
ans = 0
while ind < n:
ride = 0
for i in range(min(c, n - ind)):
if la[ind + i] <= lak[ind]:
ride += 1
ind += ride
ans += 1
print(ans)
| import sys
import bisect
input = sys.stdin.readline
n, c, k = [int(w) for w in input().split()]
la = [int(eval(input())) for _ in range(n)]
la.sort()
lak = [a + k for a in la]
ind = 0
ans = 0
while ind < n:
ride = bisect.bisect_right(la, lak[ind]) - ind
ind += min(ride, c)
ans += 1
print(ans)
| p03785 |
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
count = 0
ans = 0
start = 0
for i in range(N):
if count < C:
if count == 0:
count += 1
start = T[i]
else:
if T[i] <= start + K:
count += 1
else:
ans += 1
count = 1
start = T[i]
else:
count = 1
ans += 1
start = T[i]
if i == N - 1:
ans += 1
print(ans)
| N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
prev = -1
r = 0
ans = 0
for t in T:
if prev > 0 and t - prev > K:
prev = t
r = 1
ans += 1
elif prev < 0:
prev = t
ans += 1
r = 1
else:
r += 1
if r == C:
prev = -1
r = 0
print(ans)
| p03785 |
N, C, K = [int(_) for _ in input().split()]
times = sorted([int(eval(input())) for _ in range(N)])
count = 0
while times:
t = times.pop(0)
count += 1
num = 1
while times:
if times[0] <= t + K and num < C:
times.pop(0)
num += 1
else:
break
print(count)
| N, C, K = [int(_) for _ in input().split()]
times = sorted([int(eval(input())) for _ in range(N)], reverse=True)
count = 0
while times:
t = times.pop()
count += 1
num = 1
while times:
if times[-1] <= t + K and num < C:
times.pop()
num += 1
else:
break
print(count)
| p03785 |
N, C, K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
counter = 0
i = 0
while i<N:
for j in range(C):
if i+(C-j-1)<N and T[i]+K >= T[i+(C-j-1)]:
counter += 1
i = i+(C-j-1)+1
break
print(counter)
| N, C, K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort(reverse = True)
counter = 1
i = 0 #### whileの中のカウント（バス乗車数）
A = T.pop() #####先頭
while T:
a = T.pop()
i+=1
if i>=C or a>A+K:
i=0
A=a
counter += 1
print(counter) | p03785 |
def resolve():
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
count_bus = 0
L = len(T)
i = 0
while i < L:
# print('T[{}]: {}'.format(i, T[i]))
t = T[i]
for j in range(1, C):
if i+j >= L:
i += j
count_bus += 1
break
if T[i+j] <= t + K:
pass
if j == C-1:
i += j + 1
count_bus += 1
break
else:
count_bus += 1
i += j
break
print(count_bus)
if __name__ == '__main__':
resolve() | N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for _ in range(N)]
T.sort()
# print(T)
bus = 1
org = T[0]
_count = 0
for t in T:
if t - org <= K and _count < C:
_count += 1
# print('1- t:{}, org:{}, _count:{}, bus:{}'.format(t, org, _count, bus))
else:
bus += 1
org = t
_count = 1
# print('2- t:{}, org:{}, _count:{}, bus:{}'.format(t, org, _count, bus))
print(bus) | p03785 |
# https://atcoder.jp/contests/agc011/tasks/agc011_a
n, c, k = list(map(int, input().split()))
schedule = []
for _ in range(n):
t = int(eval(input()))
schedule.append(t)
schedule.sort()
# schedule.append(float('inf'))
def check(num, schedule, c, k):
bus = 0
start = schedule[0]
p = 0
i = 0
while i < len(schedule):
s = schedule[i]
if s <= start + k:
p += 1
i += 1
if p == c:
bus += 1
p = 0
if i == len(schedule):
break
start = schedule[i]
else:
start = schedule[i]
bus += 1
p = 1
i += 1
if p:
bus += 1
if bus <= num:
return True
return False
l = 0
r = 10 ** 10
ans = float('inf')
while l <= r:
mid = (l + r) // 2
if check(mid, schedule, c, k):
r = mid - 1
ans = min(ans, mid)
else:
l = mid + 1
print(ans)
| # https://atcoder.jp/contests/agc011/tasks/agc011_a
n, c, k = list(map(int, input().split()))
schedule = []
for _ in range(n):
t = int(eval(input()))
schedule.append(t)
schedule.sort()
ans = 0
start = schedule[0]
p = 0
for i in range(n):
s = schedule[i]
if s <= start + k:
p += 1
if p == c:
ans += 1
p = 0
if i + 1 == n:
break
start = schedule[i + 1]
else:
ans += 1
start = schedule[i]
p = 1
if p:
ans += 1
print(ans)
| p03785 |
import sys
from bisect import bisect_right
input = sys.stdin.readline
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
answer = 0
while T:
n = min(C - 1, len(T) - 1)
if T[n] <= T[0] + K:
n = C
else:
n = bisect_right(T, T[0] + K)
T = T[n:]
answer += 1
print(answer) | import sys
input = sys.stdin.readline
N, C, K = list(map(int, input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
answer = 1
limit = T[0] + K
n = 0
for i in T:
if i <= limit and n < C:
n += 1
else:
answer += 1
n = 1
limit = i + K
print(answer) | p03785 |
N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
i = 0
ans = 0
while i < N:
t = T[i]
x = T.count(T[i])
ans = ans + (x-1+C)//C
if T[N-1]<t+K:
y = N-i
else:
for j in range(i+((x-1+C)//C-1)*C,N):
if T[j]>t+K:
y = j-i
break
y=min(C,y)
i = i + y
print(ans) | N,C,K = list(map(int,input().split()))
T = [int(eval(input())) for i in range(N)]
T.sort()
i = 0
ans = 0
time =0
p = 0
for i in range(N):
if p==0 or p ==C:
ans = ans+1
p =1
time =T[i]+K
elif p<C :
if T[i]<=time:
p +=1
elif T[i]>time:
ans =ans+1
time=T[i]+K
p =1
print(ans)
| p03785 |
# import sys
# sys.stdin = open('a2.in')
n, c, k = list(map(int, input().split()))
arrivals = [int(eval(input())) for i in range(n)]
arrivals.sort()
res = 0
room = c
bus_start = None
for t in arrivals:
if room == c:
bus_start = t
has_left_because_angry_passenger = bus_start + k < t
if has_left_because_angry_passenger:
res += 1
room = c
bus_start = t
room -= 1
if room == 0:
res += 1
room = c
if room < c:
res += 1
print(res)
| n, c, k = list(map(int, input().split()))
arrivals = [int(eval(input())) for i in range(n)]
arrivals.sort()
res = 0
room = c
bus_start = None
for t in arrivals:
previous_bus_has_left = bus_start is not None and bus_start + k < t
if previous_bus_has_left:
res += 1
room = c
if room == c:
bus_start = t
room -= 1
if room == 0:
res += 1
room = c
bus_start = None
if room < c:
res += 1
print(res) | p03785 |
import bisect
# from collections import Counter, deque # https://note.nkmk.me/python-scipy-connected-components/
# from copy import copy, deepcopy
# from functools import reduce
# from heapq import heapify, heappop, heappush
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components # Pythonのみ！
# ↑cf. https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import string
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
TT = [i + K for i in T]
cnt = 0
i = 0
temp = -1
while True:
i = bisect.bisect_right(T, TT[i])
if i - temp > C:
i = temp + C + 1
temp += C
cnt += 1
temp=i-1
if i >= N:
break
print(cnt)
resolve() | import bisect
import sys
def input(): return sys.stdin.readline().strip()
N, C, K = list(map(int, input().split()))
T = sorted([int(eval(input())) for i in range(N)])
TT = [i + K for i in T]
cnt = 0
i = 0
temp = -1 # temp番まで運び終わった
while True:
i = bisect.bisect_right(T, TT[i])
if i - temp > C:
i = temp + C + 1
temp += C
cnt += 1
temp = i - 1
if i >= N:
break
print(cnt) | p03785 |
from functools import lru_cache
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
sum_x = sum(x)
X = max(x + [A])
answer = 0
@lru_cache(maxsize=None)
def solve(j, k, s):
global x
if j == 0 and k == 0 and s == 0:
return 1
elif j >= 1 and s < x[j - 1]:
return solve(j-1, k, s)
elif j >= 1 and k >= 1 and s >= x[j - 1]:
return solve(j-1, k, s) + solve(j-1, k - 1, s - x[j - 1])
else:
return 0
for k in range(1, N + 1):
answer += solve(N, k, k * A)
print(answer)
| from functools import lru_cache
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
y = list([i - A for i in x])
X = max(max(x), A)
@lru_cache(maxsize=None)
def solve(j, t):
global y
if j == 0 and t == 0:
return 1
elif j >= 1 and (t < y[j - 1] - N * X or t > y[j - 1] + N * X):
return solve(j - 1, t)
elif j >= 1 and t >= y[j - 1] - N * X and t <= y[j - 1] + N * X:
return solve(j - 1, t) + solve(j - 1, t - y[j - 1])
else:
return 0
print((solve(N, 0) - 1))
| p04013 |
from itertools import product
N, A = list(map(int, input().split()))
x = [int(xi) for xi in input().split()]
x_max = max(max(x), A)
dp = [[[0 for _ in range((N + 1) * x_max)]
for _ in range(N + 1)]
for _ in range(N + 1)]
dp[0][0][0] = 1
for j, k, s in product(list(range(1, N + 1)),
list(range(N + 1)),
list(range((N + 1) * x_max))):
if s < x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s]
elif k >= 1 and s >= x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j - 1]]
answer = sum([dp[N][k][k*A] for k in range(1, N + 1)])
print(answer)
| from itertools import product
N, A = list(map(int, input().split()))
x = [int(xi) for xi in input().split()]
y = [xi - A for xi in x]
X = max(max(x), A)
dp = [[0 for _ in range(2 * N * X + 1)] for _ in range(N + 1)]
dp[0][N * X] = 1
for k, t in product(list(range(1, N + 1)), list(range(2 * N * X + 1))):
if k > 0 and (t - y[k - 1] < 0 or t - y[k - 1] > 2 * N * X):
dp[k][t] = dp[k - 1][t]
elif k > 0 and t - y[k - 1] <= 2 * N * X:
dp[k][t] = dp[k - 1][t] + dp[k - 1][t - y[k - 1]]
print((dp[N][N * X] - 1)) | p04013 |
from itertools import combinations
N, A = list(map(int, input().split()))
l = list(map(int, input().split()))
cnt = 0
for i in range(1,N+1):
for cmb in combinations(l,i):
if sum(cmb) / i == A:
cnt += 1
print(cnt) | N, A = list(map(int, input().split()))
X = list([int(x) - A for x in input().split()])
dp = [[0 for j in range(100 * N + 1)] for i 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 - X[i]]
print((dp[N][50 * N] -1)) | p04013 |
import collections
N, A = list(map(int, input().split()))
xs = list(map(int, input().split()))
dp = collections.defaultdict(lambda: 0)
dp[(0, 0)] = 1
for n, x in enumerate(xs, start=1):
for (k, accum), count in list(dp.items()):
dp[(k + 1, accum + x)] += count
found = 0
for (k, accum), count in list(dp.items()):
if k > 0 and k * A == accum:
found += count
print(found) | import collections
N, A = list(map(int, input().split()))
ys = [int(x) - A for x in input().split()]
dp = collections.defaultdict(lambda: 0)
dp[0] = 1
for y in ys:
for accum, count in list(dp.items()):
dp[accum + y] += count
found = -1 # for dp[0]
for accum, count in list(dp.items()):
if accum == 0:
found += count
print(found) | p04013 |
def f(n,x,i):
if n == 0:
if i != 0:
if x/i == m:
return 1
return 0
if memo[n-1][i][x] != -1 :
if memo[n-1][i][x] > 0:
return memo[n-1][i][x]
memo[n-1][i][x] = f(n-1,x,i)+f(n-1,x+a[n-1],i+1)
return memo[n-1][i][x]
n, m= list(map(int,input().split()))
a = list(map(int,input().split()))
memo = [[[-1 for _ in range(sum(a)+1)]for i in range(n)]for i in range(n)]
print((f(n,0,0))) | def f(n,x,i):
if n == 0:
if i != 0:
if x/i == m:
return 1
return 0
if memo[n-1][i][x] != -1 :
return memo[n-1][i][x]
memo[n-1][i][x] = f(n-1,x,i)+f(n-1,x+a[n-1],i+1)
return memo[n-1][i][x]
n, m= list(map(int,input().split()))
a = list(map(int,input().split()))
memo = [[[-1 for _ in range(sum(a)+1)]for i in range(n)]for i in range(n)]
print((f(n,0,0))) | p04013 |
def f(n,x,i):
if n == 0:
if i != 0:
if x/i == m:
return 1
return 0
if memo[n-1][i][x] != -1 :
return memo[n-1][i][x]
memo[n-1][i][x] = f(n-1,x,i)+f(n-1,x+a[n-1],i+1)
return memo[n-1][i][x]
n, m= list(map(int,input().split()))
a = list(map(int,input().split()))
memo = [[[-1 for _ in range(sum(a)+1)]for i in range(n)]for i in range(n)]
print((f(n,0,0))) | def f(n,x,i):
if n == 0:
if x != 0:
if x / i == a:
return 1
return 0
if memo[i][n][x] != -1:
return memo[i][n][x]
memo[i][n][x] = f(n-1,x,i)+f(n-1,x+ary[n-1],i+1)
return memo[i][n][x]
n,a = list(map(int,input().split()))
ary = list(map(int,input().split()))
memo = [[[-1 for _ in range(sum(ary)+1)] for _ in range(n+1)] for _ in range(n+1)]
print((f(n,0,0))) | p04013 |
def larger(x, y):
if x > y: return x
else: return y
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
x.sort()
max = larger(x[-1], A)
dp = []
for i in range(0, N+1):
tmp1 = []
for j in range(0, N+1):
tmp2 = []
for k in range(0, N*max+1):
tmp2.append(0)
tmp1.append(tmp2)
dp.append(tmp1)
for i in range(0, N+1):
for j in range(0, N+1):
for k in range(0, N*max+1):
if i == 0:
if j == 0 and k == 0: dp[i][j][k] = 1
else:
if k < x[i-1]: dp[i][j][k] = dp[i-1][j][k]
elif j >= 1:
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i-1]]
ans = 0
for i in range(1, N+1):
ans = ans + dp[N][i][i*A]
print(ans) | def larger(x, y):
if x > y: return x
else: return y
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
x = [a-A for a in x]
max = larger(x[-1], A)
dp = []
for i in range(0, N+1):
tmp = []
for j in range(0, 2*N*max+1):
tmp.append(0)
dp.append(tmp)
for i in range(0, N+1):
for j in range(0, 2*N*max+1):
if i == 0:
if j == N*max: dp[i][j] = 1
else:
if j-x[i-1] < 0 or j-x[i-1] > 2*N*max:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = dp[i-1][j] + dp[i-1][j-x[i-1]]
print(dp[N][N*max]-1) | p04013 |
N, A, *x = list(map(int, open(0).read().split()))
c_nx = N * max(x + [A])
dp = [[[0] * (c_nx + 1) for _ in range(N + 1)]
for _ in range(N + 1)]
x = [0] + x
dp[0][0][0] = 1
for j in range(1, N + 1):
for k in range(N + 1):
for s in range(c_nx + 1):
if s < x[j]:
dp[j][k][s] = dp[j - 1][k][s]
elif s >= x[j]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j]]
print((sum(dp[N][k][k * A] for k in range(1, N + 1)))) | N, A, *x = list(map(int, open(0).read().split()))
NX = N * max(x + [A])
y = [0] + [v - A for v in x]
dp = [[0] * (2 * NX + 1) for _ in range(N + 1)]
dp[0][NX] = 1
for j in range(1, N + 1):
for t in range(2 * NX + 1):
if t - y[j] < 0 or t - y[j] > 2 * NX:
dp[j][t] = dp[j - 1][t]
elif 0 <= t - y[j] <= 2 * NX:
dp[j][t] = dp[j - 1][t] + dp[j - 1][t - y[j]]
print((dp[N][NX] - 1))
| p04013 |
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
cnt = 0
for i in range(1 << n):
ans=[]
for j in range(n):
if (i >> j) & 1:
ans.append(x[j])
if ans and sum(ans)/len(ans) == a:
cnt+=1
print(cnt) | N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
Y = [x-A for x in X]
dp = {0:1}
for y in Y:
tmp = list(dp.items())
for k,v in tmp:
dp[k+y]=dp.get(k+y,0)+v
print((dp[0]-1)) | p04013 |
# ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
from collections import defaultdict
def main():
N, A, *X = list(map(int, open(0).read().split()))
X, D = [i - A for i in X], defaultdict(int)
D[0] = 1
for i in X:
for j, k in list(D.items()):
D[i + j] += k
ans = D[0] - 1
print(ans)
if __name__ == "__main__":
main() | # ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
def main():
N, A, *X = list(map(int, open(0).read().split()))
X, D = [i - A for i in X], {0: 1}
for i in X:
for j, k in list(D.items()):
D[i + j] = D.get(i + j, 0) + k
ans = D[0] - 1
print(ans)
if __name__ == "__main__":
main() | p04013 |
n, a = list(map(int, input().split()))
xlist = list(sorted(map(int, input().split())))
maxx = xlist[-1] if xlist[-1] > a else a
# dp[j][k][s]: x_1...x_jまでのなかからk枚選んで合計をsにする総数
dp = [[[0 for _ in range(maxx * n + 1)] for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1 # 0枚選んで合計を0にするのは1通り
for j in range(n + 1):
for k in range(n + 1):
for s in range(maxx * k + 1):
if j >= 1 and s < xlist[j-1]: # x_0は選ばないのと同じなので0のまま更新しない
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= xlist[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-xlist[j-1]]
ans = 0
for k in range(1, n + 1):
ans += dp[n][k][k*a]
print(ans) | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
maxx = max(x)
maxx = max(maxx, a)
# dp[j][k][s] : j枚目までからk枚選んで合計をsにする場合の数
dp = [[[0 for _ in range(maxx * n + 1)] for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for j in range(n + 1):
for k in range(j + 1):
for s in range(maxx * k + 1):
if j >= 1 and s < x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s]
elif j >= 1 and k >= 1 and s >= x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j - 1]]
ans = 0
for k in range(1, n + 1):
ans += dp[n][k][k*a]
print(ans) | p04013 |
def count_up(N, A, x, check, card, total):
if check == N:
return 1 if card > 0 and card * A == total else 0
else:
return count_up(N, A, x, check+1, card+1, total+x[check]) + count_up(N, A, x, check+1, card, total)
def bad_method(N, A, x):
print(count_up(N, A, x, 0, 0, 0))
def well_method(N, A, x):
dp = [[[1 for a in range(N*50)] for b in range(N+1)] for c in range(N+1)]
for j in range(N+1):
for k in range(N+1):
for s in range(N*50):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
answer = 0
for i in range(1, N+1):
answer += dp[N][i][A * i]
print(answer)
line = input().split()
N = int(line[0])
A = int(line[1])
line = input().split()
x = {}
for i in range(N):
x[i] = int(line[i])
# bad_method(N, A, x)
well_method(N, A, x) | def count_up(N, A, x, check, card, total):
if check == N:
return 1 if card > 0 and card * A == total else 0
else:
return count_up(N, A, x, check+1, card+1, total+x[check]) + count_up(N, A, x, check+1, card, total)
def bad_method(N, A, x):
print(count_up(N, A, x, 0, 0, 0))
def well_method(N, A, x):
dp = [[[1 for a in range(N*50)] for b in range(N+1)] for c in range(N+1)]
for j in range(N+1):
for k in range(N+1):
for s in range(N*50):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
answer = 0
for i in range(1, N+1):
answer += dp[N][i][A * i]
print(answer)
def good_method(N, A, x):
y = {}
for i in range(len(x)):
y[i] = x[i] - A
dp = [[0 for a in range(N*50*2+1)] for b in range(N+1)]
for j in range(N+1):
for t in range(N*50*2+1):
if j == 0 and t == N*50:
dp[j][t] = 1
elif j >= 1 and (t - y[j-1] < 0 or t - y[j-1] > N*50*2):
dp[j][t] = dp[j-1][t]
elif j >= 1 and 0 <= t - y[j-1] and t - y[j-1] <= N*50*2:
dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]
else:
dp[j][t] = 0
print(dp[N][N*50]-1)
line = input().split()
N = int(line[0])
A = int(line[1])
line = input().split()
x = {}
for i in range(N):
x[i] = int(line[i])
# bad_method(N, A, x)
# well_method(N, A, x)
good_method(N, A, x) | p04013 |
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
max_x = max(x)
dp = [[[0]*(n*max_x+1) for i in range(n+1)] for j 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*max_x+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]]
else:
continue
ans = 0
for j in range(1,n+1):
if j*a <= n*max_x+1:
ans += dp[n][j][j*a]
print(ans) | n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
max_x = max(max(x),a)
dp = [[[0]*(n*max_x+1) for i in range(n+1)] for j 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*max_x+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]]
else:
continue
ans = 0
for j in range(1,n+1):
ans += dp[n][j][j*a]
print(ans) | p04013 |
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
X=max(max(x),a)
dp=[[[None for i in range(n*X+1)] for h in range(n+1)] for g in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(n*X+1):
if j==0 and k==0 and s==0:
dp[j][k][s]=1
elif j>=1 and x[j-1]>s:
dp[j][k][s]=dp[j-1][k][s]
elif j>=1 and k>=1 and x[j-1]<=s:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s]=0
ans=0
for i in range(1,n+1):
ans+=dp[n][i][i*a]
print(ans) | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
X=max(max(x),a)
y=[]
for i in x:
y.append(i-a)
dp=[[None for i in range(2*n*X+1)] for h in range(n+1)]
for j in range(n+1):
for t in range(2*n*X+1):
if j==0 and t==n*X:
dp[j][t]=1
elif j>=1 and (t-y[j-1]<0 or t-y[j-1]>2*n*X):
dp[j][t]=dp[j-1][t]
elif j>=1 and t-y[j-1]>=0 and t-y[j-1]<=2*n*X:
dp[j][t]=dp[j-1][t]+dp[j-1][t-y[j-1]]
else:
dp[j][t]=0
print((dp[n][n*X]-1)) | p04013 |
def resolve():
N, A = list(map(int, input().split()))
X = sorted(list(map(int, input().split())))
cnt = 0
for bits in range(1, 1<<N):
flags = list(bin(bits)[2:].zfill(N))
_X = [x for i, x in enumerate(X) if flags[i]=="1"]
cnt += 1 if sum(_X)/len(_X) == A else 0
print(cnt)
if '__main__' == __name__:
resolve()
| def resolve():
N, A = list(map(int, input().split()))
X = [int(i) - A for i in input().split()]
d = {0: 1}
for x in X:
for _sum, count in list(d.items()):
d[_sum+x] = d.get(_sum+x, 0) + count
print((d[0]-1))
if '__main__' == __name__:
resolve()
| p04013 |
n,a=list(map(int,input().split()))
l=[int(i) for i in input().split()]
ans=0
#dp=[[[0 for i in range(51)] for j in range(51)] for k in range(2501)]
dp=[[[0 for i in range(2501)] for j in range(51)] for k in range(51)]
dp[0][0][0]=1
for i in range(n):
for j in range(50):
for k in range(2501):
if dp[i][j][k]:
dp[i+1][j][k]+=dp[i][j][k]
dp[i+1][j+1][k+l[i]]+=dp[i][j][k]
for i in range(1,n+1):
ans+=dp[n][i][i*a]
print(ans) | def sol():
n,a=list(map(int,input().split()))
x=[int(i) for i in input().split()]
ans=chk=0
d=[[0]*2501 for j in range(51)]
d[0][0]=1
for i in x:
for j in range(2500,i-1,-1):
for k in range(50,0,-1):
d[k][j]+=d[k-1][j-i]
for i in range(1,51):
ans+=d[i][i*a]
print(ans)
if __name__=="__main__":
sol()
| p04013 |
def factorial(n):
k = 1
for i in range(n): k *= (i + 1)
return k
def binomial(a, b):
return factorial(a) // (factorial(a - b) * factorial(b))
cache = {}
def s(x, a, k, i):
key = (a, k, i)
if key in cache: return cache[key]
if a < 0: return 0
if k < 0: return 0
if k == 0:
if a == 0: return 1
else: return 0
if i > a: return 0
if i == 51: return 0
c = s(x, a, k, i + 1)
for j in range(1, x[i] + 1):
c += binomial(x[i], j) * s(x, a - i * j, k - j, i + 1)
cache[key] = c
return c
n, a = list(map(int, input().split()))
x = [0] * 51
for k in input().split():
x[int(k)] += 1
c = 0
for i in range(1, n + 1):
c += s(x, a * i, i, 0)
print(c)
| b = []
def binomial(n):
global b
b = [None] * n
for i in range(n):
b[i] = [0] * n
b[i][i] = 1
for i in range(1, n):
for j in range(1, i + 1):
b[i][j] = b[i - 1][j - 1] + b[i - 1][j]
cache = {}
def s(x, a, k, i):
key = (a, k, i)
if key in cache: return cache[key]
if a < 0: return 0
if k < 0: return 0
if k == 0:
if a == 0: return 1
else: return 0
if i > a: return 0
if i == 51: return 0
c = s(x, a, k, i + 1)
for j in range(1, x[i] + 1):
c += b[x[i] + 1][j + 1] * s(x, a - i * j, k - j, i + 1)
cache[key] = c
return c
n, a = list(map(int, input().split()))
binomial(n + 2)
x = [0] * 51
for k in input().split():
x[int(k)] += 1
c = 0
for i in range(1, n + 1):
c += s(x, a * i, i, 0)
print(c)
| p04013 |
b = []
def binomial(n):
global b
b = [None] * n
for i in range(n):
b[i] = [0] * n
b[i][i] = 1
for i in range(1, n):
for j in range(1, i + 1):
b[i][j] = b[i - 1][j - 1] + b[i - 1][j]
cache = {}
def s(x, a, k, i):
if a < 0: return 0
if k < 0: return 0
if k == 0:
if a == 0: return 1
else: return 0
if i > a: return 0
if i == 51: return 0
key = (a, k, i)
if key in cache: return cache[key]
c = s(x, a, k, i + 1)
for j in range(1, x[i] + 1):
c += b[x[i] + 1][j + 1] * s(x, a - i * j, k - j, i + 1)
cache[key] = c
return c
n, a = list(map(int, input().split()))
binomial(n + 2)
x = [0] * 51
for k in input().split():
x[int(k)] += 1
c = 0
for i in range(1, n + 1):
c += s(x, a * i, i, 0)
print(c)
| n, a = list(map(int, input().split()))
x = [int(i) for i in input().split()]
cache = {}
def s(v, k, i):
if i == n: return int(v > 0 and v == k * a)
if v > a * n: return 0
key = (v, k, i)
if key in cache: return cache[key]
cache[key] = s(v, k, i + 1) + s(v + x[i], k + 1, i + 1)
return cache[key]
print((s(0, 0, 0)))
| p04013 |
f=lambda:list(map(int,input().split()))
n,a=f()
l=[i-a for i in f()]
dp=[[0]*5000 for _ in range(51)]
Z=2500
dp[0][Z]=1
for i in range(n):
for s in range(5000-max(l[i],0)):
dp[i+1][s]+=dp[i][s]
dp[i+1][s+l[i]]+=dp[i][s]
print((dp[n][Z]-1)) | _,a,*l=list(map(int,open(0).read().split()))
d={0:1}
for i in l:
for k,v in list(d.copy().items()): d[i-a+k]=d.get(i-a+k,0)+v
print((d[0]-1)) | p04013 |
n,a,*l=list(map(int,open(0).read().split()))
R=2500
dp=[[0]*R*2,[0]*R*2]
dp[0][0]=1
for i in range(n):
for s in range(-R,R):
dp[i+1&1][s]=dp[i&1][s]+dp[i&1][s-l[i]+a]
print((dp[n&1][0]-1)) | n,a,*l=list(map(int,open(0).read().split()))
R=2500
dp=[[0]*R*2,[0]*R*2]
dp[0][0]=1
t=0
for i in range(n):
u=1-t
for s in range(-R,R):
dp[u][s]=dp[t][s]+dp[t][s-l[i]+a]
t=u
print((dp[t][0]-1)) | p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
M = max(x)
M = max(M, a)
dp = [[[0]*(n*M+1) for _ in range(n+1)] for _ in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(n*M+1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s>= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
ans = 0
for k in range(1, n+1):
ans += dp[n][k][k*a]
print(ans)
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
M = max(x)
M = max(M, a)
dp = [[[0]*(n*M+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for j in range(n):
for k in range(n+1):
for s in range(n*M+1):
if dp[j][k][s]:
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s + x[j]] += dp[j][k][s]
ans = 0
for k in range(1, n+1):
ans += dp[n][k][k*a]
print(ans)
| p04013 |
import collections
# input
n, a = list(map(int, input().split()))
X = [int(i) - a for i in input().split()]
sums = collections.Counter([0, X[0]])
# Xから1枚以上選んで作ることが可能な和:作り方の場合の数
# 1枚も選ばない＝0:1通り
# X[0]のみ選ぶ＝X[0]:1通り
for i in X[1:]: # 選べるカードを増やしていく (X[0] ~ X[i] から選ぶ)
sums2 = collections.Counter()
for s, c in list(sums.items()):
sums2[s + i] += c # X[0] ~ X[i - 1] で作れる和に X[i] を足す
sums += sums2
print((sums[0] - 1)) # 1枚も選ばないのはルール違反 | import collections
# input
n, a = list(map(int, input().split()))
X = [int(i) - a for i in input().split()]
S = collections.Counter([0, X[0]])
# Xから1枚以上選んで作ることが可能な和:作り方の場合の数
# 1枚も選ばない＝0:1通り
# X[0]のみ選ぶ＝X[0]:1通り
for i in X[1:]: # 選べるカードを増やしていく (X[0] ~ X[i] から選ぶ)
S_temp = collections.Counter()
for s, c in list(S.items()):
S_temp[s + i] += c # X[0] ~ X[i - 1] で作れる和に X[i] を足す
S += S_temp
print((S[0] - 1)) # 1枚も選ばないのはルール違反 | p04013 |
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
xlst.insert(0, 0)
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
for j in range(1, n + 1):
for k in range(1, n * 50 + 1):
if k >= x:
dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
else:
dp[i][j][k] += dp[i - 1][j][k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans) | def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
xlst.insert(0, 0)
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
main() | p04013 |
def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
xlst.insert(0, 0)
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
main() | def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
#xlst.insert(0, 0)
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
"""
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
"""
ans = 0
dp = [[0] * (n * 50 + 1) for _ in range(n + 1)]
dp[0][0] = 1
for x in xlst:
for j in range(n, 0, -1):
for k in range(n * 50, x - 1, -1):
dp[j][k] += dp[j - 1][k - x]
for j in range(1, n + 1):
ans += dp[j][j * a]
print(ans)
main() | p04013 |
def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
#xlst.insert(0, 0)
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
"""
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
"""
ans = 0
dp = [[0] * (n * 50 + 1) for _ in range(n + 1)]
dp[0][0] = 1
for x in xlst:
for j in range(n, 0, -1):
for k in range(n * 50, x - 1, -1):
dp[j][k] += dp[j - 1][k - x]
for j in range(1, n + 1):
ans += dp[j][j * a]
print(ans)
main() | def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
"""
xlst.insert(0, 0)
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
"""
dp = [[0] * (n * 50 + 1) for _ in range(n + 1)]
dp[0][0] = 1
for x in xlst:
for j in range(n, 0, -1):
dpj = dp[j]
dpj1 = dp[j - 1]
for k in range(n * 50, x - 1, -1):
dpj[k] += dpj1[k - x]
print((sum([dp[j][j * a] for j in range(1, n + 1)])))
main() | p04013 |
def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
"""
dp[i][j][k] ... iまででj個使ってkを作る
dp[i][j][k] += dp[i - 1][j - 1][k - x]
"""
"""
xlst.insert(0, 0)
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
"""
dp = [[0] * (n * 50 + 1) for _ in range(n + 1)]
dp[0][0] = 1
for x in xlst:
for j in range(n, 0, -1):
dpj = dp[j]
dpj1 = dp[j - 1]
for k in range(n * 50, x - 1, -1):
dpj[k] += dpj1[k - x]
print((sum([dp[j][j * a] for j in range(1, n + 1)])))
main() | def main():
n, a = list(map(int, input().split()))
xlst = list(map(int, input().split()))
"""
#dp[i][j][k] ... iまででj個使ってkを作る
#dp[i][j][k] += dp[i - 1][j - 1][k - x]
xlst.insert(0, 0)
dp = [[[0] * (50 * n + 1) for _ in range(n + 1)] for _ in range(n + 1)]
for i in range(n + 1):
dp[i][0][0] = 1
for i in range(1, n + 1):
x = xlst[i]
dpi = dp[i]
dpi_1 = dp[i - 1]
for j in range(1, n + 1):
dpij = dpi[j]
dpi_1j = dpi_1[j]
dpi_1j_1 = dpi_1[j - 1]
for k in range(1, n * 50 + 1):
if k >= x:
#dp[i][j][k] += dp[i - 1][j - 1][k - x] + dp[i - 1][j][k]
dpij[k] += dpi_1j_1[k - x] + dpi_1j[k]
else:
#dp[i][j][k] += dp[i - 1][j][k]
dpij[k] += dpi_1j[k]
ans = 0
for j in range(1, n + 1):
ans += dp[n][j][j * a]
print(ans)
"""
dp = [[0] * (n * 50 + 1) for _ in range(n + 1)]
dp[0][0] = 1
for x in xlst:
for j in range(n, 0, -1):
dpj = dp[j]
dpj1 = dp[j - 1]
for k in range(x, n * 50 + 1):
dpj[k] += dpj1[k - x]
print((sum([dp[j][j * a] for j in range(1, n + 1)])))
main() | p04013 |
n,a=list(map(int,input().split()))
arr=list(map(int,input().split()))
x=max(arr)
x=max(x,a)
dp=[[[0 for i in range(n*x+1)] for j in range(n+1)] for k in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1):
xi=arr[i-1]
for j in range(n+1):
for k in range(n*x+1):
if k<xi:
dp[i][j][k]=dp[i-1][j][k]
else:
if j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-xi]
ans=0
for i in range(1,n+1):
ans+=dp[n][i][i*a]
print(ans) | n,a=list(map(int,input().split()))
arr=list(map(int,input().split()))
l=n*max(a,max(arr))
dp=[[[0]*(l+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1):
xi=arr[i-1]
for j in range(0,i+1):
for k in range(0,l+1):
if k<xi:
dp[i][j][k]=dp[i-1][j][k]
elif j>=1:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-xi]
ans=0
for i in range(1,n+1):
ans+=dp[n][i][i*a]
print(ans) | p04013 |
def main():
N,A = list(map(int,input().split()))
X = [int(x) for x in input().split()]
dp = [[[0 for _ in range(2501)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for j in range(N):
now = X[j]
for k in range(N+1):
for s in range(2501):
if now>s:
dp[j+1][k][s] = dp[j][k][s]
else:
dp[j+1][k][s] = dp[j][k][s] + dp[j][k-1][s-now]
ans = 0
for i in range(1,N+1):
ans += dp[N][i][i*A]
print(ans)
if __name__=="__main__":
main() | def main():
n,a = list(map(int,input().split()))
x = [int(x) for x in input().split()]
dp= [[[0 for _ in range(2501)] for _ in range(n+1)] for _ in range(n)]
dp[0][0][0] = 1
dp[0][1][x[0]] = 1
for i in range(1,n):
for j in range(n+1):
for k in range(2501):
if k<x[i]:
dp[i][j][k] = dp[i-1][j][k]
else:
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-x[i]]
ans = 0
for i in range(1,n+1):
ans += dp[-1][i][a*i]
print(ans)
if __name__ == "__main__":
main() | p04013 |
from functools import lru_cache
N, A = list(map(int, input().split()))
X = tuple(int(x) for x in input().split())
# 平均を出すのに選んだ個数が必要
@lru_cache(maxsize=None)
def rec(x, a, k):
"""
:param x: tuple
数列
:param a: int
総和
:param k: int
選ぶ個数
:return: int
通り数
Number of patterns
"""
if k == 0:
if a == 0:
return 1
else:
return 0
if a < 0 or len(x) < k:
return 0
ret = rec(x[1:], a, k)
ret += rec(x[1:], a - x[0], k - 1)
return ret
X = tuple(sorted(X))
m = (rec(X, k * A, k) for k in range(1, N + 1))
print((sum(m))) | from functools import lru_cache
N, A = list(map(int, input().split()))
X = tuple(int(x) for x in input().split())
# 平均を出すのに選んだ個数が必要
@lru_cache(maxsize=None)
def rec(i, a, k):
"""
:param i: int
数列の長さ
:param a: int
総和
:param k: int
選ぶ個数
:return: int
通り数
Number of patterns
"""
if k == 0:
if a == 0:
return 1
else:
return 0
if a < 0 or i < k:
return 0
ret = rec(i - 1, a, k)
ret += rec(i - 1, a - X[i - 1], k - 1)
return ret
i = len(X)
m = (rec(i, k * A, k) for k in range(1, N + 1))
print((sum(m))) | p04013 |
import sys
from collections import deque, Counter
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
n, a = na()
x = na()
x = [0] + x
dp = [[[0] * (50 * n + 1) for i in range(n+1)] for j in range(n+1)]
for j in range(n + 1):
for k in range(j + 1):
for s in range(50 * n + 1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j]:
dp[j][k][s] = dp[j - 1][k][s]
elif j >= 1 and k >= 1 and s >= x[j]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j]]
else:
dp[j][k][s] = 0
print((sum([dp[n][k][k * a] for k in range(1, n+1)])))
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
n, a = na()
x = na()
x = [0] + x
dp = [[[0] * (50 * n + 1) for i in range(n+1)] for j in range(n+1)]
for j in range(n + 1):
for k in range(j + 1):
for s in range(50 * n + 1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j]:
dp[j][k][s] = dp[j - 1][k][s]
elif j >= 1 and k >= 1 and s >= x[j]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j]]
else:
dp[j][k][s] = 0
print((sum([dp[n][k][k * a] for k in range(1, n+1)])))
| p04013 |
def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
# print('cache!')
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
TABLE[i][n][total] = 1
return 1
TABLE[i][n][total] = 0
return 0
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
return ans1 + ans2
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print((solve()))
| def solve():
def recur(i, n, total):
# print("i, n, total", i, n, total)
if not TABLE[i][n][total] == -1:
# print('cache!')
return TABLE[i][n][total]
if not i < N:
if n > 0 and total == A * n:
return 1
return 0
ans1 = recur(i + 1, n, total)
ans2 = recur(i + 1, n + 1, total + XS[i])
# print(ans1, ans2)
TABLE[i][n][total] = ans1 + ans2
return TABLE[i][n][total]
N, A = tuple(map(int, input().split()))
XS = tuple(map(int, input().split()))
TABLE = []
for _ in range(N + 1):
lines = [[-1 for x in range(N * 50 + 1)] for y in range(N + 1)]
TABLE.append(lines)
return recur(0, 0, 0)
if __name__ == '__main__':
print((solve()))
| p04013 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n, a = LI()
x = LI()
dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n+1):
xi = x[i-1]
for j in range(2500+1):
for k in range(i):
dp[i][k][j] = dp[i-1][k][j]
for j in range(xi, 2500+1):
for k in range(1, i+1):
dp[i][k][j] += dp[i-1][k-1][j-xi]
ans = 0
for i in range(1, n+1):
ans += dp[-1][i][i*a]
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n, a = LI()
x = LI()
# dp[i][j][k] := i番目まで見たときj個使用してkを作る場合の数
dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n+1):
xi = x[i-1]
for j in range(2500+1):
for k in range(i):
dp[i][k][j] = dp[i-1][k][j]
for j in range(xi, 2500+1):
for k in range(1, i+1):
dp[i][k][j] += dp[i-1][k-1][j-xi]
ans = 0
for i in range(1, n+1):
ans += dp[-1][i][i*a]
print(ans) | p04013 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n, a = LI()
x = LI()
# dp[i][j][k] := i番目まで見たときj個使用してkを作る場合の数
dp = [[[0] * (2500+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n+1):
xi = x[i-1]
for j in range(2500+1):
for k in range(i):
dp[i][k][j] = dp[i-1][k][j]
for j in range(xi, 2500+1):
for k in range(1, i+1):
dp[i][k][j] += dp[i-1][k-1][j-xi]
ans = 0
for i in range(1, n+1):
ans += dp[-1][i][i*a]
print(ans) | #!/usr/bin/env python3
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
s = sum(x)
dp = [[[0] * (s+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(1, n+1):
xi = x[i-1]
for j in range(s+1):
for k in range(i):
dp[i][k][j] = dp[i-1][k][j]
for j in range(xi, s+1):
for k in range(1, i+1):
dp[i][k][j] += dp[i-1][k-1][j-xi]
ans = 0
for i in range(1, n+1):
if i*a > s:
break
ans += dp[n][i][i*a]
print(ans) | p04013 |
N,A=list(map(int,input().split()))
xlist=list(map(int,input().split()))
dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0]=1
for i in range(1,N+1):
dp[i][0][0]=1
for j in range(1,N+1):
for k in range(1,sum(xlist)+1):
dp[i][j][k]=dp[i-1][j][k]
if k-xlist[i-1]>=0:
dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]
#print(dp)
answer=0
for i in range(1,N+1):
if i*A<=sum(xlist):
answer+=dp[N][i][i*A]
print(answer) | N,A=list(map(int,input().split()))
xlist=list(map(int,input().split()))
dp=[[[0]*(sum(xlist)+1) for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0]=1
for i in range(1,N+1):
dp[i][0][0]=1
for j in range(1,i+1):
for k in range(1,sum(xlist)+1):
dp[i][j][k]=dp[i-1][j][k]
if k-xlist[i-1]>=0:
dp[i][j][k]+=dp[i-1][j-1][k-xlist[i-1]]
#print(dp)
answer=0
for j in range(1,N+1):
if j*A>sum(xlist):
break
answer+=dp[N][j][j*A]
print(answer) | p04013 |
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
X=max(max(x),a)
dp=[[[0]*(n*X+1)for j in range(n+1)]for i in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1):
xi=x[i-1]
for j in range(n+1):
for h in range(j*X+1):
if h<xi:dp[i][j][h]=dp[i-1][j][h]
if xi<=h and j>=1:dp[i][j][h]=dp[i-1][j][h]+dp[i-1][j-1][h-xi]
ans=0
for j in range(1,n+1):ans+=dp[n][j][j*a]
print(ans) | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
X=max(max(x),a)
dp=[[[0]*(X*n+1)for j in range(n+1)]for i in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1):
xi=x[i-1]
for j in range(i+1):
for h in range(j*X+1):
if h<xi:dp[i][j][h]=dp[i-1][j][h]
if xi<=h and j>=1:dp[i][j][h]=dp[i-1][j][h]+dp[i-1][j-1][h-xi]
ans=0
for j in range(1,n+1):ans+=dp[n][j][j*a]
print(ans) | p04013 |
import itertools
n, a = list(map(int, input().split()))
integers = list(int(x) - a for x in input().split())
count = 0
for i in range(1, len(integers)+1):
for combs in itertools.combinations(integers, i):
av = sum(combs) / i
if av == 0:
count += 1
print(count)
| import sys
n, a, *x = list(map(int, sys.stdin.read().split()))
def main():
ma = a * n
res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]
res[0][0][0] = 1
for i in range(n):
cur = x[i]
for j in range(i+2):
for k in range(ma + 1):
res[i+1][j][k] += res[i][j][k]
if k >= cur:
res[i+1][j][k] += res[i][j-1][k-cur]
ans = 0
for j in range(1, n+1):
ans += res[n][j][j*a]
return ans
if __name__ == '__main__':
ans = main()
print(ans) | p04013 |
import sys
n, a, *x = list(map(int, sys.stdin.read().split()))
def main():
ma = a * n
res = [[[0] * (ma + 1) for _ in range(n + 1)] for _ in range(n + 1)]
res[0][0][0] = 1
for i in range(n):
cur = x[i]
for j in range(i+2):
for k in range(ma + 1):
res[i+1][j][k] += res[i][j][k]
if k >= cur:
res[i+1][j][k] += res[i][j-1][k-cur]
ans = 0
for j in range(1, n+1):
ans += res[n][j][j*a]
return ans
if __name__ == '__main__':
ans = main()
print(ans) | import sys
n, a, *x = list(map(int, sys.stdin.read().split()))
def main():
for i in range(n):
x[i] -= a
x.sort()
res = [[0] * 99*n for _ in range(n+1)]
# res[i][49*n]を中心とする。
res[0][49*n] = 1
for i in range(n):
for j in range(99*n):
res[i+1][j] += res[i][j]
cur = x[i]
if cur >= 0:
if j >= cur:
res[i+1][j] += res[i][j-cur]
else:
if j - cur <= 99 * n - 1:
res[i+1][j] += res[i][j-cur]
ans = res[n][49*n] - 1
return ans
if __name__ == '__main__':
ans = main()
print(ans) | p04013 |
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(x)
if X < A:
X = A
def check(j, k, s):
if dp[j][k][s] != -1:
return dp[j][k][s]
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
return 1
if j >= 1 and s < x[j-1]:
a = check(j-1, k ,s)
dp[j][k][s] = a
return a
if j >= 1 and k >= 1 and s >= x[j-1]:
a = check(j-1, k, s) + check(j-1, k-1, s-x[j-1])
dp[j][k][s] = a
return a
dp[j][k][s] = 0
return 0
dp = [[[-1] * (N*X+1) for _ in range(N+1)] for _ in range(N + 1)]
# dp = np.array(dp)
# print (dp)
# for j in range(N+1):
# for k in range(N+1):
# for s in range(N*X + 1):
# print (j, k, s)
# dp[j][k][s] = check(j, k, s)
ans = 0
for k in range(1, N+1):
ans += check(N, k, k * A)
# ans += dp[N][k][k * A]
print (ans) | N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(x)
if X < A:
X = A
y = []
for i in x:
y += [i-A]
dp = [[-1] * (2*N*X+1) for _ in range(N+1)]
def check(j, t):
if dp[j][t] != -1:
return dp[j][t]
if j == 0 and t == N * X:
dp[j][t] = 1
return 1
if j >= 1 and (t-y[j-1] < 0 or t-y[j-1] > 2 * N * X):
dp[j][t] = check(j-1, t)
return dp[j][t]
if j >= 1 and 0 <= t-y[j-1] and t-y[j-1] <= 2*N*X:
dp[j][t] = check(j-1, t) + check(j-1, t- y[j-1])
return dp[j][t]
dp[j][t] = 0
return 0
print((check(N, N*X)-1))
| p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [[[0 for s in range(n * 60)] for k in range(n + 1)] for j in range(n + 1)]
for j in range(n + 1):
for k in range(n + 1):
for s in range(n * 60):
if (j == 0) and (k == 0) and (s == 0):
dp[j][k][s] = 1
elif (j > 0) and (s < x[j - 1]):
dp[j][k][s] = dp[j - 1][k][s]
elif (j > 0) and (k > 0) and (s >= x[j - 1]):
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j - 1]]
ans = 0
for k in range(1, n + 1):
ans += dp[j][k][k * a]
print(ans) | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(x)
y = [i - a for i in x]
dp = [[0 for t in range(2 * n * X + 10)] for j in range(n + 1)]
dp[0][n * X] = 1
for j in range(1, n + 1):
for t in range(2 * n * X + 1):
if 0 <= t - y[j - 1] <= 2 * n * X:
dp[j][t] = dp[j - 1][t] + dp[j - 1][t - y[j - 1]]
else:
dp[j][t] = dp[j - 1][t]
print((dp[n][n * X] - 1)) | p04013 |
import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools, random
from collections import deque
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
ans = 0
tmp = 0
inf = 10 ** 20
INF = float("INF")
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
ddn9 = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (0, 0)]
"""for dx, dy in dd:
nx = j + dx; ny = i + dy
if 0 <= nx < w and 0 <= ny < h:"""
def wi(): return list(map(int, sys.stdin.readline().split()))
def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]#WideIntPoint
def ws(): return sys.stdin.readline().split()
def i(): return int(sys.stdin.readline())
def s(): return eval(input())
def hi(n): return [i() for _ in range(n)]
def hs(n): return [s() for _ in range(n)]#HeightString
def mi(n): return [wi() for _ in range(n)]#MatrixInt
def mip(n): return [wip() for _ in range(n)]
def ms(n): return [ws() for _ in range(n)]
n, a = wi()
x = wi()
X = max(x)
dp = [[[0] * (n + 1) for j in range(X * n + 2)] for i in range(n)]
dp[0][0][0] = 1
dp[0][x[0]][1] = 1
for p in range(1, n):
for k in range(X * n + 2):
for usenum in range(p + 1):
dp[p][k][usenum] += dp[p - 1][k][usenum]
if k - x[p] >= 0:
dp[p][k][usenum + 1] += dp[p - 1][k - x[p]][usenum]
for k in range(X * n + 2):
for usenum in range(n + 1):
if usenum != 0:
if k / usenum == a:
ans += dp[n - 1][k][usenum]
print(ans) | import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools, random
from collections import deque
from heapq import heappush, heappop
sys.setrecursionlimit(10 ** 7)
ans = 0
tmp = 0
inf = 10 ** 20
INF = float("INF")
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
ddn9 = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1), (0, 0)]
"""for dx, dy in dd:
nx = j + dx; ny = i + dy
if 0 <= nx < w and 0 <= ny < h:"""
def wi(): return list(map(int, sys.stdin.readline().split()))
def wip(): return [int(x) - 1 for x in sys.stdin.readline().split()]#WideIntPoint
def ws(): return sys.stdin.readline().split()
def i(): return int(sys.stdin.readline())
def s(): return eval(input())
def hi(n): return [i() for _ in range(n)]
def hs(n): return [s() for _ in range(n)]#HeightString
def mi(n): return [wi() for _ in range(n)]#MatrixInt
def mip(n): return [wip() for _ in range(n)]
def ms(n): return [ws() for _ in range(n)]
n, a = wi()
x = wi()
X = max(x)
dp = [[[0] * (n + 1) for j in range(X * n + 2)] for i in range(n)]
dp[0][0][0] = 1
dp[0][x[0]][1] = 1
for p in range(1, n):
for k in range(X * n + 2):
for usenum in range(n):
dp[p][k][usenum] += dp[p - 1][k][usenum]
if k - x[p] >= 0:
dp[p][k][usenum + 1] += dp[p - 1][k - x[p]][usenum]
for k in range(X * n + 2):
for usenum in range(n + 1):
if usenum != 0:
if k / usenum == a:
ans += dp[n - 1][k][usenum]
print(ans) | p04013 |
from sys import stdin
input = stdin.readline
def Combi(n, r):
return int(factorial[n] / factorial[r] / factorial[n-r])
N, A = [int(x) for x in input().rstrip().split()]
x = [int(x) for x in input().rstrip().split()]
# num = [0]*51
# for i in x:
# num[i] += 1
# print(2**num[A]-1)
# factorial = [1]
# for i in range(1, 51):
# factorial.append(factorial[i-1] * i)
# for i in range(1, A):
X = max(max(x), A)
dp = [[[0]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]
for j in range(N+1):
for k in range(N+1):
for s in range(N*X+1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]: # 探索先が総和より大きい
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
sum = 0
for i in range(N+1):
sum += dp[N][i][i*A]
print((sum-1))
| from sys import stdin
input = stdin.readline
N, A = [int(x) for x in input().rstrip().split()]
x = [int(x) for x in input().rstrip().split()]
X = max(max(x), A)
# dp = [[[0]*(N*X+1) for _ in range(N+1)] for _ in range(N+1)]
# for j in range(N+1):
# for k in range(N+1):
# for s in range(N*X+1):
# if j == 0 and k == 0 and s == 0:
# dp[j][k][s] = 1
# elif j >= 1 and s < x[j-1]: # 探索先が総和より大きい
# dp[j][k][s] = dp[j-1][k][s]
# elif j >= 1 and k >= 1 and s >= x[j-1]:
# dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
# else:
# dp[j][k][s] = 0
# sum = 0
# for i in range(1, N+1):
# sum += dp[N][i][i*A]
# print(sum)
dp = [[0]*(2*N*X+1) for _ in range(N+1)]
y = [0] * len(x)
for i in range(len(x)):
y[i] = x[i]-A
for j in range(N+1):
for t in range(2*N*X+1):
if j == 0 and t == N*X:
dp[j][t] = 1
elif j >= 1 and (t-y[j-1] < 0 or t-y[j-1] > 2*N*X):
dp[j][t] = dp[j-1][t]
elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X:
dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j-1]]
else:
dp[j][t] = 0
print((dp[N][N*X]-1)) | p04013 |
N,A = list(map(int,input().split()))
X = [0]+list(map(int,input().split()))
# dp[n][k][s] : n枚目までからk枚選んで合計をsにする場合の数
dp = [[[0 for _ in range(2501)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for n in range(1,N+1):
for k in range(n+1):
for s in range(50*k+1):
if n>=1 and s<X[n]:
dp[n][k][s] = dp[n-1][k][s]
elif n>=1 and k>=1 and s>=X[n]:
dp[n][k][s] = dp[n-1][k][s] + dp[n-1][k-1][s-X[n]]
Ans = 0
for i in range(1,N+1):
Ans += dp[N][i][i*A]
print(Ans) | N,A = list(map(int,input().split()))
X = [0]+list(map(int,input().split()))
# dp[n][k][s] : n枚目までからk枚選んで合計をsにする場合の数
dp = [[[0 for _ in range(2501)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for n in range(1,N+1):
for k in range(n+1):
for s in range(50*k+1):
if s<X[n]:
dp[n][k][s] = dp[n-1][k][s]
elif k>=1 and s>=X[n]:
dp[n][k][s] = dp[n-1][k][s] + dp[n-1][k-1][s-X[n]]
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 = [0]+list(map(int,input().split()))
# dp[n][k][s] : n枚目までからk枚選んで合計をsにする場合の数
dp = [[[0 for _ in range(2501)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for n in range(1,N+1):
for k in range(n+1):
for s in range(50*k+1):
if s<X[n]:
dp[n][k][s] = dp[n-1][k][s]
elif k>=1 and s>=X[n]:
dp[n][k][s] = dp[n-1][k][s] + dp[n-1][k-1][s-X[n]]
Ans = 0
for i in range(1,N+1):
Ans += dp[N][i][i*A]
print(Ans) | # python3 (3.4.3)
import sys
input = sys.stdin.readline
# main
N,A = list(map(int,input().split()))
X = [0] + list(map(int,input().split()))
# dp[n][k][d] : n枚からk枚選んで合計dにする選び方
dp = [[[0 for _ in range(50*N+1)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for n in range(N+1):
for k in range(n+1):
for d in range(50*k+1):
# 選んだ数がn枚目のカードより小さい場合, そのカードは使えない
if d < X[n]:
dp[n][k][d] = dp[n-1][k][d]
# そうでない場合
else:
# k==0のときはカードを選べないことに注意
if k >= 1:
dp[n][k][d] = dp[n-1][k][d] + dp[n-1][k-1][d-X[n]]
ans = 0
for i in range(1,N+1):
# N枚からi枚選んで平均がA,つまり合計がA*i
ans += dp[N][i][A*i]
print(ans) | p04013 |
n,v = list(map(int,input().split()))
X = list(map(int,input().split()))
ans = [[0,0]]
for i in range(n):
ans2 = []
for x in ans:
ans2.append([x[0]+X[i],x[1]+1])
ans2.append([x[0],x[1]])
ans = ans2
cnt = 0
for a in ans:
if a[1] == 0:
continue
elif a[0]/a[1] == v:
cnt += 1
print(cnt)
| n,a = list(map(int,input().split()))
X = [int(i)-a for i in input().split()]
dp = [[0]*(100*n+1) for i 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-X[i]]
print((dp[n][50*n]-1)) | p04013 |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
OPT[i][j][k] - sum is i, j number of elements, first k elements
OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken
OPT[i][j][k-1]
OPT[A*j][j][k] for all k
"""
N, A = read_ints()
x = read_ints()
OPT = [[[0 for _ in range(51)] for _ in range(51)] for _ in range(2501)]
for k in range(N+1):
OPT[0][0][k] = 1
for i in range(len(OPT)):
for j in range(1, N+1):
for k in range(1, N+1):
if i-x[k-1] >= 0:
OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]
OPT[i][j][k] += OPT[i][j][k-1]
T = 0
for j in range(1, N+1):
T += OPT[A*j][j][N]
return T
if __name__ == '__main__':
print((solve()))
|
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
OPT[i][j][k] - sum is i, j number of elements, first k elements
OPT[i][j][k] = OPT[i-x[k]][j-1][k-1] if j-th element is taken
OPT[i][j][k-1]
OPT[A*j][j][k] for all k
"""
N, A = read_ints()
x = read_ints()
OPT = [[[0 for _ in range(N+1)] for _ in range(N+1)] for _ in range(N*max(x)+1)]
for k in range(N+1):
OPT[0][0][k] = 1
for i in range(len(OPT)):
for j in range(1, N+1):
for k in range(j, N+1):
if i-x[k-1] >= 0:
OPT[i][j][k] += OPT[i-x[k-1]][j-1][k-1]
OPT[i][j][k] += OPT[i][j][k-1]
T = 0
for j in range(1, N+1):
if A*j < len(OPT):
T += OPT[A*j][j][N]
return T
if __name__ == '__main__':
print((solve()))
| p04013 |
import copy
def main():
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [[0] * (50*N + 1) for _ in range(N+1)]
dp[0][0] = 1
for k in range(N):
dpn = copy.deepcopy(dp)
for i in range(k+1):
for j in range(50 * N + 1 -x[k]):
dpn[i+1][j+x[k]] += dp[i][j]
dp = dpn
r = 0
for i in range(1, N+1):
r += dp[i][i*A]
return r
print((main()))
| def main():
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
dp = [[0] * (50*N + 1) for _ in range(N+1)]
dp[0][0] = 1
for k in range(N):
for i in reversed(list(range(k+1))):
for j in range(50 * N + 1 -x[k]):
dp[i+1][j+x[k]] += dp[i][j]
r = 0
for i in range(1, N+1):
r += dp[i][i*A]
return r
print((main()))
| p04013 |
def tak_and_cards(N: int, A: int, x: list) -> int:
count = 0
for b in range(1, 1 << N):
n, s = 0, 0
for i in range(N):
if (b >> i) & 1 == 0:
continue
n += 1
s += x[i]
if s == n * A:
count += 1
return count
if __name__ == "__main__":
N, A = list(map(int, input().split()))
x = [int(s) for s in input().split()]
ans = tak_and_cards(N, A, x)
print(ans)
| def tak_and_cards(N: int, A: int, X: list) -> int:
# 部分点解法
# :---------:
# count = 0
# for b in range(1, 1 << N):
# n, s = 0, 0
# for i in range(N):
# if (b >> i) & 1 == 0:
# continue
# n += 1
# s += X[i]
# if s == n * A:
# count += 1
# return count
max_X = max(X)
dp = [[0] * (2 * max_X * N + 1) for _ in range(N + 1)]
dp[0][max_X * N] = 1
for k, x in enumerate(X):
for t in range(2 * max_X * N + 1):
y = x - A
dp[k + 1][t] = dp[k][t]
if 0 <= t - y and t - y <= 2 * max_X * N:
dp[k + 1][t] += dp[k][t - y]
return dp[N][max_X*N] - 1
if __name__ == "__main__":
N, A = list(map(int, input().split()))
x = [int(s) for s in input().split()]
ans = tak_and_cards(N, A, x)
print(ans)
| p04013 |
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
lim = sum(x)
dp = [[0]*(lim + 1) for i in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for k in range(N, 0, -1):
for v in range(lim, -1, -1):
if v - x[i] < 0:
break
dp[k][v] += dp[k - 1][v - x[i]]
ans = 0
for k in range(1, N + 1):
if k*A > lim:
break
ans += dp[k][k*A]
print(ans) | N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
# 3d DP
max_x = max(x)
dp = [[[0] * (max_x * N + 1) for j in range(N + 1)]
for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(0, N):
for k in range(0, N + 1):
for y in range(max_x * N + 1):
if dp[i][k][y]:
dp[i + 1][k][y] += dp[i][k][y]
dp[i + 1][k + 1][y + x[i]] += dp[i][k][y]
cnt = 0
for k in range(1, N + 1):
for y in range(1, max_x * N + 1):
if y // k == A and y % k == 0:
cnt += dp[N][k][y]
print(cnt) | p04013 |
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
# 3d DP
max_x = max(x)
dp = [[[0] * (max_x * N + 1) for j in range(N + 1)]
for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(0, N):
for k in range(0, N + 1):
for y in range(max_x * N + 1):
if dp[i][k][y]:
dp[i + 1][k][y] += dp[i][k][y]
dp[i + 1][k + 1][y + x[i]] += dp[i][k][y]
cnt = 0
for k in range(1, N + 1):
for y in range(1, max_x * N + 1):
if y // k == A and y % k == 0:
cnt += dp[N][k][y]
print(cnt) | def solve():
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
# 3d DP
max_x = max(x)
dp = [[[0] * (max_x * N + 1) for j in range(N + 1)]
for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(0, N):
for k in range(0, N + 1):
for y in range(max_x * N + 1):
if dp[i][k][y]:
dp[i + 1][k][y] += dp[i][k][y]
dp[i + 1][k + 1][y + x[i]] += dp[i][k][y]
cnt = 0
for k in range(1, N + 1):
for y in range(1, max_x * N + 1):
if y // k == A and y % k == 0:
cnt += dp[N][k][y]
print(cnt)
if __name__ == '__main__':
solve() | p04013 |
def solve():
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
# 3d DP
max_x = max(x)
dp = [[[0] * (max_x * N + 1) for j in range(N + 1)]
for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(0, N):
for k in range(0, N + 1):
for y in range(max_x * N + 1):
if dp[i][k][y]:
dp[i + 1][k][y] += dp[i][k][y]
dp[i + 1][k + 1][y + x[i]] += dp[i][k][y]
cnt = 0
for k in range(1, N + 1):
for y in range(1, max_x * N + 1):
if y // k == A and y % k == 0:
cnt += dp[N][k][y]
print(cnt)
if __name__ == '__main__':
solve() | def solve():
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
lim = sum(x)
dp = [[0]*(lim + 1) for i in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for k in range(i + 1, 0, -1):
for v in range(lim, x[i] - 1, -1):
dp[k][v] += dp[k - 1][v - x[i]]
ans = 0
for k in range(1, N + 1):
if k*A > lim:
break
ans += dp[k][k*A]
print(ans)
if __name__ == '__main__':
solve() | p04013 |
n, a = list(map(int, input().split()))
cnt = [0]
x = list(map(int, input().split()))
check = [0 for i in range(n)]
def ave(idx, k):
if idx == n:
s = 0
for i in range(n):
if check[i]:
s += x[i]
if s == k * a and k != 0:
cnt[0] += 1
return
ave(idx+1, k)
check[idx] = 1
ave(idx+1, k+1)
check[idx] = 0
def main():
ave(0, 0)
print((cnt[0]))
if __name__ == '__main__':
main()
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
def ave_comb(v_max, ave):
dp = [[[0 for c in range(n*v_max+1)] for b in range(n+1)] for a in range(n+1)]
for i in range(n+1):
dp[i][0][0] = 1
for i in range(1, n+1):
for j in range(1, i+1):
for k in range(1, n*v_max+1):
if k - x[i-1] >= 0:
dp[i][j][k] = dp[i-1][j-1][k-x[i-1]] + dp[i-1][j][k]
else:
dp[i][j][k] = dp[i-1][j][k]
ans = 0
for t in range(1, n+1):
ans += dp[n][t][ave*t]
return ans
def main():
x_max = max(max(x), a)
print((ave_comb(x_max, a)))
if __name__ == '__main__':
main()
| p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
def ave_comb(v_max, ave):
dp = [[[0 for c in range(n*v_max+1)] for b in range(n+1)] for a in range(n+1)]
for i in range(n+1):
dp[i][0][0] = 1
for i in range(1, n+1):
for j in range(1, i+1):
for k in range(1, n*v_max+1):
if k - x[i-1] >= 0:
dp[i][j][k] = dp[i-1][j-1][k-x[i-1]] + dp[i-1][j][k]
else:
dp[i][j][k] = dp[i-1][j][k]
ans = 0
for t in range(1, n+1):
ans += dp[n][t][ave*t]
return ans
def main():
x_max = max(max(x), a)
print((ave_comb(x_max, a)))
if __name__ == '__main__':
main()
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x_max = max(x)
y = [i-a for i in x]
def ave_comb():
dp = [[0 for d in range(2*n*x_max+1)] for c in range(n+1)]
for i in range(n+1):
dp[i][n*x_max] = 1
for i in range(1, n+1):
for j in range(1, 2*n*x_max+1):
if 0 <= j - y[i-1] <= 2 * n * x_max:
dp[i][j] = dp[i-1][j-y[i-1]] + dp[i-1][j]
else:
dp[i][j] = dp[i-1][j]
return dp[n][n*x_max] - 1
def main():
print((ave_comb()))
if __name__ == '__main__':
main()
| p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x_max = max(x)
x_sum = sum(x)
ans = 0
if x_max >= a:
dp = [[[0 for k in range(x_sum + 1)] for j in range(n + 1)] for i in range(2)]
dp[0][0][0] = 1
for i in range(1, n + 1):
idx = i % 2
for j in range(n + 1):
for k in range(x[i - 1]):
dp[idx][j][k] = dp[1 - idx][j][k]
if j > 0:
for k in range(x[i - 1], x_sum + 1):
dp[idx][j][k] = dp[1 - idx][j][k] + dp[1 - idx][j - 1][k - x[i - 1]]
for j in range(1, min(x_sum // a + 1, n + 1)):
ans += dp[idx][j][j * a]
print(ans)
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
x_max = max(x)
x_sum = sum(x)
ans = 0
if x_max >= a:
dp = [[0 for j in range(2 * x_sum + 1)] for i in range(2)]
dp[0][x_sum] = 1
for i in range(1, n + 1):
idx = i % 2
y = x[i - 1] - a
for j in range(2 * x_sum + 1):
if 0 <= j - y <= 2 * x_sum:
dp[idx][j] = dp[1 - idx][j] + dp[1 - idx][j - y]
else:
dp[idx][j] = dp[1 - idx][j]
ans = dp[n % 2][x_sum] - 1
print(ans)
| p04013 |
n,a = list(map(int,input().split()))
l = list(map(int,input().split()))
dp = [[[0]*(2501) for i in range(n+1)] for j in range(n+1)]
dp[0][0][0] = 1
# i 個目までのj個選んで 和のmod aが k
for i in range(n):
for j in range(i+1):
for k in range(2501):
dp[i+1][j][k] += dp[i][j][k]
if k+l[i] < 2501:
dp[i+1][j+1][k+l[i]] += dp[i][j][k]
ans = 0
for j in range(1,n+1):
ans += dp[-1][j][j*a]
print(ans)
| n,a = list(map(int,input().split()))
l = list(map(int,input().split()))
dp = [[[0]*(2501) for i in range(n+1)] for j in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
for j in range(i+1):
for k in range(2501):
dp[i+1][j][k] += dp[i][j][k]
if k+l[i] < 2501:
dp[i+1][j+1][k+l[i]] += dp[i][j][k]
ans = 0
for j in range(1,n+1):
ans += dp[-1][j][j*a]
print(ans)
| p04013 |
n,a = [int(i) for i in input().split()]
X = [int(i) for i in input().split()]
X = [0]+X
m = max(X+[a])
dp = [[[0]*50*(n+1) for i in range(n+1)] for j in range(n+1)]
#print(dp)
for i in range(n+1):
for j in range(n+1):
for k in range(m*(n+1)):
if i == j == k == 0:
dp[i][j][k] = 1
elif i >= 1 and k < X[i]:
dp[i][j][k] = dp[i-1][j][k]
elif i >= 1 and j >= 1 and k >= X[i]:
dp[i][j][k] = dp[i-1][j][k]+dp[i-1][j-1][k-X[i]]
ans = 0
for i in range(1,n+1):
ans += dp[n][i][i*a]
print(ans) | n,a = [int(i) for i in input().split()]
X = [int(i)-a for i in input().split()]
dp = [[0]*(100*n+1) for i in range(n+1)]
#print(dp)
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-X[i]]
ans = dp[n][n*50]-1
print(ans) | p04013 |
N,A=list(map(int,input().split()))
X=[int(a) for a in input().split()]
X.append(0)
X.sort()
ma=sum(X)
#[x]までのy個を使ってzを作る場合の数を数え上げるdp
#dp[x][y][z]=dp[x-1][y][z]+dp[x-1][y-1][z-X[x]](zが残っている場合）
#dp[x][y][z]=dp[x-1][y][z](zが残っていない場合)
dp=[[[0] * (ma+1) for i in range(N+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0][0]=1
for i in range(1,N+1):
cnt=X[i]
for j in range(1,N+1):
for k in range(ma+1):
if k < cnt:
dp[i][j][k]=dp[i-1][j][k]
else:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-cnt]
#ansはN枚中j枚使用かつj枚*平均Aを作れる個数。
ans=0
for x in range(1,N+1):
if x*A<=ma:
ans+=dp[N][x][x*A]
print(ans)
| def solve(N,A,X):
X.append(0)
X.sort()
ma=sum(X)
#[x]までのy個を使ってzを作る場合の数を数え上げるdp
#dp[x][y][z]=dp[x-1][y][z]+dp[x-1][y-1][z-X[x]](zが残っている場合）
#dp[x][y][z]=dp[x-1][y][z](zが残っていない場合)
dp=[[[0] * (ma+1) for i in range(N+1)] for j in range(N+1)]
#[x]までの0個を使って0を作る方法は1つ（dp初期化）
for i in range(N+1):
dp[i][0][0]=1
for i in range(1,N+1):
cnt=X[i]
for j in range(1,N+1):
for k in range(ma+1):
if k < cnt:
dp[i][j][k]=dp[i-1][j][k]
else:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-cnt]
#ansはN枚中j枚使用かつj枚*平均Aを作れる個数。
ans=0
for x in range(1,N+1):
if x*A<=ma:
ans+=dp[N][x][x*A]
return ans
N,A=list(map(int,input().split()))
X=[int(a) for a in input().split()]
ans=solve(N,A,X)
print(ans) | p04013 |
n, a = list(map(int, input().split()))
X = tuple(map(int, input().split()))
X = sorted(X)
from collections import deque
ans = 0
for i in range(n):
st = deque([[i, 1, X[i]]])
while st:
idx, count, s = st.pop()
if count*a == s:
ans += 1
elif count*a < s:
continue
for ni in range(idx+1, n):
st.append([ni, count+1, s+X[ni]])
print(ans)
| n, a = list(map(int, input().split()))
X = tuple(map(int, input().split()))
dp = [[[0] * (2550) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
# i枚目までで
for j in range(n):
# j枚のカードを選んで
for s in range(n*a+1):
# 合計がsになるパターン
if dp[i][j][s] == 0:
continue
# i枚目のカードが選ばれない場合
dp[i+1][j][s] += dp[i][j][s]
# i枚目のカードが選ばれる場合
dp[i+1][j+1][s+X[i]] += dp[i][j][s]
ans = 0
for k in range(1, n+1):
ans += dp[n][k][k*a]
print(ans)
| p04013 |
N, A = list(map(int, input().split()))
X = [int(x) - A for x in input().split()]
import functools
@functools.lru_cache(maxsize=None)
def f(acc, left):
if not left: return 0
ret = 0
y = acc + left[0]
ret += 1 if y == 0 else 0
ret += f(y, left[1:])
ret += f(acc, left[1:])
return ret
print((f(0, tuple(X)))) | N, A = list(map(int, input().split()))
X = [int(x) - A for x in input().split()]
from collections import Counter
total = Counter([0])
for x in X:
mix = Counter()
for i, cnt in list(total.items()):
mix[i + x] += cnt
total += mix
print((total[0] - 1)) | p04013 |
from itertools import product
N, A = list(map(int, input().split()))
x = [int(x) for x in input().split()]
max_x = max(max(x), A)
dp = [[[0 for _ in range((N + 1) * max_x)] for _ in range(N + 1)] for _ in range(N + 1)]
dp[0][0][0] = 1
for j, k, s in product(list(range(1, N + 1)), list(range(N + 1)), list(range((N + 1) * max_x))):
if s < x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s]
elif k >= 1 and s >= x[j - 1]:
dp[j][k][s] = dp[j - 1][k][s] + dp[j - 1][k - 1][s - x[j - 1]]
ans = 0
for k in range(1, N + 1):
ans += dp[N][k][k * A]
print(ans) | from itertools import product
N, A = list(map(int, input().split()))
x = [int(x) for x in input().split()]
X = max(max(x), A)
dp = [[0 for _ in range(2 * N * X + 1)] for _ in range(N + 1)]
dp[0][N * X] = 1
for j, t in product(list(range(1, N + 1)), list(range(2 * N * X + 1))):
y = x[j - 1] - A
if t - y < 0 or t - y > 2 * N * X:
dp[j][t] = dp[j - 1][t]
elif 0 <= t - y <= 2 * N * X:
dp[j][t] = dp[j - 1][t] + dp[j - 1][t - y]
print((dp[N][N * X] - 1)) | p04013 |
from collections import defaultdict
N, A = list(map(int, input().split()))
x = [int(x) for x in input().split()]
for i in range(N):
x[i] -= A
X = max(max(x), A)
dp = [defaultdict(int) for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(-N * X, N * X + 1):
if - N * X <= j - x[i] <= N * X:
dp[i + 1][j] = dp[i][j] + dp[i][j - x[i]]
else:
dp[i + 1][j] = dp[i][j]
print((dp[N][0] - 1))
| from collections import defaultdict
N, A = list(map(int, input().split()))
x = [int(x) for x in input().split()]
for i in range(N):
x[i] -= A
X = max(max(x), A)
dp = [defaultdict(int) for _ in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(-N * X, N * X + 1):
dp[i + 1][j] = dp[i][j] + dp[i][j - x[i]]
print((dp[N][0] - 1))
| p04013 |
N,A = list(map(int,input().split()))
x = list(map(int,input().split()))
temp = x + [A]
X = max(temp)
m = N * X
dp = [[[0]*(m+1) for k in range(N+1)] for j in range(N+1)]
dp[0][0][0] = 1
res = 0
for j in range(N+1):
for k in range(N+1):
for s in range(m+1):
if (j >= 1) & (s < x[j-1]):
dp[j][k][s] = dp[j-1][k][s]
elif (j >= 1) & (k >= 1) & (s >= x[j-1]):
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
if (k >= 1) & (j == N):
res += dp[N][k][k*A]
print(res)
| N,A = list(map(int,input().split()))
x = list(map(int,input().split()))
temp = x + [A]
X = max(temp)
m = N * X
dp = [[[0 for s in range(m+1)] for k in range(N+1)] for j in range(N+1)]
dp[0][0][0] = 1
res = 0
for j in range(N):
for k in range(N):
for s in range(m):
if dp[j][k][s]:
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s+x[j]] += dp[j][k][s]
for k in range(1,N+1):
res += dp[N][k][k*A]
print(res)
| p04013 |
import sys
from sys import stdin
input = stdin.readline
def solve(N, A, x):
x.append(0)
x.sort()
W=sum(x)
dp=[[[0]*(W+1) for _ in range(N+1)] for _ in range(N+1)]
for j in range(N+1):
dp[j][0][0]=1
for j in range(1,N+1):
xj=x[j]
for k in range(1, N+1):
for s in range(1, W+1):
if s<xj:
dp[j][k][s]=dp[j-1][k][s]
else:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-xj]
ans=0
for k in range(1,N+1):
if k*A<=W:
ans+=dp[N][k][k*A]
else:
break
return ans
def main(args):
N,A=list(map(int, input().split()))
x=[int(x) for x in input().split()]
print((solve(N, A, x)))
if __name__ == '__main__':
main(sys.argv[1:])
| import sys
from sys import stdin
input = stdin.readline
def solve(N, A, x):
x.append(0)
x.sort()
W=sum(x)
dp=[[[0]*(W+1) for _ in range(N+1)] for _ in range(N+1)]
for j in range(N+1):
dp[j][0][0]=1
for j in range(1,N+1):
xj=x[j]
for k in range(1, N+1):
for s in range(1, W+1):
if s<xj:
dp[j][k][s]=dp[j-1][k][s]
else:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-xj]
ans=0
for k in range(1,N+1):
if k*A<=W:
ans+=dp[N][k][k*A]
else:
break
return ans
def main(args):
N,A=list(map(int, input().split()))
x=[int(x) for x in input().split()]
ans=solve(N,A,x)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| p04013 |
import sys
from sys import stdin
input = stdin.readline
def solve(N, A, x):
x.append(0)
x.sort()
W=sum(x)
dp=[[[0]*(W+1) for _ in range(N+1)] for _ in range(N+1)]
for j in range(N+1):
dp[j][0][0]=1
for j in range(1,N+1):
xj=x[j]
for k in range(1, N+1):
for s in range(1, W+1):
if s<xj:
dp[j][k][s]=dp[j-1][k][s]
else:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-xj]
ans=0
for k in range(1,N+1):
if k*A<=W:
ans+=dp[N][k][k*A]
else:
break
return ans
def main(args):
N,A=list(map(int, input().split()))
x=[int(x) for x in input().split()]
ans=solve(N,A,x)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| import sys
from sys import stdin
input = stdin.readline
def solve(N, A, x):
W=sum(x)
dp=[[[0]*(W+1) for _ in range(N+1)] for _ in range(N+1)]
for j in range(N+1):
dp[j][0][0]=1
for j in range(1,N+1):
xj=x[j-1]
for k in range(1, N+1):
for s in range(1, W+1):
if s<xj:
dp[j][k][s]=dp[j-1][k][s]
else:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-xj]
ans=0
for k in range(1,N+1):
if k*A<=W:
ans+=dp[N][k][k*A]
else:
break
return ans
def main(args):
N,A=list(map(int, input().split()))
x=[int(x) for x in input().split()]
ans=solve(N,A,x)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:])
| p04013 |
from functools import lru_cache
n, a = list(map(int, input().split(' ')))
x = list(map(int, input().split(' ')))
t = 0
@lru_cache(maxsize=1024)
def dfs(i,ave):
if i ==n:
if ave == 0:
return 1
else:
return 0
return dfs(i+1,ave)+dfs(i+1,ave+x[i]-a)
print((dfs(0,0)-1))
| n,a = list(map(int, input().split(' ')))
x = list(map(int, input().split(' ')))
y = [i - a for i in x]
X = max(a,max(x))
dp = []
for i in range(n+1):
dp.append([0]*(2*n*X+1))
for j in range(n,-1,-1):
for t in range(2*n*X+1):
if j == n and t ==n*X:
dp[j][t] = 1
elif j == n:
dp[j][t] = 0
elif 0 <= t-y[j] <= 2*n*X:
dp[j][t] = dp[j+1][t] + dp[j+1][t-y[j]]
else:
dp[j][t] = dp[j+1][t]
def main():
print((dp[0][n*X]-1))
if __name__ == '__main__':
main() | p04013 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, a = list(map(int, input().split()))
X = list(map(int, input().split()))
MAX = 50 * 50 + 1
dp = [[[0] * MAX for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i in range(1, n + 1):
x = X[i - 1]
for j in range(n):
for k in range(MAX):
dp[i][j][k] += dp[i - 1][j][k]
if k + x < MAX:
dp[i][j + 1][k + x] += dp[i - 1][j][k]
res = 0
for j in range(1, n + 1):
res += dp[-1][j][a * j]
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 998244353
def resolve():
n, a = list(map(int, input().split()))
X = list(map(int, input().split()))
MAX = sum(X)
dp = [[[0] * (MAX + 1) for _ in range(n + 1)] for _ in range(n + 1)]
dp[0][0][0] = 1
for i in range(1, n + 1):
x = X[i - 1]
for j in range(n + 1):
for k in range(MAX + 1):
dp[i][j][k] += dp[i - 1][j][k]
if k + x < MAX + 1 and j + 1 <= n:
dp[i][j + 1][k + x] += dp[i - 1][j][k]
res = 0
for j in range(1, n + 1):
total = a * j
if total <= MAX:
res += dp[n][j][total]
print(res)
if __name__ == '__main__':
resolve()
| p04013 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(max(x), a)
#dp = [[[0]*(n*X+1) for _ in range(X+1)] for i in range(n+1)]
dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(n*X+1):
if j == 0 and k == 0 and s == 0:
dp[j][k][s] = 1
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >= 1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s] + dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
ans = 0
for k in range(1,n+1):
ans += dp[n][k][k*a]
print(ans) | # 配列を大きめにとって配った方がすっきりかけるのかも
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
X = max(max(x), a)
dp = [[[0]*(n*X+1) for _ in range(n+1)] for i in range(n+1)]
#if j == 0 and k == 0 and s == 0:
dp[0][0][0] = 1
for j in range(n):
for k in range(n):
for s in range(n*X):
if dp[j][k][s]:
dp[j+1][k][s] += dp[j][k][s]
dp[j+1][k+1][s+x[j]] += dp[j][k][s]
ans = 0
for k in range(1,n+1):
ans += dp[n][k][k*a]
print(ans) | p04013 |
import itertools
N, A = list(map(int, input().split()))
x = sorted([int(i)-A for i in input().split()])
ans = x.count(0)
if N >= 2:
for i in range(2, N+1):
check = list(itertools.combinations(x,i))
for i in check:
if sum(i) == 0:
ans += 1
print(ans) | N, A = [int(_) for _ in input().split()]
x = [int(_) for _ in input().split()]
dp = [[0] * (sum(x)+1) for j in range(N+1)]
dp[0][0] = 1
for i in range(1, N+1):
for j in list(range(1, N+1))[::-1]:
for k in list(range(x[i-1], sum(x[:i])+1))[::-1]:
dp[j][k] += dp[j-1][k - x[i-1]]
print((sum([dp[i][i*A] for i in range(1, N+1) if i*A <= sum(x)]))) | p04013 |
N, A = [int(_) for _ in input().split()]
x = [int(_) for _ in input().split()]
dp = [[0] * (sum(x)+1) for j in range(N+1)]
dp[0][0] = 1
for i in range(1, N+1):
for j in list(range(1, N+1))[::-1]:
for k in list(range(x[i-1], sum(x[:i])+1))[::-1]:
dp[j][k] += dp[j-1][k - x[i-1]]
print((sum([dp[i][i*A] for i in range(1, N+1) if i*A <= sum(x)]))) | N, A = [int(_) for _ in input().split()]
x = [int(i)-A for i in input().split()]
dp = [[0 for j in range(100 * N + 1)] for i 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 - x[i]]
print((dp[N][50 * N] - 1)) | p04013 |
N, A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [[[0 for i in range(N*50+1)] for j in range(N+1)] for k in range(N+1)]
for i in range(N+1):
dp[i][0][0] = 1
for i in range(1,N+1):
x = X[i-1]
for j in range(1,N+1):
for k in range(N*50+1):
if k < x:
dp[i][j][k] = dp[i-1][j][k]
elif j > i:
dp[i][j][k] = 0
else:
dp[i][j][k] += dp[i-1][j][k] + dp[i-1][j-1][k-x]
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()))
for i in range(N):
X[i] -= A
dp = [[0 for i in range(5001)] for i in range(N+1)]
dp[0][2500] = 1
u = 2500
d = 2500
for i in range(1,N+1):
x = X[i-1]
if x <= 0:
d += x
else:
u += x
for j in range(d,u+1):
dp[i][j] += dp[i-1][j-x] + dp[i-1][j]
print((dp[N][2500]-1)) | p04013 |
N, A = input().split(" ")
N, A = int(N), int(A)
x = input().split(" ")
x = [int(i) for i in x]
import itertools
cnt = 0
for n in range(1, N+1):
for i in itertools.combinations(x, n):
if sum(i) / n == A:
cnt += 1
print(cnt) | N, A = input().split(" ")
N, A = int(N), int(A)
x = input().split(" ")
x = [int(i) for i in x]
y = [0]+[int(i)-A for i in x]
X = max(x+[A])
dp = [[0 for t in range(2*N*X+1)] for j in range(N+1)]
for j in range(N+1):
for t in range(2*N*X+1):
if j == 0 and t == N*X: # 0枚の時は0しか達成できない
dp[j][t] = 1
elif j >= 1 and (t - y[j-1] < 0 or t-y[j] > 2*N*X): # xの値が平均Aを超えてしまう場合は、前回の結果から場合の総数に変化なし
dp[j][t] = dp[j-1][t]
elif j >= 1 and 0 <= t-y[j-1] <= 2*N*X: # 前回の場合の総数に、今回の数を足して0になる場合の総数を足す
dp[j][t] = dp[j-1][t] + dp[j-1][t-y[j]]
else:
dp[j][t] = 0
print((dp[N][N*X] - 1)) | p04013 |
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
sum_X = sum(X)
dp = [[[0]*(sum_X+1) 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(sum_X):
if dp[i][j][k] == 0: continue
# not used
dp[i+1][j][k] += dp[i][j][k]
# used
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
ans = 0
for k in range(1, N+1):
if k*A <= sum_X:
ans += dp[N][k][k*A]
print(ans) | N, A = list(map(int, input().split()))
# 予め-Kした状態で用意しておく
X = [A-int(x) for x in input().split()]
MAX = N*A*2
# dp[i][k] := i枚目までのカードで、合計をkにする通り数
dp = [[0]*(MAX+1) for _ in range(N+1)]
# 負の数を考慮して、N*K位置を0とする
dp[0][N*A] = 1
for i in range(N):
x = X[i]
for k in range(MAX+1):
dp[i+1][k] += dp[i][k]
if 0 <= k+x <= MAX:
dp[i+1][k+x] += dp[i][k]
# N回終わって合計が0になっている通り数 - 1枚も取らないケース
print((dp[N][N*A]-1)) | p04013 |
from collections import Counter
def main():
num, avg = list(map(int, input().split()))
data = list(map(int, input().split()))
dp = [[[0 for i in range(6000)] for j in range(num + 1)] for k in range(num + 1)]
dp[0][0][0] = 1
for i in range(1, num + 1):
now_card = data[i - 1]
for j in range(num + 1):
for k in range(6000):
# print(i, j, k)
dp[i][j][k] += dp[i - 1][j][k]
if k - now_card >= 0 and j - 1 >= 0:
dp[i][j][k] += dp[i - 1][j - 1][k - now_card]
# print(dp[i][j])
ans = 0
for i in range(1, num + 1):
ans += dp[num][i][i * avg]
print(ans)
if __name__ == '__main__':
main()
| from collections import Counter
def main():
num, avg = list(map(int, input().split()))
data = list(map(int, input().split()))
max_num = max(num, avg, max(data))
dp = [[[0 for i in range(max_num ** 2 + 1)] for j in range(num + 1)] for k in range(num + 1)]
dp[0][0][0] = 1
for i in range(1, num + 1):
now_card = data[i - 1]
for j in range(num + 1):
for k in range(max_num ** 2 + 1):
# print(i, j, k)
dp[i][j][k] += dp[i - 1][j][k]
if k - now_card >= 0 and j - 1 >= 0:
dp[i][j][k] += dp[i - 1][j - 1][k - now_card]
# print(dp[i][j])
ans = 0
for i in range(1, num + 1):
ans += dp[num][i][i * avg]
print(ans)
if __name__ == '__main__':
main()
| p04013 |
# -*- coding: utf-8 -*-
""" 3次元DP """
N,A = list(map(int, input().split()))
xN = list(map(int, input().split()))
X = max(max(xN), A)
# i(=xNリストからどこまでを選べる範囲とするか)からj(=0～N)枚選んで、選んだ値の合計をkにするような選び方の総数
dp = [[[0] * (N*X+1) for j in range(N+1)] for i in range(N+1)]
dp[0][0][0] = 1
ans = 0
for i in range(1,N+1):
for j in range(N+1):
for k in range(N*X+1):
# 求めたい合計(k)が、この周回で増えた選択肢(xN[i-1])より小さい場合、
# 選び方の総数は増える見込みがないので前回の値をそのまま使用
if k < xN[i-1]:
dp[i][j][k] = dp[i-1][j][k]
# 合計kが大きければ、増やせるかもしれないので、選んだ数と合計を減らしたところを見に行く
# 選べる数j=0は論外だし、添え字[j-1]に良くないので条件で除外する
elif k >= xN[i-1] and j > 0:
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k-xN[i-1]]
# 選んだ数と合計から判断して、平均が条件に合うものなら答えに足す
if i == N and j > 0 and k == j*A:
ans += dp[i][j][k]
# ans = 0
# for k in range(1,N+1):
# ans += dp[N][k][k*A]
print(ans) | # -*- coding: utf-8 -*-
""" 2次元DP """
N,A = list(map(int, input().split()))
xN = list(map(int, input().split()))
X = max(max(xN), A)
# 全てのxから-Aすることで、合計=0,平均=0を求める形にする
yN = [int(i)-A for i in xN]
# 二つ目の添え字はマイナスを取りうるので工夫する
dp = [[0] * (2*N*X+1) for j in range(N+1)]
# 基準点を0じゃなくて真ん中(N*X)にする
dp[0][N*X] = 1
ans = 0
for i in range(1,N+1):
for t in range(2*N*X+1):
# 範囲外ならそのまま
if t - yN[i-1] < 0 or t - yN[i-1] > 2*N*X:
dp[i][t] = dp[i-1][t]
# 範囲内なら前の値を足す
elif 0 <= t - yN[i-1] <= 2*N*X:
dp[i][t] = dp[i-1][t] + dp[i-1][t - yN[i-1]]
# 1枚も選ばないパターンを引く
print((dp[N][N*X]-1)) | p04013 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
A = LIST()
MAX = N * K
# dp[i][j][k] := i枚目までからj枚取って、合計をkにする通り数
dp = list3d(N+1, N+1, MAX+1, 0)
dp[0][0][0] = 1
for i in range(N):
a = A[i]
for j in range(i+1):
for k in range(MAX+1):
dp[i+1][j][k] += dp[i][j][k]
if j+1 <= N and k+a <= MAX:
dp[i+1][j+1][k+a] += dp[i][j][k]
ans = 0
for j in range(1, N+1):
# 1枚以上取った時の、平均がKになる所 → j枚取って合計がj*Kの所 を合計する
ans += dp[N][j][j*K]
print(ans)
| # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
# 予め-Kした状態で用意しておく
A = [a-K for a in LIST()]
MAX = N * K * 2
# dp[i][k] := i枚目までのカードで、合計をkにする通り数
dp = list2d(N+1, MAX+1, 0)
# 負の数を考慮して、N*K位置を0とする
dp[0][N*K] = 1
for i in range(N):
a = A[i]
for k in range(MAX+1):
dp[i+1][k] += dp[i][k]
if 0 <= k+a <= MAX:
dp[i+1][k+a] += dp[i][k]
# N回終わって合計が0になっている通り数 - 1枚も取らないケース
print((dp[N][N*K]-1))
| p04013 |
# -*- coding: utf-8 -*-
import sys
from collections import Counter
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
# 総和0を平均とするためKを引く
A = [a-K for a in LIST()]
# 半分全列挙
A1 = A[:N//2]
A2 = A[N//2:]
# それぞれの全組み合わせ
P1 = [0]
for S in range(1, 1<<len(A1)):
p = 0
for i in range(len(A1)):
if S & 1<<i:
p += A1[i]
P1.append(p)
P2 = [0]
for S in range(1, 1<<len(A2)):
p = 0
for i in range(len(A2)):
if S & 1<<i:
p += A2[i]
P2.append(p)
# 総和0になるペアの数を求める
C2 = Counter(P2)
ans = 0
for p in P1:
ans += C2[-p]
# どちらも1つも選ばない分の1を引く
print((ans - 1))
| # -*- coding: utf-8 -*-
import sys
from collections import defaultdict
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N, K = MAP()
# 総和0を平均KとするためKを引く
A = [a-K for a in LIST()]
# dp[i][j] := i番目まで見て、和がjとなる通り数
dp = [defaultdict(int) for i in range(N+1)]
dp[0][0] = 1
for i, a in enumerate(A):
for k, v in list(dp[i].items()):
dp[i+1][k] += v
dp[i+1][k+a] += v
# 部分和が0になった通り数から、1つも選ばない分の1を引く
print((dp[N][0] - 1))
| p04013 |
from itertools import combinations
from statistics import mean
n, a = list(map(int, input().split(" ")))
x = tuple(map(int, input().split(" ")))
count = 0
for m in range(1, n+1):
for nums in combinations(x, m):
if mean(nums) == a:
count += 1
print(count) | from collections import Counter
N, A = list(map(int, input().split(" ")))
X = list(map(int, input().split(" ")))
X = [x-A for x in X]
c = Counter([0])
for x in X:
d = Counter()
for k, v in list(c.items()):
d[k+x] += v
c += d
print((c[0]-1)) | p04013 |
N,A=list(map(int,input().split()))
x=[0]+list(map(int,input().split()))
#print x
max_n=max(x)
#dp=[[[0]*(max_n*N+1) for k in range(N+1)] for j in range(N+1)]
dp=[[[0]*3000 for k in range(51)] for j in range(51)]
#print dp
for j in range(N+1):
for k in range(N+1):
for s in range(max_n*N+1):
if j==k==s==0:
dp[j][k][s]=1
elif j>=1 and s<x[j]:
dp[j][k][s]=dp[j-1][k][s]
elif j>=1 and k>=1 and s>=x[j]:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-x[j]]
else:
dp[j][k][s]=0
#print dp
ans=0
for k in range(1,N+1):
ans+=dp[N][k][k*A]
print(ans)
| N,A=list(map(int,input().split()))
x=[0]+list(map(int,input().split()))
#print x
y=[i-A for i in x]
#print y
max_x=max(max(x),A)
#print max_x
dp=[[0]*(2*N*max_x+1) for i in range(N+1)]
for j in range(N+1):
for t in range(2*N*max_x):
if j==0 and t==N*max_x:
dp[j][t]=1
elif j>=1 and (t-y[j]<0 or t-y[j]>2*N*max_x):
dp[j][t]=dp[j-1][t]
elif j>=1 and t-y[j]>=0 and 2*N*max_x>=t-y[j]:
dp[j][t]=dp[j-1][t]+dp[j-1][t-y[j]]
else:
dp[j][t]=0
print(dp[N][N*max_x]-1)
| p04013 |
from collections import Counter
N,A = list(map(int, input().split()))
X = list(map(int, input().split()))
X = [x-A for x in X]
cnt = Counter([0, X[0]])
for x in X[1:]:
temp = Counter([])
for k,v in list(cnt.items()):
temp[k + x] += v
cnt += temp
print((cnt[0]-1))
| from collections import Counter
n,a = list(map(int, input().split()))
l = list(map(int, input().split()))
l = [ai - a for ai in l]
cnt = Counter([0, l[0]])
for li in l[1:]:
tmp = Counter([])
for k,v in list(cnt.items()):
tmp[k+li] += v
cnt += tmp
print((cnt[0]-1)) | p04013 |
from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,A = inpl()
x = inpl()
dp = [[[0 for _ in range(n+5)] for i in range(3005)] for j in range(n+5)]
dp[0][0][0] = 1
for i in range(n):
for j in range(sum(x)+1):
for k in range(n):
if j >= x[i]:
dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]
else:
dp[i+1][j][k] = dp[i][j][k]
# for i in range(n+1):
# print(dp[i][:50])
ans = 0
for j in range(1,sum(x)+1):
for k in range(1,n+1):
if j/k == A:
ans += dp[n][j][k]
print(ans) | from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))
n,A = inpl()
x = inpl()
nx = n * max(max(x),A)
dp = [[[0 for _ in range(n+5)] for i in range(nx+1)] for j in range(n+5)]
dp[0][0][0] = 1
for i in range(n):
for j in range(nx+1):
for k in range(n):
if j >= x[i]:
dp[i+1][j][k+1] = dp[i][j-x[i]][k] + dp[i][j][k+1]
else:
dp[i+1][j][k] = dp[i][j][k]
ans = 0
for j in range(1,nx+1):
for k in range(1,n+1):
if j/k == A:
ans += dp[n][j][k]
print(ans) | p04013 |
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
import collections
def Count(j,k,s):
if(j==0 and k==0 and s==0):
return 1
elif(j >= 1 and s < x[j-1]):
return Count(j-1,k,s)
elif(j >= 1 and k>=1 and s >= x[j-1]):
return Count(j-1,k,s) + Count(j-1,k-1,s-x[j-1])
elif(j < k):
return 0
else:
return 0
sum=0
for i in range(1,n+1):
sum += Count(n,i,i*a)
print(sum) | n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
def Count(n,k,a):
s = sum(x)
dp=[[[0 for l in range(s+1)] for j in range(k+1)] for i in range(n+1)]
dp[0][0][0]=1
Sum=0
for i in range(n):
for j in range(k+1):
for l in range(s+1):
if l < x[i]:
dp[i+1][j][l] = dp[i][j][l]
if j >=1 and l >= x[i]:
dp[i+1][j][l] = dp[i][j][l] + dp[i][j-1][l-x[i]]
if j <= i+1 and l ==j*a and j >= 1:
if dp[i+1][j][l]>=1:
Sum += dp[i+1][j][l]-dp[i][j][l]
return Sum
print((Count(n,n,a)))
| p04013 |
n,a = list(map(int,input().split()))
lst = [int(i) for i in input().split()]
lst.sort()
ans = 0
for i in range(2 ** n):
bit = format(i,'b')
bit = bit.rjust(n,'0')
lcs = 0
cnt = 0
for w in range(n):
if bit[w]=='1':
lcs += lst[w]
cnt += 1
if cnt != 0:
if lcs / cnt == a:
ans += 1
print(ans) | num,ave = list(map(int,input().split()))
numx = list(map(int,input().split()))
L = len(numx)
numy = [0] * L
for i in range(L):
numy[i] = numx[i] - ave
if abs(min(numy)) < abs(max(numy)):
maxX = max(numy)
else:
maxX = abs(min(numy))
dp = [[0]*(2*maxX*L+1) for _ in range(L+1)]
dp[0][maxX*L] = 1
for i in range(L):
for j in range(2*maxX*L+1):
if (j-numy[i]) < 0 or (j - numy[i]) > 2*maxX*L:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = dp[i][j] + dp[i][j-numy[i]]
print((dp[L][maxX*L]-1)) | p04013 |
# -*- coding:utf-8 -*-
"""解説
dp[j][k][s] := x1,...,xjから k枚選んで xiの合計をsにするような選び方の総数
[@lilium氏]
https://atcoder.jp/contests/abc044/submissions/5887235
"""
def solve():
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
max_x = max(X)
dp = [[[0 for _ in range(4000+1)] for __ in range(N+1)] for ___ in range(N+1)]
dp[0][0][0] = 1
# dp[i][j][k] := i枚のうちj枚を選んで、和がkになる組み合わせ
"""
dp[i][j][k] := i枚のうち、k枚のカードを選んで、選んだカードの総和がkになる選び方の総数
i: i枚目のカード
j: j枚のカードを選んだ
k: 選んだカードの総和
"""
for i in range(N):
for j in range(N):
for k in range(4000+1):
if (k+X[i] < 4000+1) :
dp[i+1][j][k] += dp[i][j][k] # i枚目を選ばなかった
dp[i+1][j+1][k+X[i]] += dp[i][j][k] # i枚目を選んだ
ans = 0
for j in range(1, N+1):
ans += dp[N][j][j*A]
print(ans)
if __name__ == "__main__":
solve()
| # -*- coding:utf-8 -*-
def solve():
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
# dp[i][j] := 左からi+1枚目までにj枚を選んで、選んだカードの総和がkになるカードの選び方
dp = [[[0 for _ in range(50*50+1)] for __ in range(N+1)] for ___ in range(N+1)]
dp[0][0][0] = 1 # 何も選んでない初期値
for i in range(0, N):
for j in range(0, N):
for k in range(50*50+1):
#if dp[i][j][k] != 0:
if 1:
dp[i+1][j][k] += dp[i][j][k] # i枚目を選ばない
if k-X[i] >= 0:
dp[i+1][j+1][k] += dp[i][j][k-X[i]] # i枚目を選んだ
ans = 0
for j in range(1, N+1): # 1枚以上選ぶ必要がある
ans += dp[N][j][j*A]
print(ans)
if __name__ == "__main__":
solve()
| p04013 |
# -*- coding:utf-8 -*-
def solve():
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[[0 for _ in range(50*50+1)] for __ in range(N+1)] for ___ in range(N+1)]
dp[0][0][0] = 1 # 何も選んでない初期値
"""
dp[i][j][k] := 左からi+1枚目までに、j枚のカードを選んで、選んだカードの総和がkになる選び方の総数
i: 左からi+1枚目のカード
j: j枚のカードを選んだ
k: 選んだカードの総和
"""
for i in range(0, N):
for j in range(0, N):
for k in range(50*50+1):
dp[i+1][j][k] += dp[i][j][k] # i枚目を選ばない
if k-X[i] >= 0:
dp[i+1][j+1][k] += dp[i][j][k-X[i]] # i枚目を選んだ
ans = 0
for j in range(1, N+1): # 1枚以上選ぶ必要がある
ans += dp[N][j][j*A]
print(ans)
if __name__ == "__main__":
solve()
| # -*- coding:utf-8 -*-
def solve():
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
# dp[i][j][k] := 左からi+1枚目までに、j枚を選んで、選んだカードの総和がkになる場合の数
dp = [[[0 for _ in range(50*50+1)] for __ in range(N+1)] for ___ in range(N)]
dp[0][0][0] = 1
dp[0][1][X[0]] = 1
for i in range(1, N):
for j in range(0, N):
for k in range(0, 50*50+1):
dp[i][j][k] += dp[i-1][j][k] # カードを選ばない
if k+X[i] < 50*50+1:
dp[i][j+1][k+X[i]] += dp[i-1][j][k] # カードを選ぶ
ans = 0
for j in range(1, N+1):
ans += dp[N-1][j][A*j]
print(ans)
if __name__ == "__main__":
solve()
| p04013 |
from itertools import combinations as c
n,a=list(map(int,input().split()))
l=list(map(int,input().split()))
v=0
for i in range(1,n+1):
v+=sum([1 for j in c(l,i) if sum(j)==a*i])
print(v) | n,a=list(map(int,input().split()))
l=list(map(int,input().split()))
x=max(l)
x=max(x,a)
dp=[[[0 for _ in range(n*x+1)] for _ in range(n+1)] for _ in range(n+1)]
for j in range(n+1):
for k in range(n+1):
for s in range(n*x+1):
if j==0 and k==0 and s==0:
dp[j][k][s]=1
elif j>=1 and s<l[j-1]:
dp[j][k][s]=dp[j-1][k][s]
elif j>=1 and k>=1 and s>=l[j-1]:
dp[j][k][s]=dp[j-1][k][s]+dp[j-1][k-1][s-l[j-1]]
else:
dp[j][k][s]=0
s=0
for k in range(1,n+1):
s+=dp[n][k][k*a]
print(s) | p04013 |
n,a=list(map(int,input().split()))
*x,=list(map(int,input().split()))
dp=[[[None]*(n*50+1) for i in range(n+1)] for _ in range(n+1)]
for i in range(n+1):
for j in range(n+1):
for k in range(n*50+1):
if i==0 and j==0 and k==0:
dp[i][j][k]=1
elif i and k<x[i-1]:
dp[i][j][k]=dp[i-1][j][k]
elif i and j and k>=x[i-1]:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i-1]]
else:
dp[i][j][k]=0
print((sum(dp[n][i][i*a] for i in range(1,n+1)))) | n,a=list(map(int,input().split()))
*x,=list(map(int,input().split()))
dp=[[[0]*(n*50+1) for i in range(n+1)] for _ in range(n+1)]
for i in range(n+1):
for j in range(n+1):
for k in range(n*50+1):
if i==0 and j==0 and k==0:
dp[i][j][k]=1
elif i and k<x[i-1]:
dp[i][j][k]=dp[i-1][j][k]
elif i and j and k>=x[i-1]:
dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-x[i-1]]
v=0
for i in range(1,n+1):
v+=dp[n][i][i*a]
print(v) | p04013 |
N,A=list(map(int, input().split()))
x=list(map(int, input().split()))
dp = [[[0]*(51*51) for _ in range(N+1)] for _ in range(N+1)]
# dp[j][k][s]
for j in range(N+1):
for k in range(N+1):
for s in range(51*51):
if j==0 and k==0 and s==0:
dp[j][k][s] = 1
elif j >=1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >=1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
ans = 0
for i in range(1, N+1):
ans+= dp[N][i][i*A]
print(ans) | N,A=list(map(int, input().split()))
x=list(map(int, input().split()))
dp = [[[0]*(51*51) for _ in range(N+1)] for _ in range(N+1)]
# dp[j][k][s]
for j in range(N+1):
for k in range(j+1):
for s in range(51*51):
if j==0 and k==0 and s==0:
dp[j][k][s] = 1
elif j >=1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
elif j >=1 and k >= 1 and s >= x[j-1]:
dp[j][k][s] = dp[j-1][k][s]+dp[j-1][k-1][s-x[j-1]]
else:
dp[j][k][s] = 0
ans = 0
for i in range(1, N+1):
ans+= dp[N][i][i*A]
print(ans) | p04013 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.