input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
def main():
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R + 1):
for g in range(N//G + 1):
res = (N - (R*r + G*g))
if res >= 0 and res % B == 0:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
def main():
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R + 1):
for g in range(N//G + 1):
res = (N - (R*r + G*g))
if res < 0 :
break
if res >= 0 and res % B == 0:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
p03048
|
import sys
input = sys.stdin.readline
r, g, b, n = list(map(int, input().split()))
cnt = 0
for i in range(int(n/r)+1):
for j in range(int(n/g)+1):
tmp = r*i + g*j
if tmp > n:
break
else:
tmp = n - tmp
if tmp%b == 0:
cnt += 1
print(cnt)
|
r, g, b, n = list(map(int, input().split()))
cnt = 0
for i in range(0, n+1, r):
for j in range(0, n+1, g):
tmp = n - (i+j)
if tmp < 0:
break
if tmp%b == 0:
cnt += 1
print(cnt)
|
p03048
|
r,g,b,n=list(map(int,input().split()))
sum=0
for x in range(0,1+(3000//r)):
for y in range(0,1+(3000-x*r)//g):
if r*x+g*y<=n and (n-r*x-g*y)%b==0:
sum+=1
print(sum)
|
r,g,b,n=list(map(int,input().split()))
sum=0
for x in range(0,1+(n//r)):
for y in range(0,1+(n-x*r)//g):
if (n-r*x-g*y)%b==0:
sum+=1
print(sum)
|
p03048
|
r,g,b,n = list(map(int,input().split(" ")))
count = 0
for i in range(n+1):
for j in range(n+1):
if (i * r + j * g) <= n:
if (n - (i * r + j * g)) % b == 0:
count += 1
print(count)
|
r,g,b,n = list(map(int,input().split(" ")))
count = 0
for i in range(0,n+1,r):
for j in range(0,n+1,g):
if i + j <= n:
if (n - (i + j)) % b == 0:
count += 1
print(count)
|
p03048
|
from sys import stdin
import math
input=input=stdin.readline().rstrip().split()
for i in range(len(input)):
input[i]=int(input[i])
output=0
R=input[0]
G=input[1]
B=input[2]
N=input[3]
for r in range(math.floor(N/R)+1):
for g in range(math.floor(N/G)+1):
#for b in range(math.floor(N/B)+1):
#print(r,g)
#if r*R+g*G+b*B==N:
b=N-(r*R+g*G)
#b/B
if b>=0:
if b % B == 0:
#print(r,g)
output+=1
print(output)
|
from sys import stdin
import math
input=input=stdin.readline().rstrip().split()
for i in range(len(input)):
input[i]=int(input[i])
output=0
R=input[0]
G=input[1]
B=input[2]
N=input[3]
for r in range(math.floor(N/R)+1):
for g in range(math.floor(N/G)+1):
#for b in range(math.floor(N/B)+1):
#print(r,g)
#if r*R+g*G+b*B==N:
b=N-(r*R+g*G)
#b/B
#if b>=0:
if b<0:
break
if b % B == 0:
#print(r,g)
output+=1
print(output)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
score = 0
for i in range(N // R + 1):
for j in range(N // G + 1):
if N - i * R - j * G >= 0 and (N - i * R - j * G) % B == 0:
score += 1
print(score)
|
R, G, B, N = list(map(int, input().split()))
score = 0
for i in range(N // R + 1):
for j in range((N-i * R) // G + 1):
if N - i * R - j * G >= 0 and (N - i * R - j * G) % B == 0:
score += 1
print(score)
|
p03048
|
R,G,B,N = list(map(int,input().split()))
count = 0
for r in range(N//R+1):
for g in range((N-r*R)//G+1):
b = (N-R*r-G*g)/B
if b.is_integer() and b >= 0:
count += 1
print(count)
|
R,G,B,N = list(map(int,input().split()))
cnt = 0
for r in range(N//R+1):
for g in range((N-R*r)//G+1):
if (N-R*r-G*g)%B == 0:
cnt += 1
print(cnt)
|
p03048
|
R,G,B,N = list(map(int,input().split()))
A = [R,G,B]
A.sort()
R = A[0]
G = A[1]
B = A[2]
rmax = N//R
gmax = N//G
bmax = N//B
cnt = 0
for i in range(rmax+1):
for j in range(gmax+1):
if R*i + G*j > N:
continue
if ((N-R*i-G*j)%B == 0) and ((N-R*i-G*j)//B <= bmax):
cnt += 1
print(cnt)
|
R,G,B,N = list(map(int,input().split()))
A = [R,G,B]
A.sort()
R = A[2]
G = A[1]
B = A[0]
rmax = N//R
gmax = N//G
bmax = N//B
cnt = 0
if R == 1:
print(((N+1)*(N+2)//2))
exit()
for i in range(rmax+1):
for j in range(gmax+1):
if R*i + G*j > N:
continue
if ((N-R*i-G*j)%B == 0) and ((N-R*i-G*j)//B <= bmax):
cnt += 1
print(cnt)
|
p03048
|
r,g,b,n=list(map(int,input().split()))
ans=0
for i in range(n+1):
if r*i>n:
break
for j in range(n+1):
if r*i+g*j>n:
break
if (n-r*i-g*j)%b==0:
ans+=1
print(ans)
|
r,g,b,n=list(map(int,input().split()))
m=[r,g,b]
m.sort(reverse=1)
r,g,b=m[0],m[1],m[2]
ans=0
if m==[1,1,1]:
print(((n+2)*(n+1)//2))
else:
for i in range(n+1):
if r*i>n:
break
for j in range(n+1):
if r*i+g*j>n:
break
if (n-r*i-g*j)%b==0:
ans+=1
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R+1):
for g in range((N-r*R)//G+1):
tmp = (N-r*R-g*G)/B
if tmp.is_integer():
ans += 1
print(ans)
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N // R + 1):
for g in range((N - r * R) // G + 1):
if (N - r * R - g * G) % B==0:
ans += 1
print(ans)
|
p03048
|
r,g,b,n = list(map(int,input().split()))
total = 0
ref = 0
count = 0
for i in range(n//r+1):
for j in range((n-r*i)//g+1):
total = r*i + g*j
ref = n - total
if (ref >= 0):
if ref%b == 0:
count += 1
print(count)
|
r,g,b,n = list(map(int,input().split()))
total = 0
ref = 0
count = 0
for i in range(n//r+1):
for j in range((n-r*i)//g+1):
total = r*i + g*j
ref = n - total
if (ref == 0) or (ref%b == 0):
count += 1
print(count)
|
p03048
|
R,G,B,N = list(map(int, input().split()))
ans = 0
for r in range(N//R+1):
for g in range(N//G+1):
check = N - (R*r + G*g)
if check == 0:
# print(r, g, check//B, check)
ans += 1
elif check > 0 and check%B == 0:
# print(r, g, check//B, check)
ans += 1
print(ans)
|
R,G,B,N = list(map(int, input().split()))
ans = 0
for r in range(N//R+1):
for g in range(N//G+1):
check = N - (R*r + G*g)
if check >= 0 and check%B == 0:
ans += 1
# if check == 0:
# # print(r, g, check//B, check)
# ans += 1
# elif check > 0 and check%B == 0:
# # print(r, g, check//B, check)
# ans += 1
print(ans)
|
p03048
|
R,G,B,N = list(map(int, input().split()))
ans = 0
for r in range(N//R+1):
for g in range(N//G+1):
check = (N - (R*r + G*g))/B
if float.is_integer(check) and check >= 0:
ans += 1
# if check >= 0 and check%B == 0:
# ans += 1
# if check == 0:
# # print(r, g, check//B, check)
# ans += 1
# elif check > 0 and check%B == 0:
# # print(r, g, check//B, check)
# ans += 1
print(ans)
|
R,G,B,N = list(map(int, input().split()))
ans=0
for r in range(N//R+1):
x = N-R*r
for g in range(x//G+1):
if (x-G*g)%B==0:
ans+=1
print(ans)
|
p03048
|
# import time
R, G, B, N = list(map(int, input().split()))
# print(R, G, B)
i = 0
# r, g = 0, 0
# s = time.time()
for r in range(N // R + 1):
for g in range(N // G + 1):
if (N - r * R - g * G) >= 0:
b = int((N - r * R - g * G) / B)
if N - (r * R + g * G + b * B) == 0:
# print(r, g, b)
i += 1
print(i)
# print(time.time()-s)
|
R, G, B, N = list(map(int, input().split()))
i = 0
for r in range(N // R + 1):
Rr = r * R
for g in range(N // G + 1):
Gg = g * G
Bb = N-Rr-Gg
if Bb < 0:
break
if Bb % B == 0:
i += 1
print(i)
|
p03048
|
R,G,B,N = list(map(int,input().split()))
ans = 0
for r in range(N+1) :
for g in range(N+1) :
if (N - (r*R + g*G)) < 0 : continue
if (N - (r*R + g*G)) % B == 0 :
ans += 1
#print(r,g)
print(ans)
|
R,G,B,N = list(map(int,input().split()))
ans = 0
for r in range(N//R + 1) :
for g in range((N-r)//G + 1) :
calc = r*R + g*G
if (N-calc) < 0 :
break
if (N-calc) % B == 0 :
ans += 1
print(ans)
|
p03048
|
R,G,B,N = list(map(int,input().split()))
ans = 0
for r in range(N//R + 1) :
for g in range((N-r)//G + 1) :
calc = r*R + g*G
if N < calc :
break
if (N-calc) % B == 0 :
ans += 1
print(ans)
|
R,G,B,N = list(map(int,input().split()))
ans = 0
for r in range(N//R + 1) :
for g in range((N-r)//G + 1) :
calc = r*R + g*G
if N < calc :
break
if not (N-calc) % B :
ans += 1
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
l = sorted([R, G, B])[::-1]
count = 0
for l0 in range(N//l[0]+1):
n0 = N-l0*l[0]
for l1 in range(n0//l[1]+1):
l2 = (n0 - l1*l[1])/l[2]
if l2%1.0 == 0 and l2 >= 0:
count += 1
print(count)
|
R, G, B, N = list(map(int, input().split()))
l = sorted([R, G, B])[::-1]
count = 0
for l0 in range(N//l[0]+1):
n0 = N-l0*l[0]
for l1 in range(n0//l[1]+1):
l2 = n0 - l1*l[1]
if l2%l[2] == 0 and l2 >= 0:
count += 1
print(count)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
rgb = []
for r in range(N//R + 1):
for g in range((N - r*R)//G + 1):
tmp = N-r*R-g*G
if tmp%B == 0:
rgb.append((r,g,tmp//B))
print((len(set(rgb))))
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R + 1):
for g in range((N - r*R)//G + 1):
tmp = N-r*R-g*G
if tmp%B == 0:
ans += 1
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R + 1):
for g in range((N - r*R)//G + 1):
tmp = N-r*R-g*G
if tmp%B == 0:
ans += 1
print(ans)
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N//R + 1):
for g in range((N - r*R)//G + 1):
if (N-r*R-g*G)%B == 0:
ans += 1
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
LIM = 3003
ans = 0
for r in range(LIM):
for g in range(LIM):
if R * r + G * g > N:
break
Bb = N - R * r - G * g
if Bb % B == 0:
ans += 1
print(ans)
|
def solve():
R, G, B, N = list(map(int, input().split()))
LIM = 3001
ans = 0
for r in range(LIM):
for g in range(LIM):
if R * r + G * g > N:
break
Bb = N - R * r - G * g
if Bb % B == 0:
ans += 1
return ans
print((solve()))
|
p03048
|
R, G, B, N = list(map(int, input().split()))
ans = 0
n_iter_r = N//R + 1
n_iter_g = N//G + 1
for r in range(n_iter_r):
for g in range(n_iter_g):
if N - R*r - G*g < 0:
break
else:
if (N - R*r - G*g)%B==0:
ans += 1
print(ans)
|
R, G, B, N = list(map(int, input().split()))
ans = 0
n_iter_r = N//R + 1
n_iter_g = N//G + 1
for r in range(n_iter_r):
for g in range(n_iter_g):
nokori = N - R*r - G*g
if nokori < 0:
break
else:
if nokori%B==0:
ans += 1
print(ans)
|
p03048
|
r,g,b,n=list(map(int,input().split()))
ans=0
r,g,b=max(r,g,b),r+g+b-max(r,g,b)-min(r,g,b),min(r,g,b)
for i in range(n//r+1):
for j in range(n//g+1):
if (n-i*r-j*g)%b or (n-i*r-j*g)<0:
continue
ans+=1
print(ans)
|
r,g,b,n=list(map(int,input().split()))
ans=0
for R in range(n//r+1):
for B in range((n)//b+1):
if (R*r+B*b-n)<=0 and (R*r+B*b-n)%g==0:
ans+=1
print(ans)
|
p03048
|
r,g,b,n = list(map(int,input().split()))
ans = 0
for i in range(n+1):
for j in range(n+1):
if r*i + g*j > n:
break
elif (n - r*i - g*j) % b == 0:
ans += 1
print(ans)
|
r,g,b,n = list(map(int,input().split()))
a = [0]*(n+1)
a[0] = 1
for i in [r,g,b]:
for j in range(n+1-i):
a[j+i]+=a[j]
print((a[n]))
|
p03048
|
R, G, B, N = [int(n) for n in input().split()]
count = 0
for r in range(N//R + 1):
for g in range((N-r*R)//G + 1):
b_ = N - (R * r + G * g)
if b_ % B == 0 and 0 <= b_ / B <= N//B:
count += 1
print(count)
|
R, G, B, N = [int(n) for n in input().split()]
count = 0
for r in range(N//R + 1):
for g in range((N-r*R)//G + 1):
b_ = N - (R * r + G * g)
if b_ % B == 0:
count += 1
print(count)
|
p03048
|
R, G, B, N = [int(n) for n in input().split()]
count = 0
for r in range(N//R + 1):
for g in range((N-r*R)//G + 1):
b_ = N - (R * r + G * g)
if b_ % B == 0 and 0 <= b_ / B:
count += 1
print(count)
|
R, G, B, N = [int(n) for n in input().split()]
count = 0
for r in range(N//R + 1):
for g in range((N-r*R)//G + 1):
b_ = N - (R * r + G * g)
if b_ % B == 0 and 0 <= b_:
count += 1
print(count)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
count = 0
for r in range(0, N//R+1):
for g in range(0, N//G+1):
# compute b
b = (N - r*R - g*G) / B
# judge
if b.is_integer() and b>=0:
count += 1
print(count)
|
R, G, B, N = list(map(int, input().split()))
count = 0
for r in range(N//R+1):
for g in range((N-r*R)//G+1):
if (N - r*R - g*G) % B == 0:
count += 1
print(count)
|
p03048
|
r, g, b, n = [int(i) for i in input().split()]
ans = 0
for i in range(n//b + 1):
for j in range((n-i*b)//g + 1):
if (n - i*b - g*j) % r == 0:
ans += 1
print(ans)
|
def trans(n, dp, color):
for i in range(n-color+1):
dp[i+color] += dp[i]
return dp
def main():
r, g, b, n = [int(i) for i in input().split()]
dp = [0 for i in range(n+1)]
dp[0] = 1
dp = trans(n, dp, r)
dp = trans(n, dp, g)
dp = trans(n, dp, b)
print((dp[-1]))
main()
|
p03048
|
r, g, b, n = (int(i) for i in input().split())
rmax = int(n/r)
gmax = int(n/g)
count = 0
for i in range(0, rmax + 1):
for j in range(0, gmax + 1):
tmp = (n - r * i - g * j)
if (tmp % b == 0 and tmp >=0):
count += 1
print(count)
|
r, g, b, n = (int(i) for i in input().split())
rmax = int(n/r)
count = 0
for i in range(0, rmax + 1):
gmax = (n - r * i) // g
for j in range(0, gmax + 1):
tmp = n - r * i - g * j
if (tmp % b == 0 and tmp >=0):
count += 1
print(count)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N + 1):
for g in range(N + 1):
v = N - r * R - g * G
if v >= 0 and v % B == 0:
ans += 1
print(ans)
|
def solve():
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N + 1):
for g in range(N + 1):
v = N - r * R - g * G
if v >= 0 and v % B == 0:
ans += 1
print(ans)
solve()
|
p03048
|
a = [0]*3
a[0],a[1],a[2],n = list(map(int,input().split()))
a.sort()
cnt = 0
for i in range(n//a[2]+1):
for j in range(n//a[1]+1):
d = n-a[2]*i-a[1]*j
if d%a[0] == 0 and d >= 0:
cnt += 1
print(cnt)
|
a = [0]*3
a[0],a[1],a[2],n = list(map(int,input().split()))
a.sort()
cnt = 0
for i in range(n//a[2]+1):
for j in range((n-i*a[2])//a[1]+1):
d = n-a[2]*i-a[1]*j
if d%a[0] == 0 and d >= 0:
cnt += 1
print(cnt)
|
p03048
|
def input_from_console():
r, g, b, n = list(map(int, input().split()))
return r, g, b, n
def main():
r, g, b, n = input_from_console()
counter = 0
r, g, b = sorted([r, g, b], reverse=True)
# print(r,g,b)
for i1 in reversed(list(range(int(n / r) + 1))):
n1 = n - r * i1
for i2 in reversed(list(range(int(n1 / g) + 1))):
n2 = n1 - g * i2
# print(n2, i1, i2)
if r * i1 + g * i2 + b * (n - i1 - i2) < n2:
continue
for i3 in reversed(list(range(int(n2 / b) + 1))):
# print(i1, i2, i3, r * i1 + g * i2 + b * i3)
n_new = r * i1 + g * i2 + b * i3
if r * i1 + g * i2 + b * i3 == n:
counter += 1
break
elif n_new < n:
break
print(counter)
if __name__ == "__main__":
main()
|
def input_from_console():
r, g, b, n = list(map(int, input().split()))
return r, g, b, n
def main():
r, g, b, n = input_from_console()
counter = 0
r, g, b = sorted([r, g, b], reverse=True)
for i1 in reversed(list(range(int(n / r) + 1))):
n1 = n - r * i1
for i2 in reversed(list(range(int(n1 / g) + 1))):
n2 = n1 - g * i2
if n2 % b == 0:
counter += 1
print(counter)
if __name__ == "__main__":
main()
|
p03048
|
r,g,b,n=list(map(int,input().split()))
cnt=0
s=0
for i in range(n//r+1):
for j in range(n//g+1):
k=(n-(i*r+j*g))//b
s=i*r+j*g+k*b
if s==n and k>=0:
cnt+=1
print(cnt)
|
# 2019/10/17
R,G,B,n=list(map(int,input().split()))
cnt=0
for i in range(n//R+1):
r=i*R
rem=n-r
for j in range((n-r)//G+1):
g=j*G
b=n-(r+g)
if b%B:continue
cnt+=1
print(cnt)
|
p03048
|
#%%
r, g, b, n = list(map(int, input().split()))
ans = 0
for i in range(n//r+2):
flag = False
for j in range(n//g+2):
tmp = n - (r*i + g*j)
if j == 0 and tmp < 0:
flag = True
if tmp < 0:
break
if tmp % b == 0:
ans += 1
if flag:
break
print(ans)
|
r, g, b, n = list(map(int, input().split()))
ans = 0
for i in range(n//r+2):
flag = False
for j in range(n//g+2):
tmp = n - (r*i + g*j)
if tmp < 0:
break
if tmp % b == 0:
ans += 1
print(ans)
|
p03048
|
*j, n = list(map(int, input().split()))
j.sort()
a, b, c = j
count = 0
for y in range(n//b+1):
for z in range((n-y*b)//c+1):
if (n - b*y - c*z) % a == 0 and (n - b*y - c*z) >= 0:
count += 1
print(count)
|
*j, n = list(map(int, input().split()))
j.sort()
a, b, c = j
count = 0
for y in range(n//b+1):
for z in range((n-y*b)//c+1):
if (n - b*y - c*z) % a == 0:
count += 1
print(count)
|
p03048
|
r, g, b, n = list(map(int, input().split()))
r_num = n // r
g_num = n // g
b_num = n // b
count = 0
for i in range(r_num+1):
r_remain = n - r * i
if r_remain == 0:
count += 1
else:
for j in range(g_num+1):
g_remain = r_remain - g * j
if g_remain == 0:
count += 1
elif g_remain > 0:
if g_remain % b == 0:
count += 1
print(count)
|
r, g, b, n = list(map(int, input().split()))
count = 0
for i in range(0, n+1, r):
rem = n-i
for j in range(0, rem+1, g):
if (rem-j)%b==0:
count += 1
print(count)
|
p03048
|
r, g, b, n = list(map(int, input().split()))
ans = 0
for i in range(n // r + 1):
for j in range((n - i * r) // g + 1):
if (n - r * i - g * j) / b == abs(int((n - r * i - g * j) / b)):
ans += 1
print(ans)
|
r, g, b, n = list(map(int, input().split()))
ans = 0
for i in range(n // r + 1):
for j in range((n - r * i) // g + 1):
if (n - r * i - g * j) % b == 0 and (n - r * i - g * j) // b >= 0:
ans += 1
print(ans)
|
p03048
|
import sys
input = sys.stdin.readline
def main():
R, G, B, N = list(map(int, input().split()))
ans = 0
for r in range(N // R + 1):
gGbB = N - r * R
for g in range(gGbB // G + 1):
bB = gGbB - g * G
if bB % B == 0:
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def main():
R, G, B, N = list(map(int, input().split()))
dp = [0] * (N + 1)
dp[0] = 1
for c in [R, G, B]:
for i in range(N - c + 1):
dp[i + c] += dp[i]
ans = dp[N]
print(ans)
if __name__ == "__main__":
main()
|
p03048
|
R,G,B,N =list(map(int,input().split()))
cnt =0
for r in range(N+1):
for g in range(N+1-r*R):
ball = r*R+g*G
res = N-ball
if res >=0 and res%B ==0:
cnt+=1
print(cnt)
|
R,G,B,N =list(map(int,input().split()))
cnt =0
for r in range(N+1):
for g in range(N+1-r*R):
res = N- (r*R+g*G)
if res >=0 and res%B ==0:
cnt+=1
print(cnt)
|
p03048
|
R,G,B,N=list(map(int,input().split()))
dp=[0]*(N+1)
dp[0]=1
for C in (R,G,B):
for i in range(len(dp)-C):
if dp[i]!=-1:
dp[i+C]=dp[i]+dp[i+C]
print((dp[N]))
|
R,G,B,N=list(map(int,input().split()))
dp=[0]*(N+1)
dp[0]=1
for C in (R,G,B):
for i in range(len(dp)-C):
dp[i+C]=dp[i]+dp[i+C]
print((dp[N]))
|
p03048
|
r,g,b,n=list(map(int,input().split()))
c=0
for i in range(-(-n//r)+1):
for j in range(-(-n//g)+1):
x=n-(i*r+j*g)
if x>=0 and x%b==0:
c+=1
print(c)
|
r,g,b,n=list(map(int,input().split()))
c=0
for i in range(-(-n//r)+1):
for j in range(-(-n//g)+1):
x=n-(i*r+j*g)
if x<0:
break
elif x%b==0:
c+=1
print(c)
|
p03048
|
import math
R, G, B, N = list(map(int, input().split()))
rg_lis = []
ans = 0
cr = math.ceil(N/R)
cg = math.ceil(N/G)
cb = math.ceil(N/B)
for i in range(cr + 1):
for j in range(cg + 1):
tmp = i * R + j * G
if N - tmp >= 0:
rg_lis.append(tmp)
else:
break
for l in rg_lis:
if (N - l )% B == 0:
ans += 1
print(ans)
|
import math
R, G, B, N = list(map(int, input().split()))
ans = 0
cr = math.ceil(N/R)
cg = math.ceil(N/G)
cb = math.ceil(N/B)
for i in range(cr + 1):
for j in range(cg + 1):
tmp = i * R + j * G
if N - tmp >= 0 and (N - tmp) % B == 0:
ans += 1
elif N - tmp < 0:
break
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for i in range(int(N / R) + 1):
for j in range(int((N - i * R) / G) + 1):
if (N - (i * R + j * G)) % B == 0 and (N - (i * R + j * G)) >= 0:
ans += 1
print(ans)
|
R, G, B, N = list(map(int, input().split()))
ans = 0
for i in range(int(N / R) + 1):
for j in range(int((N - i * R) / G) + 1):
if ((N - (i * R + j * G)) % B == 0):
ans += 1
print(ans)
|
p03048
|
R,G,B,N=list(map(int,input().split()))
RL=(N+R-1)//R
if RL*R>N:
RL=RL-1
cnt=0
for r in range(RL+1):
GL=(N-r*R+G-1)//G
for g in range(GL+1):
if (r*R+g*G)>N:continue
if (N-r*R-g*G)%B==0:
cnt+=1
print(cnt)
|
R,G,B,N=list(map(int,input().split()))
RL=(N+R-1)//R
if RL*R>N:
RL=RL-1
cnt=0
for r in range(RL+1):
GL=(N-r*R+G-1)//G
if (r*R+GL*G)>N:
GL=GL-1
for g in range(GL+1):
if (N-r*R-g*G)%B==0:
cnt+=1
print(cnt)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
cnt = 0
for r in range(N//R+1):
for g in range(N+1):
b = (N - R * r - G * g) / B
if b.is_integer() and b >= 0:
cnt += 1
print(cnt)
|
R, G, B, N = list(map(int, input().split()))
cnt = 0
for r in range(N//R+1):
for g in range((N-R*r)//G+1):
if (N - R * r - G * g) % B == 0:
cnt += 1
print(cnt)
|
p03048
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
R, G, B, N = list(map(int, input().split(" ")))
ans = 0
for i in range(N+1):
r = i * R
for j in range(N+1):
g = j * G
if N - r - g < 0:
continue
if (N - r - g) % B != 0:
continue
k = (N - r - g) // B
#print("{} {} {}".format(i, j, k))
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
# -*- coding: utf-8 -*-
import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
input = sys.stdin.readline
# bisect_left(lists, 3)
# bisect_right(lists, 3)
def main():
R, G, B, N = list(map(int, input().split(" ")))
ans = 0
for i in range(N+1):
r = i * R
for j in range(N+1):
g = j * G
if N - r - g < 0:
continue
if (N - r - g) % B != 0:
continue
#k = (N - r - g) // B
#print("{} {} {}".format(i, j, k))
ans += 1
print(ans)
if __name__ == "__main__":
main()
|
p03048
|
def b_rgb_boxes(R, G, B, N):
"""Rr+Gg+Bb=N となる整数(r, g, b)の組はいくつか。"""
ans = 0
for r in range(N + 1):
for g in range(N + 1):
t = N - R * r - G * g
if t >= 0 and (t % B == 0):
ans += 1
return ans
R, G, B, N = [int(i) for i in input().split()]
print((b_rgb_boxes(R, G, B, N)))
|
def b_rgb_boxes(R, G, B, N):
"""Rr+Gg+Bb=N となる非負整数(r, g, b)の組はいくつか。"""
# dp[i]: Rr+Gg+Bb=i となる非負整数(r, g, b)の組はいくつか
dp = [0] * (N + 1)
dp[0] = 1
for c in (R, G, B):
for i in range(N + 1):
if i + c <= N:
# Rr+Gg+Bb=i を達成する組のそれぞれに対して、
# R,G,Bのどれかを足すと Rr+Gg+Bb=i+c を達成できる
dp[i + c] += dp[i]
return dp[N]
R, G, B, N = [int(i) for i in input().split()]
print((b_rgb_boxes(R, G, B, N)))
|
p03048
|
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
# import math
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
# sys.setrecursionlimit(int(pow(10, 2)))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = int(pow(10, 9) + 7)
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return list(map(int, data().split()))
def ssp(): return list(map(str, data().split()))
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
# @lru_cache(None)
r,g,b,n=l()
ans=0
r,g,b=sorted([r,g,b])[::-1]
for i in range(n//r+1):
for j in range(n//g+1):
k=n-i*r-j*g
if(k<0):
break
if(k>=0 and k%b==0):
ans+=1
print(ans)
|
r,g,b,n=list(map(int,input().split()))
ans=0
r,g,b=sorted([r,g,b])[::-1]
for i in range(n//r+1):
for j in range(n//g+1):
k=n-i*r-j*g
if(k<0):
break
if(k>=0 and k%b==0):
ans+=1
print(ans)
|
p03048
|
r, g, b, n = list(map(int, input().split()))
cnt = 0
for red in range(n // r + 1):
for green in range(n // g + 1):
blue = n - red * r - green * g
if blue >= 0 and blue % b == 0:
cnt += 1
print(cnt)
|
r, g, b, n = list(map(int, input().split()))
cnt = 0
for red in range(n // r + 1):
for green in range((n - r * red) // g + 1):
blue = n - red * r - green * g
if blue >= 0 and blue % b == 0:
cnt += 1
print(cnt)
|
p03048
|
import math
r,g,b,n=list(map(int, input().split()))
count=0
k=[]
for i in range(n+1):
for j in range(n+1):
if n-(i*g+j*r)>=0:
k.append(i*g+j*r)
else:
break
for i in range(len(k)):
if (n-k[i])%b==0:
count+=1
print(count)
|
r,g,b,n= list(map(int, input().split()))
x=n//r
y=n//g
ans=0
for i in range(x+1):
for j in range(y+1):
v=n-r*i-g*j
if v<0:
continue
else:
if v%b==0:
ans+=1
print(ans)
|
p03048
|
def main():
R, G, B, N = [int(x) for x in input().split()]
ct = 0
for r in range(N + 1):
for g in range(N + 1):
b = (N-R*r-G*g) / B
if b < 0: continue
if (b % 1) == 0:
ct += 1
print(ct)
if __name__ == "__main__":
main()
|
def main():
R, G, B, N = [int(x) for x in input().split()]
ct = 0
for r in range(N + 1):
for g in range(N + 1):
b = (N-R*r-G*g) / B
if b < 0: break
if (b % 1) == 0:
ct += 1
print(ct)
if __name__ == "__main__":
main()
|
p03048
|
# 2019/05/12
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int, input().split()))
cnt = 0
for i in range(n+1):
rcnt = r * i
if rcnt > n:
break
for j in range(n+1):
gcnt = g * j
rgcnt = rcnt + gcnt
if rgcnt > n:
break
bcnt = n - rgcnt
if bcnt % b == 0:
cnt += 1
print(cnt)
|
# 2019/05/12
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int, input().split()))
# Init
cnt = 0
# Calc
for i in range(n+1):
rcnt = r * i
if rcnt > n:
break
for j in range(n+1):
rgcnt = rcnt + g * j
if rgcnt > n:
break
bcnt = n - rgcnt
if bcnt % b == 0:
cnt += 1
# Output
print(cnt)
|
p03048
|
# 2020/07/26
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int,input().split()))
ans = 0
# Calc
for ir in range(n+1):
vr = r * ir
if vr > n:
break
for ig in range(n+1):
vg = g * ig
if vg > n:
break
cb = n - r * ir - vg
if cb >= 0 and cb % b == 0:
ans = ans + 1
# Output
print(ans)
|
# 2020/07/26
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int,input().split()))
ans = 0
# Calc
for ir in range(n+1):
vr = r * ir
if vr > n:
break
for ig in range(n+1):
vg = g * ig
if vg > n:
break
cb = n - vr - vg
if cb >= 0 and cb % b == 0:
ans = ans + 1
# Output
print(ans)
|
p03048
|
# 2020/07/26
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int,input().split()))
ans = 0
# Calc
for ir in range(n+1):
vr = r * ir
if vr > n:
break
for ig in range(n+1):
vg = g * ig
if vg > n:
break
cb = n - vr - vg
if cb >= 0 and cb % b == 0:
ans = ans + 1
# Output
print(ans)
|
# 2020/07/26
# diverta 2019 Programming Contest - B
# Input
r, g, b, n = list(map(int,input().split()))
ans = 0
# Calc
for ir in range(n+1):
vr = r * ir
if vr > n:
break
for ig in range(n+1):
vg = g * ig
if vg + vr > n:
break
cb = n - vr - vg
if cb % b == 0:
ans = ans + 1
# Output
print(ans)
|
p03048
|
r, g, b, n = list(map(int, input().split()))
counter = 0
for s in range(n+1):
for t in range(n-s+1):
u = n - r*s - g*t
if u >= 0 and u % b == 0:
counter += 1
print(counter)
|
R, G, B, N = list(map(int, input().split()))
counter = 0
r = N // R + 1
for s in range(r):
g = (N - s*R) // G + 1
for t in range(g):
u = N - R*s - G*t
if u >= 0 and u % B == 0:
counter += 1
print(counter)
|
p03048
|
r,g,b,n = list(map(int, input().split()))
cnt = 0
i=0
while r*i <= n:
j=0
while (r*i+g*j) <= n:
if ( (n-(r*i+g*j)) % b ) == 0 :
cnt += 1
j += 1
i += 1
print((str(cnt)))
|
r,g,b,n = list(map(int, input().split()))
cnt = 0
for i in range(0, n+1, r):
if i == n:
cnt += 1
continue
for j in range(0, n-i+1, g):
if ( (n-(i+j)) % b ) == 0 :
cnt += 1
print((str(cnt)))
|
p03048
|
from sys import stdin
def main():
point = 0
r,g,b,n = [int(x) for x in stdin.readline().rstrip().split()]
for i in range(n//r+1):
for j in range(n//g+1):
if n-r*i-g*j >= 0:
if (n-r*i-g*j)%b == 0:
point += 1
print(point)
if __name__ == "__main__":
main()
|
from sys import stdin
def main():
point = 0
r,g,b,n = [int(x) for x in stdin.readline().rstrip().split()]
for i in range(n//r+1):
for j in range((n-r*i)//g+1):
if n-r*i-g*j >= 0:
if (n-r*i-g*j)%b == 0:
point += 1
print(point)
if __name__ == "__main__":
main()
|
p03048
|
R, G, B, n = list(map(int, input().split()))
ans = 0
r = 0
while r*R <= n:
g = 0
while r*R + g*G <= n:
b = (n - r*R - g*G) // B
if (r*R + g*G + b*B == n) and (b >= 0):
ans += 1
g += 1
r += 1
print(ans)
|
r, g, b, n = list(map(int, input().split()))
ans = 0
for i in range(0, n+1, r):
for j in range(i, n+1, g):
if (n-j) % b == 0:
ans += 1
print(ans)
|
p03048
|
R, G, B, N = list(map(int, input().split()))
cnt = 0
for i in range(N//R+1):
for j in range(N//G+1):
b = N - R*i - G*j
if(b >= 0 and b%B == 0):
cnt += 1
print(cnt)
|
R, G, B, N = list(map(int, input().split()))
cnt = 0
for i in range(N//R+1):
for j in range(N//G+1):
b = N - R*i - G*j
if(b < 0):
break
if(b%B == 0):
cnt += 1
print(cnt)
|
p03048
|
MOD = 10 ** 9 + 7
fac = [1] * (10 ** 5 * 3)
def nCr(n, r):
return fac[n] * pow(fac[n - r], MOD - 2, MOD) * pow(fac[r], MOD - 2, MOD) % MOD
for i in range(len(fac) - 1):
fac[i + 1] = fac[i] * (i + 1) % MOD
b, w = list(map(int, input().split()))
n = b + w
p = [0] * n
q = [0] * n
for i in range(b, n):
p[i] = (p[i - 1] + nCr(i - 1, b - 1) *
pow(pow(2, i, MOD), MOD - 2, MOD)) % MOD
for i in range(w, n):
q[i] = (q[i - 1] + nCr(i - 1, w - 1) *
pow(pow(2, i, MOD), MOD - 2, MOD)) % MOD
for i in range(n):
print(((q[i] + (1 - p[i] - q[i]) * pow(2, MOD - 2, MOD)) % MOD))
|
MOD = 10 ** 9 + 7
fac = [1] * (10 ** 5 * 3)
def nCr(n, r):
return fac[n] * pow(fac[n - r], MOD - 2, MOD) * pow(fac[r], MOD - 2, MOD) % MOD
for i in range(len(fac) - 1):
fac[i + 1] = fac[i] * (i + 1) % MOD
b, w = list(map(int, input().split()))
n = b + w
p = [0] * n
q = [0] * n
for i in range(b, n):
p[i] = (p[i - 1] + nCr(i - 1, b - 1) *
pow(pow(2, i, MOD), MOD - 2, MOD)) % MOD
for i in range(w, n):
q[i] = (q[i - 1] + nCr(i - 1, w - 1) *
pow(pow(2, i, MOD), MOD - 2, MOD)) % MOD
t = pow(2, MOD - 2, MOD)
for i in range(n):
print(((q[i] + (1 - p[i] - q[i]) * t) % MOD))
|
p03083
|
B,W=list(map(int,input().split()))
mod=10**9+7
kaijo=[1]
Xdiv=[1]
two=pow(2,mod-2,mod)
for i in range(1,1+B+W):
kaijo.append((kaijo[-1])*i%mod)
Xdiv.append((Xdiv[-1]*two)%mod)
from collections import deque
gyaku=deque()
gyaku.append(pow(kaijo[B+W],mod-2,mod))
for i in range(B+W,0,-1):
gyaku.appendleft((gyaku[0]*i)%mod)
def conb(a,b):
return (kaijo[a]*gyaku[a-b]*gyaku[b])%mod
Blost,Wlost=0,0
if B==W:
for k in range(1,B):
print(two)
for k in range(B,B+W):
print((((1+Wlost-Blost)%mod*two)%mod))
Blost=(Blost+conb(k-1,B-1)*Xdiv[k])%mod
Wlost=(Wlost+conb(k-1,W-1)*Xdiv[k])%mod
print((((1+Wlost-Blost)%mod*two)%mod))
elif B<W:
for k in range(1,B):
print(two)
for k in range(B,W):
print((((1+Wlost-Blost)%mod*two)%mod))
Blost=(Blost+conb(k-1,B-1)*Xdiv[k])%mod
for k in range(W,B+W):
print((((1+Wlost-Blost)%mod*two)%mod))
Blost=(Blost+conb(k-1,B-1)*Xdiv[k])%mod
Wlost=(Wlost+conb(k-1,W-1)*Xdiv[k])%mod
print((((1+Wlost-Blost)%mod*two)%mod))
elif B>W:
for k in range(1,W):
print(two)
for k in range(W,B):
print((((1+Wlost-Blost)%mod*two)%mod))
Wlost=(Wlost+conb(k-1,W-1)*Xdiv[k])%mod
for k in range(B,B+W):
print((((1+Wlost-Blost)%mod*two)%mod))
Blost=(Blost+conb(k-1,B-1)*Xdiv[k])%mod
Wlost=(Wlost+conb(k-1,W-1)*Xdiv[k])%mod
print((((1+Wlost-Blost)%mod*two)%mod))
|
B,W=list(map(int,input().split()))
mod=10**9+7
kaijo={0:1}
Xdiv={0:1}
two=pow(2,mod-2,mod)
for i in range(1,1+B+W):
kaijo[i]=(kaijo[i-1]*i)%mod
Xdiv[i]=(Xdiv[i-1]*two)%mod
gyaku={B+W:pow(kaijo[B+W],mod-2,mod)}
for i in range(B+W,0,-1):
gyaku[i-1]=(gyaku[i]*i)%mod
def conb(a,b):
if a<b:return 0
return (kaijo[a]*gyaku[a-b]*gyaku[b])%mod
Blost,Wlost=0,0
for k in range(1,B+W):
print((((1+Wlost-Blost)*two)%mod))
Blost=(Blost+conb(k-1,B-1)*Xdiv[k])%mod
Wlost=(Wlost+conb(k-1,W-1)*Xdiv[k])%mod
print((((1+Wlost-Blost)*two)%mod))
|
p03083
|
Q = 10**9+7
def getInv(N):#Qはmod
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
return inv
B, W = list(map( int, input().split()))
Z = getInv(B+W)
I = [1]*(B+W+1)
for i in range(1,B+W+1):
I[i] = (I[i-1]*Z[i])%Q
F = [1]*(B+W+1)
for i in range(1,B+W+1):
F[i] = F[i-1]*i%Q
w = 0
b = 0
for i in range(1,B+W+1):
if i - 1 < B and i - 1 < W:
print((I[2]))
elif i - 1 == W and i - 1< B:
w = pow(I[2],i-1,Q)
print((((1 - w)%Q*I[2]%Q + w)%Q))
elif i - 1 >= W and i - 1< B: #i > B
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
print((((1 - w)%Q*I[2]%Q + w)%Q))
elif i - 1 == B and i - 1 < W:
b = pow(I[2],i-1,Q)
print(((1-b)%Q*I[2]%Q))
elif i - 1 >= B and i - 1 < W: #i > W
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print(((1-b)%Q*I[2]%Q))
elif i - 1 == B and i - 1 == W:
w = pow(I[2],i-1,Q)
b = pow(I[2],i-1,Q)
print((((1 - w - b)%Q*I[2]%Q + w)%Q))
else:
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print((((1 - w - b)%Q*I[2]%Q + w)%Q))
|
Q = 10**9+7
def getInv(N):#Qはmod
inv = [0] * (N + 1)
inv[0] = 1
inv[1] = 1
for i in range(2, N + 1):
inv[i] = (-(Q // i) * inv[Q%i]) % Q
return inv
B, W = list(map( int, input().split()))
Z = getInv(B+W)
I = [1]*(B+W+1)
for i in range(1,B+W+1):
I[i] = (I[i-1]*Z[i])%Q
F = [1]*(B+W+1)
for i in range(1,B+W+1):
F[i] = F[i-1]*i%Q
w = 0
b = 0
for i in range(1,B+W+1):
if i - 1 < B and i - 1 < W:
print((I[2]))
# elif i - 1 == W and i - 1< B:
# w = pow(I[2],i-1,Q)
# print(((1 - w)%Q*I[2]%Q + w)%Q)
elif i - 1 >= W and i - 1< B: #i > B
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
print((((1 - w)%Q*I[2]%Q + w)%Q))
# elif i - 1 == B and i - 1 < W:
# b = pow(I[2],i-1,Q)
# print((1-b)%Q*I[2]%Q)
elif i - 1 >= B and i - 1 < W: #i > W
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print(((1-b)%Q*I[2]%Q))
# elif i - 1 == B and i - 1 == W:
# w = pow(I[2],i-1,Q)
# b = pow(I[2],i-1,Q)
# print(((1 - w - b)%Q*I[2]%Q + w)%Q)
else:
w += F[i-2]*I[i-1-W]%Q*I[W-1]%Q*pow(I[2],i-1,Q)%Q
w %= Q
b += F[i-2]*I[i-1-B]%Q*I[B-1]%Q*pow(I[2],i-1,Q)%Q
b %= Q
print((((1 - w - b)%Q*I[2]%Q + w)%Q))
|
p03083
|
b, w = list(map(int, input().split()))
MOD = 10 ** 9 + 7
list_size = 200001
f_list = [1] * list_size
f_r_list = [1] * list_size
for i in range(list_size - 1):
f_list[i + 1] = int((f_list[i] * (i + 2)) % MOD)
def power(n, x):
if x == 1:
return n
elif x % 2 == 0:
return power(int((n * n) % MOD), int(x / 2))
else:
return int((n * power(n, x - 1)) % MOD)
f_r_list[-1] = power(f_list[-1], MOD - 2)
for i in range(2, list_size + 1):
f_r_list[-i] = int((f_r_list[-i + 1] * (list_size + 2 - i)) % MOD)
def comb(n, r):
if n < r:
return 0
elif n == 0 or r == 0 or n == r:
return 1
else:
return (((f_list[n - 1] * f_r_list[n - r - 1]) % MOD) * f_r_list[r - 1]) % MOD
def calc(y, x):
return (y * pow(x, MOD-2, MOD)) % MOD
ans = 500000004
print(ans)
for i in range(1, b+w):
if i-1 >= b-1:
ans -= calc(comb(i-1, b-1), pow(2, i+1))
if i-w >= 0:
ans += calc(comb(i-1, i-w), pow(2, i+1))
ans %= MOD
print(ans)
|
b, w = list(map(int, input().split()))
MOD = 10 ** 9 + 7
list_size = 200001
f_list = [1] * list_size
f_r_list = [1] * list_size
for i in range(list_size - 1):
f_list[i + 1] = int((f_list[i] * (i + 2)) % MOD)
f_r_list[-1] = pow(f_list[-1], MOD - 2, MOD)
for i in range(2, list_size + 1):
f_r_list[-i] = int((f_r_list[-i + 1] * (list_size + 2 - i)) % MOD)
def comb(n, r):
if n < r:
return 0
elif n == 0 or r == 0 or n == r:
return 1
else:
return (((f_list[n - 1] * f_r_list[n - r - 1]) % MOD) * f_r_list[r - 1]) % MOD
two_pow = [1]
for i in range(b+w+1):
two_pow.append((two_pow[-1] * 500000004) % MOD)
ans = 500000004
print(ans)
for i in range(1, b+w):
if i-1 >= b-1:
ans -= comb(i-1, b-1) * two_pow[i+1]
if i-w >= 0:
ans += comb(i-1, i-w) * two_pow[i+1]
ans %= MOD
print(ans)
|
p03083
|
import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
rev2 = pow(2, MOD-2, MOD)
p = q = 0
base = 1
ans = ["%d\n" % rev2]
for i in range(1, B+W):
base = rev2 * base % MOD
if i-B >= 0:
p = (p + ((fact[i-1]*rfact[B-1] % MOD)*rfact[i-B] % MOD)*base % MOD) % MOD
if i-W >= 0:
q = (q + ((fact[i-1]*rfact[W-1] % MOD)*rfact[i-W] % MOD)*base % MOD) % MOD
ans.append("%d\n" % ((1-p+q)*rev2 % MOD))
sys.stdout.writelines(ans)
|
import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
rev2 = pow(2, MOD-2, MOD)
p = q = 0
base = 1
ans = ["%d\n" % rev2]
for i in range(1, B+W):
base = rev2 * base % MOD
if i-B >= 0:
p = (p + (fact[i-1]*rfact[B-1]*rfact[i-B] % MOD)*base % MOD) % MOD
if i-W >= 0:
q = (q + (fact[i-1]*rfact[W-1]*rfact[i-W] % MOD)*base % MOD) % MOD
ans.append("%d\n" % ((1-p+q)*rev2 % MOD))
sys.stdout.writelines(ans)
|
p03083
|
import sys
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[i+1] = pow(r, MOD-2, MOD)
rev2 = pow(2, MOD-2, MOD)
p = q = 0
L = min(B, W)
r2 = "%d\n" % rev2
for i in range(L):
sys.stdout.write(r2)
base = pow(rev2, L-1, MOD)
rB = rfact[B-1]; rW = rfact[W-1]
for i in range(L, B+W):
base = rev2 * base % MOD
if i >= B:
p = (p + (fact[i-1]*rfact[i-B] % MOD) * (rB * base % MOD) % MOD) % MOD
if i >= W:
q = (q + (fact[i-1]*rfact[i-W] % MOD) * (rW * base % MOD) % MOD) % MOD
sys.stdout.write("%d\n" % ((1-p+q)*rev2 % MOD))
|
import sys
write = sys.stdout.write
B, W = list(map(int, sys.stdin.readline().split()))
MOD = 10**9 + 7
L = B+W
fact = [1]*(L+1)
rfact = [1]*(L+1)
for i in range(L):
fact[i+1] = r = fact[i] * (i+1) % MOD
rfact[L] = pow(fact[L], MOD-2, MOD)
for i in range(L, 0, -1):
rfact[i-1] = rfact[i] * i % MOD
rev2 = pow(2, MOD-2, MOD)
p = q = 0
L = min(B, W)
r2 = "%d\n" % rev2
for i in range(L):
write(r2)
base = pow(rev2, L-1, MOD)
rB = rfact[B-1]; rW = rfact[W-1]
for i in range(L, B+W):
base = rev2 * base % MOD
if i >= B:
p = (p + (fact[i-1]*rfact[i-B] % MOD) * (rB * base % MOD) % MOD) % MOD
if i >= W:
q = (q + (fact[i-1]*rfact[i-W] % MOD) * (rW * base % MOD) % MOD) % MOD
write("%d\n" % ((1-p+q)*rev2 % MOD))
|
p03083
|
mod=10**9+7
inv2=5*10**8+4
B,W=list(map(int,input().split()))
Factorial=[1]*(B+W+1)
for i in range(1,B+W+1):
Factorial[i]=Factorial[i-1]*(i)%mod
def power(x,y):
if y==0:
return 1
elif y==1:
return x%mod
elif y%2==0:
return power(x,y//2)**2%mod
else:
return (power(x,y//2)**2)*x%mod
inverseFactorial=[1]*(B+W+1)
inverseFactorial[B+W]=power(Factorial[B+W],mod-2)
for i in range(0,B+W)[::-1]:
inverseFactorial[i]=(inverseFactorial[i+1]*(i+1))%mod
def comb(x,y):
if x<y or y<0:
return 0
else:
return (Factorial[x]*inverseFactorial[y]*inverseFactorial[x-y])%mod
w,b=[0]*(B+W+1),[0]*(B+W+1)
for i in range(1,B+W+1):
w[i]=(w[i-1]+comb(i-1,W-1)*power(2,B+W-i))%mod
b[i]=(b[i-1]+comb(i-1,B-1)*power(2,B+W-i))%mod
ans=[0]*(B+W+1)
#print(w)
#print(b)
for i in range(1,B+W+1):
ans[i]=(power(2,B+W)+w[i-1]-b[i-1])*power(inv2,B+W+1)
print((ans[i]%mod))
|
mod=10**9+7
inv2=5*(10**8)+4
B,W=list(map(int,input().split()))
Factorial=[1]*(B+W+1)
for i in range(1,B+W+1):
Factorial[i]=Factorial[i-1]*(i)%mod
def power(x,y):
if y==0:
return 1
elif y==1:
return x%mod
elif y%2==0:
return power(x,y//2)**2%mod
else:
return (power(x,y//2)**2)*x%mod
inverseFactorial=[1]*(B+W+1)
inverseFactorial[B+W]=power(Factorial[B+W],mod-2)
for i in range(0,B+W)[::-1]:
inverseFactorial[i]=(inverseFactorial[i+1]*(i+1))%mod
def comb(x,y):
if x<y or y<0:
return 0
else:
return (Factorial[x]*inverseFactorial[y]*inverseFactorial[x-y])%mod
w,b=[0]*(B+W+1),[0]*(B+W+1)
p2=[1]*(B+W+1)
for i in range(1,B+W+1):
p2[i]=(p2[i-1]*2)%mod
bunbo=power(inv2,B+W+1)
for i in range(1,B+W+1):
w[i]=(w[i-1]+comb(i-1,W-1)*p2[B+W-i])%mod
b[i]=(b[i-1]+comb(i-1,B-1)*p2[B+W-i])%mod
ans=[0]*(B+W+1)
#print(w)
#print(b)
for i in range(1,B+W+1):
ans[i]=(p2[B+W]+w[i-1]-b[i-1])*bunbo
print((ans[i]%mod))
|
p03083
|
B, W = list(map(int, input().split()))
mod = 1000000007
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def power(x, y):
#print(x,y)
if y == 0 : return 1
elif y == 1 : return x % mod
elif y % 2 == 0 : return power(x, y/2)**2 % mod
else : return power(x, y//2)**2 * x % mod
memo={0:1,1:2}
def power2(y):
if y in memo:
pass
elif y % 2 == 0 :
memo[y] = power2(y/2)**2 % mod
else :
memo[y] = power2(y//2)**2 * 2 % mod
return memo[y]
def div(a, b):
return mul(a, power(b, mod-2))
#B-1列目
B_1 = [0]*(B) + [1]*(W)
for i in range(B, W+B-1):
#print(i)
B_1[i+1]=(B_1[i]*(i))//(i-B+1)
#print(B_1)
#print(B_1)
#B列目
B_0 = [0]*(B) + [1]*(W)
for i in range(B, W+B-1):
B_0[i+1]=B_0[i]*2 + B_1[i+1]
#print(B_0)
#W-1列目
W_1 = [0]*(W) + [1]*(B)
for i in range(W, W+B-1):
W_1[i+1]=W_1[i]*(i)//(i-W+1)
#print(W_1)
#W列目
W_0 = [0]*(W) + [1]*(B)
for i in range(W, W+B-1):
W_0[i+1]=W_0[i]*2 + W_1[i+1]
#print(W_0)
#分母
for i in range(B+W):
b = B_0[i]
w = W_0[i]
log2m = i
#print(b,w,log2m)
while not b%2 and not w%2 and log2m:
b=b//2
w=w//2
log2m-=1
p = power2((mod-2)*(log2m+1))
a = (mul(power2(log2m)-b + w,p))%mod
print(a)
|
B, W = list(map(int, input().split()))
mod = 1000000007
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
memo={0:1,1:2}
def power2(y):
if y in memo:
pass
elif y % 2 == 0 :
memo[y] = power2(y/2)**2 % mod
else :
memo[y] = power2(y//2)**2 * 2 % mod
return memo[y]
#B列目
B_0 = [0 for _ in range(B)] + [1 for _ in range(W)]
B_1 = 1
for i in range(B, W+B-1):
B_1 = (B_1*i//(i-B+1))%mod
B_0[i+1]=(B_0[i]*2 + B_1)%mod
#W列目
W_0 = [0 for _ in range(W)] + [1 for _ in range(B)]
W_1 = 1
for i in range(W, W+B-1):
W_1 = W_1 * i//(i-W+1) %mod
W_0[i+1]=(W_0[i]*2 + W_1) %mod
#print(W_0)
#分母
for i in range(B+W):
b = B_0[i]
w = W_0[i]
log2m = i
#print(b,w,log2m)
while not b%2 and not w%2 and log2m:
b=b//2
w=w//2
log2m-=1
p = power2((mod-2)*(log2m+1))
a = (mul(power2(log2m)-b + w,p))%mod
print(a)
|
p03083
|
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def POW(x, y):
if y == 0:
return 1
elif y == 1:
return x
elif y % 2 == 0:
return POW(x, y // 2) ** 2 % MOD
else:
return POW(x, y // 2) ** 2 * x % MOD
def mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
from fractions import Fraction
def binomials(n, k):
ret = [0] * (n + 1)
ret[k] = 1
for i in range(k, n):
ret[i + 1] = ret[i] * i // (i - k + 1)
return ret
def main():
B, W = LI()
N = B + W
p, q = 0, 0
biB = binomials(N, B)
biW = binomials(N, W)
cnt = 1
inv2 = mod_factorial(1, 2)
denomi = inv2
for i in range(N):
p = p * 2 + biB[i]
q = q * 2 + biW[i]
ans = (cnt - p + q) * denomi % MOD
print(ans)
cnt = (cnt * 2) % MOD
denomi = (denomi * inv2) % MOD
return 0
main()
|
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def POW(x, y):
if y == 0:
return 1
elif y == 1:
return x
elif y % 2 == 0:
return POW(x, y // 2) ** 2 % MOD
else:
return POW(x, y // 2) ** 2 * x % MOD
def mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return eval(input())
from fractions import Fraction
def binomials(n, k):
ret = [0] * (n + 1)
ret[k] = 1
for i in range(k, n):
ret[i + 1] = mod_factorial(ret[i] * i % MOD, i - k + 1)
return ret
def main():
B, W = LI()
N = B + W
p, q = 0, 0
biB = binomials(N, B)
biW = binomials(N, W)
cnt = 1
inv2 = mod_factorial(1, 2)
denomi = inv2
for i in range(N):
p = p * 2 + biB[i]
q = q * 2 + biW[i]
ans = (cnt - p + q) * denomi % MOD
print(ans)
cnt = (cnt * 2) % MOD
denomi = (denomi * inv2) % MOD
return 0
main()
|
p03083
|
MOD = 10**9+7
fact = [1]
invfact = [1]
for i in range(1,2*10**5 + 100):
fact.append((fact[i-1] * i) % MOD)
invI = pow(i,MOD-2,MOD)
invfact.append((invfact[i-1] * invI) % MOD)
B,W = list(map(int,input().split()))
N = B+W
pcSum = [1 for _ in range(B+W+1)]
qcSum = [1 for _ in range(B+W+1)]
def modComb(n,m):
if m < 0 or m > n: return(0)
ans = fact[n] * invfact[m]
ans %= MOD
ans *= invfact[n-m]
ans %= MOD
return(ans)
for i in range(B+W-1):
pcSum[i+1] = 2*pcSum[i] - modComb(i,B-1)
pcSum[i+1] %= MOD
if (i+1-W) <= B-1:
qcSum[i+1] = 2*qcSum[i] - modComb(i,B-1) - modComb(i,i+1-W)
qcSum[i+1] %= MOD
else:
qcSum[i+1] = 0
p = []
q = []
for i in range(B+W):
coefficient = pow(2,i*(MOD-2),MOD)
pvalue = pcSum[i] * coefficient
pvalue %= MOD
p.append(pvalue)
qvalue = qcSum[i] * coefficient
qvalue %= MOD
q.append(qvalue)
invTwo = pow(2,MOD-2,MOD)
for i in range(N):
answer = p[i] - invTwo * q[i]
answer %= MOD
print(answer)
|
MOD = 10**9+7
fact = [1]
invfact = [1]
for i in range(1,2*10**5 + 100):
fact.append((fact[i-1] * i) % MOD)
invI = pow(i,MOD-2,MOD)
invfact.append((invfact[i-1] * invI) % MOD)
B,W = list(map(int,input().split()))
N = B+W
pcSum = [1 for _ in range(B+W+1)]
qcSum = [1 for _ in range(B+W+1)]
def modComb(n,m):
if m < 0 or m > n: return(0)
ans = fact[n] * invfact[m]
ans %= MOD
ans *= invfact[n-m]
ans %= MOD
return(ans)
for i in range(B+W-1):
pcSum[i+1] = 2*pcSum[i] - modComb(i,B-1)
pcSum[i+1] %= MOD
if (i+1-W) <= B-1:
qcSum[i+1] = 2*qcSum[i] - modComb(i,B-1) - modComb(i,i+1-W)
qcSum[i+1] %= MOD
else:
qcSum[i+1] = 0
p = []
q = []
powOfTwo = []
value = 1
invTwo = pow(2,MOD-2,MOD)
for _ in range(N):
powOfTwo.append(value)
value *= invTwo
value %= MOD
for i in range(B+W):
# coefficient = pow(2,i*(MOD-2),MOD)
coefficient = powOfTwo[i]
pvalue = pcSum[i] * coefficient
pvalue %= MOD
p.append(pvalue)
qvalue = qcSum[i] * coefficient
qvalue %= MOD
q.append(qvalue)
for i in range(N):
answer = p[i] - invTwo * q[i]
answer %= MOD
print(answer)
|
p03083
|
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
B,W=list(map(int,input().split()))
p=[1]
for i in range(1,B+W+1) :
p.append((p[-1]*inverse[2])%mod)
BD=[0]
for i in range(1,B+W+1):
t=(BD[-1]+cmb(i-1,B-1,mod)*p[i])%mod
BD.append(t)
WD=[0]
for i in range(1,B+W+1):
t=(WD[-1]+cmb(i-1,W-1,mod)*p[i])%mod
WD.append(t)
for i in range(1,B+W+1):
ans=(1-BD[i-1]-WD[i-1])*p[1]+WD[i-1]
ans%=mod
print(ans)
|
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9+7 #出力の制限
N = 2*10**5
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
import sys
write=sys.stdout.write
B,W=list(map(int,input().split()))
p=[1]
for i in range(1,B+W+1) :
p.append((p[-1]*inverse[2])%mod)
BD=[0]
for i in range(1,B+W+1):
t=(BD[-1]+cmb(i-1,B-1,mod)*p[i])%mod
BD.append(t)
WD=[0]
for i in range(1,B+W+1):
t=(WD[-1]+cmb(i-1,W-1,mod)*p[i])%mod
WD.append(t)
for i in range(1,B+W+1):
ans=(1-BD[i-1]-WD[i-1])*p[1]+WD[i-1]
ans%=mod
write(str(ans)+"\n")
|
p03083
|
from functools import lru_cache
import sys
sys.setrecursionlimit(2*10**5)
# 入力
B, W = list(map(int, input().split()))
# ModInt定義
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
def __repr__(self):
return str(self.x)
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
__radd__ = __add__
__rsub__ = __sub__
__rmul__ = __mul__
__rtruediv__ = __truediv__
__rpow__ = __pow__
# 最初にm個あったチョコレートについて、i番目までにすべて食べきる確率と確率の計算に必要な二項係数を返す
@lru_cache(maxsize=None)
def p(i, m):
if i < m:
return ModInt(0), ModInt(0)
elif i == m:
return ModInt(1) / ModInt(pow(2, i, MOD)), ModInt(1)
else:
x, y = p(i - 1, m)
c = y * (i - 1) / (i - m)
return x + c / pow(2, i, MOD), c
# i番目の解は i-1番目までに白チョコレートが枯渇している確率 +
# i-1番目までにどちらのチョコレートも枯渇しない確率 / 2
ans = '\n'.join(
str((1 + p(i - 1, W)[0] - p(i - 1, B)[0]) / 2)
for i in range(1, B + W + 1)
)
# 出力
print(ans)
|
# 入力
B, W = list(map(int, input().split()))
# ModInt定義
MOD = 10**9 + 7
class ModInt:
def __init__(self, x):
self.x = x % MOD
def __str__(self):
return str(self.x)
def __repr__(self):
return str(self.x)
def __add__(self, other):
return (
ModInt(self.x + other.x) if isinstance(other, ModInt) else
ModInt(self.x + other)
)
def __sub__(self, other):
return (
ModInt(self.x - other.x) if isinstance(other, ModInt) else
ModInt(self.x - other)
)
def __mul__(self, other):
return (
ModInt(self.x * other.x) if isinstance(other, ModInt) else
ModInt(self.x * other)
)
def __truediv__(self, other):
return (
ModInt(
self.x * pow(other.x, MOD - 2, MOD)
) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
def __pow__(self, other):
return (
ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
ModInt(self.x * pow(other, MOD - 2, MOD))
)
__radd__ = __add__
__rsub__ = __sub__
__rmul__ = __mul__
__rtruediv__ = __truediv__
__rpow__ = __pow__
p = ModInt(0)
q = ModInt(0)
cp = ModInt(0)
cq = ModInt(0)
for i in range(1, B + W + 1):
# i番目の解は i-1番目までに白チョコレートが枯渇している確率 +
# i-1番目までにどちらのチョコレートも枯渇しない確率 / 2
ans = (1 + q - p) / 2
# 出力
print(ans)
cp = (
ModInt(0) if i < B else
ModInt(1) if i == B else
cp * (i - 1) / (i - B)
)
p = (
ModInt(0) if i < B else
ModInt(1) / ModInt(2**i) if i == B else
p + cp / pow(2, i, MOD)
)
cq = (
ModInt(0) if i < W else
ModInt(1) if i == W else
cq * (i - 1) / (i - W)
)
q = (
ModInt(0) if i < W else
ModInt(1) / ModInt(2**i) if i == W else
q + cq / pow(2, i, MOD)
)
|
p03083
|
B,W = list(map(int, input().split()))
N = B+W
factorial = [1]
for i in range(N+1):
factorial.append( factorial[-1] * (i+1))
# print(factorial)
mod = 10**9+7
de_factorial = [0] * (N+1)
de_factorial[N] = pow( factorial[N] , mod-2, mod )
for i in range( N, 0, -1):
de_factorial[i-1] = de_factorial[i] * i % mod
def comb(n,r):
if n < r: return 0
if n == r: return 1
return (factorial[n] * de_factorial[r] * de_factorial[n-r]) % mod
p = [0] * (N+1) # Bを食べきった確率
q = [0] * (N+1) # Wを食べきった確率
de2 = de_factorial[2]
for i in range(1, N+1):
p[i] = p[i-1] + comb(i-1 ,B-1) * de2 % mod
q[i] = q[i-1] + comb(i-1 ,W-1) * de2 % mod
de2 = de2 * de_factorial[2] % mod
tmp = ( q[i-1] + 1-p[i-1] ) * de_factorial[2] % mod
print(tmp)
|
B,W = list(map(int, input().split()))
N = B+W
mod = 10**9+7
factorial = [1]
for i in range(N+1):
factorial.append( factorial[-1] * (i+1) % mod)
# print(factorial)
de_factorial = [0] * (N+1)
de_factorial[N] = pow( factorial[N] , mod-2, mod )
for i in range( N, 0, -1):
de_factorial[i-1] = de_factorial[i] * i % mod
def comb(n,r):
if n < r: return 0
if n == r: return 1
return (factorial[n] * de_factorial[r] * de_factorial[n-r]) % mod
p = [0] * (N+1) # Bを食べきった確率
q = [0] * (N+1) # Wを食べきった確率
de2 = de_factorial[2]
for i in range(1, N+1):
p[i] = p[i-1] + comb(i-1 ,B-1) * de2 % mod
q[i] = q[i-1] + comb(i-1 ,W-1) * de2 % mod
de2 = de2 * de_factorial[2] % mod
tmp = ( q[i-1] + 1-p[i-1] ) * de_factorial[2] % mod
print(tmp)
|
p03083
|
B, W = list(map(int,input().split()))
Mod = 10**9+7
magick = 500000004
inv_t = [0]+[1]
for i in range(2,B+W+1):
inv_t += [inv_t[Mod % i] * (Mod - int(Mod / i)) % Mod]
consts_B, consts_W = [0]*(B-1)+ [1], [0]*(W-1)+[1]
for i in range(B+W):
if i >= B: consts_B += [consts_B[-1]*(i)*inv_t[i-B+1]%Mod]
if i >= W: consts_W += [consts_W[-1]*(i)*inv_t[i-W+1]%Mod]
p, q = 0, 0
inv = 1
for i in range(B+W):
print(((1-p+q)*magick%Mod))
inv *= magick%Mod
p += consts_B[i]*inv
q += consts_W[i]*inv
|
B, W = list(map(int,input().split()))
Mod = 10**9+7
magick = 500000004
inv_t = [0]+[1]
inv_2 = [0]+[magick]
for i in range(2,B+W+1):
inv_t += [inv_t[Mod % i] * (Mod - int(Mod / i)) % Mod]
inv_2 += [inv_2[-1]*magick % Mod]
consts_B, consts_W = [0]*(B-1)+ [1], [0]*(W-1)+[1]
for i in range(B+W):
if i >= B: consts_B += [consts_B[-1]*(i)*inv_t[i-B+1]%Mod]
if i >= W: consts_W += [consts_W[-1]*(i)*inv_t[i-W+1]%Mod]
p, q = 0, 0
for i in range(B+W):
print(((1-p+q)*magick%Mod))
p += consts_B[i]*inv_2[i+1]
q += consts_W[i]*inv_2[i+1]
|
p03083
|
from fractions import Fraction
B, W = list(map(int, input().split()))
def ExtendedEuclidianAlgorithms(a, b):
"""
返り値: 自然数a, bの最小公倍数d, ax+by=gcd(a, b)を満たす(x, y)が、
(d, x, y)のtuple
d = 1ならxはaの逆元(inverse element)
"""
d, c1 = a, b
x0, x1 = 1, 0
y0, y1 = 0, 1
while c1 != 0:
m = d % c1
q = d // c1
d, c1 = c1, m
x0, x1 = x1, (x0 - q * x1)
y0, y1 = y1, (y0 - q * y1)
return d, x0, y0
def makeTable(N):
table = [1]
for i in range(1, N+1):
table.append(table[-1]*i)
return table
def binomialCoefficient(N, r, MOD=1):
if MOD == 1:
return int(table[N] / (table[N - r] * table[r]))
else:
return int(table[N] / (table[N - r] * table[r])) % MOD
table = makeTable(B+W)
mod = 10 ** 9 + 7
P = [Fraction(0, 1)]
Q = [Fraction(0, 1)]
def unknown(x, y, mod=10**9+7):
g, a, b = ExtendedEuclidianAlgorithms(x, mod)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return a*y % mod
for i in range(B + W):
if i == 0:
print((500000004))
continue
p = Fraction(P[-1]) + Fraction(binomialCoefficient(i - 1, B - 1, mod), 2 ** i)
q = Fraction(Q[-1]) + Fraction(binomialCoefficient(i - 1, W - 1, mod), 2 ** i)
P.append(p)
Q.append(q)
ans = Fraction((1 - Fraction(P[-1]) + Fraction(Q[-1])), 2)
bunshi, bunbo = ans.numerator, ans.denominator
ans = unknown(bunbo, bunshi)
print(ans)
|
from fractions import Fraction
B, W = list(map(int, input().split()))
def ExtendedEuclidianAlgorithms(a, b):
"""
返り値: 自然数a, bの最小公倍数d, ax+by=gcd(a, b)を満たす(x, y)が、
(d, x, y)のtuple
d = 1ならxはaの逆元(inverse element)
"""
d, c1 = a, b
x0, x1 = 1, 0
y0, y1 = 0, 1
while c1 != 0:
m = d % c1
q = d // c1
d, c1 = c1, m
x0, x1 = x1, (x0 - q * x1)
y0, y1 = y1, (y0 - q * y1)
return d, x0, y0
def makeTableMod(N, mod=10**9+7):
table = [1]
for i in range(1, N+1):
table.append((table[-1]*i)%mod)
return table
def binomialCoefficient(N, r, MOD=1):
if MOD == 1:
return int(table[N] / (table[N - r] * table[r]))
else:
return int(table[N] / (table[N - r] * table[r])) % MOD
table = makeTableMod(B+W)
mod = 10 ** 9 + 7
P = [Fraction(0, 1)]
Q = [Fraction(0, 1)]
def unknown(x, y, mod=10**9+7):
g, a, b = ExtendedEuclidianAlgorithms(x, mod)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return a*y % mod
for i in range(B + W):
if i == 0:
print((500000004))
continue
p = Fraction(P[-1]) + Fraction(binomialCoefficient(i - 1, B - 1, mod), 2 ** i)
q = Fraction(Q[-1]) + Fraction(binomialCoefficient(i - 1, W - 1, mod), 2 ** i)
P.append(p)
Q.append(q)
ans = Fraction((1 - Fraction(P[-1]) + Fraction(Q[-1])), 2)
bunshi, bunbo = ans.numerator, ans.denominator
ans = unknown(bunbo, bunshi)
print(ans)
|
p03083
|
b,w=list(map(int,input().split()))
dp=[0]*(b+w)
dp[0]=1/2
mod=pow(10,9)+7
def cmb(n,r,mod):
if (r<0 or r>n):
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
g1=[1,1] # g1[i]=i! % mod :階乗
g2=[1,1] # g2[i]=(i!)^(-1) % mod :階乗の逆元
inverse=[0,1]
for i in range(2,b+w+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
t1,t2=0,0
for i in range(1,1+b+w):
t=pow(2,mod-2,mod)
if i-b>0:
t1*=2
t1+=cmb(i-2,b-1,mod)
tmp=t1*pow(2,mod-1-i,mod)
tmp%=mod
t-=tmp
t%=mod
if i-w>0:
t2*=2
t2+=cmb(i-2,w-1,mod)
tmp=t2*pow(2,mod-1-i,mod)
tmp%=mod
t+=tmp
t%=mod
print(t)
|
b,w=list(map(int,input().split()))
dp=[0]*(b+w)
dp[0]=1/2
mod=pow(10,9)+7
def cmb(n,r,mod):
if (r<0 or r>n):
return 0
r=min(r,n-r)
return g1[n]*g2[r]*g2[n-r]%mod
g1=[1,1] # g1[i]=i! % mod :階乗
g2=[1,1] # g2[i]=(i!)^(-1) % mod :階乗の逆元
inverse=[0,1]
for i in range(2,b+w+1):
g1.append((g1[-1]*i)%mod)
inverse.append((-inverse[mod%i]*(mod//i))%mod)
g2.append((g2[-1]*inverse[-1])%mod)
t1,t2=0,0
for i in range(1,1+b+w):
t=pow(2,mod-2,mod)
if i-b>0:
t1*=2
t1%=mod
t1+=cmb(i-2,b-1,mod)
t1%=mod
tmp=t1*pow(2,mod-1-i,mod)
tmp%=mod
t-=tmp
t%=mod
if i-w>0:
t2*=2
t2%=mod
t2+=cmb(i-2,w-1,mod)
t2%=mod
tmp=t2*pow(2,mod-1-i,mod)
tmp%=mod
t+=tmp
t%=mod
print(t)
|
p03083
|
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
two = [1]*(U+1)
two_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
two[i] = (two[i-1]*2)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
two_inv[U] = pow(two[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
two_inv[i-1] = (two_inv[i]*2)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
B, W = list(map(int, input().split()))
p = 0
q = 0
for i in range(1, B+W+1):
ans = 1 - p + q
ans %= MOD
ans *= two_inv[1]
ans %= MOD
print(ans)
p += comb(i-1, B-1) * two_inv[i] % MOD
p %= MOD
q += comb(i-1, W-1) * two_inv[i] % MOD
q %= MOD
|
def main():
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
two = [1]*(U+1)
two_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
two[i] = (two[i-1]*2)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
two_inv[U] = pow(two[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
two_inv[i-1] = (two_inv[i]*2)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
B, W = list(map(int, input().split()))
p = 0
q = 0
for i in range(1, B+W+1):
ans = 1 - p + q
ans %= MOD
ans *= two_inv[1]
ans %= MOD
print(ans)
p += comb(i-1, B-1) * two_inv[i] % MOD
p %= MOD
q += comb(i-1, W-1) * two_inv[i] % MOD
q %= MOD
if __name__ == "__main__":
main()
|
p03083
|
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
two = [1]*(U+1)
two_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
two[i] = (two[i-1]*2)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
two_inv[U] = pow(two[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
two_inv[i-1] = (two_inv[i]*2)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
B, W = list(map(int, input().split()))
p = 0
q = 0
for i in range(1, B+W+1):
ans = 1 - p + q
ans %= MOD
ans *= two_inv[1]
ans %= MOD
print(ans)
p += comb(i-1, B-1) * two_inv[i] % MOD
p %= MOD
q += comb(i-1, W-1) * two_inv[i] % MOD
q %= MOD
|
def main():
U = 2*10**5
MOD = 10**9+7
fact = [1]*(U+1)
fact_inv = [1]*(U+1)
two = [1]*(U+1)
two_inv = [1]*(U+1)
for i in range(1,U+1):
fact[i] = (fact[i-1]*i)%MOD
two[i] = (two[i-1]*2)%MOD
fact_inv[U] = pow(fact[U], MOD-2, MOD)
two_inv[U] = pow(two[U], MOD-2, MOD)
for i in range(U,0,-1):
fact_inv[i-1] = (fact_inv[i]*i)%MOD
two_inv[i-1] = (two_inv[i]*2)%MOD
def comb(n, k):
if k < 0 or k > n:
return 0
z = fact[n]
z *= fact_inv[k]
z %= MOD
z *= fact_inv[n-k]
z %= MOD
return z
B, W = list(map(int, input().split()))
p = 0
q = 0
for i in range(1, B+W+1):
ans = 1 - p + q
ans %= MOD
ans *= two_inv[1]
ans %= MOD
print(ans)
p += comb(i-1, B-1) * two_inv[i] % MOD
p %= MOD
q += comb(i-1, W-1) * two_inv[i] % MOD
q %= MOD
if __name__ == "__main__":
main()
|
p03083
|
B, W = list(map(int, input().split()))
MOD = 10**9+7
facts = [1,1]
invs = [1,1]
invfacts = [1,1]
for ind in range(1, B+W):
i = ind+1
facts += [ facts[-1]*i % MOD ]
invs += [ -(MOD//i)*invs[MOD%i] % MOD ]
invfacts += [ invfacts[-1]*invs[i] % MOD ]
y_pi = 0 #i回目までにBを食べ尽くした確率piの分子
y_qi = 0 #i回目までにWを食べ尽くした確率qiの分子
pow2 = 1
inv2i = 1
for i in range(B+W):
y_pi = 0 if i < B else 2*y_pi + ((facts[i-1]*invfacts[i-B] % MOD)*invfacts[B-1] % MOD)
y_qi = 0 if i < W else 2*y_qi + ((facts[i-1]*invfacts[i-W] % MOD)*invfacts[W-1] % MOD)
invxi = inv2i * invs[2] % MOD
yi = (pow2-y_pi+y_qi) % MOD
z = yi*invxi % MOD
print(z)
pow2 = pow2*2 %MOD
inv2i = invxi
|
B, W = list(map(int, input().split()))
MOD = 10**9+7
facts = [1,1] #階乗
invs = [1,1] #整数の逆元
invfacts = [1,1] #階乗の逆元
for ind in range(1, B+W):
i = ind+1
facts.append(facts[-1]*i % MOD)
invs.append( -(MOD//i)*invs[MOD%i] % MOD )
invfacts.append( invfacts[-1]*invs[i] % MOD )
def Comb(n, r, MOD=MOD):
if n < r:
return 0
return facts[n]*invfacts[n-r]*invfacts[r] % MOD
y_pi = 0 #i回目までにBを食べ尽くした確率piの分子
y_qi = 0 #i回目までにWを食べ尽くした確率qiの分子
pow2 = 1
invxi = 1
inv2 = invs[2]
for i in range(B+W):
#y_pi = 0 if i < B else 2*y_pi + ((facts[i-1]*invfacts[i-B] % MOD)*invfacts[B-1] % MOD)
y_pi = (2*y_pi + Comb(i-1, B-1))%MOD
#y_qi = 0 if i < W else 2*y_qi + ((facts[i-1]*invfacts[i-W] % MOD)*invfacts[W-1] % MOD)
y_qi = (2*y_qi + Comb(i-1, W-1))%MOD
invxi = invxi * inv2 % MOD
yi = (pow2-y_pi+y_qi) % MOD
z = yi*invxi % MOD
print(z)
pow2 = pow2*2 %MOD
|
p03083
|
from collections import Counter
from itertools import product
N, W = list(map(int, input().split()))
items = {}
weight = []
for i in range(N):
w, v = list(map(int, input().split()))
weight.append(w)
if items.get(w, None) is None:
items[w] = []
items[w].append(v)
items[w] = sorted(items[w], reverse = True)
cnt = Counter(weight)
w_num = [] #各重さの個数。組み合わせのために使う。[range(0,2), range(0,3), range(0,2)]のような出力
w_set = [] # 重さは w0 <= wi <= w0+3の４通りしかない
for w in range(weight[0], weight[0] + 4):
if cnt[w] == 0:
continue
w_num.append(list(range(cnt[w] + 1)))
w_set.append(w)
ans = 0
for i in product(*w_num):
w = sum([x[0] * x[1] for x in zip(i, w_set)])
if 1 > w or w > W:
continue
v = sum([sum(items[k][:j]) for j, k in zip(i, w_set)])
if ans < v:
ans = v
print(ans)
|
N, W = list(map(int, input().split()))
w, v = [], []
for _ in range(N):
a, b = list(map(int, input().split()))
w.append(a)
v.append(b)
memo = {}
def nap(i, j):
if i == N:
return 0
if (i, j) in memo:
return memo[i, j]
elif j < w[i]:
temp = nap(i+1, j)
else:
temp = max(nap(i+1, j), nap(i+1, j-w[i]) + v[i])
memo[i,j] = temp
return memo[i,j]
print((nap(0, W)))
|
p03732
|
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
N,W = list(map(int,input().split()))
w = [0 for i in range(N)]
v = [0 for i in range(N)]
for i in range(N):
w[i],v[i] = list(map(int,input().split()))
dp = [[0 for i in range(W+1)] for j in range(N)]
for i in range(N):
if N < w[i]:
pass
else:
dp[i][w[i]] = v[i]
for j in range(W+1):
if i-1 >= 0:
dp[i][j] = max(dp[i][j],dp[i-1][j])
if j-w[i] >= 0:
dp[i][j] = max(dp[i][j],dp[i-1][j-w[i]]+v[i])
print((max(dp[-1])))
|
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
mod = 10**9+7
N,W = list(map(int,input().split()))
w = [0 for i in range(N)]
v = [0 for i in range(N)]
for i in range(N):
w[i],v[i] = list(map(int,input().split()))
w_sum = [0 for i in range(N+1)]
v_sum = [0 for i in range(N+1)]
w.insert(0,0)
v.insert(0,0)
for i in range(N):
w_sum[i+1] = w_sum[i]+w[i+1]
v_sum[i+1] = v_sum[i]+v[i+1]
nap_memo = {}
def nap(i,W2):#i:count_pieces,W2:rest_weight
key = str(i)+":"+str(W2)
if key in nap_memo:
return nap_memo[key]
elif i == 0:#品物０個の時は価値０
r = 0
elif W2 < w[0]:
r = 0
elif W2 < w[i]:#i番目の荷物が残量を超えるなら入らない
r = nap(i-1,W2)
elif w_sum[i] <= W2:
r = v_sum[i]
else:
r = max(nap(i-1,W2-w[i])+v[i], nap(i-1,W2))
nap_memo[key] = r
return r
print((nap(N,W)))
#
# dp = [[[0 for i in range(W+1)] for j in range(N)]
#
#
# for i in range(N):
# if N < w[i]:
# pass
# else:
# dp[i][w[i]] = v[i]
# for j in range(W+1):
# if i-1 >= 0:
# dp[i][j] = max(dp[i][j],dp[i-1][j])
# if j-w[i] >= 0:
# dp[i][j] = max(dp[i][j],dp[i-1][j-w[i]]+v[i])
#
# print(max(dp[-1]))
|
p03732
|
import sys
input = sys.stdin.readline
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def func(N, mod):
F = [1]
for i in range(1, N + 1):
F.append(F[-1] * i % mod)
return F
INV = {}
def inv(a, mod):
if a in INV:
return INV[a]
r = pow(a, mod - 2, mod)
INV[a] = r
return r
def C(F, a, b, mod):
return F[a] * inv(F[b], mod) * inv(F[a - b], mod) % mod
def main():
N, W = read_values()
dp = [
[[0 for _ in range(N * 3 + 10)] for __ in range(N + 10)]
for ___ in range(N + 10)
]
I = [tuple(read_values()) for _ in range(N)]
w0 = I[0][0]
if w0 > W:
print((0))
return
for i, (w1, v) in enumerate(I):
w = w1 - w0
for k in range(N):
for j in range(N * 3 + 5):
dp[i + 1][k][j] = max(dp[i][k][j], dp[i + 1][k][j])
dp[i + 1][k + 1][j + w] = max(dp[i][k][j] + v, dp[i + 1][k + 1][j + w])
res = 0
for k in range(N + 1):
r = min(W - k * w0, 3 * N + 5)
if r < 0:
continue
for i in range(r + 1):
res = max(res, dp[N][k][i])
print(res)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.readline
def read_values():
return list(map(int, input().split()))
def read_list():
return list(read_values())
def func(N, mod):
F = [1]
for i in range(1, N + 1):
F.append(F[-1] * i % mod)
return F
INV = {}
def inv(a, mod):
if a in INV:
return INV[a]
r = pow(a, mod - 2, mod)
INV[a] = r
return r
def C(F, a, b, mod):
return F[a] * inv(F[b], mod) * inv(F[a - b], mod) % mod
def main():
import bisect
N, W = read_values()
I = [tuple(read_values()) for _ in range(N)]
init_w = I[0][0]
D = {i: [] for i in range(4)}
S = {i: [0] for i in range(4)}
for w, v in I:
bisect.insort(D[w - init_w], -v)
for i, d in list(D.items()):
for v in d:
S[i].append(v + S[i][-1])
res = 0
for t0 in range(len(D[0]) + 1):
for t1 in range(len(D[1]) + 1):
for t2 in range(len(D[2]) + 1):
for t3 in range(len(D[3]) + 1):
if (t0 + t1 + t2 + t3) * init_w + t1 + 2 * t2 + 3 * t3 > W:
continue
res = min(res, S[0][t0] + S[1][t1] + S[2][t2] + S[3][t3])
print((-res))
if __name__ == "__main__":
main()
|
p03732
|
N, W = list(map(int, input().split()))
w, v = [], []
for _ in range(N):
x, y = list(map(int, input().split()))
w.append(x)
v.append(y)
from collections import defaultdict
dp = defaultdict(lambda: 0)
dp[0,0] = 0
for i in range(N):
for weight in range(W+1):
if weight >= w[i]:
dp[i+1,weight] = max(dp[i,weight], dp[i,weight-w[i]]+v[i])
else:
dp[i+1,weight] = dp[i,weight]
print((dp[N,W]))
|
N, W = list(map(int, input().split()))
Items = [tuple(map(int, input().split())) for _ in range(N)]
from collections import defaultdict as dd
Bag = dd(lambda:0)
Bag[0] = 0
for w,v in Items:
temp = [(key+w,Bag[key]+v) for key in Bag if key + w <= W]
for key,value in temp:
Bag[key] = max(Bag[key],value)
ans = max(Bag.values())
print(ans)
|
p03732
|
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for i in range(N)]
v = [[] for i in range(4)]
standard = wv[0][0]
for wi, vi in wv:
plus = wi - standard
v[plus].append(vi)
for i in range(4):
v[i].sort(reverse=True)
for j in range(len(v[i])-1):
v[i][j+1] = v[i][j] + v[i][j+1]
v[i].insert(0, 0)
ans = 0
for a in range(len(v[0])):
for b in range(len(v[1])):
for c in range(len(v[2])):
for d in range(len(v[3])):
if standard*a + (standard+1)*b + (standard+2)*c + (standard+3)*d > W:
continue
else:
ans = max(ans, v[0][a]+v[1][b]+v[2][c]+v[3][d])
print(ans)
|
from itertools import accumulate
N, W = list(map(int, input().split()))
w0, w1, w2, w3 = [], [], [], []
base_w = -1
for i in range(N):
w, v = list(map(int, input().split()))
if base_w < 0:
base_w = w
# 重みごとの箱にいれる
w -= base_w
if w == 0:
w0.append(v)
elif w == 1:
w1.append(v)
elif w == 2:
w2.append(v)
else:
w3.append(v)
# 降順ソート
w0.sort(reverse=True)
w1.sort(reverse=True)
w2.sort(reverse=True)
w3.sort(reverse=True)
# 累積和
w0 = [0] + list(accumulate(w0))
w1 = [0] + list(accumulate(w1))
w2 = [0] + list(accumulate(w2))
w3 = [0] + list(accumulate(w3))
ans = 0
for i0 in range(len(w0)):
for i1 in range(len(w1)):
for i2 in range(len(w2)):
for i3 in range(len(w3)):
if base_w * i0 + (base_w + 1) * i1 + (base_w + 2) * i2 + (base_w + 3) * i3 > W:
continue
ans = max(ans, w0[i0] + w1[i1] + w2[i2] + w3[i3])
print(ans)
|
p03732
|
# ABC060D - Simple Knapsack (ARC073D)
# exhaustive search
from itertools import accumulate
def main():
N, W, *A = list(map(int, open(0).read().split()))
V, x = [[] for _ in range(4)], A[0] # x: w1 (W1 ≤ wi ≤ w1 + 3)
for i in range(0, 2 * N, 2): # group by weight
w, v = A[i : i + 2]
V[w - x] += [v]
for i in range(4): # V[i][j] := max value of picking up j items from group i
V[i] = tuple(accumulate([0] + sorted(V[i], reverse=1)))
L = [len(v) for v in V]
ans = 0
for i in range(L[0]):
for j in range(L[1]):
for k in range(L[2]):
w = i * x + j * (x + 1) + k * (x + 2)
if w > W:
break
l = min(L[3] - 1, (W - w) // (x + 3))
v = V[0][i] + V[1][j] + V[2][k] + V[3][l]
ans = max(ans, v)
print(ans)
if __name__ == "__main__":
main()
|
# ABC060D - Simple Knapsack (ARC073D)
from itertools import accumulate as acc
def main():
N, W, *A = list(map(int, open(0).read().split()))
V, x = [[] for _ in range(4)], A[0] # x: w1 (W1 ≤ wi ≤ w1 + 3)
for w, v in zip(*[iter(A)] * 2): # group by weight
V[w - x].append(v)
for i in range(4): # V[i][j] := max value of picking up j items from group i
V[i] = tuple(acc([0] + sorted(V[i], reverse=1)))
L = [len(v) for v in V]
ans = 0
for i in range(L[0]):
for j in range(L[1]):
for k in range(L[2]):
w = i * x + j * (x + 1) + k * (x + 2)
if w > W:
break
l = min(L[3] - 1, (W - w) // (x + 3))
v = V[0][i] + V[1][j] + V[2][k] + V[3][l]
ans = max(ans, v)
print(ans)
if __name__ == "__main__":
main()
|
p03732
|
def resolve():
N, W = list(map(int, input().split()))
WV = [[0, 0]]+[list(map(int, input().split())) for _ in range(N)]
dp = [[0 for _ in range(W+1)] for ___ in range(N+1)]
for i in range(1, N+1):
for j in range(W+1):
w, v = WV[i]
if j >= w:
dp[i][j] = max(dp[i-1][j-w] + v, dp[i-1][j])
else:
dp[i][j] = dp[i-1][j]
print((dp[N][W]))
if __name__ == '__main__':
resolve()
|
def resolve():
N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
wbase = WV[0][0]
d = {
wbase: [0],
wbase+1: [0],
wbase+2: [0],
wbase+3: [0],
}
for w, v in WV:
d[w].append(v)
for v in list(d.values()):
v.sort(reverse=True)
accs = {}
for i in range(4):
accs[wbase+i] = [0]
for j in range(len(d[wbase+i])):
accs[wbase+i].append(accs[wbase+i][j]+d[wbase+i][j])
res = 0
for i in range(len(d[wbase])):
for j in range(len(d[wbase+1])):
for k in range(len(d[wbase+2])):
for l in range(len(d[wbase+3])):
if i*wbase+j*(wbase+1)+k*(wbase+2)+l*(wbase+3) <= W:
res = max(res, accs[wbase][i]+accs[wbase+1][j]+accs[wbase+2][k]+accs[wbase+3][l])
print(res)
if __name__ == '__main__':
resolve()
|
p03732
|
import sys
def input(): return sys.stdin.readline().strip()
offset = 10**10
def main():
N, W = list(map(int, input().split()))
w0, v0 = list(map(int, input().split()))
item = [0, w0 * offset + v0]
weight_sum, value_sum = w0, v0
for _ in range(1, N):
w, v = list(map(int, input().split()))
item.append(w * offset + v)
weight_sum += w
value_sum += v
if W < w0:
print((0))
return
if weight_sum <= W:
print(value_sum)
return
if w0 <= 3 * (N - 1):
# dp[i][j] = (1~i番目の荷物を重さj以下で詰めたときの最大価値)
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
w, v = item[i] // offset, item[i] % offset
for j in range(w): dp[i][j] = dp[i - 1][j]
for j in range(w, W + 1):
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
print((dp[N][W]))
return
# dp[i][j][k] = (1~i番目までのものを見たとき、重さが(j * w0 + k)以下で最大価値がいくらか)
dp = [[[0] * (3 * (N - 1) + 1) for _ in range(N + 1)] for _ in range(N + 1)]
for i in range(1, N + 1):
w, v = item[i] // offset, item[i] % offset
for j in range(i + 1):
for k in range(3 * (N - 1) + 1):
weight = j * w0 + k
q, r = (weight - w) // w0, (weight - w) % w0
if weight < w:
dp[i][j][k] = dp[i - 1][j][k]
elif (weight - w) % w0 > 3 * (N - 1):
dp[i][j][k] = max(dp[i - 1][j][k], dp[i - 1][q][3 * (N - 1)] + v)
else:
dp[i][j][k] = max(dp[i - 1][j][k], dp[i - 1][q][r] + v)
q, r = W // w0, min(W % w0, 3 * (N - 1))
print((dp[N][q][r]))
if __name__ == "__main__":
main()
|
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
offset = 10**10
def main():
"""
ナップサックで重さを飛び飛びにしてdpを軽くしなくても、
そもそも重さが４パターンだから全探索で解けたのか。。。。。。
"""
N, W = list(map(int, input().split()))
item = [[] for _ in range(4)]
length = [1, 0, 0, 0]
w0, v0 = list(map(int, input().split()))
item[0].append(v0)
for _ in range(N - 1):
w, v = list(map(int, input().split()))
item[w - w0].append(v)
length[w - w0] += 1
for i in range(4): item[i].sort(reverse=True)
# 重さの累積和
S = []
for i in range(4):
S.append([0] + list(accumulate(item[i])))
ans = 0
for a in range(length[0] + 1):
for b in range(length[1] + 1):
for c in range(length[2] + 1):
for d in range(length[3] + 1):
weight = a * w0 + b * (w0 + 1) + c * (w0 + 2) + d * (w0 + 3)
if weight > W: continue
ans = max(ans, S[0][a] + S[1][b] + S[2][c] + S[3][d])
print(ans)
if __name__ == "__main__":
main()
|
p03732
|
def main():
N, W = list(map(int, input().split()))
w1 = [0, 0]
w2 = [0, 0]
w3 = [0, 0]
w4 = [0, 0]
v1 = []
v2 = []
v3 = []
v4 = []
i = 0
while i < N:
w, v = list(map(int, input().split()))
if i == 0 or w == w1[0]:
w1[0] = w
w1[1] += 1
v1.append(v)
elif w == w1[0] + 1:
w2[0] = w
w2[1] += 1
v2.append(v)
elif w == w1[0] + 2:
w3[0] = w
w3[1] += 1
v3.append(v)
elif w == w1[0] + 3:
w4[0] = w
w4[1] += 1
v4.append(v)
i += 1
v1.sort(reverse=True)
v2.sort(reverse=True)
v3.sort(reverse=True)
v4.sort(reverse=True)
ans = []
for i in range(w1[1] + 1):
for j in range(w2[1] + 1):
for k in range(w3[1] + 1):
for l in range(w4[1] + 1):
w = w1[0] * i + w2[0] * j + w3[0] * k + w4[0] * l
v = sum(v1[:i] + v2[:j] + v3[:k] + v4[:l])
if w <= W:
ans.append(v)
print((max(ans)))
main()
|
def main():
N, W = list(map(int, input().split()))
w1 = [0, 0]
w2 = [0, 0]
w3 = [0, 0]
w4 = [0, 0]
v1 = []
v2 = []
v3 = []
v4 = []
i = 0
while i < N:
w, v = list(map(int, input().split()))
if i == 0 or w == w1[0]:
w1[0] = w
w1[1] += 1
v1.append(v)
elif w == w1[0] + 1:
w2[0] = w
w2[1] += 1
v2.append(v)
elif w == w1[0] + 2:
w3[0] = w
w3[1] += 1
v3.append(v)
elif w == w1[0] + 3:
w4[0] = w
w4[1] += 1
v4.append(v)
i += 1
v1.sort(reverse=True)
v2.sort(reverse=True)
v3.sort(reverse=True)
v4.sort(reverse=True)
ans = []
for i in range(w1[1] + 1):
for j in range(w2[1] + 1):
for k in range(w3[1] + 1):
for l in range(w4[1] + 1):
w = w1[0] * i + w2[0] * j + w3[0] * k + w4[0] * l
if w <= W:
v = sum(v1[:i] + v2[:j] + v3[:k] + v4[:l])
ans.append(v)
print((max(ans)))
main()
|
p03732
|
#060_D
n, w_ = list(map(int, input().split()))
w, v = [], []
for _ in range(n):
a, b = list(map(int, input().split()))
w.append(a)
v.append(b)
dp = [[0 for _ in range(w_+1)] for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, w_+1):
if j < w[i-1]:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1])
print((dp[n][w_]))
|
#060_D
n, W = list(map(int, input().split()))
w1, w2, w3, w4 = [], [], [], []
w, v = list(map(int, input().split()))
w1.append(v)
for _ in range(n-1):
a, b = list(map(int, input().split()))
if a == w: w1.append(b)
if a == w+1: w2.append(b)
if a == w+2: w3.append(b)
if a == w+3: w4.append(b)
for w_ in [w1, w2, w3, w4]:
w_.sort(reverse= True)
ans = 0
for i in range(0, len(w1)+1):
for j in range(0, len(w2)+1):
for k in range(0, len(w3)+1):
res = W - (i * w + j * (w+1) + k * (w+2))
if res < 0:
continue
tmp = sum(w1[:i])+sum(w2[:j])+sum(w3[:k])+sum(w4[:res//(w+3)])
ans = max(tmp, ans)
print(ans)
|
p03732
|
from itertools import accumulate
N,W = list(map(int,input().split()))
w0,v0 = list(map(int,input().split()))
W0,W1,W2,W3 = [],[],[],[]
W0.append(v0)
for i in range(1,N):
w,v = list(map(int,input().split()))
if w == w0:
W0.append(v)
elif w == w0+1:
W1.append(v)
elif w == w0+2:
W2.append(v)
else:
W3.append(v)
W0.sort(reverse=True)
W1.sort(reverse=True)
W2.sort(reverse=True)
W3.sort(reverse=True)
V0 = [0]+list(accumulate(W0))
V1 = [0]+list(accumulate(W1))
V2 = [0]+list(accumulate(W2))
V3 = [0]+list(accumulate(W3))
Ans = 0
for i0 in range(len(V0)):
for i1 in range(len(V1)):
for i2 in range(len(V2)):
for i3 in range(len(V3)):
if w0*i0 + (w0+1)*i1 + (w0+2)*i2 + (w0+3)*i3 <= W:
Ans = max(Ans,V0[i0]+V1[i1]+V2[i2]+V3[i3])
print(Ans)
|
from itertools import accumulate
N,W = list(map(int,input().split()))
V = [[] for _ in range(4)]
w0 = 0
for i in range(N):
w,v = list(map(int,input().split()))
if i==0:
V[0].append(v)
w0 = w
else:
V[w - w0].append(v)
# 降順ソート
for i in range(4):
V[i].sort(reverse=True)
# 累積和
S = [[] for _ in range(4)]
for i in range(4):
S[i] = [0] + list(accumulate(V[i]))
# 全探索
ans = 0
for i0 in range(len(S[0])):
for i1 in range(len(S[1])):
for i2 in range(len(S[2])):
for i3 in range(len(S[3])):
if w0*i0 + (w0+1)*i1 + (w0+2)*i2 + (w0+3)*i3 <= W:
ans = max(ans, S[0][i0]+S[1][i1]+S[2][i2]+S[3][i3])
print(ans)
|
p03732
|
def solve(N, W, WVs):
Ws = {}
# print(N, ",", W, ",", WVs)
for w, v in WVs:
Ws.setdefault(w, []).append(v)
for w, v in list(Ws.items()):
Ws[w] = sorted(v, key=lambda x: -x)
wkeys = sorted(Ws.keys())
m = 0
for n1 in range(N + 1):
w1 = n1 * wkeys[0]
v1 = sum(Ws[wkeys[0]][:n1])
if w1 > W:
break
for n2 in range(N - n1 + 1):
if len(wkeys) >= 2:
w2 = n2 * wkeys[1]
v2 = sum(Ws[wkeys[1]][:n2])
else:
w2, v2 = 0, 0
if w1 + w2 > W:
break
for n3 in range(N - n1 - n2 + 1):
if len(wkeys) >= 3:
w3 = n3 * wkeys[2]
v3 = sum(Ws[wkeys[2]][:n3])
else:
w3, v3 = 0, 0
if w1 + w2 + w3 > W:
break
for n4 in range(N - n1 - n2 - n3 + 1):
if len(wkeys) >= 4:
w4 = n4 * wkeys[3]
v4 = sum(Ws[wkeys[3]][:n4])
else:
w4, v4 = 0, 0
if w1 + w2 + w3 + w4 > W:
break
m = max(m, v1 + v2 + v3 + v4)
return m
if __name__ == "__main__":
N, W = list(map(int, input().split(" ")))
WVs = [tuple(map(int, input().split(" "))) for _ in range(N)]
print((solve(N, W, WVs)))
|
def solve(N, W, WVs):
Ws = {}
for w, v in WVs:
Ws.setdefault(w, []).append(v)
for w, v in list(Ws.items()):
Ws[w] = sorted(v, key=lambda x: -x)
wkeys = sorted(Ws.keys())
m = 0
for n1 in range(N + 1):
w1 = n1 * wkeys[0]
if w1 > W:
break
v1 = sum(Ws[wkeys[0]][:n1])
for n2 in range(N - n1 + 1):
if len(wkeys) >= 2:
w2 = n2 * wkeys[1]
if w1 + w2 > W:
break
v2 = sum(Ws[wkeys[1]][:n2])
else:
w2, v2 = 0, 0
for n3 in range(N - n1 - n2 + 1):
if len(wkeys) >= 3:
w3 = n3 * wkeys[2]
if w1 + w2 + w3 > W:
break
v3 = sum(Ws[wkeys[2]][:n3])
else:
w3, v3 = 0, 0
for n4 in range(N - n1 - n2 - n3 + 1):
if len(wkeys) >= 4:
w4 = n4 * wkeys[3]
if w1 + w2 + w3 + w4 > W:
break
v4 = sum(Ws[wkeys[3]][:n4])
else:
w4, v4 = 0, 0
m = max(m, v1 + v2 + v3 + v4)
return m
if __name__ == "__main__":
N, W = list(map(int, input().split(" ")))
WVs = [tuple(map(int, input().split(" "))) for _ in range(N)]
print((solve(N, W, WVs)))
|
p03732
|
N, W = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for i in range(N)]
w0 = items[0][0]
sizeX = min(W, sum([items[i][0] for i in range(N)])) // w0 + 1
sizeY = min(w0, 3 * (N - 1) + 1)
memo = [[[-1 for y in range(sizeY)] for x in range(sizeX)] for i in range(N + 1)]
memo[0][0][0] = 0
for i, (wi, vi) in enumerate(items):
for x in range(sizeX):
for y in range(sizeY):
if memo[i][x][y] == -1: continue
wn = w0 * x + y + wi
if wn <= W:
memo[i + 1][wn // w0][wn % w0] = memo[i][x][y] + vi
memo[i + 1][x][y] = max(memo[i + 1][x][y], memo[i][x][y])
print((max(list(map(max, [memo[N][x] for x in range(sizeX)])))))
|
N, W = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for i in range(N)]
memo = [{} for i in range(N + 1)]
memo[0] = {0: 0}
for i, (wi, vi) in enumerate(items):
for w, v in list(memo[i].items()):
if w + wi <= W:
memo[i + 1][w + wi] = max(memo[i + 1].get(w + wi, 0), v + vi)
memo[i + 1][w] = max(memo[i + 1].get(w, 0), v)
print((max(memo[N].values())))
|
p03732
|
N,W = list(map(int, input().split()))
knap = [0 for i in range(W+1)]
mono = []
for i in range(N):
w,v = list(map(int, input().split()))
mono.append([w,v])
mono.sort(key = lambda x:x[1], reverse=True)
for w, v in mono:
for i in range(w, W+1)[::-1]:
if knap[i] < knap[i-w] + v:
knap[i] = knap[i-w] + v
print((knap[W]))
|
from itertools import accumulate
n,w=list(map(int, input().split()))
items = {}
for _ in range(n):
u,v = list(map(int, input().split()))
if u not in items:
items[u] = []
items[u].append(v)
cost = 0
acc = []
minkey = min(items.keys())
for i in range(4):
if minkey + i in items:
items[minkey + i].sort(reverse=True)
acc.append([0] + list(accumulate(items[minkey + i])))
else:
acc.append([0])
ans = 0
for i in range(len(acc[0])):
a = (i) * minkey
if w < a:
continue
for j in range(len(acc[1])):
b = (j) * (minkey+1)
if w < a + b:
continue
for k in range(len(acc[2])):
c = (k) * (minkey+2)
if w < a + b + c:
continue
for l in range(len(acc[3])):
d = (l) * (minkey+3)
if w < a + b + c + d:
continue
cost = acc[0][i] + acc[1][j] + acc[2][k] + acc[3][l]
if cost > ans :
ans = cost
print(ans)
|
p03732
|
#coding:utf-8
from collections import defaultdict
import itertools
if __name__ == "__main__":
N, W = list(map(int, input().split(" ")))
items = defaultdict(list)
item_num = defaultdict(int)
for i in range(N):
w, v = list(map(int, input().split(" ")))
if i == 0:
w_list = list(range(w, w + 4))
items[w].append(v)
item_num[w] += 1
for k in list(items.keys()):
items[k].sort(reverse = True)
cum = defaultdict(list)
for k in list(items.keys()):
sum_val = 0
for e in items[k]:
sum_val += e
cum[k].append(sum_val)
max_val = 0
weights = list(items.keys())
kinds = len(list(items.keys()))
for element in itertools.product(list(range(N + 1)), repeat = kinds):
w_sum = 0
over_flag = False
for i in range(kinds):
if element[i] > item_num[weights[i]]:
over_flag = True
break
w_sum += weights[i] * element[i]
if w_sum > W or over_flag:
continue
val = 0
for i in range(kinds):
if element[i] >= 1:
val += cum[weights[i]][element[i] - 1]
if val > max_val:
max_val = val
print(max_val)
|
#coding:utf-8
N, W = list(map(int, input().split(" ")))
items = [tuple(map(int, input().split(" "))) for _ in range(N)]
dic = {}
def search(i, j):
if i == N:
return 0
if (i, j) not in dic:
dic[(i, j)] = search(i + 1, j)
w, v = items[i]
if j + w <= W:
dic[(i, j)] = max(dic[(i, j)] , search(i + 1, j + w) + v)
return dic[(i, j)]
print(search(0, 0))
|
p03732
|
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
N,W = list(map(int,(input().split())))
ww = []
vv = []
for i in range(N):
w,v = list(map(int,(input().split())))
ww.append(w)
vv.append(v)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(1,N+1):
weight = ww[i-1]
value = vv[i-1]
for j in range(W+1):
if j >= weight:
dp[i][j] = max(dp[i-1][j],dp[i-1][j-weight]+value)
else:
dp[i][j] = dp[i-1][j]
print((dp[N][W]))
|
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
AtoZ = [chr(i) for i in range(65,65+26)]
atoz = [chr(i) for i in range(97,97+26)]
N,W = list(map(int,(input().split())))
wv = [[] for i in range(4)]
w,v = list(map(int,(input().split())))
min_w = w
wv[0].append(v)
for i in range(N-1):
w,v = list(map(int,(input().split())))
wv[w-min_w].append(v)
wv[0].sort(reverse=True)
wv[1].sort(reverse=True)
wv[2].sort(reverse=True)
wv[3].sort(reverse=True)
L1 = len(wv[0])
L2 = len(wv[1])
L3 = len(wv[2])
L4 = len(wv[3])
SUM = 0
sum_wv1 = [0]
for i in range(L1):
SUM += wv[0][i]
sum_wv1.append(SUM)
SUM = 0
sum_wv2 = [0]
for i in range(L2):
SUM += wv[1][i]
sum_wv2.append(SUM)
SUM = 0
sum_wv3 = [0]
for i in range(L3):
SUM += wv[2][i]
sum_wv3.append(SUM)
SUM = 0
sum_wv4 = [0]
for i in range(L4):
SUM += wv[3][i]
sum_wv4.append(SUM)
ans = 0
for n1 in range(L1+1):
for n2 in range(L2+1):
for n3 in range(L3+1):
for n4 in range(L4+1):
weight = min_w*(n1+n2+n3+n4) + n2 + 2*n3 + 3*n4
if weight <= W:
ans = max(ans,sum_wv1[n1]+sum_wv2[n2]+sum_wv3[n3]+sum_wv4[n4])
print(ans)
|
p03732
|
from sys import stdin
from itertools import accumulate
readline = stdin.readline
N, W = list(map(int, input().split()))
vs = [[] for _ in range(4)]
w, v = list(map(int, input().split()))
w1 = w
vs[0].append(v)
for _ in range(N - 1):
w, v = list(map(int, input().split()))
vs[w - w1].append(v)
for i in range(4):
vs[i].sort(reverse=True)
vs[i] = list(accumulate(vs[i]))
result = 0
for i in range(len(vs[0]) + 1):
a = W - w1 * i
if a < 0:
break
for j in range(len(vs[1]) + 1):
b = a - (w1 + 1) * j
if b < 0:
break
for k in range(len(vs[2]) + 1):
c = b - (w1 + 2) * k
if c < 0:
break
t = 0
if i != 0:
t += vs[0][i - 1]
if j != 0:
t += vs[1][j - 1]
if k != 0:
t += vs[2][k - 1]
for l in range(len(vs[3]) + 1):
d = c - (w1 + 3) * l
if d < 0:
break
if l == 0:
result = max(result, t)
else:
result = max(result, t + vs[3][l -1])
print(result)
|
from sys import stdin
from itertools import accumulate
readline = stdin.readline
N, W = list(map(int, input().split()))
vs = [[] for _ in range(4)]
w, v = list(map(int, input().split()))
w1 = w
vs[0].append(v)
for _ in range(N - 1):
w, v = list(map(int, input().split()))
vs[w - w1].append(v)
for i in range(4):
vs[i].sort(reverse=True)
vs[i] = [0] + list(accumulate(vs[i]))
result = 0
for i in range(len(vs[0])):
a = W - w1 * i
if a < 0:
break
for j in range(len(vs[1])):
b = a - (w1 + 1) * j
if b < 0:
break
for k in range(len(vs[2])):
c = b - (w1 + 2) * k
if c < 0:
break
t = vs[0][i] + vs[1][j] + vs[2][k]
for l in range(len(vs[3])):
d = c - (w1 + 3) * l
if d < 0:
break
result = max(result, t + vs[3][l])
print(result)
|
p03732
|
from collections import defaultdict
N, W = list(map(int, input().split()))
MAX_NUM = []
len_weights = 0
def dfs(nums):
if len(nums) == len_weights:
sum_w = 0
value = 0
for i in range(len_weights):
sum_w += weights[i] * nums[i]
value += sum(items[weights[i]][0:nums[i]])
return value if sum_w <= W else 0
value = 0
i = len(nums)
for j in range(MAX_NUM[i] + 1):
value = max(value, dfs(nums + [j]))
return value
items = defaultdict(list)
for i in range(N):
w, v = list(map(int, input().split()))
items[w].append(v)
for v in list(items.values()):
v.sort(reverse=True)
weights = sorted(items.keys())
len_weights = len(weights)
for w in weights:
MAX_NUM.append(W // w)
print((dfs([])))
|
from collections import defaultdict
N, W = list(map(int, input().split()))
MAX_NUM = []
len_weights = 0
def dfs(nums):
if len(nums) == len_weights:
sum_w = 0
value = 0
for i in range(len_weights):
sum_w += weights[i] * nums[i]
if nums[i] >= 1:
value += items[weights[i]][nums[i] - 1]
return value if sum_w <= W else 0
value = 0
i = len(nums)
for j in range(MAX_NUM[i] + 1):
value = max(value, dfs(nums + [j]))
return value
items = defaultdict(list)
for i in range(N):
w, v = list(map(int, input().split()))
items[w].append(v)
for v in list(items.values()):
v.sort(reverse=True)
for i in range(1, len(v)):
v[i] = v[i - 1] + v[i]
weights = sorted(items.keys())
len_weights = len(weights)
for w in weights:
MAX_NUM.append(min(W // w, len(items[w])))
print((dfs([])))
|
p03732
|
from collections import defaultdict
def main():
n, w = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(n)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in items:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
candidates = [0]
for weight, value in sorted(DP.items()):
if weight > w:
break
candidates.append(value)
print((max(candidates)))
if __name__ == "__main__":
main()
|
from collections import defaultdict
def main():
n, w = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(n)]
DP = defaultdict(int)
DP[0] = 0
for weight, value in items:
exists = list(DP.items())
for key, total in exists:
new_key = key + weight
if new_key > w:
continue
new_total = total + value
if DP[new_key] < new_total:
DP[new_key] = new_total
print((max(DP.values())))
if __name__ == "__main__":
main()
|
p03732
|
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,W=list(map(int,input().split()))
WV=[tuple(map(int,input().split())) for _ in range(n)]
weight=set()
for i in range(n+1):
if(WV[0][0]*i>W): break
for j in range(3*i+1):
if(WV[0][0]*i+j>W): break
weight.add(WV[0][0]*i+j)
weight=sorted(weight)
dp=defaultdict(int)
for i in range(n):
ndp=defaultdict(int)
w,v=WV[i]
for key in weight:
ndp[key]=max(ndp[key],dp[key])
if(key+w<=W): ndp[key+w]=max(ndp[key+w],dp[key]+v)
dp=ndp
print((max(dp.values())))
resolve()
|
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,W=list(map(int,input().split()))
w0,v=list(map(int,input().split()))
V=[[] for _ in range(4)]
V[0].append(v)
for _ in range(n-1):
w,v=list(map(int,input().split()))
V[w-w0].append(v)
for i in range(4):
V[i].sort(reverse=1)
for j in range(len(V[i])-1):
V[i][j+1]+=V[i][j]
for i in range(4):
V[i].insert(0,0)
ans=0
from itertools import product
for a,b,c,d in product(list(range(len(V[0]))),list(range(len(V[1]))),list(range(len(V[2]))),list(range(len(V[3])))):
v=V[0][a]+V[1][b]+V[2][c]+V[3][d]
if(a*w0+b*(w0+1)+c*(w0+2)+d*(w0+3)<=W): ans=max(ans,v)
print(ans)
resolve()
|
p03732
|
N, WW = list(map(int, input().split()))
l = [list(map(int, input().split())) for _ in range(N)]
W, V = list(zip(*l))
M = [{} for i in range(N + 1)]
def cal(i, w):
if w in M[i]:
return M[i][w]
if i == N:
v = 0
elif w < W[i]:
v = cal(i + 1, w)
else:
v = max(cal(i + 1, w), cal(i + 1, w - W[i]) + V[i])
M[i][w] = v
return v
print((cal(0, WW)))
|
N, W = list(map(int, input().split()))
d = {0:0}
for _ in range(N):
w, v = list(map(int, input().split()))
for dw, dv in list(d.copy().items()):
if dw + w <= W:
d[dw + w] = max(d.get(dw + w, 0), dv + v)
print((max(d.values())))
|
p03732
|
N,W=list(map(int,input().split()));d={0:0}
for _ in [0]*N:
w,v=list(map(int,input().split()))
for x,y in list(d.copy().items()):
if x+w<=W:d[x+w]=max(d.get(x+w,0),y+v)
print((max(d.values())))
|
N,W,*A=list(map(int,open(0).read().split()));d={0:0}
for w,v in zip(A[::2],A[1::2]):
for x,y in list(d.copy().items()):
if x+w<=W:d[x+w]=max(d.get(x+w,0),y+v)
print((max(d.values())))
|
p03732
|
N,W,*A=list(map(int,open(0).read().split()));d={0:0}
for w,v in zip(A[::2],A[1::2]):
for x,y in list(d.copy().items()):
if x+w<=W:d[x+w]=max(d.get(x+w,0),y+v)
print((max(d.values())))
|
N,W,*A=list(map(int,open(0).read().split()));d={0:0}
while A:
v,w=A.pop(),A.pop()
for x,y in list(d.copy().items()):
if x+w<=W:d[x+w]=max(d.get(x+w,0),y+v)
print((max(d.values())))
|
p03732
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.