input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
import sys
input=sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
Devide_N=10**9+7
Rem_2_32_DN=(2**32)%Devide_N
if N%2==1:
if A.count(0)!=1:
print((0))
else:
for ch_n in range(1,(N-1)//2+1):
if A.count(ch_n*2)!=2:
break
else:
A.remove(ch_n*2)
A.remove(ch_n*2)
else:
exp=(N-1)//2
exp_quotient_32=exp//32
exp_rem_32=exp%32
Rem_ans_Devide_N=1
for _ in range(exp_quotient_32):
Rem_ans_Devide_N=(Rem_ans_Devide_N*Rem_2_32_DN)%Devide_N
print(((Rem_ans_Devide_N*2**(exp_rem_32))%Devide_N))
sys.exit()
print((0))
else:
for ch_n in range(1,N//2+1):
if A.count(ch_n*2-1)!=2:
break
else:
A.remove(ch_n*2-1)
A.remove(ch_n*2-1)
else:
exp=N//2
exp_quotient_32=exp//32
exp_rem_32=exp%32
Rem_ans_Devide_N=1
for _ in range(exp_quotient_32):
Rem_ans_Devide_N=(Rem_ans_Devide_N*Rem_2_32_DN)%Devide_N
print(((Rem_ans_Devide_N*2**(exp_rem_32))%Devide_N))
sys.exit()
print((0)) | import sys
input=sys.stdin.readline
N=int(eval(input()))
A=list(map(int,input().split()))
A.sort()
Devide_N=10**9+7
Rem_2_32_DN=(2**32)%Devide_N
if N%2==1:
if (A[0]!=0 or A[1]==0 if N>2 else A[0]!=0):
print((0))
else:
del A[0]
for ch_n in range(1,(N-1)//2+1):
if A[0]!=ch_n*2 or A[1]!=ch_n*2:
break
else:
del A[0:2]
else:
exp=(N-1)//2
exp_quotient_32=exp//32
exp_rem_32=exp%32
Rem_ans_Devide_N=1
for _ in range(exp_quotient_32):
Rem_ans_Devide_N=(Rem_ans_Devide_N*Rem_2_32_DN)%Devide_N
print(((Rem_ans_Devide_N*2**(exp_rem_32))%Devide_N))
sys.exit()
print((0))
else:
for ch_n in range(1,N//2+1):
if A[0]!=ch_n*2-1 or A[1]!=ch_n*2-1:
break
else:
del A[0:2]
else:
exp=N//2
exp_quotient_32=exp//32
exp_rem_32=exp%32
Rem_ans_Devide_N=1
for _ in range(exp_quotient_32):
Rem_ans_Devide_N=(Rem_ans_Devide_N*Rem_2_32_DN)%Devide_N
print(((Rem_ans_Devide_N*2**(exp_rem_32))%Devide_N))
sys.exit()
print((0))
| p03846 |
N=int(eval(input()))
A=list(map(int,input().split()))
mod=10**9+7
A.sort()
ans=1
if N%2==1:
i=1
if A[0]!=0:
print((0))
exit()
while i<N:
if A[i]==A[i+1] and A[i]==(i//2+1)*2:
i+=2
ans*=2
ans%=mod
else:
print((0))
exit()
print(ans)
else:
i=0
while i<N:
if A[i]==A[i+1] and A[i]==(i//2)*2+1:
i+=2
ans*=2
ans%=mod
else:
print((0))
print(ans) | def main():
N=int(eval(input()))
A=list(map(int,input().split()))
mod=10**9+7
ans=1
A.sort()
if N%2==0:
for i in range(0,N,2):
if A[i]!=A[i+1] or A[i]!=i+1:
print((0))
exit()
ans=ans*2%mod
print(ans)
else:
if A[0]!=0:
print((0))
exit()
ans=1
for i in range(1,N,2):
if A[i]!=A[i+1] or A[i]!=i+1:
print((0))
exit()
ans=ans*2%mod
print(ans)
if __name__=='__main__':
main() | p03846 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
l.sort()
x=1
if n%2==0:
f=True
for i in range(n):
if f:
f=False
x*=2
x%=mod
else:
f=True
if (i//2)*2+1!=l[i]:
return 0
return x
else:
if l[0]!=0:
return 0
f=True
for i in range(n-1):
if f:
f=False
x*=2
x%=mod
else:
f=True
if (i//2)*2+2!=l[1:][i]:
return 0
return x
print((main()))
| a=1000000007
n=int(eval(input()))
l=list(map(int,input().split()))
l.sort()
if n%2==1:
if l[0]!=0:
print((0))
exit()
else:
l.remove(0)
sh=2
f=0
for i in l:
if f==0:
if i!=sh:
print((0))
exit()
else:
f=1
else:
if i!=sh:
print((0))
exit()
else:
sh+=2
f=0
sh=(n-1)//2
b=1
for i in range(sh):
b*=2
b%=a
print(b)
else:
sh=1
f=0
for i in l:
if f==0:
if i!=sh:
print((0))
exit()
else:
f=1
else:
if i!=sh:
print((0))
exit()
else:
sh+=2
f=0
sh=n//2
b=1
for i in range(sh):
b*=2
b%=a
print(b)
| p03846 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
l.sort()
if n%2==0:
for i in range(n):
if (i//2)*2+1!=l[i]:
return 0
return pow(2,n//2)%mod
else:
if l[0]!=0:
return 0
for i in range(n-1):
if (i//2)*2+2!=l[1:][i]:
return 0
return pow(2,n//2)%mod
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
l.sort()
if n%2==0:
for i in range(n):
if (i//2)*2+1!=l[i]:
return 0
return pow(2,n//2)%mod
else:
if l[0]!=0:
return 0
l.remove(0)
for i in range(n-1):
if (i//2)*2+2!=l[i]:
return 0
return pow(2,n//2)%mod
print((main()))
| p03846 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
l.sort()
if n%2==0:
for i in range(n):
if (i//2)*2+1!=l[i]:
return 0
return pow(2,n//2)%mod
else:
if l[0]!=0:
return 0
l=l[1:]
for i in range(n-1):
if (i//2)*2+2!=l[i]:
return 0
return pow(2,n//2)%mod
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
def LI(): return list(map(int,input().split()))
def I(): return int(eval(input()))
def LS(): return input().split()
def S(): return eval(input())
def main():
n=I()
l=LI()
l.sort()
if n%2==0:
for i in range(n//2):
if l[i]!=i//2*2+1:
return 0
else:
if l[0]!=0:
return 0
for i in range(1,n):
if -(-i//2)*2!=l[i]:
return 0
return pow(2,n//2)%mod
print((main()))
| p03846 |
def index(n:int, a: int):
if a % 2 == 0:
i = n // 2 - a // 2
j = (i + 1) * -1
return (i, j) if i != n // 2 else (i,)
else:
i = (n // 2 - 1) - (a - 1) // 2
j = (i + 1) * -1
return (i, j)
n = int(eval(input()))
line = [0 for _ in range(n)]
for a in map(int, input().split()):
for i in index(n, a):
line[i] += 1
else:
if n == 1 and line == [1]:
print((1))
elif n % 2 == 0 and set(line) == {2}:
print((2 ** (n // 2) % (10 ** 9 + 7)))
elif n % 2 == 1 and set(line) == {1, 2} and line[n//2] == 1:
print((2 ** ((n - 1) // 2) % (10 ** 9 + 7)))
else:
print((0)) | n = int(eval(input()))
a = [int(x) for x in input().split()]
line = [abs(i - (n - i - 1)) for i in range(n)]
if sorted(a) == sorted(line):
print(((2 ** (n // 2)) % (10 ** 9 + 7)))
else:
print((0)) | p03846 |
from collections import Counter
mod = 10 ** 9 + 7
n = int(eval(input()))
A = Counter([int(i) for i in input().split()])
ans = 0
if n % 2 == 1:
for k, v in list(A.items()):
if k == 0 and v != 1:
ans = 0
break
elif v >= 3:
ans = 0
break
elif v == 2:
ans += 1
else:
for k, v in list(A.items()):
if v != 2:
ans = 0
break
else:
ans += 1
if n == 1:
if A[0] == 1:
print((1))
else:
print((0))
elif ans == 0:
print((0))
else:
print((2 ** ans % mod)) | from collections import Counter
mod = 10 ** 9 + 7
n = int(eval(input()))
A = Counter([int(i) for i in input().split()])
flag = 0
cnt = 0
if n % 2 == 1:
for k, v in list(A.items()):
if k != 0 and v == 2:
cnt += 1
elif k == 0 and v == 1:
pass
else:
flag = 1
else:
for k, v in list(A.items()):
if v == 2:
cnt += 1
else:
flag = 1
if flag == 1:
print((0))
else:
print((2 ** cnt % mod)) | p03846 |
import queue, math
while True:
l = 0; r = []
try:
inp = list(map(int, input().split()))
l = inp[0]
r = inp[1:]
except EOFError:
break
n = len(r)
if 2*sum(r) < l:
print("OK")
else:
que = queue.PriorityQueue()
dp = [[1000.0 for i in range(n)] for j in range(2**n)]
que.put((0.0, 0, -1))
while not que.empty():
co, state, last = que.get()
if last!=-1 and dp[state][last] < co:
continue
for i in range(n):
if (state & (1<<i))==0:
nxt = co + math.sqrt(r[last]*r[i])*2.0 if last!=-1 else r[i]
if nxt < dp[state | (1<<i)][i]:
dp[state | (1<<i)][i] = nxt
que.put((nxt, state | (1<<i), i))
ans = 1000.0
for i in range(n):
ans = min(ans, dp[2**n-1][i]+r[i])
print("OK" if ans < l+0.000000001 else "NA") | import queue, math
while True:
l = 0; r = []
try:
inp = list(map(int, input().split()))
l = inp[0]
r = inp[1:]
except EOFError:
break
n = len(r)
if 2*sum(r) <= l:
print("OK")
else:
n2 = 2**n-1
que = queue.PriorityQueue()
dp = [[1000.0 for i in range(n)] for j in range(2**n)]
que.put((0.0, 0, -1))
ok = False
while not ok and not que.empty():
co, state, last = que.get()
if last!=-1 and dp[state][last] < co:
continue
for i in range(n):
if (state & (1<<i))==0:
nxt = co + math.sqrt(r[last]*r[i])*2.0 if last!=-1 else r[i]
nst = state | (1<<i)
if nxt + r[i] < l+0.000000001 and nxt < dp[nst][i]:
if nst==n2:
ok = True
break
dp[nst][i] = nxt
que.put((nxt, nst, i))
print("OK" if ok else "NA") | p00120 |
import sys
from math import sqrt
def rec(state, v):
if state == (1 << N) - 1:
return cakes[v]
if dp[state][v] != -1:
return dp[state][v]
ret = INF
for i in range(N):
if not (state >> i & 1):
ret = min(ret, rec(state | 1 << i, i) + sqrt(pow(cakes[i] + cakes[v], 2) - pow(cakes[i] - cakes[v], 2)))
dp[state][v] = ret
return ret
testcases = [[int(x) for x in line.split()] for line in sys.stdin.readlines()]
for testcase in testcases:
box, *cakes = testcase
N = len(cakes)
INF = box + 1
ans = INF
for i in range(N):
dp = [[-1] * N for _ in range(1 << N)]
ans = min(ans, rec(1 << i, i) + cakes[i])
print(('OK' if ans <= box else 'NA')) | import sys
from math import sqrt
def rec(state, v):
if state == (1 << N) - 1:
return cakes[v]
if dp[state][v] != -1:
return dp[state][v]
ret = INF
for i in range(N):
if state == 0:
ret = min(ret, rec(1 << i, i) + cakes[i])
elif not (state >> i & 1):
ret = min(ret, rec(state | 1 << i, i) + sqrt(pow(cakes[i] + cakes[v], 2) - pow(cakes[i] - cakes[v], 2)))
dp[state][v] = ret
return ret
testcases = [[int(x) for x in line.split()] for line in sys.stdin.readlines()]
for testcase in testcases:
box, *cakes = testcase
N = len(cakes)
INF = box + 1
dp = [[-1] * N for _ in range(1 << N)]
print(('OK' if rec(0, 0) <= box else 'NA')) | p00120 |
import sys
from math import sqrt
testcases = [[int(x) for x in line.split()] for line in sys.stdin.readlines()]
for testcase in testcases:
box, *cakes = testcase
N = len(cakes)
INF = box + 1
dp = [[INF] * N for _ in range(1 << N)]
dp[(1 << N) - 1][0] = 0
for state in reversed(list(range(1 << N))):
for v in range(N):
if not dp[state][v]:
continue
for u in range(N):
if not (state >> u & 1):
dp[state][v] = min(dp[state][v], dp[state | 1 << u][u] + sqrt(pow(cakes[u] + cakes[v], 2) - pow(cakes[u] - cakes[v], 2)))
print(('OK' if min(dp[0]) <= box else 'NA')) | import sys
from math import sqrt
def rec(state, v):
if state == (1 << N) - 1:
return cakes[v]
if dp[state][v] != -1:
return dp[state][v]
ret = INF
for u in range(N):
if state == 0:
ret = min(ret, rec(1 << u, u) + cakes[u])
elif not (state >> u & 1):
ret = min(ret, rec(state | 1 << u, u) + sqrt(pow(cakes[u] + cakes[v], 2) - pow(cakes[u] - cakes[v], 2)))
dp[state][v] = ret
return ret
testcases = [[int(x) for x in line.split()] for line in sys.stdin.readlines()]
for testcase in testcases:
box, *cakes = testcase
N = len(cakes)
INF = box + 1
dp = [[-1] * N for _ in range(1 << N)]
print(('OK' if rec(0, 0) <= box else 'NA')) | p00120 |
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0120
"""
import sys
from sys import stdin
input = stdin.readline
def calc_width(cakes):
# ??±????????????????????????(?????????)????????????????????????????????????????¨??????????
if len(cakes) == 1:
return cakes[0]*2
prev_r = cakes[0]
width = prev_r
for r in cakes[1:]:
h_diff = abs(prev_r - r)
if h_diff == 0:
width += prev_r
width += r
else:
w = ((prev_r + r)**2 - h_diff**2)**0.5
width += w
prev_r = r
width += cakes[-1]
return width
def main(args):
for line in sys.stdin:
data = [int(x) for x in line.strip().split()]
box_size = data[0]
temp = data[1:]
temp.sort()
min_width = float('inf')
cake = []
if len(temp) < 3:
cakes = temp[:]
elif len(temp) == 3:
cakes = [temp[1], temp[2], temp[0]]
else:
cakes = [temp[1] ,temp[-1], temp[0]]
temp = temp[2:-1]
tail = True
small = False
while temp:
if tail:
if small:
cakes.append(temp[0])
temp = temp[1:]
tail = False
else:
cakes.append(temp[-1])
temp = temp[:-1]
tail = False
else:
if small:
cakes.insert(0, temp[0])
temp = temp[1:]
small = False
tail = True
else:
cakes.insert(0, temp[-1])
temp = temp[:-1]
small = True
tail = True
result = calc_width(cakes)
min_width = min(result, min_width)
temp = data[1:]
temp.sort()
cake = []
if len(temp) < 3:
cakes = temp[:]
elif len(temp) == 3:
cakes = [temp[1], temp[0], temp[2]]
else:
cakes = [temp[-2] ,temp[0], temp[-1]]
temp = temp[1:-2]
tail = True
small = True
while temp:
if tail:
if small:
cakes.append(temp[0])
temp = temp[1:]
tail = False
else:
cakes.append(temp[-1])
temp = temp[:-1]
tail = False
else:
if small:
cakes.insert(0, temp[0])
temp = temp[1:]
small = False
tail = True
else:
cakes.insert(0, temp[-1])
temp = temp[:-1]
small = True
tail = True
result = calc_width(cakes)
min_width = min(result, min_width)
if min_width <= box_size:
print('OK')
else:
print('NA')
from itertools import permutations
def main2(args):
data = [3, 3, 3, 10, 10]
p = permutations(data, len(data))
best_fit = float('inf')
for cakes in p:
result = calc_width(cakes)
if result < best_fit:
best_fit = result
print(cakes)
print(result)
if __name__ == '__main__':
main(sys.argv[1:])
| # -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0120
"""
import sys
from sys import stdin
input = stdin.readline
def calc_width(cakes):
# ??±????????????????????????(?????????)????????????????????????????????????????¨??????????
if len(cakes) == 1:
return cakes[0]*2
prev_r = cakes[0]
width = prev_r
for r in cakes[1:]:
h_diff = abs(prev_r - r)
w = ((prev_r + r)**2 - h_diff**2)**0.5
width += w
prev_r = r
width += cakes[-1]
return width
def main(args):
for line in sys.stdin:
data = [int(x) for x in line.strip().split()]
box_size = data[0]
temp = data[1:]
temp.sort()
# ??±??????????????????????????????????????????????????????????????????????????????
min_width = float('inf')
cakes = [temp[0]]
temp = temp[1:]
pick_large = True
while temp:
if pick_large:
pick = temp[-1]
temp = temp[:-1]
pick_large = False
diff_front = abs(pick - cakes[0])
diff_rear = abs(pick - cakes[-1])
if diff_front > diff_rear:
cakes.insert(0, pick)
else:
cakes.append(pick)
else:
pick = temp[0]
temp = temp[1:]
pick_large = True
diff_front = abs(pick - cakes[0])
diff_rear = abs(pick - cakes[-1])
if diff_front > diff_rear:
cakes.insert(0, pick)
else:
cakes.append(pick)
result = calc_width(cakes)
min_width = min(result, min_width)
if min_width <= box_size:
print('OK')
else:
print('NA')
if __name__ == '__main__':
main(sys.argv[1:])
| p00120 |
import sys,itertools
for s in sys.stdin:
a=list(map(int,s.split(" ")))
w=a[0]
n=len(a)-1
A=itertools.permutations(a[1:],n)
s0=1e9
for e in A:
s=e[0]+e[-1]
for i in range(n-1): s+=2*(e[i]*e[i+1])**.5
if s<s0: s0=s
if s0<=w: break
print(["OK","NA"][s0>w]) | import sys
for s in sys.stdin:
a=list(map(int,s.split(" ")))
w=a[0]
a=sorted(a[1:])
n=len(a)
A=[]
A.append(a.pop(0))
while a:
A=[a.pop()]+A
if a==[]: break
A+=[a.pop()]
if a==[]: break
A=[a.pop(0)]+A
if a==[]: break
A+=[a.pop(0)]
a=A[0]+A[-1]
for i in range(n-1): a+=2*(A[i]*A[i+1])**.5
print(["OK","NA"][a>w]) | p00120 |
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
s=n*a
dp=[[[0 for i in range(s+1)] for j in range(n+1)] for k in range(n+1)]
dp[0][0][0]=1
for i in range(n):
for j in range(i+2):
for k in range(s+1):
if(k>=x[i]):
dp[i+1][j][k]=dp[i][j-1][k-x[i]]+dp[i][j][k]
else:
dp[i+1][j][k]=dp[i][j][k]
outp=0
for i in range(1,n+1):
outp+=dp[n][i][i*a]
print(outp) | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
y=[]
for i in x:
y.append(i-a)
s=2*n*a
dp=[[0 for i in range(s+1)] for j in range(n+1)]
dp[0][n*a]=1
for i in range(n):
for j in range(s+1):
x=j-y[i]
if(0<=x and x<=2*n*a):
dp[i+1][j]=dp[i][j-y[i]]+dp[i][j]
else:
dp[i+1][j]=dp[i][j]
print((dp[n][n*a]-1)) | p04015 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[0] * 2501 for _ in range(51)]
dp[0][0] = 1
for i in range(N):
x = X[i]
for j in range(i, -1, -1):
for k in range(2501):
if k < x:
continue
dp[j + 1][k] += dp[j][k - x]
ans = 0
for i in range(1, 51):
ans += dp[i][i * A]
print(ans)
| N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
Y = [x - A for x in X]
dp = [0] * 5010
dp[2500] = 1
for y in Y:
r = []
if y >= 0:
r = list(range(5009, -1, -1))
else:
r = list(range(5010))
for i in r:
if i - y < 0 or i - y >= 5010:
continue
dp[i] += dp[i - y]
print((dp[2500] - 1))
| p04015 |
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
dp = [[[0 for _ in range(50*N + 1)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
# i番目までのカードが選べる時にj-1枚選んでありｊ枚目にiを選ぶとき合計がA*(j)になるかどうか
# dp[i][j][k] : j-1枚選んでいてiを次に選んだ時に合計がｋになる組の数
for i in range(N+1):
for j in range(i+1):
for k in range(50*j + 1):
# カードを選択するが、i番目のカードを選んでも合計がkに一致しない
if i >= 1 and k < X[i-1]:
# i番目を使っても合計がｋにならないなら、i-1枚目までで作った時と同じ組の数
dp[i][j][k] = dp[i-1][j][k]
# i番目のカードをj枚目に選んで合計がｋになるものがある場合。
# k >= X[i-1] がなんとなく直感と一致しない気もするが、ｋは０～枚数＊目標平均値の範囲の値をとるのでこれでいい
elif i >= 1 and j >= 1 and k >= X[i-1]:
# i-1番目までで合計がｋになる個数＋ｊ-1番目までの合計がｋ-X[i]
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-1][k - X[i-1]]
ans = 0
# N枚目までからi枚選んだ時に平均がA（合計がA*i）になる個数をi=１～Nまで見る
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()))
# i番目までからｊ枚選んで合計がｋ
dp = [[[0 for _ in range(50*N + 1)] for _ in range(N+1)] for _ in range(N+1)]
# 何も選ばず平均が０
dp[0][0][0] = 1
#全てのカードについてみる
#i-1番までからj-1枚選んで、j番目にiを選択したときの合計がA*jになるかどうか
for i in range(N+1):
#i-1番目までからj-1枚選んであるので、最大でi-1枚選んである
for j in range(i+1):
# ｋは合計値
for k in range(50*j + 1):
# i番目を選んで合計がｋになるには、i番目の値がｋより小さくなければならない
if i >= 1 and k < X[i-1]:
# i番目がｋより大きいから、i-1番目までで合計がｋになる組の個数と同じ
dp[i][j][k] = dp[i-1][j][k]
#
elif i >= 1 and j >= 1 and k >= X[i-1]:
#i番目を選んで合計がｋになるとき、ｋがi番目より大きい＆i-1からj-1枚選んだ時に合計がｋ－X[i-1]と、i-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):
#N枚からi枚選んで合計がi*A
ans += dp[N][i][i*A]
print(ans) | p04015 |
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
for i in range(n):
x[i]-=a
dp=[]
for i in range(n+1):
dp.append([])
for i in range(6000):
dp[-1].append(0)
dp[0][3000]=1
for i in range(n):
for j in range(6000):
if j+x[i]<6000 and j+x[i]>=0:
dp[i+1][j+x[i]]+=dp[i][j]
dp[i+1][j]+=dp[i][j]
print((dp[n][3000]-1))
| n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
dic={}
dic2=dic.copy()
for i in range(n):
for j in dic:
if j+x[i]-a in dic2:
dic2[j+x[i]-a]+=dic[j]
else:
dic2[j+x[i]-a]=dic[j]
if x[i]-a in dic2:
dic2[x[i]-a]+=1
else:
dic2[x[i]-a]=1
dic=dic2.copy()
if 0 in dic:
print((dic[0]))
else:
print((0)) | p04015 |
N, A = (int(i) for i in input().split())
x = [int(i) for i in input().split()]
sumx = sum(x)
DP = [[[0] * (N+1) for i in range(sumx+1)] for i in range(N+1)]
DP[0][0][0] = 1
for i in range(N):
for j in range(sumx+1):
for k in range(N):
if j - x[i] >= 0:
DP[i+1][j][k+1] += DP[i][j-x[i]][k]
DP[i+1][j][k] += DP[i][j][k]
res = 0
for i in range(1,N+1):
if i * A <= sumx:
res += DP[N][i * A][i]
print(res) | N, A = (int(i) for i in input().split())
x = [int(i) for i in input().split()]
sumx = sum(x)
DP = [[[0] * (N+1) for i in range(sumx+1)] for i in range(N+1)]
DP[0][0][0] = 1
for i in range(N):
for j in range(sumx+1):
for k in range(i+1):
if j - x[i] >= 0:
DP[i+1][j][k+1] += DP[i][j-x[i]][k]
DP[i+1][j][k] += DP[i][j][k]
res = 0
for i in range(1,N+1):
if i * A <= sumx:
res += DP[N][i * A][i]
print(res) | p04015 |
# ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
def main():
N, A = tuple(map(int, input().split()))
X = tuple(map(int, input().split()))
# dp[i][j][k] := patterns to make k with j cards from X1, X2, ..., Xi
dp = [[[0] * (N * 50 + 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(N * 50 + 1):
if dp[i][j][k]:
dp[i + 1][j][k] += dp[i][j][k]
dp[i + 1][j + 1][k + X[i]] += dp[i][j][k]
ans = sum(dp[N][i][i * A] for i in range(1, N + 1))
print(ans)
if __name__ == "__main__":
main() | # ABC044C - 高橋君とカード / Tak and Cards (ARC060C)
def main():
N, A = tuple(map(int, input().split()))
X = tuple([int(x) - A for x in input().split()])
D = {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() | p04015 |
from collections import Counter
def inpl():
return list(map(int, input().split()))
N, A = inpl()
X = inpl()
cX = Counter(X)
dp = [[[0 for _ in range(N * max(X) + 1)] for j in range(i + 1)]
for i in range(N + 1)]
dp[0][0][0] = 1
for i in range(1, N + 1):
x = X[i - 1]
for j in range(i + 1):
for k in range(N * max(X) + 1):
# print(i, j, k)
if j == i and k - x < 0:
dp[i][j][k] = 0
elif j == i and k - x >= 0:
dp[i][j][k] = dp[i - 1][j - 1][k - x]
elif k - x < 0 or j == 0:
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]
ans = 0
for j in range(1, N + 1):
if j * A > N * max(X):
continue
ans += dp[N][j][j * A]
print(ans)
| def inpl():
return list(map(int, input().split()))
N, A = inpl()
X = inpl()
maxX = max(X)
dp = [[[0 for _ in range(N * maxX + 1)] for j in range(i + 1)]
for i in range(51)]
dp[0][0][0] = 1
for i in range(N):
x = X[i - 1]
for j in range(i + 1):
for k in range(N * maxX + 1):
# print(i, j, k)
if dp[i][j][k] == 0:
continue
dp[i + 1][j][k] += dp[i][j][k]
dp[i + 1][j + 1][k + x] += dp[i][j][k]
ans = 0
for j in range(1, N + 1):
if j * A > N * maxX:
continue
ans += dp[N][j][j * A]
print(ans)
| p04015 |
N,A = list(map(int,input().split()))
X = [int(x)-A for x in input().split()]
z = 0
dic = {}
for x in X:
if x==0:
z += 1
else:
dic[x] = dic.get(x,0) + 1
line = {}
line[0] = 1
for k in dic:
line_k = {}
for i in range(dic[k]+1):
line_k[k*i] = 1
for j in range(dic[k],dic[k]-i,-1):
line_k[k*i] *= j
for j in range(1,1+i):
line_k[k*i] //= j
line_tmp = {}
for k_lk in line_k:
for k_l in line:
line_tmp[k_lk+k_l] = line_tmp.get(k_lk+k_l,0) + line_k[k_lk] * line[k_l]
line = line_tmp.copy()
print((line[0] * (2**z) -1))
| N,A = list(map(int,input().split()))
X = [int(x)-A for x in input().split()]
d = {0:1}
for x in X:
d_tmp = d.copy()
for k in d_tmp:
d[k+x] = d.get(k+x,0)+d_tmp[k]
print((d[0]-1))
| p04015 |
import sys
import itertools
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N, A = in_nn()
X = in_nl()
for i in range(N):
X[i] -= A
N1 = N // 2
N2 = N - N1
comb1 = itertools.product(list(range(2)), repeat=N1)
comb2 = itertools.product(list(range(2)), repeat=N2)
d1 = defaultdict(int)
d2 = defaultdict(int)
for comb in comb1:
sum = 0
for i, c in enumerate(comb):
if c == 1:
sum += X[i]
d1[sum] += 1
for comb in comb2:
sum = 0
for i, c in enumerate(comb):
if c == 1:
sum += X[N1 + i]
d2[sum] += 1
ans = 0
for k, v in list(d1.items()):
ans += v * d2[-k]
ans -= 1
print(ans)
if __name__ == '__main__':
main()
| import sys
import copy
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N, A = in_nn()
X = in_nl()
X = [x - A for x in X]
dp = [0] * 5050
dp[2525] = 1
for i in range(N):
next_dp = copy.copy(dp)
for t in range(5050):
if X[i] + t < 5050:
next_dp[X[i] + t] += dp[t]
dp = next_dp
print((dp[2525] - 1))
if __name__ == '__main__':
main()
| p04015 |
import sys
import copy
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
in_n = lambda: int(readline())
in_nn = lambda: list(map(int, readline().split()))
in_s = lambda: readline().rstrip().decode('utf-8')
in_nl = lambda: list(map(int, readline().split()))
in_nl2 = lambda H: [in_nl() for _ in range(H)]
in_map = lambda: [s == ord('.') for s in readline() if s != ord('\n')]
in_map2 = lambda H: [in_map() for _ in range(H)]
in_all = lambda: list(map(int, read().split()))
def main():
N, A = in_nn()
X = in_nl()
X = [x - A for x in X]
dp = [0] * 5050
dp[2525] = 1
for i in range(N):
next_dp = copy.copy(dp)
for t in range(5050):
if X[i] + t < 5050:
next_dp[X[i] + t] += dp[t]
dp = next_dp
print((dp[2525] - 1))
if __name__ == '__main__':
main()
| import sys
import copy
readline = sys.stdin.buffer.readline
def main():
N, A = list(map(int, readline().split()))
X = list(map(int, readline().split()))
X = [x - A for x in X]
dp = [0] * 5050
dp[2525] = 1
for i in range(N):
next_dp = copy.copy(dp)
for t in range(5050):
if X[i] + t < 5050:
next_dp[X[i] + t] += dp[t]
dp = next_dp
print((dp[2525] - 1))
if __name__ == '__main__':
main()
| p04015 |
MAX=2500
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
# dp[i][j][k] := x[0:i]のカードからj枚とって合計がkとなる取り方の数
dp = [[[0] * (MAX+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(0,n+1):
for k in range(0, MAX+1):
dp[i+1][j][k] += dp[i][j][k] # i番目のカードを取らない
for j in range(0,n):
for k in range(0, MAX+1-x[i]):
dp[i+1][j+1][k+x[i]] += dp[i][j][k] # i番目のカードを取る
ans = 0
for i in range(1,n+1):
ans += dp[n][i][a*i]
print(ans)
| MAX=2500
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
# dp[i][j][k] := x[0:i]のカードからj枚とって合計がkとなる取り方の数
dp = [[[0] * (MAX+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(0,n+1):
for k in range(0, MAX+1):
dp[i+1][j][k] += dp[i][j][k] # i番目のカードを取らない
for j in range(1,n+1):
for k in range(x[i], MAX+1):
dp[i+1][j][k] += dp[i][j-1][k-x[i]] # i番目のカードを取る
ans = 0
for i in range(1,n+1):
ans += dp[n][i][a*i]
print(ans)
| p04015 |
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
table = [[[0]*(N*A+1) for i in range(N+1)] for j in range(N+1)]
table[0][0][0] = 1
for j in range(1,N+1):
for k in range(N+1):
for s in range(N*A+1):
c = x[j-1]
if s-c<0:
table[j][k][s] = table[j-1][k][s]
elif s-c>=0 and k>=1:
table[j][k][s] = table[j-1][k][s] + table[j-1][k-1][s-c]
ans = 0
for i in range(1,N+1):
ans += table[N][i][i*A]
print(ans) | N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
table = [[[0]*(N*A+1) for i in range(N+1)] for j in range(N+1)]
table[0][0][0] = 1
for j in range(1,N+1):
for k in range(j+1):
for s in range(N*A+1):
c = x[j-1]
if s-c<0:
table[j][k][s] = table[j-1][k][s]
elif s-c>=0 and k>=1:
table[j][k][s] = table[j-1][k][s] + table[j-1][k-1][s-c]
ans = 0
for i in range(1,N+1):
ans += table[N][i][i*A]
print(ans) | p04015 |
N, A = list(map(int, input().split()))
x = [int(i) for i in input().split()]
ans = 0
dp = [[[0]*(50*N+1) for j in range(N+1)] for k in range(N+1)]
dp[0][0][0] = 1
for j in range(1,N+1):
for k in range(N+1):
for s in range(50*N+1):
dp[j][k][s] = dp[j-1][k][s]
if s>=x[j-1]:
dp[j][k][s] += dp[j-1][k-1][s-x[j-1]]
for k in range(1,N+1):
ans += dp[N][k][k*A]
print(ans) | N, A = list(map(int, input().split()))
x= [int(i) for i in input().split()]
X = max(x)
dp = [[[0]*(X*N+1) for i in range(N+1)] for j in range(N+1)]
dp[0][0][0] = 1
ans = 0
for j in range(1,N+1):
for k in range(j+1):
for s in range(X*N+1):
dp[j][k][s] = dp[j-1][k][s]
if s >= x[j-1]:
dp[j][k][s] += dp[j-1][k-1][s-x[j-1]]
for i in range(N+1):
ans += dp[-1][i][i*A]
if (i+1)*A > X*N:
break
print((ans-1)) | p04015 |
n, A = list(map(int,input().split()))
x = list(map(int,input().split()))
dp = [list( [0 for _ in range(10**4)] for _ in range(n+1)) for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
for k in range(n):
for s in range(sum(x)+1):
dp[i+1][k][s] += dp[i][k][s]
dp[i+1][k+1][s+x[i]] += dp[i][k][s]
ans = 0
for i in range(1,n+1):
ans += dp[n][i][A*i]
print(ans)
| n, A = list(map(int,input().split()))
x = list(map(int,input().split()))
dp = [list( [0 for _ in range(3000)] for _ in range(n+1)) for _ in range(n+1)]
dp[0][0][0] = 1
for i in range(n):
for k in range(n):
for s in range(sum(x)+1):
dp[i+1][k][s] += dp[i][k][s]
dp[i+1][k+1][s+x[i]] += dp[i][k][s]
ans = 0
for i in range(1,n+1):
ans += dp[n][i][A*i]
print(ans)
| p04015 |
n, a =list(map(int, input().split()))
x=list(map(int, input().split()))
x=[i-a for i in x]
memo=[[-1]*6000 for i in range(60)]
def dp(k, value):
if k==n:
if value==0:
return 1
else:
return 0
if memo[k][value]>0:
return memo[k][value]
memo[k][value]=dp(k+1, value+x[k])+dp(k+1, value)
return memo[k][value]
print((dp(0, 0)-1)) | n, a =list(map(int, input().split()))
x=list(map(int, input().split()))
x=[i-a for i in x]
memo=[[-1]*6000 for i in range(60)]
def dp(k, value):
if k==n:
if value==0:
return 1
else:
return 0
if memo[k][value]>=0:
return memo[k][value]
memo[k][value]=dp(k+1, value+x[k])+dp(k+1, value)
return memo[k][value]
print((dp(0, 0)-1)) | p04015 |
N, A = list(map(int, input().split(' ')))
X = list(map(int, input().split(' ')))
X = [x - A for x in X]
from collections import defaultdict
counter = defaultdict(int)
counter[0] = 1
for x in X:
copy = dict(counter)
for d,c in list(copy.items()):
counter[d+x] += c
print((counter[0]-1)) |
from collections import defaultdict
N, A = list(map(int, input().split()))
X = [int(s) - A for s in input().split()]
counter = defaultdict(int)
counter[0] = 1
for x in X:
for d,c in list(counter.items()):
counter[d+x] += c
print((counter[0]-1)) | p04015 |
n,a=list(map(int,input().split()))
X=list(map(int,input().split()))
dp=[[[0]*(sum(X)+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1): #x_1,x_2...x_n
for k in range(i): #k枚数選ぶ
for j in range(sum(X)+1): #合計
if dp[i-1][k][j]:
dp[i][k+1][j+X[i-1]]+=dp[i-1][k][j]
dp[i][k][j]+=dp[i-1][k][j]
ans=0
for i in range(1,n+1):
for j in range(1,sum(X)+1):
if j==i*a:
ans+=dp[n][i][j]
print(ans) | n,a=list(map(int,input().split()))
X=list(map(int,input().split()))
dp=[[[0]*(sum(X)+1) for _ in range(n+1)] for _ in range(n+1)]
dp[0][0][0]=1
for i in range(1,n+1): #x_1,x_2...x_n
for k in range(i): #k枚数選ぶ
for s in range(sum(X)+1): #合計
if dp[i-1][k][s]:
dp[i][k+1][s+X[i-1]]+=dp[i-1][k][s] #1枚選択肢が増えた時の、そのカードを加えた結果を加算
dp[i][k][s]+=dp[i-1][k][s]
ans=0
for i in range(1,n+1):
for j in range(1,sum(X)+1):
if j == i*a: #合計が平均のi倍の時に加える
ans+=dp[n][i][j]
print(ans) | p04015 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
from collections import defaultdict
from copy import copy
def resolve():
n,a=list(map(int,input().split()))
X=list([int(x)-a for x in input().split()])
dp=defaultdict(int)
dp[0]=1
for x in X:
ndp=copy(dp)
for key,val in list(dp.items()):
ndp[key+x]+=val
dp=ndp
print((dp[0]-1))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
from collections import defaultdict
def resolve():
n,a=list(map(int,input().split()))
dp=defaultdict(int)
dp[0]=1
for x in map(int,input().split()):
x-=a
ndp=dp.copy()
for key,val in list(dp.items()):
ndp[key+x]+=val
dp=ndp
print((dp[0]-1))
resolve() | p04015 |
N, A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [[[ 0 for _ in range(50*N + 1)] for _ in range(N+1) ] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(1, N+1):
for j in range(N+1):
for k in range(50*N+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 += dp[N][i][A * i]
print(ans)
| N, A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [[[0 for _ in range(50*N + 1)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(1, N+1):
for j in range(i+1):
for k in range(50*N+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 += dp[N][i][A * i]
print(ans) | p04015 |
N, A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [[[0 for _ in range(50*N + 1)] for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(1, N+1):
for j in range(i+1):
for k in range(50*N+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 += dp[N][i][A * i]
print(ans) | 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
for i in range(1, N+1):
for j in range(i+1):
for k in range(50*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 += dp[N][i][A * i]
print(ans) | p04015 |
#!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SLR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
def main():
N, A = LI()
X = LI()
dp = make_list(N+1, N+1, 2501)
dp[0][0][0] = 1
for i in range(1, N+1):
for k in range(i+1):
for s in range(2501):
if X[i-1] > s:
dp[i][k][s] = dp[i-1][k][s]
else:
dp[i][k][s] = dp[i-1][k][s] + dp[i-1][k-1][s-X[i-1]]
print((sum(dp[N][k][k * A] for k in range(1, N+1))))
if __name__ == '__main__':
main() | #!usr/bin/env python3
from collections import defaultdict, deque, Counter, OrderedDict
from bisect import bisect_left, bisect_right
from functools import reduce, lru_cache
from heapq import heappush, heappop, heapify
import itertools
import math, fractions
import sys, copy
def L(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline().rstrip())
def SL(): return list(sys.stdin.readline().rstrip())
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LS(): return [list(x) for x in sys.stdin.readline().split()]
def R(n): return [sys.stdin.readline().strip() for _ in range(n)]
def LR(n): return [L() for _ in range(n)]
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def LIR1(n): return [LI1() for _ in range(n)]
def SLR(n): return [SL() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
def perm(n, r): return math.factorial(n) // math.factorial(r)
def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r))
def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)]
dire = [[1, 0], [0, 1], [-1, 0], [0, -1]]
dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
alphabets = "abcdefghijklmnopqrstuvwxyz"
ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(1000000)
def main():
N, A = LI()
X = LI()
Y = [xi - A for xi in X]
z = max(A, max(X))
dp = make_list(N+1, 2*z*N+1)
dp[0][z*N] = 1
for i in range(1, N+1):
for s in range(2*z*N+1):
if 0 <= s - Y[i-1] <= 2*z*N:
dp[i][s] = dp[i-1][s] + dp[i-1][s - Y[i-1]]
else:
dp[i][s] = dp[i-1][s]
print((dp[-1][z*N]-1))
if __name__ == '__main__':
main() | p04015 |
N, A = list(map(int, input().split()))
X = list([int(x)-A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[[0] * (N+1) for i in range(N+1)] for _ in range(NX * 2 + 1)]
dp[NX][0][0] = 1
for i in range(1, N+1):
for j in range(0, i+1):
for k in range(NX * 2 + 1):
if k == NX and j == 0:
dp[k][i][j] = 1
continue
dp[k][i][j] += dp[k][i-1][j]
if 0 <= k - X[i-1] < NX * 2 + 1:
dp[k][i][j] += dp[k-X[i-1]][i-1][j-1]
print((sum(dp[NX][N]) - 1)) | N, A = list(map(int, input().split()))
X = list([int(x)-A for x in input().split()])
X_MAX = max(max(X), -min(X))
NX = N * X_MAX
dp = [[0] * (X_MAX * (N+1) * 2 + 1) for i in range(N+1)]
dp [0][NX] = 1
for i in range(1, N+1):
for j in range(NX*2+1):
dp[i][j] += dp[i-1][j]
dp[i][j] += dp[i-1][j-X[i-1]]
print((dp[N][NX]-1)) | p04015 |
N,A = list(map(int,input().split()))
x = list(map(int,input().split()))
X = N*50
dp = [[[0 for i in range(X+1)] for j in range(N+1)] for k in range(N+1)]
dp[0][0][0] = 1
for k in range(1,N+1):
for j in range(k+1):
for i in range(X+1):
if i - x[k-1] < 0:
dp[k][j][i] = dp[k-1][j][i]
elif k >= 1:
dp[k][j][i] = dp[k-1][j-1][i-x[k-1]] + dp[k-1][j][i]
ans = 0
for j in range(1,N+1):
ans += dp[-1][j][j*A]
print(ans) | N,A = list(map(int,input().split()))
x = list(map(int,input().split()))
X = N*50
dp = [[[0 for i in range(X+1)] for j in range(N+1)] for k in range(N+1)]
dp[0][0][0] = 1
for k in range(1,N+1):
for j in range(k+1):
for i in range(j*50+1):
if i - x[k-1] < 0:
dp[k][j][i] = dp[k-1][j][i]
elif k >= 1:
dp[k][j][i] = dp[k-1][j-1][i-x[k-1]] + dp[k-1][j][i]
ans = 0
for j in range(1,N+1):
ans += dp[-1][j][j*A]
print(ans) | p04015 |
# -*- coding: utf-8 -*-
line = input().split(" ")
n = int(line[0])
a = int(line[1])
x = [int(i) for i in input().split(" ")]
X = max(max(x), a)
dp = [[[0 for s in range(n*X+1)] for k in range(n+1)] for j in range(n+1)]
dp[0][0][0] = 1
for j in range(n+1):
for k in range(n+1):
for s in range(n*X+1):
if 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]]
ret = 0
for k in range(1,n+1):
ret += dp[n][k][k*a]
print(ret)
| n,a = list(map(int, input().split()))
xl = list(map(int, input().split()))
offset = 300
dp = [[0]*600 for _ in range(n+1)]
dp[0][offset] = 1
for i in range(1,n+1):
x = xl[i-1]-a
for j in range(-300,300):
dp[i][offset+j] = dp[i-1][offset+j]
if 600>offset+j-x>=0:
dp[i][offset+j] += dp[i-1][offset+j-x]
print((dp[n][offset]-1)) | p04015 |
n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
dp=[[[0 for i in range(2501)] for j in range(n+1)] for k in range(n+1)]
#dp[i][j][k]:=i枚目まで見てj枚選んで和がkとなるようなカードの取り方の数
dp[0][0][0]=1
for i in range(n):
see=x[i]
for j in range(i+2):
for k in range(2501):
dp[i+1][j][k]+=dp[i][j][k]
if see>k or j==0:continue
dp[i+1][j][k]+=dp[i][j-1][k-see]
ans=0
for i in range(1,n+1):
ans+=dp[-1][i][i*a]
print(ans) | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
dp=[[[0 for i in range(2501)] for j in range(k+2)] for k in range(n+1)]
#dp[i][j][k]:=i枚目まで見てj枚選んで和がkとなるようなカードの取り方の数
dp[0][0][0]=1
for i in range(n):
see=x[i]
for j in range(i+2):
for k in range(2501):
dp[i+1][j][k]+=dp[i][j][k]
if see>k or j==0:continue
dp[i+1][j][k]+=dp[i][j-1][k-see]
ans=0
for i in range(1,n+1):
ans+=dp[-1][i][i*a]
print(ans) | p04015 |
def main():
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
x.insert(0, 0)
dp = [[[0 for _ in range(N * A + 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):
for j in range(1, i + 1):
for k in range(1, N * A + 1):
dp[i][j][k] = dp[i - 1][j][k]
if k >= x[i]:
dp[i][j][k] += dp[i - 1][j - 1][k - x[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[N][j][A * j]
print(ans)
if __name__ == '__main__':
main()
| def main():
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
x.insert(0, 0)
dp = [[[0] * (N * A + 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):
for j in range(1, i + 1):
for k in range(1, N * A + 1):
dp[i][j][k] = dp[i - 1][j][k]
if k >= x[i]:
dp[i][j][k] += dp[i - 1][j - 1][k - x[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[N][j][A * j]
print(ans)
if __name__ == '__main__':
main()
| p04015 |
def main():
N, A = list(map(int, input().split()))
x = list(map(int, input().split()))
x.insert(0, 0)
dp = [[[0] * (N * A + 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):
for j in range(1, i + 1):
for k in range(1, N * A + 1):
dp[i][j][k] = dp[i - 1][j][k]
if k >= x[i]:
dp[i][j][k] += dp[i - 1][j - 1][k - x[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[N][j][A * j]
print(ans)
if __name__ == '__main__':
main()
| def main():
N, A = list(map(int, input().split()))
x = [0]
x.extend(list(map(int, input().split())))
dp = [[[0 for _ in range(N * A + 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):
for j in range(1, i + 1):
for k in range(1, N * A + 1):
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 j in range(1, N + 1):
ans += dp[N][j][A * j]
print(ans)
if __name__ == '__main__':
main()
| p04015 |
N,A=list(map(int,input().split()))
x=list(map(int,input().split()))
dp=[[[0 for i in range(50*50+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):
for j in range(N+1):
for k in range(50*50+1):
dp[i][j][k]=dp[i-1][j][k]
if x[i-1]<= k and j>0: dp[i][j][k]+=dp[i-1][j-1][k-x[i-1]]
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)
y=[x[i]-A for i in range(N)]
dp=[[0 for i in range(2*N*X+1)] for j in range(N+1)]
dp[0][N*X]=1
for j in range(1,N+1):
for k in range(2*N*X+1):
dp[j][k]=dp[j-1][k]
if 0<= k-y[j-1] and k-y[j-1]<=2*N*X:
dp[j][k]+=dp[j-1][k-y[j-1]]
print((dp[N][N*X]-1)) | p04015 |
n,a,*x=list(map(int,open(0).read().split()));dp={0:1}
for i in x:
for k,v in set(dp.items()):
dp[i+k-a]=dp.get(i+k-a,0)+v
print((dp[0]-1)) | n,a,*X=list(map(int,open(0).read().split()))
y=[a-x for x in X]
dp={0:1}
for i in y:
for k,v in set(dp.items()):
dp[i+k]=dp.get(i+k,0)+v
print((dp[0]-1)) | p04015 |
n,a=list(map(int,input().split()))
y=[a-int(x) for x in input().split()]
dp={0:1}
for i in y:
for k,v in list(dp.items()):
dp[i+k]=dp.get(i+k,0)+v
print((dp[0]-1)) | def main():
n,a=list(map(int,input().split()))
y=[a-int(x) for x in input().split()]
dp={0:1}
for i in y:
for k,v in list(dp.items()):
dp[i+k]=dp.get(i+k,0)+v
print((dp[0]-1))
if __name__=="__main__":
main() | p04015 |
def solve():
ans = 0
N, A = list(map(int, input().split()))
X = list(map(int, input().split()))
x = sum(X)
dp = [[[0]*2550 for _ in range(N+1)] for _ in range(N+1)]
dp[0][0][0] = 1
for i in range(N):
for j in range(i+1):
for k in range(x):
dp[i+1][j][k] += dp[i][j][k]
dp[i+1][j+1][k+X[i]] += dp[i][j][k]
for j in range(1,N+1):
ans += dp[-1][j][j*A]
return ans
print((solve())) | N, A = list(map(int, input().split()))
X = list([int(x)-A for x in input().split()])
dp = [0]*10000
dp[0] = 1
for i in range(N):
new_dp = dp[:]
for j in range(-3000,3000):
if dp[j]>0:
new_dp[j+X[i]] += dp[j]
dp = new_dp
print((dp[0]-1))
| p04015 |
N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [[[0 for k in range(2501)] for j in range(N+1)] for i in range(N+1)]
for i in range(1,N+1):
x = X[i-1]
dp[i][1][x] += 1
for j in range(1,i+1):
for k in range(1,2501):
if k-x > 0:
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) | N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
for i in range(N):
X[i] -= A
from collections import defaultdict
counter = defaultdict(int)
counter[0] = 1
for x in X:
copy = dict(counter)
for k,v in list(copy.items()):
counter[k+x] += v
print((counter[0]-1))
| p04015 |
from collections import Counter
N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
dp = [Counter() for i in range(N+1)]
dp[0][0] = 1
for i,x in enumerate(X):
for j in range(i,-1,-1):
for k,v in list(dp[j].items()):
dp[j+1][k+x] += v
ans = 0
for i in range(1,N+1):
ans += dp[i][A*i]
print(ans) | N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
from collections import defaultdict
dp = [defaultdict(lambda: 0) for _ in range(N+1)]
dp[0][0] = 1
for i,x in enumerate(X):
for j in range(i,-1,-1):
for k,v in list(dp[j].items()):
dp[j+1][k+x] += v
ans = 0
for i in range(1,N+1):
ans += dp[i][i*A]
print(ans) | p04015 |
n, a = list(map(int, input().split()))
xlist = list(map(int, input().split()))
j = n
k = n
t = n * a
dp = [[[0 for t in range(t + 1)] for k in range(k + 1)] for j in range(j + 1)]
dp[1][0][0] = 1
dp[0][0][0] = 1
# for d in dp:
# print(d)
# print(dp[1][1][15])
for ji in range(1, j + 1):
for ki in range(0, ji + 1):
for ti in range(0, t + 1):
# print('now', ji, ki, ti)
if ji == 0 and ki == 0 and ti == 0:
# print('branch 1')
dp[ji][ki][ti] = 1
elif ji >= 1 and ti < xlist[ji - 1]:
dp[ji][ki][ti] = dp[ji - 1][ki][ti]
# print('branch 2')
elif ji >= 1 and ki >= 1 and ti >= xlist[ji - 1]:
# print('branch 3', ji - 1)
dp[ji][ki][ti] = dp[ji - 1][ki][ti] + dp[ji - 1][ki - 1][ti - xlist[ji - 1]]
# print(dp[ji][ki][ti])
count = 0
for i in range(1, k + 1):
count += dp[j][i][i*a]
print(count) | n, a = list(map(int, input().split()))
xlist = list(map(int, input().split()))
j = n
k = n
t = n * a
maxv = max(a, max(xlist))
dp = [[[0 for t in range(n*maxv + 1)] for k in range(k + 1)] for j in range(j + 1)]
dp[1][0][0] = 1
dp[0][0][0] = 1
# for d in dp:
# print(d)
# print(dp[1][1][15])
for ji in range(0, j + 1):
for ki in range(0, ji + 1):
for ti in range(0, ki * maxv + 1):
# print('now', ji, ki, ti)
if ji == 0 and ki == 0 and ti == 0:
# print('branch 1')
dp[ji][ki][ti] = 1
elif ji >= 1 and ti < xlist[ji - 1]:
dp[ji][ki][ti] = dp[ji - 1][ki][ti]
# print('branch 2')
elif ji >= 1 and ki >= 1 and ti >= xlist[ji - 1]:
# print('branch 3', ji - 1)
dp[ji][ki][ti] = dp[ji - 1][ki][ti] + dp[ji - 1][ki - 1][ti - xlist[ji - 1]]
# print(dp[ji][ki][ti])
count = 0
for i in range(1, k + 1):
count += dp[j][i][i*a]
print(count) | p04015 |
import sys
from collections import defaultdict
def main():
N, A, *xlst = list(map(int, sys.stdin.read().split()))
x_p = []
x_n = []
x_z = 0
xlst.sort()
for i in xlst:
if A < i:
x_p.append(i - A)
elif i < A:
x_n.append(A - i)
else:
x_z += 1
x_p_sum = defaultdict(int, {0: 1})
x_n_sum = defaultdict(int, {0: 1})
for i in range(len(x_p)):
for j in sorted(x_p_sum, reverse=1):
x_p_sum[j + x_p[i]] += x_p_sum[j]
for i in range(len(x_n)):
for j in sorted(x_n_sum, reverse=1):
x_n_sum[j + x_n[i]] += x_n_sum[j]
res = 0
for i in x_n_sum:
if i in x_p_sum:
res += (x_n_sum[i] * x_p_sum[i])
res *= 1 << x_z
res -= 1
print(res)
if __name__ == '__main__':
main() | import sys
from collections import defaultdict
def main():
N, A, *xlst = list(map(int, sys.stdin.read().split()))
x_p = []
x_n = []
x_z = 0
for i in xlst:
if A < i:
x_p.append(i - A)
elif i < A:
x_n.append(A - i)
else:
x_z += 1
x_p.sort(), x_n.sort()
x_p_sum = defaultdict(int, {0: 1})
x_n_sum = defaultdict(int, {0: 1})
for i in range(len(x_p)):
for j in sorted(x_p_sum, reverse=1):
x_p_sum[j + x_p[i]] += x_p_sum[j]
for i in range(len(x_n)):
for j in sorted(x_n_sum, reverse=1):
x_n_sum[j + x_n[i]] += x_n_sum[j]
res = 0
for i in x_p_sum:
if i in x_n_sum:
res += (x_n_sum[i] * x_p_sum[i])
res *= 1 << x_z
res -= 1
print(res)
if __name__ == '__main__':
main()
| p04015 |
n, a = list(map(int, input().split()))
xs = list(map(int, input().split()))
na = n*a
DP = [[0]*(na+1) for i in range(n+1)]
DP[0][0] = 1
for _ in range(n):
x = xs[_]
next = [[0]*(na+1) for i in range(n+1)]
for i in range(n):
for j in range(na+1):
# xを使わないとき
next[i][j] += DP[i][j]
if j+x <= na:
next[i+1][j+x] += DP[i][j]
DP = next
# i枚使ったとき合計がi*aである場合の数
ans = 0
for i in range(1,n+1):
ans += DP[i][i*a]
print(ans) | n, a = list(map(int, input().split()))
xs = list(map(int, input().split()))
na = n*a
DP = [[0]*(na+1) for i in range(n+1)]
DP[0][0] = 1
for _ in range(n):
x = xs[_]
next = [[0]*(na+1) for i in range(n+1)]
for i in range(_+1):
for j in range(na+1):
# xを使わないとき
next[i][j] += DP[i][j]
if j+x <= na:
next[i+1][j+x] += DP[i][j]
DP = next
# i枚使ったとき合計がi*aである場合の数
ans = 0
for i in range(1,n+1):
ans += DP[i][i*a]
print(ans) | p04015 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# ありえる平均は1..50のいずれか
import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys
N, A = list(map(int, input().split()))
Xs = list(sorted(map(int, input().split())))
lower = []
same = 0
upper = []
for x in Xs:
if x < A:
lower.append(A - x)
elif x == A:
same += 1
else:
upper.append(x - A)
def make_counter(nums):
counter = Counter({0: 1})
for n in nums:
# 使う場合、使わない場合
new_counter = Counter()
for k, v in list(counter.items()):
new_counter[k] += v
new_counter[k + n] += v
counter = new_counter
return counter
lower_counter = make_counter(lower)
upper_counter = make_counter(upper)
ans = 0
for lk, lv in list(lower_counter.items()):
# (i) Aに等しい数だけ使う
if lk == 0:
# ひとつも選ばれない場合を除くために-1
ans += 2 ** same - 1
# (ii) それ以外
else:
# Aより小さい数たちと、Aより大きい数たちとの集合の平均がちょうどA
if lk in upper_counter:
ans += (2 ** same) * lv * upper_counter[lk]
print(ans)
| #!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 終了後に自力AC
#
# カードを「Aより小さい」「Aに等しい」「Aより大きい」に分ける。
#
# 「Aより小さい」カードで「和がSになる組み合わせの数」は容易に計算できる。
# 「Aより大きい」カードで「和がTになる組み合わせの数」も計算できる。
#
# あとはこれらを組み合わせるだけ
import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys
N, A = list(map(int, input().split()))
Xs = list(sorted(map(int, input().split())))
lower = []
same = 0
upper = []
for x in Xs:
if x < A:
lower.append(A - x)
elif x == A:
same += 1
else:
upper.append(x - A)
def make_counter(nums):
counter = Counter({0: 1})
for n in nums:
new_counter = Counter()
for k, v in list(counter.items()):
# 使う場合、使わない場合それぞれの場合の数を増やす
new_counter[k] += v
new_counter[k + n] += v
counter = new_counter
return counter
lower_counter = make_counter(lower)
upper_counter = make_counter(upper)
ans = 0
for lk, lv in list(lower_counter.items()):
# (i) Aに等しい数だけ使う
if lk == 0:
# ひとつも選ばれない場合を除くために-1
ans += 2 ** same - 1
# (ii) それ以外
else:
# Aより小さい数たちと、Aより大きい数たちとの集合の平均がちょうどA
if lk in upper_counter:
ans += (2 ** same) * lv * upper_counter[lk]
print(ans)
| p04015 |
n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
# import numpy as np
# dp = np.full((n + 1, n + 1, n * max(x + [a]) + 1), None).tolist()
#
def full(shape, value):
if not shape:
return value
return [full(shape[1:], value) for _ in range(shape[0])]
dp = full((n + 1, n + 1, n * max(x + [a]) + 1), None)
def dfs(j=n, k=n, s=n * max(x)):
if dp[j][k][s] is not None:
return dp[j][k][s]
if j == k == s == 0:
dp[0][0][0] = 1
return 1
result = 0
if j >= 1:
if x[j - 1] > s:
result = dfs(j - 1, k, s)
elif k >= 1:
result = dfs(j - 1, k, s) + dfs(j - 1, k - 1, s - x[j - 1])
dp[j][k][s] = result
return result
print((sum(dfs(n, k, k * a) for k in range(1, n + 1))))
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= a
def full(shape, value):
if not shape:
return value
return [full(shape[1:], value) for _ in range(shape[0])]
minus_cnt = 0
plus_cnt = 0
for v in x:
if v < 0:
minus_cnt -= v
elif v > 0:
plus_cnt += v
dp = full((n + 1, minus_cnt + plus_cnt + 5, n + 1), None)
def dfs(k, s=0, depth=n - 1): # ret -> pattern count
if dp[k][s][depth] is not None:
return dp[k][s][depth]
if k == 0:
if s == 0:
result = 1
else:
result = 0
dp[k][s][depth] = result
return result
if depth == -1:
dp[k][s][depth] = 0
return 0
result = dfs(k - 1, s + x[depth], depth - 1) + dfs(k, s, depth - 1)
dp[k][s][depth] = result
return result
result = 0
for i in range(1, n + 1):
result += dfs(i)
print(result)
| p04015 |
N, A = list(map(int, input().split()))
x = sorted(map(int, input().split()))
def solve(n):
mem = {}
def rec(i, a, d):
if (i, a, d) in mem:
return mem[(i, a, d)]
if i >= N:
return 0
if a < x[i]:
return 0
if d > n:
return 0
if x[i] == a and d == n-1:
mem[(i, a, d)] = rec(i+1, a, d) + 1
else:
mem[(i, a, d)] = rec(i+1, a, d) + rec(i+1, a-x[i], d+1)
return mem[(i, a, d)]
return rec(0, n*A, 0)
s = 0
for i in range(1, N+1):
s += solve(i)
print(s)
| N, A = list(map(int, input().split()))
a = sorted([int(x)-A for x in input().split()])
mem = {}
def rec(p, acm):
if (p, acm) in mem:
return mem[(p, acm)]
if p >= N:
return 0
if a[p] > 0 and acm > 0:
return 0
mem[(p, acm)] = rec(p+1, acm+a[p]) + rec(p+1, acm)
if acm+a[p] == 0:
mem[(p, acm)] += 1
return mem[(p, acm)]
print(rec(0, 0))
| p04015 |
import itertools
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
xa = []
xb = []
count = 0
for i in x:
if i > a:
xa.append(i-a)
elif i < a:
xb.append(i-a)
else:
count += 1
ans = 0
if len(xa) == 0 or len(xb) == 0:
print((2**count-1))
else:
for i in range(1,len(xa)+1):
for j in range(1,len(xb)+1):
for k in itertools.combinations(xa,i):
for l in itertools.combinations(xb,j):
if sum(k)+sum(l) == 0:
ans += 1
if ans == 0:
print((0))
elif count == 0:
print(ans)
else:
print(((ans+1)*2**count-count)) | n,a = list(map(int, input().split()))
x = list(map(int,input().split()))
x = [i-a for i in x]
d = {}
d[0] = 1
for i in x:
for j,k in list(d.items()):
d[j+i] = d.get(j+i,0)+k
print((d[0]-1)) | p04015 |
n,a=list(map(int,input().split()))
l=list(map(int,input().split()))
dp=[0]*5300
dp[l[0]-a]=1
for x in l[1:]:
b=x-a
if b>=0:
for i in range(2500,-2501,-1):
dp[i+b]+=dp[i]
else:
for i in range(-2500,2501):
dp[i+b]+=dp[i]
dp[b]+=1
print((dp[0])) | n,a=list(map(int,input().split()))
from collections import defaultdict
dp=defaultdict(int)
dp[0]=1
for i in map(int,input().split()):
i-=a
for k in sorted(list(dp.keys()),reverse=(i>=0)):
dp[k+i]+=dp[k]
print((dp[0]-1)) | p04015 |
def makelist(n,m,p):
return [[[0 for k in range(p)]for i in range(m)]for j in range(n)]
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
X = max(x)
X = max(X,a)
dp = makelist(n+1,n+1,n*X+1)
dp[0][0][0] = 1
for j in range(n+1):
for k in range(n+1):
for s in range(n*X+1):
if j*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]]
elif j >= 1 and s < x[j-1]:
dp[j][k][s] = dp[j-1][k][s]
ans = 0
for k in range(1,n+1):
ans += dp[n][k][k*a]
print(ans) | def makelist2(n,m):
return[[0 for k in range(m)]for i in range(n)]
n,a = list(map(int,input().split()))
x = list(map(int,input().split()))
X = max(x)
X = max(X,a)
b=[]
for i in range(n):
b.append(x[i]-a)
dp =makelist2(n+1,2*n*X+1)
dp[0][n*X] = 1
for j in range(n+1):
for t in range(2*n*X+1):
if j>=1 and (t-b[j-1] < 0 or t-b[j-1]>2*n*X):
dp[j][t] = dp[j-1][t]
elif j>= 1:
dp[j][t] = dp[j-1][t] + dp[j-1][t-b[j-1]]
print((dp[n][n*X]-1)) | p04015 |
"""
普通に数え上げDPで行けそう
dp[i][j][k] -> カードをi枚使う/j種類目のカードまで見る/カードの数字の合計がkになる
j種類目のカードを使う場合：
dp[i][j][k] += dp[i-1][j-1][k-x]
j種類目のカードを使わない場合：
dp[i][j][k] += dp[i][j-1][k]
という風に計算していって、最終的に各iごとにk/i=Aとなるようなkを見出して、dp[i][-1][k]をanswerとして加算する。
"""
N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
sumX = sum(X)
dp = [[[0]*(sumX+1) for _ in range(N+1)]for _ in range(N+1)]
for j in range(N+1):
dp[0][j][0] = 1
for i in range(1,N+1):
for j in range(1,N+1):
x = X[j-1]
for k in range(1,sumX+1):
dp[i][j][k] += dp[i][j-1][k]
if k-x >= 0:
dp[i][j][k] += dp[i-1][j-1][k-x]
ans = 0
for i in range(1,N+1):
target = A*i
if target <= sumX:
ans += dp[i][-1][target]
print(ans)
| N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
Y = [x-A for x in X]
t = sum(X)
dp = [[0]*(t*2+1) for _ in range(N+1)]
#dp[i][j] -> i枚目まで見る。合計をj-tにするパターン数
#i枚目を使う場合 -> dp[i][j] += dp[i-1][j-Yi]
#i枚目を使わない場合 -> dp[i][j] += dp[i-1][j]
dp[0][t] = 1
for i in range(1,N+1):
y = Y[i-1]
for j in range(t*2+1):
if 0 <= j-y <= t*2:
dp[i][j] += dp[i-1][j-y]
dp[i][j] += dp[i-1][j]
print((dp[-1][t]-1)) | p04015 |
N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
X = [x-A for x in X]
dp = [[0]*(5001) for _ in range(N+1)]
dp[0][2500] = 1
for i in range(1,N+1):
x = X[i-1]
for j in range(5001):
dp[i][j] += dp[i-1][j]
if 0<=j-x<5001:
dp[i][j] += dp[i-1][j-x]
print((dp[-1][2500]-1))
| N,A = list(map(int,input().split()))
X = list(map(int,input().split()))
X = [A-x for x in X]
dp = [[0]*(5001) for _ in range(N+1)]
dp[0][2500] = 1
for i in range(1,N+1):
x = X[i-1]
for j in range(5001):
if 0<=j-x<5001:
dp[i][j] = dp[i-1][j-x]+dp[i-1][j]
else:
dp[i][j] = dp[i-1][j]
print((dp[-1][2500]-1)) | p04015 |
n,a=list(map(int,input().split()))
X=list(map(int,input().split()))
dp=[[[0]*52 for _ in range(2505)] for _ in range(52)]
ans=0
dp[0][0][0]=1
for i in range(n):
for j in range(52+50*i):
for k in range(51):
ni=i+1
nj=j+X[i]
nk=k+1
dp[ni][nj][nk]+=dp[i][j][k]
dp[ni][j][k]+=dp[i][j][k]
ans=0
for i in range(1,n+1):
ans+=dp[n][i*a][i]
print(ans) | n,a=list(map(int,input().split()))
X=list(map(int,input().split()))
dp=[[[0]*55 for _ in range(2555)] for _ in range(55)]
ans=0
dp[0][0][0]=1
for i in range(n):
for j in range(52+50*i):
for k in range(n):
ni=i+1
nj=j+X[i]
nk=k+1
dp[ni][nj][nk]+=dp[i][j][k]
dp[ni][j][k]+=dp[i][j][k]
ans=0
for i in range(1,n+1):
ans+=dp[n][i*a][i]
print(ans) | p04015 |
N = list(map(int,input().split()))[0]
lis = [[] for i in range(N)]
for a_i,b_i in [ list(map(int,input().split())) for _ in range(N-1) ]:
lis[a_i-1].append(b_i-1)
lis[b_i-1].append(a_i-1)
flag = False
while True:
flag = False
sumsum = 0
for x in lis:
sumsum += sum(x)
if sumsum == 0:
print("Second")
quit()
for i in range(len(lis)):
if flag:
break
if len(lis[i]) == 1:
b = lis[i][0]
lis[i].remove(b)
lis[b].remove(i)
for c in lis[b]:
lis[c].remove(b)
if len(lis[c]) == 0:
print("First")
quit()
lis[b] = []
flag = True | N = list(map(int,input().split()))[0]
lis = [[] for i in range(N)]
for a_i,b_i in [ list(map(int,input().split())) for _ in range(N-1) ]:
lis[a_i-1].append(b_i-1)
lis[b_i-1].append(a_i-1)
while True:
sumsum = 0
for x in lis:
sumsum += sum(x)
if sumsum == 0:
print("Second")
quit()
for i in range(len(lis)):
if len(lis[i]) == 1:
b = lis[i][0]
lis[i].remove(b)
lis[b].remove(i)
for c in lis[b]:
lis[c].remove(b)
if len(lis[c]) == 0:
print("First")
quit()
lis[b] = [] | p03726 |
import collections
class Dinic:
def __init__(self, vnum):
self.edge = [[] for i in range(vnum)]
self.n = vnum
self.inf = float('inf')
def addedge(self, st, en, c):
self.edge[st].append([en, c, len(self.edge[en])])
self.edge[en].append([st, 0, len(self.edge[st])-1])
def bfs(self, vst):
dist = [-1]*self.n
dist[vst] = 0
Q = collections.deque([vst])
while Q:
nv = Q.popleft()
for vt, c, r in self.edge[nv]:
if dist[vt] == -1 and c > 0:
dist[vt] = dist[nv] + 1
Q.append(vt)
self.dist = dist
def dfs(self, nv, en, nf):
nextv = self.nextv
if nv == en:
return nf
dist = self.dist
ist = nextv[nv]
for i, (vt, c, r) in enumerate(self.edge[nv][ist:], ist):
if dist[nv] < dist[vt] and c > 0:
df = self.dfs(vt, en, min(nf, c))
if df > 0:
self.edge[nv][i][1] -= df
self.edge[vt][r][1] += df
return df
nextv[nv] += 1
return 0
def getmf(self, st, en):
mf = 0
while True:
self.bfs(st)
if self.dist[en] == -1:
break
self.nextv = [0]*self.n
while True:
fl = self.dfs(st, en, self.inf)
if fl > 0:
mf += fl
else:
break
return mf
def Fi():
print('First')
exit()
N = int(eval(input()))
Edge = [[] for _ in range(N+2)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
Edge[a].append(b)
Edge[b].append(a)
if N % 2:
Fi()
dist = [0]*(N+1)
visited = set([1])
stack = [1]
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
dist[vf] = not dist[vn]
stack.append(vf)
Din = Dinic(N+2)
for i in range(1, N+1):
if dist[i]:
Din.addedge(0, i, 1)
for j in Edge[i]:
Din.addedge(i, j, 1)
else:
Din.addedge(i, N+1, 1)
if Din.getmf(0, N+1) != N//2:
Fi()
print('Second')
| from sys import exit
def Fi():
print('First')
exit()
N = int(eval(input()))
dim = [-1]*N
Edge = [[] for _ in range(N)]
for _ in range(N-1):
a, b = list(map(int, input().split()))
dim[a-1] += 1
dim[b-1] += 1
Edge[a-1].append(b-1)
Edge[b-1].append(a-1)
par = [None] + [0]*(N-1)
stack = [0]
visited = set([0])
while stack:
vn = stack.pop()
for vf in Edge[vn]:
if vf in visited:
continue
visited.add(vf)
par[vf] = vn
stack.append(vf)
L = [i for i in range(1,N) if dim[i] == 0]
used = set(L)
stack = L[:]
mat = [0]*N
dim[0] += 2
while stack:
vn = stack.pop()
pv = par[vn]
if pv is None:
break
if mat[vn] == 0:
mat[vn] += 1
mat[pv] += 1
dim[pv] -= 1
if dim[pv] == 0:
stack.append(pv)
print(('Second' if all(m == 1 for m in mat) else 'First')) | p03726 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
G = [[] for _ in range(n)]
for _ in range(n-1):
a,b=LI()
G[a-1]+=[b-1]
G[b - 1] += [a - 1]
def dfs(v, visited):
"""
:param v: X側の未マッチングの頂点の1つ
:param visited: 空のsetを渡す（外部からの呼び出し時）
:return: 増大路が見つかればTrue
"""
for u in G[v]:
if u in visited:
continue
visited.add(u)
if matched[u] == -1 or dfs(matched[u], visited):
matched[u] = v
return True
return False
cnt = 0
matched = [-1] * n
for i in range(n):
cnt += int(dfs(i, set()))
if cnt == n:
print("Second")
else:
print("First")
| from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
n = I()
G = [[] for _ in range(n)]
for _ in range(n-1):
a,b=LI()
G[a-1]+=[b-1]
G[b - 1] += [a - 1]
def dfs(v, visited):
"""
:param v: X側の未マッチングの頂点の1つ
:param visited: 空のsetを渡す（外部からの呼び出し時）
:return: 増大路が見つかればTrue
"""
for u in G[v]:
if u in visited:
continue
visited.add(u)
if matched[u] == -1 or dfs(matched[u], visited):
matched[u] = v
matched[v] = u
return True
return False
cnt = 0
matched = [-1] * n
for i in range(n):
if matched[i] != -1:
continue
cnt += int(dfs(i, set())) * 2
if cnt == n:
print("Second")
else:
print("First")
| p03726 |
from collections import deque
class BipartiteGraph:
"""二部グラフの最大マッチングを求めるなどする"""
def __init__(self, input_graph: list):
"""重み無し二部グラフinput_graphを入力する"""
n = len(input_graph)
self.INF = float("inf")
self.max_bipartite_matching = -1
# DFSでグラフを2色に彩色する
visited = [-1] * n
for i in range(n):
if visited[i] >= 0:
continue
visited[i] = 0
q = deque([i])
while q:
_from = q.pop()
for to in input_graph[_from]:
if visited[to] >= 0:
continue
visited[to] = visited[_from] ^ 1
q.append(to)
# 残余グラフを構築する
self.s = n
self.t = n + 1
self.n = n + 2
self.graph = [[] for i in range(self.n)]
used = set([])
for pos1 in range(n):
if visited[pos1] == 0:
self.add_edge(self.s, pos1)
else:
self.add_edge(pos1, self.t)
for pos2 in input_graph[pos1]:
if (min(pos1, pos2), max(pos1, pos2)) in used:
continue
used.add((min(pos1, pos2), max(pos1, pos2)))
if visited[pos1] == 0:
self.add_edge(pos1, pos2)
else:
self.add_edge(pos2, pos1)
def add_edge(self, _from: int, to: int):
"""残余グラフを構築
1. _fromからtoへ向かう容量capacity = 1の辺をグラフに追加する
2. toから_fromへ向かう容量0の辺をグラフに追加する
"""
forward = [to, 1, None]
forward[2] = backward = [_from, 0, forward]
self.graph[_from].append(forward)
self.graph[to].append(backward)
def bfs(self, s: int, t: int):
"""capacityが正の辺のみを通ってsからtに移動可能かどうかBFSで探索
level: sからの最短路の長さ
"""
self.level = [-1] * self.n
q = deque([s])
self.level[s] = 0
while q:
_from = q.popleft()
for to, capacity, _ in self.graph[_from]:
if capacity > 0 and self.level[to] < 0:
self.level[to] = self.level[_from] + 1
q.append(to)
def dfs(self, _from: int, t: int, f: int) -> int:
"""流量が増加するパスをDFSで探索
BFSによって作られた最短路に従ってfを更新する
"""
if _from == t:
return f
for edge in self.itr[_from]:
to, capacity, reverse_edge = edge
if capacity > 0 and self.level[_from] < self.level[to]:
d = self.dfs(to, t, min(f, capacity))
if d > 0:
edge[1] -= d
reverse_edge[1] += d
return d
return 0
def max_flow(self):
"""s-tパス上の最大流を求める = 最大マッチングを求める = 最商店被覆を求める
計算量: O(|E||V|^2)
"""
if self.max_bipartite_matching >= 0:
return self.max_bipartite_matching
flow = 0
while True:
self.bfs(self.s, self.t)
if self.level[self.t] < 0:
break
self.itr = list(map(iter, self.graph))
f = self.dfs(self.s, self.t, self.INF)
while f > 0:
flow += f
f = self.dfs(self.s, self.t, self.INF)
self.max_bipartite_matching = flow
return flow
def maximum_matching(self):
"""最大マッチングを求める"""
return self.max_flow()
def minimum_point_covering(self):
"""最小点被覆を求める"""
return self.max_flow()
def maximum_independent_set(self):
"""最大安定集合を求める"""
return (self.n - 2) - self.max_flow()
def minimum_edge_covering(self):
"""最小辺被覆を求める"""
return (self.n - 2) - self.max_flow()
n = int(eval(input()))
info = [list(map(int, input().split())) for i in range(n - 1)]
tree = [[] for i in range(n)]
for a, b in info:
a -= 1
b -= 1
tree[a].append(b)
tree[b].append(a)
bg = BipartiteGraph(tree)
if bg.maximum_matching() * 2 == n:
print("Second")
else:
print("First") | from collections import deque
n = int(eval(input()))
info = [list(map(int, input().split())) for i in range(n - 1)]
tree = [[] for i in range(n)]
for a, b in info:
a -= 1
b -= 1
tree[a].append(b)
tree[b].append(a)
root = 0
par = {root: -1}
q = deque([root])
topo = []
while q:
v = q.popleft()
topo.append(v)
for nxt_v in tree[v]:
if nxt_v in par:
continue
par[nxt_v] = v
q.append(nxt_v)
used = [False] * n
for v in topo[::-1]:
if used[v]:
continue
else:
used[v] = True
if par[v] == -1:
print("First")
exit()
if used[par[v]]:
print("First")
exit()
used[par[v]] = True
print("Second") | p03726 |
import sys
import random
input = sys.stdin.readline
n = int(eval(input()))
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
degorigin = [0]*(n+1)
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
degorigin[a] += 1
degorigin[b] += 1
if n == 2:
print("Second")
exit()
stackorigin = []
root = 0
candidate = []
for i in range(1,n+1)[::-1]:
if degorigin[i] == 1:
stackorigin.append(i)
else:
candidate.append(i)
flg = 0
for _ in range(18):
if flg:
break
stack = stackorigin[:]
deg = degorigin[:]
root = candidate[random.randint(0,len(candidate)-1)]
deg[root] += 1
dp = [[] for i in range(n+1)]
parity = [-1]*(n+1)
while stack:
x = stack.pop()
if dp[x]:
if dp[x].count(0) >= 2:
flg = 1
break
elif dp[x].count(2):
parity[x] = 2
elif dp[x].count(1) and dp[x].count(0):
parity[x] = 2
elif dp[x].count(1):
parity[x] = 0
elif dp[x].count(0):
parity[x] = 1
else:
parity[x] = 0
for y in graph[x]:
if deg[y] >= 2:
dp[y].append(parity[x])
deg[y] -= 1
if deg[y] == 1:
stack.append(y)
if flg:
print("First")
else:
print("Second") |
import sys
input = sys.stdin.readline
n = int(eval(input()))
ab = [list(map(int,input().split())) for i in range(n-1)]
graph = [[] for i in range(n+1)]
deg = [0]*(n+1)
for a,b in ab:
graph[a].append(b)
graph[b].append(a)
deg[a] += 1
deg[b] += 1
if n == 2:
print("Second")
exit()
stack = []
root = 0
for i in range(1,n+1)[::-1]:
if deg[i] == 1:
stack.append(i)
else:
root = i
flg = 0
deg[root] += 1
dp = [[] for i in range(n+1)]
dist = [-1]*(n+1)
while stack:
x = stack.pop()
if dp[x]:
if dp[x].count(0)>=2:
flg = 1
if dp[x].count(0):
dist[x] = 1
else:
dist[x] = 0
else:
dist[x] = 0
for y in graph[x]:
if deg[y] >= 2:
dp[y].append(dist[x])
deg[y] -= 1
if deg[y] == 1:
stack.append(y)
if flg or dist[root]==0:
print("First")
else:
print("Second")
| p03726 |
a=int(eval(input()))
b=list(map(int,input().split()))
c=max(b)+1
d=[]
ans=0
for i in range(a):
e=0
while c-e>b[i]:
e+=b[i]
d+=[e]
for i in b:
if d.count(i)==1:
ans+=1
print(ans) | n = int(eval(input()))
a = [int(i) for i in input().split()]
max_a = max(a)
cnt_d = [0] * (max_a + 1)
for ai in a:
for multi in range(ai, max_a + 1, ai):
cnt_d[multi] += 1
print((sum(cnt_d[ai] == 1 for ai in a))) | p02642 |
N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
check = [0] * 1000001
res = 0
for i in range(N):
if not check[A[i]] and (i == N-1 or A[i] != A[i+1]):
res += 1
for j in range(A[i], 1000001, A[i]):
check[j] = 1
print(res) | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
check = [0] * 1000001
res = 0
for i in range(N):
if check[A[i]]:
continue
if i == N-1 or A[i] != A[i+1]:
res += 1
for j in range(A[i], 1000001, A[i]):
check[j] = 1
print(res) | p02642 |
import collections
from copy import copy
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
def f(n):
facs = factorization(n)
res = set()
def g(arr, total):
if len(arr) == 0:
res.add(total)
return
a, b = arr.pop()
for i in range(0, b + 1):
num = a ** i
res.add(num)
g(copy(arr), total * num)
g(facs, 1)
return res
def main():
n = int(eval(input()))
A = tuple(map(int, input().split()))
D = collections.defaultdict(int)
for a in A:
D[a] += 1
ans = n
for i in range(n):
a = A[i]
if D[a] > 1:
ans -= 1
continue
if a == 1:
continue
res = f(a)
res.remove(a)
for num in res:
if num in D:
ans -= 1
break
print(ans)
main()
|
import collections
def main():
n = int(eval(input()))
A = sorted(map(int, input().split()))
D = collections.defaultdict(int)
for a in A:
D[a] += 1
m = max(A)
S = set()
ans = 0
for i in range(n):
a = A[i]
if a in S:
continue
if D[a] == 1:
ans += 1
num = a
while num <= m:
S.add(num)
num += a
print(ans)
main()
| p02642 |
N = int(eval(input()))
nokori = N
kaburi = set()
ans = 0
A = list(map(int,input().rstrip().split(" ")))
A2 = set()
for i in A:
if i in A2:
kaburi.add(i)
else:
A2.add(i)
for i in kaburi:
A2.remove(i)
for i in kaburi:
k = i * 2
while k < 1000000:
A2.discard(k)
k += i
while len(A2) != 0:
i = min(A2)
ans += 1
k = i
while k < 1000000:
A2.discard(k)
k += i
print(ans) | N = int(eval(input()))
ans = 0
A = list(map(int,input().rstrip().split(" ")))
A.sort()
A2 = [True for i in range(A[-1] + 1)]
for i in range(len(A)):
k = A[i] * 2
if A2[A[i]]:
if i != 0 and A[i-1] == A[i]:
A2[A[i]] = False
while(k < len(A2)):
A2[k] = False
k += A[i]
for i in A:
if A2[i]:
ans += 1
print(ans) | p02642 |
n=int(eval(input()))
a=list(map(int,input().split()))
l=[0 for i in range(10**6+1)]
for i in range(n):
l[a[i]]+=1
d={}
ans=0
for i in range(n):
x=a[i]
if x not in d:
if l[a[i]]==1:
flag=1
for j in range(1,int(x**0.5)+2):
if x%j==0:
if x!=j and l[j]>0:
flag=0
break
if x!=x//j and x%(x//j)==0 and l[x//j]>0:
flag=0
break
if flag==1:
ans+=1
d[x]=1
else:
d[x]=0
else:
ans+=d[x]
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
if n!=1 and len(set(a))==1:
print((0))
exit()
l=[0 for i in range(10**6+1)]
for i in range(n):
l[a[i]]+=1
if n!=1 and min(a)>max(a)/2:
ct=0
for i in range(len(l)):
if l[i]==1:
ct+=1
print(ct)
exit()
d={}
ans=0
for i in range(n):
x=a[i]
if x not in d:
if l[a[i]]==1:
flag=1
for j in range(1,int(x**0.5)+2):
if x%j==0:
if x!=j and l[j]>0:
flag=0
break
if x!=x//j and x%(x//j)==0 and l[x//j]>0:
flag=0
break
if flag==1:
ans+=1
d[x]=1
else:
d[x]=0
else:
ans+=d[x]
print(ans) | p02642 |
N = int(eval(input()))
A = list(map(int,input().split()))
T = set()
def counter(array):
from collections import Counter
return Counter(array)
c = counter(A)
for x in A:
T.add(x)
cnt = 0
maxi = max(A)
for x in sorted(A):
i = 2
while x * i <= maxi:
if x * i in T:
T.remove(x*i)
i += 1
ans = 0
for x in T:
if c[x] == 1:
ans += 1
print(ans)
| N = int(eval(input()))
A = list(map(int,input().split()))
T = set()
for x in A: T.add(x)
maxi = max(A)
for x in sorted(A):
i = 2
while x * i <= maxi:
if x * i in T:
T.remove(x*i)
i += 1
ans = 0
def counter(array):
from collections import Counter
return Counter(array)
c = counter(A)
for x in T:
if c[x] == 1:
ans += 1
print(ans)
| p02642 |
N = 1000001
a = [0]* N
eval(input())
for x in input().split():
a[int(x)] += 1
for i in range(1, N):
for j in range(i + i, N, i):
if a[i]:
a[j] = 0
print((a.count(1)))
| N = 1000001
a = [0]* N
eval(input())
for x in input().split():
a[int(x)] += 1
for i in range(1, N):
if a[i]:
for j in range(i + i, N, i):
a[j] = 0
print((a.count(1)))
| p02642 |
N = 1000001
a = [0]* N
_, s = open(0)
for x in s.split():
a[int(x)] += 1
for i in range(1, N):
for j in range(i + i, N, i):
if a[i]:
a[j] = 0
print((a.count(1)))
| N = 1000001
a = [0]* N
_, s = open(0)
for x in s.split():
a[int(x)] += 1
for i in range(1, N):
if a[i]:
for j in range(i + i, N, i):
a[j] = 0
print((a.count(1)))
| p02642 |
N = 1000001
a = [0]* N
_, s = open(0)
for x in s.split():
a[int(x)] += 1
for i in range(1, N):
if a[i]:
for j in range(i + i, N, i):
a[j] = 0
print((a.count(1)))
| N = 1000001
a = [0]* N
eval(input())
for x in input().split():
a[int(x)] += 1
for i in range(1, N):
if a[i]:
for j in range(i + i, N, i):
a[j] = 0
print((a.count(1)))
| p02642 |
n=int(eval(input()))
A=sorted(list(map(int,input().split())))
B=[0]*(1+max(A))
for i in A:
B[i]+=1
if B[i]==1:
for j in range(2*i,max(A)+1,i):
B[j]+=1
else:
continue
ans=0
for i in A:
if B[i]==1: ans+=1
print(ans) | n=int(eval(input()))
A=sorted(list(map(int,input().split())))
B=[0]*(1+A[-1])
for i in A:
B[i]+=1
if B[i]==1:
for j in range(2*i,A[-1]+1,i):
B[j]+=1
else:
continue
ans=0
for i in A:
if B[i]==1: ans+=1
print(ans) | p02642 |
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
M=10**6+10
n=int(eval(input()))
a=sorted(lmp())
c=[0]*M
for j in a:
if c[j]==0:
k=2
while j*k<M:
c[j*k]=1
k+=1
ans=0
s=Counter(a).most_common()
for x,y in s:
if c[x]==0 and y==1:
ans+=1
print(ans) | import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
M=10**6+10
n=int(eval(input()))
a=Counter(lmp()).most_common()
a=sorted(a, key=lambda x: x[0])
c=[0]*M
for j,x in a:
if c[j]==0:
k=2
while j*k<M:
c[j*k]=1
k+=1
ans=0
for x,y in a:
if c[x]==0 and y==1:
ans+=1
print(ans) | p02642 |
inf = 1100000
def main():
N = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
detect = [0] *inf
for x in a:
if detect[x] != 0:
detect[x] = 2
for i in range(x, inf, x):
detect[i] += 1
ans = 0
for i in range(N):
if detect[a[i]] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main() | inf = 1100000
def main():
N = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
detect = [0] *inf
for x in a:
if detect[x] != 0:
detect[x] = 2
continue
for i in range(x, inf, x):
detect[i] += 1
ans = 0
for i in range(N):
if detect[a[i]] == 1:
ans += 1
print(ans)
if __name__ == "__main__":
main() | p02642 |
N =eval(input())
A = list(map(int, input().split()))
MA =max(A)
N=int(N)
s=0
A2 = [-1]
B =[-1]#重複
LS =[-1]
for i in range(0,N):
k=1
P =A[i]
if P in A2:
B.append(P)
pass
else:
while P*k<=MA:
LS.append(P*k)
k+=1
A2.append(P)
for j in range(0,N):
if A[j] in B:
pass
else:
if LS.count(A[j]) ==1:
s=s+1
print(s)
| N = eval(input())
A = list(map(int, input().split()))
N = int(N)
MA = max(A)
s=0
LS = [0 for i in range(0,MA)]
for i in range(0,N):
k=1
while A[i]*k<=MA:
LS[A[i]*k-1] +=1
k +=1
for j in range(0,N):
if LS[A[j]-1]==1:
s+=1
print(s) | p02642 |
import sys
import math
N = int(sys.stdin.readline().strip())
A = list(map(int, sys.stdin.readline().strip().split()))
A.sort()
# print(A)
ans = 0
invalid = set()
for i in range(N):
if A[i] in invalid:
continue
flag = True
for j in range(i+1, N):
if A[j] in invalid:
continue
# print(A[i], A[j])
if A[j] % A[i] == 0:
invalid.add(A[j])
if A[i] == A[j]:
# print("break")
#break
flag = False
else:
if flag:
ans += 1
print(ans) | import sys
N = int(sys.stdin.readline().strip())
A = list(map(int, sys.stdin.readline().strip().split()))
A.sort()
max_a = max(A)
counts = [0 for _ in range(max_a + 1)]
ans = 0
for a in A:
counts[a] += 1
for a in A:
if counts[a] == 1:
ans += 1
n = 1
while n * a <= max_a:
counts[n * a] += 2
n += 1
print(ans) | p02642 |
N = int(eval(input()))
A_list = list(map(int, input().split()))
A_list.sort()
A_max = A_list[N-1]
is_prime = [True] * (A_max+1)
is_prime[0] = False
for i in range(1, A_max):
if i not in A_list:
is_prime[i] = False
for i in A_list:
if not is_prime[i]:
continue
for j in range(i*2, A_max+1, i):
is_prime[j] = False
if A_list.count(i) >= 2:
is_prime[i] = False
print((is_prime.count(True)))
| N = int(eval(input()))
A_list = list(map(int, input().split()))
A_list.sort()
A_max = A_list[N-1]
is_prime = [False] * (A_max+1)
for i in A_list:
is_prime[i] = True
x = -1
for i in A_list:
if not is_prime[i]:
continue
elif x == i:
is_prime[i] = False
continue
for j in range(i*2, A_max+1, i):
is_prime[j] = False
x = i
count = 0
for i in A_list:
if is_prime[i]:
count += 1
print(count)
| p02642 |
from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
divisible = [False for _ in range(int(1e6+1))]
cnt = defaultdict(int)
for a in A:
cnt[a] += 1
if divisible[a] == False:
for i in range(a+a, len(divisible), a):
divisible[i] = True
ans = 0
for a in A:
if divisible[a] is False and cnt[a] <= 1:
ans += 1
print(ans)
| from collections import defaultdict
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
divisible = [False for _ in range(int(1e6+1))]
cnt = defaultdict(int)
for a in A:
cnt[a] += 1
if divisible[a] == False and cnt[a] <= 1:
for i in range(a+a, len(divisible), a):
divisible[i] = True
ans = 0
for a in A:
if divisible[a] is False and cnt[a] <= 1:
ans += 1
print(ans)
| p02642 |
n = int(eval(input()))
ints = list(map(int, input().split()))
m = max(ints)
x = [0] * m
cnt = 0
for i in ints:
for j in range(m):
if (j + 1) % i == 0:
x[j] += 1
for i in ints:
if x[i-1] == 1:
cnt += 1
print(cnt)
| n = int(eval(input()))
ints = list(map(int, input().split()))
m = max(ints)
x = [0] * m
cnt = 0
for i in ints:
if x[i-1] >= 2:
continue
for j in range(m // i):
x[i * (j + 1) - 1] += 1
for i in ints:
if x[i - 1] == 1:
cnt += 1
print(cnt)
| p02642 |
import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = list(sorted(map(int, readline().split())))
nums = [0] * (10 ** 6 + 5)
for a in A:
nums[a] += 1
MAX = 10 ** 6 + 1
pr = set()
for a in A:
nums[a] -= 1
b = a
while b <= MAX:
if nums[b] > 0:
pr.add(b)
b += a
nums[a] += 1
ans = len(A)
for a in A:
if a in pr:
ans -= 1
# print(pr)
print(ans)
| import sys
import itertools
# import numpy as np
import time
import math
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
A = list(sorted(map(int, readline().split())))
amax = max(A)
dp = [True] * (amax + 1)
count = [0] * (amax + 1)
for a in A:
count[a] += 1
b = 2 * a
while b <= amax:
dp[b] = False
b += a
ans = 0
for a in A:
if count[a] > 1:
continue
if dp[a]:
ans += 1
print(ans)
| p02642 |
def make_divisors(n):
if n == 1:
return [1]
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
N = int(eval(input()))
A = list(map(int, input().split()))
X = [0] * (10**6 + 1)
for a in A:
X[a] += 1
ans = 0
for a in A:
if X[a] > 1:
continue
for d in make_divisors(a)[:-1]:
if X[d]:
break
else:
ans += 1
print(ans) | def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1 << 32 else [2, 3, 5, 7, 11, 13, 17] if n < 1 << 48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g):
return g
elif isPrimeMR(n // g):
return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(N):
pf = primeFactor(N)
ret = [1]
for p in pf:
ret_prev = ret
ret = []
for i in range(pf[p] + 1):
for r in ret_prev:
ret.append(r * (p ** i))
return sorted(ret)
N = int(eval(input()))
A = list(map(int, input().split()))
ma = max(A)
X = [0] * (ma + 1)
Ans = [True] * (ma + 1)
ans = 0
A.sort()
for a in A:
X[a] += 1
for a in A:
if X[a] > 1:
continue
for d in divisors(a)[:-1]:
if X[d]:
break
else:
ans += 1
print(ans)
| p02642 |
def gcd(a, b):
while b: a, b = b, a % b
return a
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 7, 61] if n < 1 << 32 else [2, 3, 5, 7, 11, 13, 17] if n < 1 << 48 else [2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = y * y % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g):
return g
elif isPrimeMR(n // g):
return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i * i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += i % 2 + (3 if i % 3 == 1 else 1)
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(N):
pf = primeFactor(N)
ret = [1]
for p in pf:
ret_prev = ret
ret = []
for i in range(pf[p] + 1):
for r in ret_prev:
ret.append(r * (p ** i))
return sorted(ret)
N = int(eval(input()))
A = list(map(int, input().split()))
ma = max(A)
X = [0] * (ma + 1)
Ans = [True] * (ma + 1)
ans = 0
A.sort()
for a in A:
X[a] += 1
for a in A:
if X[a] > 1:
continue
for d in divisors(a)[:-1]:
if X[d]:
break
else:
ans += 1
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
ma = max(A)
X = [0] * (ma + 1)
ans = 0
A.sort()
for a in A:
X[a] += 1
for a in A:
if X[a] ==1:
ans += 1
num = 1
while num * a <= ma:
X[num * a] += 2
num += 1
print(ans)
| p02642 |
from collections import deque
n = int(eval(input()))
a = list(map(int, input().split()))
a.sort(reverse=True)
d = deque(a)
cnt = 0
while len(d) > 0:
dd = d.pop()
flg = 0
for i in reversed(list(range(len(d)))):
if d[i] == dd:
del d[i]
flg = 1
elif d[i] % dd == 0:
del d[i]
if flg == 0:
cnt = cnt + 1
print(cnt) | n = int(eval(input()))
a = list(map(int, input().split()))
a.sort()
a_max=max(a)
check = [0]*(a_max+1)
for i in a:
if check[i] != 0:
check[i] = 2
continue
if check[i] == 0:
check[i] = 1
for j in range(1,a_max//i):
check[(j+1)*i] = 2
print((check.count(1))) | p02642 |
N = int(eval(input()))
leng = 10**6+1
memo = [0]*leng
li = []
for n in map(int, input().split()):
x = 0
li.append(n)
while x < leng:
memo[x] +=1
x += n
count = 0
for n in li:
if memo[n] == 1:
count+=1
print(count) | N = int(eval(input()))
leng = 10**6+1
memo = [0]*leng
li = []
for n in map(int, input().split()):
x = 0
li.append(n)
if memo[n] >1:
pass
else:
while x < leng:
memo[x] +=1
x += n
count = 0
for n in li:
if memo[n] == 1:
count+=1
print(count) | p02642 |
N = int(eval(input()))
A = list(map(int, input().split()))
def divisor(N):
from math import sqrt
D = []
for i in range(1, int(sqrt(N)) + 1):
if N % i == 0:
D.append(i)
D.append(N // i)
return list(set(D))
count = 0
A_set = set(A)
A_dict = {a: 0 for a in A}
for a in A:
A_dict[a] += 1
for a in A:
a_div = set(divisor(a)) - {a}
if len(a_div - A_set) == len(a_div):
if A_dict[a] == 1:
count += 1
print(count) | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
A_max = max(A)
dp = [True] * (A_max + 1)
count = 0
A_f = {a: 0 for a in A}
for a in A:
A_f[a] += 1
for a in A:
if dp[a]:
for i in range(1, A_max + 1):
if a * i > A_max:
break
dp[a * i] = False
if A_f[a] == 1:
count += 1
print(count) | p02642 |
N = int(eval(input()))
A = list(map(int, input().split()))
def divisor(N):
from math import sqrt
D = []
for i in range(1, int(sqrt(N)) + 1):
if N % i == 0:
D.append(i)
D.append(N // i)
return list(set(D))
count = 0
A_set = set(A)
A_dict = {a: 0 for a in A}
for a in A:
A_dict[a] += 1
for a in A:
a_div = set(divisor(a)) - {a}
if len(a_div - A_set) == len(a_div):
if A_dict[a] == 1:
count += 1
print(count) | N = int(eval(input()))
A = list(map(int, input().split()))
A.sort()
A_max = max(A)
dp = [True] * (A_max + 1)
count = 0
A_f = {a: 0 for a in A}
for a in A:
A_f[a] += 1
for a in A:
if dp[a]:
for i in range(1, A_max + 1):
if a * i > A_max:
break
dp[a * i] = False
if A_f[a] == 1:
count += 1
print(count) | p02642 |
from collections import Counter
def solve(string):
n, *a = list(map(int, string.split()))
table = [True] * (10**6 + 1)
for _a in a:
if table[_a]:
for i in range(2 * _a, max(a) + 1, _a):
table[i] = False
return str(sum(table[k] for k, v in list(Counter(a).items()) if v == 1))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| from collections import Counter
def solve(string):
n, *a = list(map(int, string.split()))
table = [True] * (10**6 + 1)
ma = max(a)
for _a in a:
if table[_a]:
for i in range(2 * _a, ma + 1, _a):
table[i] = False
return str(sum(table[k] for k, v in list(Counter(a).items()) if v == 1))
if __name__ == '__main__':
import sys
print((solve(sys.stdin.read().strip())))
| p02642 |
n = int(eval(input()))
a = list(map(int, input().split()))
m = 10 ** 6 + 7
count = [0] * m
for x in a:
if count[x] != 0:
count[x] = 2
continue
for i in range(x, m, x):
count[i] += 1
ans = 0
for x in a:
if count[x] == 1:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
m = max(a) + 1
a = sorted(a)
count = [0] * m
for x in a:
if count[x] != 0:
count[x] = 2
continue
for i in range(x, m, x):
count[i] += 1
ans = 0
for x in a:
if count[x] == 1:
ans += 1
print(ans) | p02642 |
# ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import * # ll = deepcopy(l)
from heapq import * # heappush(hp,x)
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize # minn = -maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import * # pre = [0] + list(accumulate(l))
from decimal import Decimal # a = Decimal(a) # use this for math questions
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
5
24 11 8 3 16
'''
def solve(l):
n = len(l)
l.sort()
maxx,ans = max(l),0
cancel,p = [0]*(maxx+1),[0]*(maxx+1)
for i in l:
p[i] += 1
for i in l:
for j in range(2*i,maxx+1,i):
cancel[j] = 1
for i in l:
if(p[i] == 1 and not cancel[i]):
ans += 1
return ans
N = int(stdin.readline())
l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)
| # ANSHUL GAUTAM
# IIIT-D
from math import *
from copy import * # ll = deepcopy(l)
from heapq import * # heappush(hp,x)
from string import * # alpha = ascii_lowercase
from random import * # l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import * # bisect_left(arr,x,start,end) => start and end parameters are temporary
from sys import stdin # bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize # minn = -maxsize
from operator import * # d = sorted(d.items(), key=itemgetter(1))
from itertools import * # pre = [0] + list(accumulate(l))
from decimal import Decimal # a = Decimal(a) # use this for math questions
from collections import Counter # d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)
'''
5
24 11 8 3 16
'''
def solve(l):
n = len(l)
ans,maxx = 0,max(l)
done = [0]*(maxx+1)
l.sort()
ans = 0
d = dict(Counter(l))
for i in l:
zz = 2
while(i*zz <= maxx):
done[i*zz] = 1
zz += 1
for i in l:
if(not done[i] and d[i] == 1):
ans += 1
return ans
N = int(stdin.readline())
l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)
| p02642 |
N = int(eval(input()))
X = list(map(int, input().split()))
MAX = 10 ** 6 + 1
prime = [True] * MAX
counted = set()
for v in X:
if v in counted:
prime[v] = False
for j in range(2 * v, MAX, v):
prime[j] = False
counted.add(v)
ans = 0
for v in X:
ans += int(prime[v])
print(ans)
|
N = int(eval(input()))
X = list(map(int, input().split()))
MAX = 10 ** 6 + 1
prime = [True] * MAX
counted = set()
for v in X:
if v in counted:
prime[v] = False
continue
for j in range(2 * v, MAX, v):
prime[j] = False
counted.add(v)
ans = 0
for v in X:
ans += int(prime[v])
print(ans)
| p02642 |
N = int(eval(input()))
X = list(map(int, input().split()))
MAX = 10 ** 6 + 1
prime = [True] * MAX
counted = set()
for v in X:
if v in counted:
prime[v] = False
continue
for j in range(2 * v, MAX, v):
prime[j] = False
counted.add(v)
ans = 0
for v in X:
ans += int(prime[v])
print(ans)
|
from collections import Counter
N = int(eval(input()))
X = list(map(int, input().split()))
lim = 10 ** 6 + 10
ok = [True] * (lim + 1)
ans = 0
ctr = Counter(X)
for n in sorted(X):
if ok[n]:
if ctr[n] == 1:
ans += 1
for j in range(n, lim + 1, n):
ok[j] = False
print(ans)
| p02642 |
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
"""
3
1 1 2
のパターンが例外だった
"""
N = int(eval(input()))
A = LI()
A.sort()
table = [0 for i in range(10 ** 6 + 1)]
cnt = 0
cc = collections.Counter(A)
duplicate = []
for key in list(cc.keys()):
if cc[key] > 1:
duplicate.append(key)
for a in A:
if table[a] != 0:
pass
else:
if a not in duplicate:
cnt += 1
for i in range(1, 10 ** 6 + 1):
if a * i > 10 ** 6:
break
table[a * i] = 1
print(cnt)
| # encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(eval(input()))
A = LI()
A.sort()
table = [0 for i in range(10**6 + 1)] # 約数のテーブル
cc = collections.Counter(A)
cnt = 0
for a in A:
if table[a] == 0:
for i in range(10 ** 6):
if a * i > 10 ** 6:
break
table[a * i] = 1
if cc[a] == 1:
cnt += 1
print(cnt)
| p02642 |
from collections import Counter
n = int(eval(input()))
A = sorted(list(map(int, input().split())))
c = Counter(A)
result = 0
piyo = []
for k, v in list(c.items()):
if v > 1:
piyo.append(k)
A.remove(k)
for a in A:
flag = False
for hoge in piyo:
if a % hoge == 0:
flag = True
break
if not flag:
piyo.append(a)
result += 1
print(result) | def main():
from collections import Counter
n = int(eval(input()))
A = sorted(list(map(int, input().split())))
c = Counter(A)
result = 0
flag = [True] * (A[-1] + 1)
for i in A:
if flag[i]:
result += 1
for j in range(2*i, A[-1] + 1, i):
flag[j] = False
for k, v in list(c.items()):
if v > 1:
if flag[k]:
result -= v
print(result)
main() | p02642 |
# coding: utf-8
def yakusu(n):
ans = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
ans.append(i)
if n // i != i:
ans.append(n // i)
return sorted(ans)
def main():
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)
# is_in_A_flag = [0] * (10**6+1)
is_in_A_flag = {f"{i}": 0 for i in range(10**6+1)}
for a in A:
is_in_A_flag[f"{a}"] += 1
B = [None] * N
for i in range(N):
B[i] = yakusu(A[i])
ans = 0
for i in range(N):
is_ans = True
# for b in B[i][:-1]:
for j in range(len(B[i])-1):
b = B[i][j]
if is_in_A_flag[f"{b}"] > 0:
is_ans = False
break
if is_ans:
if is_in_A_flag[f"{B[i][-1]}"] > 1:
is_ans = False
if is_ans:
ans += 1
return ans
print((main()))
| # coding: utf-8
# 13:42- kaisetsu and try again
# -14:03 giveup (WA*6) -> testcase
def main():
N = int(eval(input()))
A = sorted(list(map(int, input().split())))
M = 10**6
is_ans_flag = [0] * (M+1)
n_appeared_in_A = [0] * (M+1)
for a in A:
n_appeared_in_A[a] += 1
is_ans_flag[a] = 1
for a in A:
if n_appeared_in_A[a] == -1:
continue
if n_appeared_in_A[a] >= 2:
is_ans_flag[a] = 0
for i in range(2, M+1):
if a*i > M:
break
is_ans_flag[a*i] = 0
n_appeared_in_A[a] = -1
return sum(is_ans_flag)
print((main()))
| p02642 |
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = [0] * ((10**6) + 1)
ans = 0
for i in a:
for j in range(i, (10**6)+1,i):
cnt[j] += 1
for i in a:
if cnt[i] == 1:
ans += 1
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
a_max = max(a)
cnt = [0] * (max(a) + 1)
ans = 0
for ai in a:
for multi in range(ai, a_max + 1, ai):
cnt[multi] += 1
for ai in a:
if cnt[ai] == 1:
ans += 1
print(ans) | p02642 |
n=int(eval(input()))
import math
a=list(map(int,input().split()))
d=dict()
for i in range(n):
if d.get(a[i],None)==None:
d[a[i]]=0
d[a[i]]+=1
ans=0
s=list(d.keys())
for i in range(n):
if d[a[i]]>1:
continue
flag=True
# print(a[i],end=' s\n')
for ii in range(1,math.ceil(a[i]**(1/2))+1):
if (a[i]%ii)==0:
aa,bb=ii,a[i]//ii
if aa!=a[i] and aa in s:
# print(aa)
# print('aa')
flag=False
break
if bb!=a[i] and bb in s:
# print('bb')
# print(bb)
flag=False
break
if(flag):
# print(a[i])
ans+=1
print(ans)
| n=int(eval(input()))
a=list(map(int,input().split()))
m=max(a)
dp=[0 for i in range(m+1)]
ans=0
for i in range(n):
if dp[a[i]]>=1:
dp[a[i]]+=1
continue
for j in range(2*a[i],m+1,a[i]):
dp[j]+=1
dp[a[i]]=1
for i in range(n):
if dp[a[i]]==1:
ans+=1
print(ans)
| p02642 |
from sys import stdin
def main():
n = int(stdin.readline().strip())
a = list(map(int, stdin.readline().strip().split()))
if n == 1:
print((1))
exit()
a.sort()
# bにチェックする数を追加していく
b = []
ans = 0
for i in range(n):
if a[i] == a[i-1]:
continue
flag = True
for j in b:
if a[i] % j == 0:
flag = False
break
if flag:
b.append(a[i])
if i == n-1 or a[i] != a[i+1]:
ans += 1
print(ans)
main()
| from sys import stdin
def main():
n = int(stdin.readline().strip())
a = list(map(int, stdin.readline().strip().split()))
if n == 1:
print((1))
exit()
a.sort()
dp = [True] * (a[-1] + 1)
ans = 0
for i in range(n):
if a[i] == a[i-1]:
continue
if dp[a[i]]:
for j in range(2 * a[i], a[-1] + 1, a[i]):
dp[j] = False
if i == n-1 or a[i] != a[i+1]:
ans += 1
print(ans)
main() | p02642 |
n = int(eval(input()))
An = list(map(int, input().split()))
An.sort()
idx = 0
while True:
if idx == len(An):
ans = len(An) - An.count(0)
print(ans)
exit()
flg = False
if An[idx] != 0:
for i in range(idx + 1, len(An)):
if An[i] != 0 and An[i] % An[idx] == 0:
if An[i] == An[idx]:
flg = True
An[i] = 0
if flg:
An[idx] = 0
idx += 1 | n = int(eval(input()))
An = list(map(int, input().split()))
An.sort()
max_num = An[-1]
primes = [True] * max_num
once = [False] * max_num
i = 0
while i < n:
once[An[i] - 1] = True
j = 1
while i + j < n:
if An[i] == An[i + j]:
once[An[i] - 1] = False
j += 1
else:
break
i += j
for i in range(n):
if primes[An[i] - 1]:
base = An[i]
idx = An[i] * 2 - 1
while idx < max_num:
primes[idx] = False
idx += base
ans = [x and y for (x, y) in zip(once, primes)]
print((ans.count(True))) | p02642 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = list(map(int, read().split()))
a.sort()
a = tuple(a)
TorF = [0] * (a[-1] + 1)
for ae in a:
TorF[ae] = 1
for i1 in range(n - 1):
if TorF[a[i1]]:
t = a[i1] * 2
while t <= max(a):
TorF[t] = 0
t += a[i1]
if a[i1 + 1] == a[i1]:
TorF[a[i1]] = 0
r = sum(TorF)
print(r)
if __name__ == '__main__':
main() | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n, *a = list(map(int, read().split()))
a.sort()
a = tuple(a)
TorF = [0] * (a[-1] + 1)
for ae in a:
TorF[ae] = 1
for i1 in range(n - 1):
a1 = a[i1]
if TorF[a1]:
m = a[-1] // a1 + 1
for i2 in range(2, m):
TorF[a1 * i2] = 0
if a[i1 + 1] == a[i1]:
TorF[a[i1]] = 0
r = sum(TorF)
print(r)
if __name__ == '__main__':
main() | p02642 |
N = int(eval(input()))
A = list(map(int, input().split()))
MAX_A = 10 ** 6
X = [0] * (MAX_A + 1)
for a in A:
for i in range(a, MAX_A + 1, a):
X[i] += 1
ans = len([a for a in A if X[a] == 1])
print(ans)
| from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
C = Counter(A)
A = set(A)
MAX_A = 10 ** 6
X = [0] * (MAX_A + 1)
for a in A:
for i in range(a, MAX_A + 1, a):
X[i] += 1
ans = len([a for a in A if (X[a] == 1) and (C[a] == 1)])
print(ans)
| p02642 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.