input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
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()))
WV=[tuple(map(int,input().split())) for _ in range(n)]
dp=[-INF]*(W+1)
dp[0]=0
for w,v in WV:
for x in range(W,-1,-1):
if(x+w<=W):
dp[x+w]=max(dp[x+w],dp[x]+v)
print((max(dp)))
resolve() | import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, W = list(map(int, input().split()))
dp = [-INF] * (W + 1)
dp[0] = 0
for _ in range(n):
w, v = list(map(int, input().split()))
for w0 in range(W, -1, -1):
if dp[w0] == INF:
continue
if w + w0 <= W:
dp[w + w0] = max(dp[w + w0], dp[w0] + v)
print((max(dp)))
resolve() | p03163 |
import sys
import pdb
input = sys.stdin.readline
N, W = list(map(int, input().split()))
ws = []
vs = []
for _ in range(N):
w, v = list(map(int, input().split()))
ws.append(w)
vs.append(v)
inf = 1e10
# Value[i番目までの品番][重さj以下]
Value = [[-inf for _ in range(W+1)] for __ in range(N)]
for load in range(W+1):
if load < ws[0]:
# 1番目の品物を入れようがなければスキップ
Value[0][load] = 0
else:
Value[0][load] = vs[0]
for num in range(1, N):
for load in range(W+1):
if load >= ws[num]: # 新しい品物を入れられるとき
Value[num][load] = max(Value[num][load], Value[num-1][load], Value[num-1][load-ws[num]] + vs[num])
else: # 新しい品物を入れられないとき
# 価値を変えることはできない
Value[num][load] = Value[num-1][load]
# Value[num][load] = max(Value[num][load], Value[num-1][load])
print((Value[N-1][W]))
| import sys
import pdb
input = sys.stdin.readline
N, W = list(map(int, input().split()))
ws = []
vs = []
for _ in range(N):
w, v = list(map(int, input().split()))
ws.append(w)
vs.append(v)
# Value[i番目までの品番][重さj以下]
Value = [[0 for _ in range(W+1)] for __ in range(N)]
for load in range(W+1):
if load < ws[0]:
# 1番目の品物を入れようがなければスキップ
Value[0][load] = 0
else:
Value[0][load] = vs[0]
for num in range(1, N):
for load in range(W+1):
if load >= ws[num]: # 新しい品物を入れられるとき
Value[num][load] = max(Value[num][load], Value[num-1][load], Value[num-1][load-ws[num]] + vs[num])
else: # 新しい品物を入れられないとき
# 価値を変えることはできない
Value[num][load] = Value[num-1][load]
# Value[num][load] = max(Value[num][load], Value[num-1][load])
print((Value[N-1][W]))
| p03163 |
n,w = list(map(int,input().strip().split()))
a = [[0] * 2 for i in [0] * n]
for i in range(n):
a[i] = list(map(int,input().strip().split()))
weight_max = 0
for i in range(n):
weight_max += a[i][0]
dp = [[0] * (w+1) for i in [0] * (n+1)]
for i in range(n):
for sum_w in range(w+1):
if sum_w >= a[i][0]:
dp[i+1][sum_w] = max(dp[i][sum_w], dp[i][sum_w-a[i][0]]+a[i][1])
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w])
print((dp[n][w])) | n,w = list(map(int,input().strip().split()))
a = [[0] * 2 for i in [0] * n]
for i in range(n):
a[i] = list(map(int,input().strip().split()))
weight_max = 0
for i in range(n):
weight_max += a[i][0]
dp = [[0] * (w+1) for i in [0] * (n+1)]
for i in range(n):
for sum_w in range(w+1):
if sum_w >= a[i][0]:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w-a[i][0]]+a[i][1])
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w])
print((dp[n][w]))
| p03163 |
def knapsack(n,c,w,v):
if n == 0 or c == 0:
return n
if w[n] > c:
return knapsack(n-1,c,w,v)
else:
opt1 = v[n] + knapsack(n-1,c-w[n],w,v)
opt2 = knapsack(n-1,c,w,v)
return max(opt1,opt2)
n,c = list(map(int,input().split()))
w = [-1]; v = [-1]
for _ in range(n):
wi , vi= list(map(int,input().split()))
w.append(wi)
v.append(vi)
result = knapsack(n,c,w,v)
print(result)
| n ,c = list(map(int,input().split()))
wt =[]; val=[]
for _ in range(n):
wi , vi = list(map(int,input().split()))
wt.append(wi)
val.append(vi)
# dp [n][c+1] = 0
dp = [[0 for i in range(c+1)]for j in range(n)]
for w in range(c+1):
wi = wt[0]
if wi<=w:
dp[0][w]=val[0]
else:
dp[0][0]=0
for i in range(1,n):
wi = wt[i];vi = val[i]
for w in range(1,c+1):
if wi<=w:
dp[i][w] = max(vi+dp[i-1][w-wi] , dp[i-1][w])
else:
dp[i][w] = dp[i-1][w]
print((dp[n-1][c]))
| p03163 |
from sys import stdin,stdout
def knapsack(i,w):
if dp[i][w]!=-1:
return dp[i][w]
else:
if w-wi[i]>=0:
dp[i][w] = max(knapsack(i-1,w-wi[i])+v[i],knapsack(i-1,w))
else:
dp[i][w] = knapsack(i-1,w)
return dp[i][w]
n,w= list(map(int,input().split()))
wi=[0]
v=[0]
for i in range(n):
x,y= list(map(int,stdin.readline().split()))
wi.append(x)
v.append(y)
dp = [[-1 for i in range(w+1)] for j in range(n+1)]
for i in range(w+1):
dp[0][i]=0
for j in range(n+1):
dp[j][0]=0
stdout.write(str(knapsack(n,w)) + "\n")
#print(dp) | N,W=list(map(int,input().split()))
dp=[-1]*(W+1)
dp[0]=0
for _ in range(N):
w,v=list(map(int,input().split()))
for i in range(W+1)[::-1]:
if dp[i]!=-1 and i+w<=W:
dp[i+w]=max(dp[i+w],dp[i]+v)
print((max(dp)))
| p03163 |
num, capacity = list(map(int, input().split()))
dp = [0]*(capacity+1)
for _ in range(num):
weight, value = list(map(int, input().split()))
for w in range(capacity,weight - 1,-1):
tmp = dp[w - weight] + value
if dp[w] < tmp:
dp[w] = tmp
print((dp[capacity])) | def calc(num,capacity):
dp = [0]*(capacity+1)
for _ in range(num):
weight, value = list(map(int, input().split()))
for w in range(capacity,weight - 1,-1):
tmp = dp[w - weight] + value
if dp[w] < tmp:
dp[w] = tmp
return dp[capacity]
num, capacity = list(map(int, input().split()))
print((calc(num,capacity))) | p03163 |
n, weightMax = list(map(int, input().split()))
itemList = [[0 for _ in range(weightMax+1)] for _ in range(n+1)]
for i in range(n):
w,v = list(map(int, input().split()))
for j in reversed(list(range(weightMax+1))):
if j-w >= 0:
itemList[i+1][j] = max([itemList[i][j],itemList[i][j-w] + v])
else:
itemList[i+1][j] = itemList[i][j]
print((max(itemList[n])))
| n, max_weight = list(map(int, input().split()))
dp = [[0 for _ in range(max_weight+1)] for _ in range(n+1)]
for i in range(n):
weight, value = list(map(int,input().split()))
for w in range(max_weight+1):
if w >= weight:
dp[i+1][w] = max(dp[i][w-weight] + value, dp[i][w])
else:
dp[i+1][w] = dp[i][w]
print((dp[n][max_weight])) | p03163 |
N, W = list(map(int, input().split()))
DP = {0: 0}
for i in range(N):
wi, vi = list(map(int, input().split()))
DP_dst = DP.copy()
for j in DP:
if j+wi <= W:
DP_dst[j+wi] = max(DP.get(j+wi, 0), DP[j]+vi)
DP = DP_dst
print((max((DP[x] for x in DP))))
| # TODO:実装
N, W = list(map(int, input().split()))
DP = {0: 0}
for i in range(N):
wi, vi = list(map(int, input().split()))
DP_dst = DP.copy()
for j in DP:
if j+wi <= W:
DP_dst[j+wi] = max(DP.get(j+wi, 0), DP[j]+vi)
DP = DP_dst
print((max((DP[x] for x in DP))))
| p03163 |
n,tw = list(map(int, input().split()))
wt = []; val = []
for i in range(n):
a,b = list(map(int, input().split()))
wt.append(a); val.append(b)
dp = [[0 for i in range(tw+1)] for j in range(n+1)]
for i in range(n):
for j in range(1,tw+1):
if j < wt[i]:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j], val[i]+dp[i][j-wt[i]])
print((dp[n][tw]))
| def ks(n, W, arr):
dp = [[0 for i in range(W+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(1,W+1):
if arr[i-1][0] > j:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-arr[i-1][0]]+arr[i-1][1])
return dp[n][W]
if __name__ == "__main__":
n, W = list(map(int, input().split()))
arr = []
for i in range(n):
w,v = list(map(int, input().split()))
arr.append([w,v])
arr.sort(key = lambda x:x[0])
ans = ks(n,W,arr)
print(ans)
| p03163 |
import sys
input = sys.stdin.readline
n,w=list(map(int,input().split()))
dp=[[0]*(w+1) for _ in range(n)]
l=[0]*n
for i in range(n):
l[i]=list(map(int,input().split()))
#print(l)
for i in range(w+1):
if i>=l[0][0]:
dp[0][i]=l[0][1]
for i in range(w+1):
for j in range(n-1):
if i<l[j+1][0]:
dp[j+1][i]=dp[j][i]
else:
dp[j+1][i]=max(dp[j][i-l[j+1][0]]+l[j+1][1],dp[j][i])
print((dp[-1][-1])) | n,w=list(map(int,input().split()))
dp=[[0]*(w+1) for _ in range(n)]
l=[0]*n
for i in range(n):
l[i]=list(map(int,input().split()))
#print(l)
for i in range(w+1):
if i>=l[0][0]:
dp[0][i]=l[0][1]
for i in range(w+1):
for j in range(n-1):
if i<l[j+1][0]:
dp[j+1][i]=dp[j][i]
else:
dp[j+1][i]=max(dp[j][i-l[j+1][0]]+l[j+1][1],dp[j][i])
print((dp[-1][-1])) | p03163 |
n, w = list(map(int, input().split()))
goods = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (w + 1) for _ in range(n)]
for i in range(n):
for j in range(w + 1):
if 0 <= j - goods[i][0]:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - goods[i][0]] + goods[i][1])
dp[i][j] = max(dp[i][j], dp[i - 1][j])
print((dp[n - 1][w]))
| n, w = list(map(int, input().split()))
goods = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(n):
for j in range(w + 1):
if 0 <= j - goods[i][0]:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - goods[i][0]] + goods[i][1])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
print((dp[n][w]))
| p03163 |
def knapsack(sizes, vals, volume):
n = len(sizes)
dp = [[0] * (volume+1) for _ in range(n)] # j is 0...volume
for i in range(n):
for j in range(volume+1):
dp[i][j] = max(dp[i][j], dp[i-1][j])
if j - sizes[i] >= 0:
dp[i][j] = max(dp[i][j], dp[i-1][j-sizes[i]] + vals[i])
dp[i][j] = max(dp[i][j], dp[i-1][j])
return dp[-1][-1]
if __name__ == "__main__":
n, volume = [int(x) for x in input().split()]
sizes, vals = [], []
for _ in range(n):
s, v = [int(x) for x in input().split()]
sizes.append(s)
vals.append(v)
print((knapsack(sizes, vals, volume)))
| def knapsack(sizes, vals, volume):
n = len(sizes)
dp = [[0] * (volume+1) for _ in range(n)] # j is 0...volume
for i in range(n):
for j in range(volume+1):
dp[i][j] = max(dp[i][j], dp[i-1][j])
if j - sizes[i] >= 0:
dp[i][j] = max(dp[i][j], dp[i-1][j-sizes[i]] + vals[i])
#dp[i][j] = max(dp[i][j], dp[i-1][j])
return dp[-1][-1]
if __name__ == "__main__":
n, volume = [int(x) for x in input().split()]
sizes, vals = [], []
for _ in range(n):
s, v = [int(x) for x in input().split()]
sizes.append(s)
vals.append(v)
print((knapsack(sizes, vals, volume)))
| p03163 |
from collections import Counter
from functools import reduce
import fractions
import pprint
import math
import statistics
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) for x in sys.stdin.readline().split()] # LIST INT
def LF(): return [float(x) for x in sys.stdin.readline().split()] # LIST FLOAT
def LS(): return sys.stdin.readline().split() # LIST STRING
def MI(): return map(int, sys.stdin.readline().split()) # MAP INT
def II(): return int(sys.stdin.readline()) # INPUT INT
def IS(): return input() # INPUT STRING
def P(x): return print(x)
def C(x): return Counter(x)
def GCD_LIST(numbers): # greatest common divisor
return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): # least common multiple
return reduce(LCM, numbers)
def LCM(m, n):
return (m * n // fractions.gcd(m, n))
N, W = MI()
dp = [[0 for i in range(100001)] for i in range(N+1)]
for i in range(N):
w, v = MI()
for sum_w in range(W+1):
if sum_w - w >= 0:
dp[i+1][sum_w] = max(dp[i][sum_w - w] + v, dp[i+1][sum_w])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
P(max(dp[-1]))
| N, W = list(map(int,input().split()))
dp = [[0 for i in range(100001)] for i in range(N+1)]
for i in range(N):
w, v = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w - w >= 0:
dp[i+1][sum_w] = max(dp[i][sum_w - w] + v, dp[i+1][sum_w])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((max(dp[-1]))) | p03163 |
N, W = list(map(int, input().split(" ")))
l = []
for i in range(N):
w, v = list(map(int, input().split(" ")))
l.append((w, v))
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(0, N):
for w in range(1, W+1):
weight = l[i-1][0]
value = l[i-1][1]
if w >= weight:
dp[i + 1][w] = max([dp[i][w - weight] + value, dp[i][w]])
else:
dp[i + 1][w] = dp[i][w]
print((dp[N][W]))
| N, W = list(map(int, input().split(" ")))
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(0, N):
weight, value = list(map(int, input().split(" ")))
for w in range(1, W+1):
if w >= weight:
dp[i + 1][w] = max([dp[i][w - weight] + value, dp[i][w]])
else:
dp[i + 1][w] = dp[i][w]
print((dp[N][W])) | p03163 |
'''
in
-----
6 15
6 5
5 6
6 4
6 6
3 5
7 2
'''
'''
out
-----
17
'''
from collections import defaultdict
dp = defaultdict(lambda:int(0))
N, M = list(map(int, input().split()))
W = [0] * (N +2)
V = [0] * (N +2)
for i in range(0, N):
W[i],V[i] = list(map(int, input().split()))
for i in range(0, N):
for j in range(1, M+1):
if (j - W[i] >= 0):
dp[(i+1,j)] = max(dp[(i+1,j)], dp[(i,j-W[i])] + V[i])
dp[(i+1,j)] = max(dp[(i+1,j)], dp[(i,j)])
'''
for i in range(0,N+1):
for j in range(1, M+1):
print(dp[(i,j)])
print('')
'''
print((max(dp.values())))
| N,M = list(map(int,input().split()))
dp = [[0]*(M+1) for _ in range(N+1)]
for i in range(1, N+1):
W,V = list(map(int,input().split()))
for j in range(W):
dp[i][j] = dp[i-1][j]
for j in range(M-W+1):
dp[i][j+W] = max(dp[i-1][j+W],dp[i-1][j]+V)
print((max(dp[-1]))) | p03163 |
'''
in
-----
6 15
6 5
5 6
6 4
6 6
3 5
7 2
'''
'''
out
-----
17
'''
from collections import defaultdict
dp = defaultdict(lambda:int(0))
N, M = list(map(int, input().split()))
W = [0] * (N +2)
V = [0] * (N +2)
for i in range(0, N):
W[i],V[i] = list(map(int, input().split()))
for i in range(0, N):
for j in range(0, W[i]+1):
dp[(i+1,j)] = max(dp[(i+1,j)], dp[(i,j)])
for j in range(W[i], M+1):
dp[(i+1,j)] = max(dp[(i+1,j)], dp[(i,j-W[i])] + V[i])
'''
for i in range(0,N+1):
for j in range(1, M+1):
print(dp[(i,j)])
print('')
'''
print((max(dp.values())))
| '''
in
-----
6 15
6 5
5 6
6 4
6 6
3 5
7 2
'''
'''
out
-----
17
'''
N, M = list(map(int, input().split()))
dp = [[0]*(M+1) for _ in range(N+1)]
for i in range(1, N+1):
W,V = list(map(int, input().split()))
for j in range(0,M+1):
dp[i][j] = max(dp[i][j], dp[i-1][j])
if j - W >= 0:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-W] + V)
'''
for i in range(0,N+1):
for j in range(1, M+1):
print(dp[i][j])
print('')
'''
print((max(dp[-1])))
| p03163 |
def solve(N, W, weight_values):
dp = [0 for _ in range(W + 1)]
dp[0] = 0
for i in range(N + 1):
i_weight, i_value = weight_values[i - 1]
for w in range(W, -1, -1):
if i_weight <= w:
dp[w] = max(dp[w - i_weight] + i_value, dp[w])
else:
dp[w] = dp[w]
print((dp[W]))
def iln(): return list(map(int, input().split()))
N, W = iln()
w_v = []
for i in range(N):
w_v.append(iln())
solve(N, W, w_v)
| def solve(N, W, weight_values):
dp = [0 for _ in range(W + 1)]
for i in range(N):
i_weight, i_value = weight_values[i]
for w in range(W, i_weight - 1, -1):
# dp[w] = max(dp[w - i_weight] + i_value, dp[w])
temp = dp[w - i_weight] + i_value
if temp > dp[w]:
dp[w] = temp
print((dp[W]))
def iln(): return list(map(int, input().split()))
N, W = iln()
w_v = []
for i in range(N):
w_v.append(iln())
solve(N, W, w_v)
| p03163 |
N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if w[i] <= sum_w:
dp[i+1][sum_w] = max(dp[i][sum_w], dp[i][sum_w-w[i]] + v[i])
dp[i+1][sum_w] = max(dp[i][sum_w], dp[i+1][sum_w])
print((dp[N][W])) | N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W+1) for i in range(N+1)]
for i in range(1, N+1):
for s in range(1, W+1):
if w[i-1] <= s:
dp[i][s] = max(dp[i][s], dp[i-1][s-w[i-1]] + v[i-1])
dp[i][s] = max(dp[i][s], dp[i-1][s])
print((dp[N][W]))
| p03163 |
import sys
input = sys.stdin.readline
n,w = list(map(int,input().split()))
wv = [tuple(map(int,input().split())) for i in range(n)]
dp = [0]*(w+1)
for i in range(n):
for j in range(w,wv[i][0]-1,-1):
dp[j] = max(dp[j],dp[j-wv[i][0]]+wv[i][1])
print((max(dp))) | def MI(): return list(map(int, input().split()))
import sys
input = sys.stdin.readline
n,w = list(map(int,input().split()))
#wv = [tuple(map(int,input().split())) for i in range(n)]
W=[]
V=[]
for i in range(n):
a,b=MI()
W.append(a)
V.append(b)
dp = [0]*(w+1)
for i in range(n):
for j in range(w,W[i]-1,-1):
dp[j] = max(dp[j],dp[j-W[i]]+V[i])
print((max(dp))) | p03163 |
N,W = list(map(int,input().split()))
w = []
v = []
for i in range(N):
x,y = list(map(int,input().split()))
w.append(x)
v.append(y)
dp = [[0]*(W+1) for j in range(N+1)] # DPテーブルの作成
for i in range(N):
for j in range(W+1):
if j < w[i]: # 選ばない時
dp[i+1][j] = dp[i][j]
else: # 選ぶ時
dp[i+1][j] = max(dp[i][j],dp[i][j-w[i]]+v[i])
print((dp[N][W])) | def MI(): return list(map(int, input().split()))
N,W=MI()
w=[]
v=[]
for i in range(N):
a,b=MI()
w.append(a)
v.append(b)
dp=[[0]*(W+1) for _ in range(N+1)]
for i in range(N):
for j in range(W+1):
if j<w[i]:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=max(dp[i][j],dp[i][j-w[i]]+v[i])
ans=dp[-1][-1]
print(ans) | p03163 |
def main():
def solve(N, W, wv):
dp = [-1] * (W+1)
dp[0] = 0
for i in range(N):
wi = wv[i][0]
vi = wv[i][1]
for j in range(W-wi, -1, -1):
# print('i, wi, j = {}, {}, {}'.format(i, wi, j))
if dp[j] == -1:
continue
dp[j+wi] = max(dp[j+wi], dp[j] + vi)
# print(dp)
return max(dp)
N, W = list(map(int, input().split()))
wv = tuple(tuple(map(int, input().split())) for i in range(N))
print((solve(N, W, wv)))
##########
if __name__ == "__main__":
main()
| def solve(N,W,wv):
dp=[-1]*(W+1)
dp[0]=0
for i in range(N):
cur_w=wv[i][0]
cur_v=wv[i][1]
for j in range(W-cur_w,-1,-1):
if dp[j]==-1:
continue
if dp[j+cur_w]<dp[j]+cur_v:
dp[j+cur_w]=dp[j]+cur_v
return max(dp)
N,W=list(map(int,input().split()))
wv=tuple(tuple(map(int,input().split())) for _ in range(N))
print((solve(N,W,wv)))
| p03163 |
# Educational DP Contest D-knapsack
def knapsack(N, W, wv):
# initialize
dp = [list(0 for _ in range(W+1)) for j in range(N+1)]
# DP
for i in range(N):
for j in range(W+1):
if j >= wv[i][0]:
dp[i+1][j] = max(dp[i][j], dp[i][j - wv[i][0]] + wv[i][1])
else:
dp[i+1][j] = dp[i][j]
return dp[N][W]
if __name__ == "__main__":
N, W = list(map(int, input().split()))
wv = []
for _ in range(N):
wv.append(list(map(int, input().split())))
print((knapsack(N, W, wv))) | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = []
for _ in range(N+1):
dp.append([0] * (W+1))
for i in range(N):
for j in range(W+1):
if j >= wv[i][0]:
dp[i+1][j] = max(dp[i][j], dp[i][j - wv[i][0]] + wv[i][1])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W])) | p03163 |
# -*- coding: utf-8 -*-
import math
import datetime
import itertools
import sys
import copy
# 入力
#N = int(input())
#S = str(input())
#N, A, B = map(int, input().split())
N, W = list(map(int, input().split()))
H = []
for _ in range(N) :
H.append(list(map(int, input().split())))
#print(H)
#N(i+1)個目の品物を追加したときにWjとなる場合のWj地点の最大価値
dp = [0 for _ in range(W+1)]
for i in range(N) :
dptemp = copy.deepcopy(dp)
for j in range(W+1) :
if dptemp[j] > 0 and j+H[i][0] <= W:
dp[j+H[i][0]] = max(dptemp[j+H[i][0]], dptemp[j] + H[i][1])
dp[H[i][0]] = max(dptemp[H[i][0]], H[i][1])
#print (dp)
#print (dp)
print((max(dp))) | # -*- coding: utf-8 -*-
import math
import datetime
import itertools
import sys
import copy
# 入力
#N = int(input())
#S = str(input())
#N, A, B = map(int, input().split())
N, W = list(map(int, input().split()))
H = []
for _ in range(N) :
H.append(list(map(int, input().split())))
#print(H)
#N(i+1)個目の品物を追加したときにWjとなる場合のWj地点の最大価値
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) :
dp[i][j] = max(dp[i-1][j], dp[i][j])
if dp[i-1][j] > 0 and j+H[i-1][0] <= W:
dp[i][j+H[i-1][0]] = max(dp[i-1][j+H[i-1][0]], dp[i-1][j] + H[i-1][1])
dp[i][H[i-1][0]] = max(dp[i-1][H[i-1][0]], H[i-1][1])
#print (dp[i])
#print (dp)
print((max(dp[N]))) | p03163 |
N, Weight = list(map(int, input().split()))
w = []
V = []
for _ in range(N):
w_tmp, v = list(map(int, input().split()))
w.append(w_tmp)
V.append(v)
dp = [[0 for i in range(Weight+1)] for j in range(N+1)]
for i in range(Weight+1):
dp[0][i] = 0
for i in range(N):
for j in range(Weight+1):
if j - w[i] >= 0:
dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]]+V[i])
else:
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
print((dp[N][Weight])) | N, W = list(map(int, input().split()))
weight = []
value = []
for _ in range(N):
w_tmp, v_tmp = list(map(int, input().split()))
weight.append(w_tmp)
value.append(v_tmp)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i] = 0
for i in range(N):
for j in range(W+1):
if j - weight[i] >= 0:
dp[i+1][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i])
else:
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
print((dp[N][W])) | p03163 |
def solve():
dp = {}
for i in range(W + 1):
dp[0, i] = 0
for i in range(N):
for j in range(W + 1):
if j < w[i]:
dp[i + 1, j] = dp[i, j]
else:
dp[i + 1, j] = max(dp[i, j], dp[i, j - w[i]] +v[i])
return dp[N, W]
N, W = list(map(int, input().split()))
w = {}
v = {}
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
print((solve())) | N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W - w, -1, -1):
dp[j + w] = max(dp[j + w], dp[j] + v)
print((dp[W])) | p03163 |
N, W = list(map(int, input().split()))
dp = {}
for i in range(W + 1):
dp[i] = 0
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W - w, -1, -1):
dp[j + w] = max(dp[j + w], dp[j] + v)
print((dp[W])) | N, W = list(map(int, input().split()))
dp = [[0] * (W + 1)] * (N + 1)
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W - w, -1, -1):
dp[i+1][j + w] = max(dp[i][j + w], dp[i][j] + v)
print((dp[N][W])) | p03163 |
N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(W+1):
if j-w[i]>=0:
dp[i+1][j]=max(dp[i+1][j],dp[i][j-w[i]]+v[i])
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[N][W])) | n,w=list(map(int,input().split()))
mer=[list(map(int,input().split())) for i in range(n)]
dp=[[0]*(w+1) for i in range(n+1)]
for i in range(1,n+1):
for j in range(w+1):
if j>=mer[i-1][0]:
dp[i][j]=mer[i-1][1]+dp[i-1][j-mer[i-1][0]]
dp[i][j]=max(dp[i][j],dp[i-1][j])
print((dp[-1][-1])) | p03163 |
import sys
sys.setrecursionlimit(2147483647)
N,W = list(map(int,input().split()))
A = [list(map(int, input().split())) for i in range(N)]
def dfs(i,w):
if (i,w) in dic: return dic[(i,w)]
if i == N or w <=0:
dic[(i,w)] = 0
return 0
ma = 0
res1 = res2 = 0
if A[i][0] <=w:
res1 = dfs(i + 1,w - A[i][0]) + A[i][1]
res2 = dfs(i + 1,w)
ma = max(res1,res2)
dic[(i,w)] = ma
return ma
dic = {}
res = dfs(0,W)
print(res) | import sys
sys.setrecursionlimit(2147483647)
N,W = list(map(int,input().split()))
A = [list(map(int, input().split())) for i 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):
if j - A[i-1][0] >= 0:
res1 = dp[i - 1][j - A[i-1][0]] + A[i - 1][1]
res2 = dp[i - 1][j]
dp[i][j] = max(res1,res2)
else:
dp[i][j] = dp[i-1][j]
#print(dp)
print((max(dp[N]))) | p03163 |
import sys
# import numpy as np
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))
# import profile
def solve():
n, w = read();
dp = [[0 for i in range(w+1)] for j in range(3)]
w_v_list = [read() for i in range(n)]
# for i in dp:print(*i)
# print("\n")
# print(w_v_list)
for i in range(n):
for j in range(w+1):
elem_w, elem_v = w_v_list[i]
if elem_w <= j:
dp[i%3][j] = max(elem_v + dp[(i-1)%3][j - elem_w], dp[i%3][j-1], dp[(i-1)%3][j])
# w_v_list[i][1] = 0
else:
dp[i%3][j] = max(dp[i%3][j-1], dp[(i-1)%3][j])
dp[(i+1)%3] = [0]*(w+1)
# for i in dp:print(*i)
# print("\n")
print((dp[(n-1)%3][w]))
if __name__ == "__main__":
solve() | import sys
# import numpy as np
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))
# import profile
def solve():
n, w = read();
dp = [[0 for i in range(w+1)] for j in range(3)]
w_v_list = [read() for i in range(n)]
# for i in dp:print(*i)
# print("\n")
# print(w_v_list)
for i in range(n):
for j in range(w+1):
elem_w, elem_v = w_v_list[i]
if elem_w <= j:
dp[i%3][j] = max(elem_v + dp[(i-1)%3][j - elem_w], dp[i%3][j-1], dp[(i-1)%3][j])
# w_v_list[i][1] = 0
else:
dp[i%3][j] = max(dp[i%3][j-1], dp[(i-1)%3][j])
for k in range(w+1):
dp[(i+1)%3][k] = 0
# for i in dp:print(*i)
# print("\n")
print((dp[(n-1)%3][w]))
if __name__ == "__main__":
solve() | p03163 |
n, w = [int(i) for i in input().split()]
a = [0] * (w + 1)
for _ in range(n):
b, c = [int(i) for i in input().split()]
for i in reversed(list(range(w + 1))):
if i + b >= w + 1:
continue
d = i + b
a[d] = max(a[d], a[i] + c)
print((a[-1]))
| n, w = [int(i) for i in input().split()]
dp = [0] * (w + 1)
for _ in range(n):
u, v = [int(i) for i in input().split()]
for i in reversed(list(range(w - u + 1))):
dp[i + u] = max(dp[i + u], dp[i] + v)
print((max(dp)))
| p03163 |
def knapsack(N,W,weight,value):
#初期化
inf=float("inf")
dp=[[-inf for i in range(W+1)] for j in range(N+1)]
for i in range(W+1):
dp[0][i]=0
#DP
for i in range(N):
for w in range(W+1):
if weight[i]<=w: #dp[i][w-weight[i]の状態にi番目の荷物が入る可能性がある
dp[i+1][w]=max(dp[i][w-weight[i]]+value[i], dp[i][w])
else: #入る可能性はない
dp[i+1][w]=dp[i][w]
return dp[N][W]
n,w=list(map(int,input().split()))
weight=[0]*n
value=[0]*n
for i in range(n):
weight[i],value[i]=list(map(int,input().split()))
print((knapsack(n,w,weight,value))) | n,w=list(map(int,input().split()))
weight=[]
value=[]
for i in range(n):
x,v=list(map(int,input().split()))
weight.append(x)
value.append(v)
dp=[[0 for i in range(w+1)]for i in range(n+1)]
for i in range(n):
for j in range(w+1):
if j+weight[i]<=w :
dp[i+1][j+weight[i]]=max(dp[i+1][j+weight[i]],dp[i][j]+value[i])
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[-1][-1])) | p03163 |
N, W = list(map(int, input().split()))
wv = []
for _ in range(N):
wv.append(tuple(map(int, input().split())))
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(N):
wi, vi = wv[i]
for j in range(wi):
dp[i+1][j] = dp[i][j]
for j in range(wi, W+1):
dp[i+1][j] = max(dp[i][j], dp[i][j-wi] + vi)
print((dp[N][W]))
| # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
geta = lambda fn: list(map(fn, input().split()))
gete = lambda fn: fn(eval(input()))
N, W = geta(int)
cur = [0] * (W+1)
for i in range(N):
w, v = geta(int)
update = cur[:]
for j in range(w,W+1):
tmp = cur[j-w] + v
if tmp > cur[j]: update[j] = tmp
cur = update
print((cur[W]))
| p03163 |
# import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
N, W = geta(int)
cur = [0] * (W+1)
for i in range(N):
w, v = geta(int)
update = cur[:]
for j in range(w,W+1):
tmp = cur[j-w] + v
if tmp > cur[j]: update[j] = tmp
cur = update
print((cur[W]))
| # import sys
# sys.setrecursionlimit(10**5)
# from collections import defaultdict
import sys
readline = sys.stdin.buffer.readline
geta = lambda fn: list(map(fn, readline().split()))
gete = lambda fn: fn(readline())
def main():
N, W = geta(int)
cur = [0] * (W+1)
for i in range(N):
w, v = geta(int)
update = cur[:]
for j in range(w,W+1):
tmp = cur[j-w] + v
if tmp > cur[j]: update[j] = tmp
cur = update
print((cur[W]))
if __name__ == "__main__":
main() | p03163 |
import collections,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
dp = [collections.defaultdict(int) for _ in range(N+1)] #1_indexed
dp[0][0] = 0
for i in range(1,N+1):
w,v = wv[i-1]
for dw,dv in list(dp[i-1].items()):
dp[i][dw] = max(dp[i][dw],dv)
if dw+w<=W:
dp[i][dw+w] = max(dp[i][dw+w],dv+v)
print((max(dp[-1].values())))
| import collections,itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)] #1_indexed
for i,j in itertools.product(list(range(1,N+1)),list(range(W+1))):
w,v = wv[i-1]
if j-w>=0:
dp[i][j] = max(dp[i][j],dp[i-1][j-w]+v)
dp[i][j] = max(dp[i][j],dp[i-1][j])
print((dp[-1][-1]))
| p03163 |
import collections,itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)] #1_indexed
for i,j in itertools.product(list(range(1,N+1)),list(range(W+1))):
w,v = wv[i-1]
if j-w>=0:
dp[i][j] = max(dp[i][j],dp[i-1][j-w]+v)
dp[i][j] = max(dp[i][j],dp[i-1][j])
print((dp[-1][-1]))
| import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)] #1_indexed
for i in range(1,N+1):
w,v = wv[i-1]
for j in range(W+1):
if j-w>=0:
dp[i][j] = max(dp[i][j],dp[i-1][j-w]+v)
dp[i][j] = max(dp[i][j],dp[i-1][j])
print((dp[-1][-1]))
| p03163 |
n,w=list(map(int, input().split()))
wv=[list(map(int, input().split())) for _ in range(n)]
dp = [[-float("inf") for _ in range(w+1)] for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(w+1):
if j >= wv[i][0]:
dp[i + 1][j] = max(dp[i][j], dp[i][j - wv[i][0]] + wv[i][1])
else:
dp[i+1][j] = dp[i][j]
print((max(dp[-1])))
| n,w=list(map(int, input().split()))
wv=[list(map(int, input().split())) for _ in range(n)]
dp = [[0 for _ in range(w+1)] for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(w+1):
if j >= wv[i][0]:
dp[i + 1][j] = max(dp[i][j], dp[i][j - wv[i][0]] + wv[i][1])
else:
dp[i+1][j] = dp[i][j]
print((dp[-1][-1])) | p03163 |
N, W = list(map(int, input().split()))
weights, values = [], []
for _ in range(N):
w, v = list(map(int, input().split()))
weights.append(w)
values.append(v)
def solve(n, w ,weights, values):
def rec_solve(cw, cv, max_w, i):
nonlocal weights, values
#print(cw, cv, i)
if i == -1:
return cv
# take
if weights[i] + cw <= max_w:
return max(rec_solve(cw+weights[i], cv + values[i], max_w, i-1),
rec_solve(cw, cv, max_w, i-1))
else:
# dont take
return rec_solve(cw, cv, max_w, i-1)
return rec_solve(0, 0, w, n-1)
print((solve(N, W, weights, values))) | N, W = list(map(int, input().split()))
weights, values = [], []
for _ in range(N):
w, v = list(map(int, input().split()))
weights.append(w)
values.append(v)
def solve(n, w ,weights, values):
def rec_solve(cw, cv, max_w, i):
nonlocal weights, values
#print(cw, cv, i)
if i == -1:
return cv
# take
if weights[i] + cw <= max_w:
return max(rec_solve(cw+weights[i], cv + values[i], max_w, i-1),
rec_solve(cw, cv, max_w, i-1))
else:
# dont take
return rec_solve(cw, cv, max_w, i-1)
return rec_solve(0, 0, w, n-1)
def solve_fast(n_items, max_w, weights, values):
dp = [[0]*(max_w+1) for _ in range(n_items)]
dp[0] = [values[0] if i >= weights[0] else 0 for i in range(max_w+1)]
for r in range(1, n_items):
cw, cv = weights[r], values[r]
for c in range(max_w+1):
if cw > c:
dp[r][c] = dp[r-1][c]
else:
dp[r][c] = max(dp[r-1][c], dp[r-1][c-cw] + cv)
#for r in dp:
#print(r)
return dp[-1][-1]
print((solve_fast(N, W, weights, values))) | p03163 |
n,w=list(map(int,input().split()))
dp=[0]*(w+1)
for i in range(w+1):
dp[i]=[0]*(n+1)
wt=[0]*n
val=[0]*n
for i in range(n):
wt[i],val[i]=list(map(int,input().split()))
for i in range(1,w+1):
for j in range(1,n+1):
if i-wt[j-1]>=0:
# print(i,j)
dp[i][j]=max(val[j-1]+dp[i-wt[j-1]][j-1],dp[i][j-1])
else:
dp[i][j]=dp[i][j-1]
print((dp[w][n]))
# for i in range(w+1):
# print(dp[i])
| n,w=list(map(int,input().split()))
dp=[0]*(w+1)
for i in range(n):
wt,val=list(map(int,input().split()))
for j in range(w,wt-1,-1):
dp[j]=max(dp[j],dp[j-wt]+val)
# print(dp)
print((dp[w])) | p03163 |
n,w=list(map(int,input().split()))
wv=[list(map(int, input().split())) for i in range(n)]
dp=[[0]*(w+1) for _ in range(n)]
for i in range(n):
for j in range(w+1):
if i==0:
if j>=wv[i][0]:
dp[i][j]=wv[i][1]
else:
if j< wv[i][0]:
dp[i][j]=dp[i-1][j]
else:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-wv[i][0]]+wv[i][1])
print((max(dp[-1])))
| n,w=list(map(int,input().split()))
wv=[list(map(int, input().split())) for i in range(n)]
dp=[[0]*(w+1) for _ in range(n)]
for i in range(n):
for j in range(w+1):
if i==0:
if j>=wv[i][0]:
dp[i][j]=wv[i][1]
else:
if j< wv[i][0]:
dp[i][j]=dp[i-1][j]
else:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-wv[i][0]]+wv[i][1])
print((dp[n-1][w]))
| p03163 |
N,W=list(map(int,input().split()))
weights,profits = [0]*N, [0]*N
def solve_knapsack(profits, weights, capacity):
# basic checks
n = len(profits)
dp = [[0 for x in range(capacity+1)] for y in range(n)]
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, n):
dp[i][0] = 0
for c in range(0, capacity+1):
if weights[0] <= c: dp[0][c] = profits[0]
for i in range(1, n):
for c in range(1, capacity+1):
if weights[i] <= c:
dp[i][c] = max(profits[i] + dp[i - 1][c - weights[i]], dp[i - 1][c])
else: dp[i][c] = dp[i - 1][c]
# maximum profit will be at the bottom-right corner.
return dp[n - 1][capacity]
def main():
for i in range(N):
weights[i],profits[i] = list(map(int,input().split()))
res = solve_knapsack(profits, weights, W)
print(res)
if __name__ == "__main__":
main() | def main():
n, w = [int(e) for e in input().split()]
t = [-1 for i in range(w + 1)]
t[w] = 0
for _ in range(n):
nw, nv = [int(e) for e in input().split()]
for i in range(nw, w + 1):
if t[i] == -1:
continue
if t[i - nw] < t[i] + nv:
t[i - nw] = t[i] + nv
print((max(t)))
main() | p03163 |
import sys
input=sys.stdin.readline
N,W=list(map(int,input().split()))
weights,profits = [0]*N, [0]*N
def solve_knapsack(capacity):
# basic checks
n = len(profits)
dp = [0]*(capacity + 1)
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, n):
weights[i],profits[i] = list(map(int,input().split()))
for c in range(capacity, weights[i]-1, -1):
tmp = profits[i] + dp[c - weights[i]]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | import sys
input=sys.stdin.readline
N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
dp = [0]*(capacity + 1)
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, N):
weights,profits = list(map(int,input().split()))
for c in range(capacity, weights-1, -1):
tmp = profits + dp[c - weights]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | p03163 |
N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
dp = [0]*(capacity + 1)
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, N):
weights,profits = list(map(int,input().split()))
for c in range(capacity, weights-1, -1):
dp[c] = max(dp[c], profits + dp[c - weights])
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
dp = [0]*(capacity + 1)
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, N):
weights,profits = list(map(int,input().split()))
for c in range(capacity, weights-1, -1):
tmp = profits + dp[c - weights]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | p03163 |
import sys
input=sys.stdin.readline
n,w=list(map(int,input().split()))
dp=[0]*(w+1)
def ans(n,w):
for _ in range(n):
c,p=list(map(int,input().split()))
for j in range(w,c-1,-1):
tmp=dp[j-c]+p
if dp[j]<tmp:
dp[j]=tmp
return dp[-1]
print((ans(n,w))) | N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
dp = [0]*(capacity + 1)
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
for i in range(0, N):
weights,profits = list(map(int,input().split()))
for c in range(capacity, weights-1, -1):
tmp = profits + dp[c - weights]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | p03163 |
N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
dp = [0]*(W + 1)
weights, profits = [0]*(N+1), [0]*(N+1)
for i in range(0, N):
weights[i],profits[i] = list(map(int,input().split()))
for c in range(capacity, weights[i]-1, -1):
tmp = profits[i] + dp[c - weights[i]]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | N,W=list(map(int,input().split()))
def solve_knapsack(capacity):
# basic checks
# populate the capacity = 0 columns, with '0' capacity we have '0' profit
dp = [0]*(W + 1)
weights, profits = [0]*(N+1), [0]*(N+1)
for i in range(0, N):
weights[i],profits[i] = list(map(int,input().split()))
for i in range(0, N):
for c in range(capacity, weights[i]-1, -1):
tmp = profits[i] + dp[c - weights[i]]
if tmp > dp[c]: dp[c] = tmp
# maximum profit will be at the bottom-right corner.
return dp[capacity]
def main():
res = solve_knapsack(W)
print(res)
if __name__ == "__main__":
main() | p03163 |
def main():
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
wl, vl = list(zip(*wv))
srs = {
(w, -1): 0 for w in range(W+1)
}
def dp(w, i):
if w - wl[i] < 0:
return srs[(w, i-1)]
return max(
srs[(w - wl[i], i-1)] + vl[i],
srs[(w, i-1)]
)
for w in range(W+1):
for i in range(N):
srs[(w, i)] = dp(w, i)
print((srs[W, N-1]))
main()
| N, W = list(map(int, input().split()))
wvs = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * (W+1) for _ in range(N+1)]
for i, (w, v) in enumerate(wvs):
i += 1
for j in range(W+1):
if j < w:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j - w] + v, dp[i-1][j])
print((dp[N][W]))
| p03163 |
n, W = list(map(int, input().split()))
w, v = [], []
for i in range(n):
temp1, temp2 = list(map(int, input().split()))
w.append(temp1)
v.append(temp2)
#print(w, v)
#dp[i] = max(dp[i-1], dp[i]) + dp[i-2]
dp = [[None for i in range(W+1)] for j in range(n+1)]
#dp[0][0] = 0
#print(dp)
def solve(total, i):
if dp[i][total] is not None:
return dp[i][total]
if i > n-1:
return 0
if total > W:
return 0
weight, val = w[i], v[i]
if total + weight <= W:
chose = val + solve(total + weight, i+1)
unchose = solve(total, i+1)
dp[i][total] = max(chose, unchose)
return dp[i][total]
else:
dp[i][total] = solve(total, i+1)
return dp[i][total]
print((solve(0, 0))) | n, W = list(map(int, input().split()))
w, v = [], []
for i in range(n):
temp1, temp2 = list(map(int, input().split()))
w.append(temp1)
v.append(temp2)
#dp = [[None for i in range(W+1)] for j in range(n+1)]
dp = [[0 for i in range(W+1)] for j in range(n+1)]
for i in reversed(list(range(n))):
for j in reversed(list(range(W))):
weight, val = w[i], v[i]
if j + weight <= W:
chose = dp[i+1][j + weight] + val
unchose = dp[i+1][j]
dp[i][j] = max(chose, unchose)
else:
dp[i][j] = dp[i+1][j]
#print(dp)
#print(dp[n][W])
print((dp[0][0])) | p03163 |
N, W = list(map(int, input().split()))
w, v = [], []
for i in range(N):
t1, t2 = list(map(int, input().split()))
w.append(t1)
v.append(t2)
def solve(idx, weight, val):
if weight > W:
return -1
if idx == N:
return val
# select
v1 = solve(idx + 1, weight + w[idx], val + v[idx])
# not select
v2 = solve(idx + 1, weight, val)
return max(v1, v2)
print((solve(0, 0, 0))) | import sys
sys.setrecursionlimit(10**6)
N, W = list(map(int, input().split()))
w, v = [], []
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(N):
t1, t2 = list(map(int, input().split()))
w.append(t1)
v.append(t2)
for idx in range(1, N+1):
for weight in range(W+1):
if weight - w[idx - 1] < 0:
dp[idx][weight] = dp[idx - 1][weight]
continue
# Select
# v1 = dp[idx - 1][weight - w[idx]] + v[idx]
v1 = dp[idx - 1][weight - w[idx - 1]] + v[idx - 1]
# Not Select
v2 = dp[idx - 1][weight]
dp[idx][weight] = max(v1, v2)
# for i in range(N+1):
# print(dp[i])
print((dp[N][W])) | p03163 |
N, W = list(map(int, input().split()))
w_list = []
v_list = []
dp = []
for _ in range(N):
w, v = list(map(int, input().split()))
w_list.append(w)
v_list.append(v)
dp.append({})
dp.append({})
for i in range(N + 1):
for w in range(0, W + 1):
dp[i][w] = 0
for i in range(N):
for j in range(W + 1):
sum_w = j
if sum_w - w_list[i] >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - w_list[i]] + v_list[i])
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((max(max(x.values()) for x in dp)))
| N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(W - w, -1, -1):
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
| p03163 |
def main():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[0] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(W - w, -1, -1):
pre_v = dp[i]
if pre_v == -1: continue
dp[i + w] = max(dp[i + w], pre_v + v)
print((max(dp)))
main()
| def main():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[0] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(W - w, -1, -1):
if dp[i] != -1 and dp[i + w] < dp[i] + v:
dp[i + w] = dp[i] + v
print((max(dp)))
main()
| p03163 |
"""
AtCoder Educational DP Contest
https://atcoder.jp/contests/dp/tasks/dp_d
D - Knapsack 1
"""
INF = 100000007
def solve(wv_pairs):
dp = [0] * (W + 1)
for i in range(N):
w_i, v_i = wv_pairs[i]
for ww in range(W, w_i - 1, -1):
dp[ww] = max(dp[ww], dp[ww - w_i] + v_i)
return max(dp[ww] for ww in range(W + 1))
N, W = list(map(int, input().split()))
pairs = [[int(s) for s in input().split()] for _ in range(N)]
res = solve(pairs)
print(res)
| """
AtCoder Educational DP Contest
https://atcoder.jp/contests/dp/tasks/dp_d
D - Knapsack 1
"""
def solve(wv_pairs):
dp = [0] * (W + 1)
for i in range(N):
w_i, v_i = wv_pairs[i]
for ww in range(W, w_i - 1, -1):
dp[ww] = max(dp[ww], dp[ww - w_i] + v_i)
return max(dp)
N, W = list(map(int, input().split()))
pairs = [[int(s) for s in input().split()] for _ in range(N)]
res = solve(pairs)
print(res)
| p03163 |
N,W=list(map(int,input().split()))
A=[]
for _ in range(N):
B=list(map(int,input().split()))
A.append(B)
dp=[]
for _ in range(N):
dp.append([0]*(W+1))
for j in range(W+1):
if j>=A[0][0]:
dp[0][j]=A[0][1]
for i in range(0,N-1):
for w in range(W+1):
if w>=A[i+1][0]:
dp[i+1][w]=max(dp[i][w-A[i+1][0]]+A[i+1][1],dp[i][w])
else:
dp[i+1][w]=dp[i][w]
print((dp[N-1][W])) | N,W = list(map(int,input().split()))
v = [0] * (N)
w = [0] * (N)
for i in range(N):
w_t,v_t = list(map(int,input().split()))
v[i] = v_t
w[i] = w_t
dp = [[0] * (W+1) for _ in range(N+1)]
for j in range(N):
for k in range(1,W+1):
if k >= w[j]:
dp[j+1][k] = max(dp[j][k],dp[j][k-w[j]]+v[j])
else:
dp[j+1][k] = dp[j][k]
print((dp[N][W]))
| p03163 |
import sys
input = sys.stdin.readline
N, W = [int(x) for x in input().split()]
wv = []
for _ in range(N):
wv.append([int(x) for x in input().split()])
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
w, v = wv[i]
if j >= w:
dp[i + 1][j] = max(dp[i][j], dp[i][j - w] + v)
else:
dp[i + 1][j] = dp[i][j]
print((dp[N][W])) | import sys
input = sys.stdin.readline
n, W = [int(x) for x in input().split()]
wv = [[int(x) for x in input().split()] for _ in range(n)]
dp = [[0] * (W + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
w, v = wv[i - 1]
for j in range(W + 1):
if j - w >= 0:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
print((dp[-1][-1])) | p03163 |
N,W=list(map(int,input().split()))
w=[]
v=[]
for i in range(N):
ww,vv=list(map(int,input().split()))
w.append(ww)
v.append(vv)
dp=[[0 for i in range(W+10)] for j in range(N+10)]
for i in range(N):
for j in range(W+1):
if(j-w[i]>=0):
dp[i+1][j]=max(dp[i+1][j],dp[i][j-w[i]]+v[i])
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[N][W])) | N,W=list(map(int,input().split()))
w=[]
v=[]
for i in range(N):
ww,vv=list(map(int,input().split()))
w.append(ww)
v.append(vv)
dp=[[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N):
for j in range(W+1):
if(j-w[i]>=0):
dp[i+1][j]=max(dp[i+1][j],dp[i][j-w[i]]+v[i])
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[N][W])) | p03163 |
n,w = list(map(int,input().split()))
v = [0]*(n+1)
for i in range(1,n+1):
v[i] = list(map(int,input().split()))
dp = [[0 for j in range(w+1)] for i in range(n+1)]
for i,[W,V] in enumerate(v[1:],1):
for j in range(w):
dp[i][w-1-j] = dp[i-1][w-1-j]
if w-1-j + W <= w:
dp[i][w-1-j+W] = max(dp[i][w-1-j]+V, dp[i][w-1-j+W])
ans = 0
for i in range(n+1):
ans = max(ans, max(dp[i]))
print(ans) | n,w = list(map(int,input().split()))
v = [0]*n
for i in range(n):
v[i] = list(map(int,input().split()))
dp = [[0 for j in range(w+1)] for i in range(n+1)]
for i,[W,V] in enumerate(v):
for j in range(w):
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
if j + W <= w:
dp[i+1][j+W] = max(dp[i][j]+V, dp[i+1][j+W])
ans = 0
for i in range(1,n+1):
ans = max(ans, max(dp[i]))
print(ans)
| p03163 |
def chmax(a, b):
if a < b:
return b
return a
def main():
N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
dp = [0] * (W + 1)
for w, v in WV:
for sumw in range(W, w - 1, -1):
dp[sumw] = chmax(dp[sumw], dp[sumw - w] + v)
#for x in dp:
# print("{:4d}".format(x), end="")
#print()
return max(dp)
print((main()))
| def main():
N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
dp = [0] * (W + 1)
for w, v in WV:
for sumw in range(W, w - 1, -1):
t = dp[sumw - w] + v
if dp[sumw] < t:
dp[sumw] = t
#for x in dp:
# print("{:4d}".format(x), end="")
#print()
return max(dp)
print((main()))
| p03163 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
N,W = imn()
wv = [iln() for _ in range(N)]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for sum_w in range(0,W+1):
if (sum_w - wv[i][0]) >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w-wv[i][0]]+wv[i][1])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[N][W]))
| import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
N,W = imn()
wv = [iln() for _ in range(N)]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if sum_w - wv[i][0] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w-wv[i][0]]+wv[i][1])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[N][W])) | p03163 |
n, w = [int(i) for i in input().split()]
wv = [[int(i) for i in input().split()] for _ in range(n)]
# i番目以降の品物で、容量がjのときの価値の最大値
def value(i, j):
# もう品物がない
if i == n:
ret = 0
# 品物が入らない
elif j < wv[i][0]:
ret = value(i+1, j)
# 品物を入れない場合と入れる場合
else:
ret = max(value(i+1, j), value(i+1, j-wv[i][0]) + wv[i][1])
return ret
print((value(0, w)))
| n, w = [int(i) for i in input().split()]
wv = [[int(i) for i in input().split()] for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(1, n+1):
wi, vi = wv[i-1]
for j in range(1, w+1):
if j < wi:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-wi] + vi)
print((dp[-1][-1]))
| p03163 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,w = LI()
aa = [LI() for _ in range(n)]
r = [0] * (w+1)
for a,b in aa:
for i in range(w-a,-1,-1):
if r[i+a] < b + r[i]:
r[i+a] = b + r[i]
return max(r)
print(main())
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
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 I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
n,w = LI()
aa = sorted([LI() for _ in range(n)])
r = [0] * (w+1)
mx = 0
for a,b in aa:
mx += a
for i in range(min(mx, w-a),-1,-1):
if r[i+a] < b + r[i]:
r[i+a] = b + r[i]
return max(r)
print(main())
| p03163 |
N,W = list(map(int, input().split()))
w = [0]*N
v = [0]*N
for i in range(N):
w[i],v[i] = list(map(int,input().split()))
dp = [[int(0) for i in range(W+1)] for i in range(N)]
ans = int(0)
dp[0][0] = 0
for i in range(0,N):
for j in range(W+1):
if j==0:
dp[i][j] = 0
elif w[i]>j:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = dp[i - 1][j - w[i]] + v[i]
ans = max(max(dp))
print(ans) |
N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
# dp[i][j](j=0,1,...,W)の値が求まっている状態で、dp[i+1][j]を更新することを考える
for i in range(N):
for j in range(W + 1):
# 品物(w[i],v[i])を選ぶとき、j-w[i]>=0に限って、価値v[i]が加算される
if j - w[i] >= 0:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - w[i]] + v[i])
# 品物(w[i],v[i])を選ばないとき、何も加算しない
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
print((dp[N][W])) | p03163 |
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
items = []
for i in range(N):
w, v = list(map(int, input().split()))
items.append((w, v))
for w, v in items:
for wk in range(W, w - 1, -1):
tv = dp[wk - w] + v
if tv > dp[wk]:
dp[wk] = tv
print((max(dp)))
| def nap(n, cap):
val = [0] * (cap + 1)
for _ in range(n):
w, v = list(map(int, input().split()))
for wk in range(cap, w - 1, -1):
nv = val[wk - w] + v
if val[wk] < nv:
val[wk] = nv
return max(val)
n, cap = list(map(int, input().split()))
print((nap(n, cap)))
| p03163 |
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
items = []
for i in range(N):
w, v = list(map(int, input().split()))
items.append((w, v))
for w, v in items:
for wk in range(W, w - 1, -1):
tv = dp[wk - w] + v
if tv > dp[wk]:
dp[wk] = tv
res = max(dp)
print(res)
| def solve():
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
items = []
for i in range(N):
w, v = list(map(int, input().split()))
items.append((w, v))
for w, v in items:
for wk in range(W, w - 1, -1):
tv = dp[wk - w] + v
if tv > dp[wk]:
dp[wk] = tv
res = max(dp)
print(res)
if __name__ == "__main__":
solve()
| p03163 |
n,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
res=[0 for _ in range(w+1)]
for i in range(n):
for j in range(w,a[i][0]-1,-1):
res[j]=max(res[j],res[j-a[i][0]]+a[i][1])
print((res[w])) | import sys
input=sys.stdin.readline
n,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
res=[0 for _ in range(w+1)]
for i in range(n):
for j in range(w,a[i][0]-1,-1):
res[j]=max(res[j],res[j-a[i][0]]+a[i][1])
print((res[w])) | p03163 |
def solve():
N, W = list(map(int, input().split()))
w = []
v = []
for i in range(N):
tmpw, tmpv = list(map(int, input().split()))
w.append(tmpw)
v.append(tmpv)
dp = [[0] * (W+1) for i in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if sum_w - w[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w-w[i]]+ v[i])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[-1][-1]))
if __name__ == '__main__':
solve()
| def solve():
N, W = list(map(int, input().split()))
weight = []
value = []
for i in range(N):
tmpw, tmpv = list(map(int, input().split()))
weight.append(tmpw)
value.append(tmpv)
dp = [[0] * (W+1) for i in range(N+1)]
for i in range(N):
for w_i in range(W+1):
if w_i - weight[i] >= 0:
dp[i+1][w_i] = max(dp[i+1][w_i], dp[i][w_i - weight[i]] + value[i])
dp[i+1][w_i] = max(dp[i+1][w_i], dp[i][w_i])
print((dp[N][W]))
if __name__ == '__main__':
solve()
| p03163 |
def solve():
N, W = list(map(int, input().split()))
w = []
v = []
for i in range(N):
tmpw, tmpv = list(map(int, input().split()))
w.append(tmpw)
v.append(tmpv)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0] = 0
for j in range(W+1):
dp[0][j] = 0
for i in range(1,N+1):
for sum_w in range(1, W+1):
if sum_w - w[i-1] >= 0:
dp[i][sum_w] = max(dp[i][sum_w], dp[i-1][sum_w - w[i-1]] + v[i-1])
dp[i][sum_w] = max(dp[i][sum_w], dp[i-1][sum_w])
print((dp[N][W]))
if __name__ == '__main__':
solve() | def solve():
N,W = list(map(int,input().split()))
weight = []
value = []
for i in range(N):
w, v = list(map(int,input().split()))
weight.append(w)
value.append(v)
dp = [[0] * (W+1) for i in range(N+1)]
for i in range(1,N+1):
for w in range(W+1):
if w - weight[i-1] < 0:
dp[i][w] = max(dp[i][w], dp[i-1][w])
else:
dp[i][w] = max(dp[i][w], dp[i-1][w-weight[i-1]] + value[i-1])
dp[i][w] = max(dp[i][w], dp[i-1][w])
print((max(dp[-1])))
if __name__ == '__main__':
solve() | p03163 |
import sys
input = sys.stdin.readline
def main():
N,W = list(map(int,input().split()))
dp = [0 for _ in range(W+1)]
for _ in range(N):
nm,nv = [int(a) for a in input().split()]
for j in range(W-nm+1)[::-1]:
a = nm
if dp[j+a] < dp[j] + nv:
dp[j+a] = dp[j] + nv
print((max(dp)))
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
N,W = list(map(int,input().split()))
dp = [-1 for _ in range(W+1)]
dp[W] = 0
for _ in range(N):
nm,nv = [int(a) for a in input().split()]
for j in range(nm,W+1):
a = nm
if dp[j] == -1:
continue
if dp[j-a] < dp[j] + nv:
dp[j-a] = dp[j] + nv
print((max(dp)))
if __name__ == "__main__":
main() | p03163 |
# AtCoder DP Task D - Knapsack 1
def knapsack(target, W, V): # target=knapsack weight
P = [[0] * (target + 1) for _ in range(len(V))]
for vi in range(len(V)):
row, prev = P[vi], P[vi - 1]
for w in range(target + 1):
if vi > 0:
row[w] = prev[w] # same value without vi-th item
if w >= W[vi]:
new = P[vi - 1][w - W[vi]] + V[vi]
if new > P[vi][w]: # most value
row[w] = new
else:
if w >= W[vi]:
row[w] = V[vi]
return P[len(V) - 1][target]
def knapsack_rec(target, W, V): # target=knapsack weight
P = [[-1] * (target + 1) for _ in range(len(V))]
def rec(w, index):
if index == 0 and w >= W[index]:
return V[index]
elif index > 0:
if P[index][w] != -1:
return P[index][w]
r = rec(w, index - 1)
if w >= W[index]:
y = rec(w - W[index], index - 1) + V[index]
r = r if r > y else y
P[index][w] = r
return r
return 0
ret = rec(target, len(V) - 1)
return ret
assert knapsack_rec(15, [6, 5, 6, 6, 3, 7], [5, 6, 4, 6, 5, 2]) == 17
if __name__ == "__main__":
import sys
n, w, *r = list(map(int, sys.stdin.read().split()))
W, V = r[::2], r[1::2]
ans = knapsack_rec(w, W, V)
print(ans)
| # AtCoder DP Task D - Knapsack 1
def knapsack(target, W, V): # target=knapsack weight
P = [[0] * (target + 1) for _ in range(len(V))]
for vi in range(len(V)):
row, prev = P[vi], P[vi - 1]
for w in range(target + 1):
if vi > 0:
row[w] = prev[w] # same value without vi-th item
if w >= W[vi]:
new = P[vi - 1][w - W[vi]] + V[vi]
if new > P[vi][w]: # most value
row[w] = new
else:
if w >= W[vi]:
row[w] = V[vi]
return P[len(V) - 1][target]
def knapsack_rec(target, W, V): # target=knapsack weight
P = [-1] * (target + 1)
P[target] = 0 # default + max
for vi in range(len(V)):
we = W[vi]
va = V[vi]
for i in range(we, target + 1):
if P[i] != -1 and P[i - we] < P[i] + va:
P[i - we] = P[i] + va
return max(P)
assert knapsack_rec(15, [6, 5, 6, 6, 3, 7], [5, 6, 4, 6, 5, 2]) == 17
if __name__ == "__main__":
import sys
n, w, *r = list(map(int, sys.stdin.read().split()))
W, V = r[::2], r[1::2]
ans = knapsack_rec(w, W, V)
print(ans)
| p03163 |
N,W = list(map(int, input().split()))
dp = [0] * (W + 1)
nupList = [list(map(int, input().split())) for _ in range(N)]
for w, v in nupList:
for j in range(W, w - 1, -1 ):
DP = dp[j - w] + v
if dp[j] < DP:
dp[j] = DP
print((dp[W]))
| def DP():
n,W = list(map(int, input().split(' ')))
WV = (list(map(int, input().split(' '))) for _ in range(n))
dp = [0] * (W+1)
for w, v in WV:
for j in range(W, w-1, -1):
DP = dp[j-w] + v
if dp[j] < DP:
dp[j] = DP
return max(dp)
print((DP())) | p03163 |
N,W = list(map(int, input().split()))
nupList = (list(map(int, input().split())) for _ in range(N))
dp = [0] * (W + 1)
for w, v in nupList:
for j in range(W, w - 1, -1 ):
DP = dp[j - w] + v
if dp[j] < DP:
dp[j] = DP
print((dp[W])) | def d():
N,W = list(map(int, input().split()))
nupList = (list(map(int, input().split())) for _ in range(N))
dp = [0] * (W + 1)
for w, v in nupList:
for j in range(W, w - 1, -1 ):
DP = dp[j - w] + v
if dp[j] < DP:
dp[j] = DP
return max(dp)
print((d())) | p03163 |
n, W = list(map(int, input().split()))
weights = []
values = []
for _ in range(n):
w, v = list(map(int, input().split()))
weights.append(w)
values.append(v)
def iterative_knapsack(wt, val, W, n):
# Take the equations in recursive_knapsack. Change the recursive call to the table t. CHange all instances of n to i and W to j.
# Also the table t was initialized using the base conditions of recursive_knapsack.
t = [[0]*(W+1) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, W+1):
# if weight of item less than knapsack
if wt[i-1]<=j:
include = val[i-1] + t[i-1][j-wt[i-1]] # val[n-1] + recursive_knapsack(wt, val, W-wt[n-1], n-1)
exclude = t[i-1][j] # recursive_knapsack(wt, val, W, n-1)
t[i][j] = max(include, exclude)
else:
t[i][j] = t[i-1][j] # recursive_knapsack(wt, val, W, n-1)
return t[n][W]
print((iterative_knapsack(weights, values, W, n))) | def memo_knapsack(w, n):
if memo[w][n]!=-1:
return memo[w][n]
else:
if w == 0 or n == 0: return 0 # no capacity knapsack has 0 value; no items has 0 value
if weights[n-1]>w:
# cant include
memo[w][n] = memo_knapsack(w, n-1)
return memo[w][n]
else:
include = values[n-1] + memo_knapsack(w - weights[n-1], n-1)
exclude = memo_knapsack(w, n-1)
memo[w][n] = max(include, exclude)
return memo[w][n]
n, W = list(map(int, input().split()))
weights = []
values = []
for _ in range(n):
w, v = list(map(int, input().split()))
weights.append(w)
values.append(v)
# memo[w][n] - max value we can obtain with capacity w and number of items n
memo = [[-1]*(n+1) for _ in range(W + 1)]
print((memo_knapsack(W, n))) | p03163 |
n,w = list(map(int,input().split()))
dp = {(0,0)}
for i in range(n):
weight,value = list(map(int,input().split()))
gone=set()
for noww,nowv in dp:
if noww + weight <= w:
gone.add((noww + weight,nowv + value))
gone.add((noww,nowv))
dp = gone
ans = 0
for lastw,lastv in dp:
ans = max(ans,lastv)
print(ans) | n,w = list(map(int,input().split()))
dp = [-1] * (w + 1)
dp[0] = 0
for i in range(n):
weight,value = list(map(int,input().split()))
for j in range(w,-1,-1):
if dp[j] != -1 and weight + j <= w:
dp[weight+j] = max(dp[weight+j],dp[j] + value)
print((max(dp))) | p03163 |
n,w = list(map(int,input().split()))
lstw, lstv = [], []
for i in range(n):
w_,v_ = list(map(int,input().split()))
lstw.append(w_)
lstv.append(v_)
#dp[i+1][j] := i番目までの商品で重さの総和がj以下の最大価値
dp = [[0 for i in range(w+1)] for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
if j < lstw[i]:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j], dp[i][j-lstw[i]]+lstv[i])
print((dp[n][w])) | n,w = list(map(int,input().split()))
lstw, lstv = [], []
for i in range(n):
w_,v_ = list(map(int,input().split()))
lstw.append(w_)
lstv.append(v_)
dp = [[0 for i in range(w+1)] for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
if j < lstw[i]:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j], dp[i][j-lstw[i]]+lstv[i])
print((dp[n][w])) | p03163 |
def knapsack_1(N, W, lst):
#N : 品物数
#W : 重みの総和
#lst (wi,vi) : 商品iの重みwi、価値vi
#dp[i][j] : i番目の品物から重さの総和がj以下になるように選んだ場合の価値の総和の最大値
dp = [[0 for i in range(W+1)] for _ in range(N+1)]
for i in range(N):
for j in range(W+1):
if j < lst[i][0]:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j],dp[i][j - lst[i][0]] + lst[i][1])
return dp[N][W]
n,w = list(map(int,input().split()))
lst = []
for i in range(n):
w_, v_ = list(map(int,input().split()))
lst.append((w_, v_))
print((knapsack_1(n,w,lst))) | n,w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
wi, vi = wv[i]
for j in range(w+1):
if j<wi:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j], dp[i][j-wi]+vi)
print((dp[n][w])) | p03163 |
N, W = list(map(int, input().split()))
w = [0]*N
v = [0]*N
for i in range(N):
w[i],v[i] = list(map(int, input().split()))
def solve(w,v):
dp = [[0]*(W+1) for i in range(N+1)]
for i in range(1,N+1):
for j in range(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])
ans = dp[-1][-1]
return ans
print((solve(w,v))) | def solve():
ans = 0
N, W = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(1,N+1):
w,v = list(map(int, input().split()))
for j in range(W+1):
dp[i][j] = max(dp[i-1][j],dp[i][j])
if j+w<=W:
dp[i][j+w] = max(dp[i-1][j+w],dp[i-1][j]+v)
return dp[-1][-1]
print((solve())) | p03163 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(N+1)]
def npsk_1(N, W):
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W+1):
if j >= w:
dp[i+1][j] = max(dp[i][j], dp[i][j - w] + v)
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
npsk_1(N, W) | # PyPy3
N, W = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(N+1)]
def npsk_1(N, W):
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W+1):
if j >= w:
dp[i+1][j] = max(dp[i][j], dp[i][j - w] + v)
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
npsk_1(N, W) | p03163 |
def aaa():
N, W = list(map(int, input().split()))
dp = [0] * (W+1) # DP枠_重さ’0’～'W'まで準備
for i in range(N):
w, v = list(map(int, input().split())) # 商品, 各々重さと価値
tmp =tuple(dp[:]) # ひとつ前の商品までのDP枠を参照用にコピー
for j in range(1, W+1): # 各商品のDP枠への落とし込み
if j >= w and tmp[j] < tmp[j-w] + v: # 商品の重さよりDP枠の重さが重い場合で...
dp[j] = tmp[j-w] + v # この商品を加え, 合計価値が up する場合は replace
else: # 商品の重さよりDP枠の重さが軽い場合と, ↑で価値が up しない場合は...
dp[j] = tmp[j] # ↑ 参照データをそのままコピー
print((dp[-1]))
aaa() | # AC by Pypy not Python
# Pythonで通すためには, npで配列毎まるっと処理する必要あり
N, W = list(map(int, input().split()))
dp = [0] * (W+1) # DP枠_重さ’0’～'W'まで準備
for i in range(N):
w, v = list(map(int, input().split())) # 商品, 各々重さと価値
tmp = dp[:] # ひとつ前の商品までのDP枠を参照用にコピー
for j in range(1, W+1): # 各商品のDP枠への落とし込み
if j >= w and tmp[j] < tmp[j-w] + v: # 商品の重さよりDP枠の重さが重い場合で...
dp[j] = tmp[j-w] + v # この商品を加え, 合計価値が up する場合は replace
else: # 商品の重さよりDP枠の重さが軽い場合と, ↑で価値が up しない場合は...
dp[j] = tmp[j] # ↑ 参照データをそのままコピー
print((dp[-1]))
| p03163 |
#!/usr/bin/env python3
N, W=list(map(int, input().split()))
WV=[list(map(int, input().split())) for i in range(N)]
dp = [-1] * (W+1)
dp[0] = 0
for w, v in WV:
for i in range(W, w-1, -1):
if dp[i-w] == -1:
continue
dp[i] = max(dp[i], dp[i-w] + v)
print((max(dp)))
| N, W=list(map(int, input().split()))
WV=[list(map(int, input().split())) for i in range(N)]
dp = [-1] * (W+1)
dp[0] = 0
for w, v in WV:
for i in range(W, w-1, -1):
if dp[i-w] == -1:
continue
dp[i] = max(dp[i], dp[i-w] + v)
print((max(dp)))
| p03163 |
# -*- coding:utf-8 -*-
"""
問題
https://atcoder.jp/contests/dp/tasks/dp_d
解説
https://qiita.com/drken/items/dc53c683d6de8aeacf5a#d-%E5%95%8F%E9%A1%8C---knapsack-1
"""
def solve():
N, LIMIT = list(map(int, input().split()))
W, V = [None], [None]
for i in range(N):
w, v = list(map(int, input().split()))
W.append(w)
V.append(v)
# dp[i][w] := i個目までの品物を選んだ時の、重さがwのときの価値の最大値
dp = [[w for w in range(LIMIT+1)] for i in range(N+1)]
for w in range(LIMIT+1):
dp[0][w] = 0
#O(N*LIMIT) = O(10**7)
for i in range(1, N+1):
for w in range(LIMIT+1):
if w-W[i] >= 0:
dp[i][w] = max(dp[i-1][w], dp[i-1][w-W[i]] + V[i])
else:
dp[i][w] = dp[i-1][w]
ans = 0
for w in range(LIMIT+1):
ans = max(ans, dp[N][w])
print(ans)
if __name__ == "__main__":
solve()
| # -*- coding:utf-8 -*-
"""
問題
https://atcoder.jp/contests/dp/tasks/dp_d
解説
https://qiita.com/drken/items/dc53c683d6de8aeacf5a#d-%E5%95%8F%E9%A1%8C---knapsack-1
"""
def solve():
"""
Python: TLE (´･_･`)
"""
N, LIMIT = list(map(int, input().split()))
W, V = [None], [None]
for i in range(N):
w, v = list(map(int, input().split()))
W.append(w)
V.append(v)
# dp[i][w] := i個目までの品物を選んだ時の、重さがwのときの価値の最大値
dp = [[w for w in range(LIMIT+1)] for i in range(N+1)]
for w in range(LIMIT+1):
dp[0][w] = 0
#O(N*LIMIT) = O(10**7)
for i in range(1, N+1):
for w in range(LIMIT+1):
if w-W[i] >= 0:
dp[i][w] = max(dp[i-1][w], dp[i-1][w-W[i]] + V[i])
else:
dp[i][w] = dp[i-1][w]
ans = 0
for w in range(LIMIT+1):
ans = max(ans, dp[N][w])
print(ans)
if __name__ == "__main__":
solve()
| p03163 |
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
inf = float("inf")
dp = [[-inf for _ in range(W+1)] for _ in range(N+1)]
for i in range(W+1):
dp[0][i] = 0
for i in range(N):
weight = wv[i][0]
value = wv[i][1]
for w in range(W+1):
# 重量に収まる場合のみ価値を加える
if weight <= w:
dp[i+1][w] = max(dp[i][w-weight] + value, dp[i][w])
else:
dp[i+1][w] = dp[i][w]
print((max(dp[-1])))
| # ナップザック問題
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
inf = float("inf")
dp = [[-inf for _ in range(W+1)] for _ in range(N+1)]
for i in range(W+1):
dp[0][i] = 0
for i in range(N):
weight = wv[i][0]
value = wv[i][1]
for w in range(W+1):
# 重量に収まる場合のみ価値を加える
if weight <= w:
dp[i+1][w] = max(dp[i][w-weight] + value, dp[i][w])
else:
dp[i+1][w] = dp[i][w]
print((max(dp[-1])))
| p03163 |
N, W = list(map(int, input().split()))
WEIGHTS = list(list(map(int, input().split())) for _ in range(N))
M = len(WEIGHTS)
DP = [[0] * M for _ in range(W + 3)]
for i in range(W+1):
for j, (weight, value) in enumerate(WEIGHTS):
if i - weight >= 0:
DP[i+1][j] = max(x if index != j else 0 for index, x in enumerate(DP[max(i - weight + 1, 0)])) + value
print((max(DP[W + 1])))
| N, W = list(map(int, input().split()))
WEIGHTS = list(list(map(int, input().split())) for _ in range(N))
M = len(WEIGHTS)
DP = [[0 for _ in range(W + 1)] for _ in range(M + 1)]
for i, (weight, value) in enumerate(WEIGHTS):
for w in range(W + 1):
if w - weight >= 0:
DP[i+1][w] = max(DP[i][w - weight] + value, DP[i][w])
else:
DP[i+1][w] = DP[i][w]
print((DP[M][W])) | p03163 |
N, W = list(map(int, input().split()))
WEIGHTS = list(list(map(int, input().split())) for _ in range(N))
M = len(WEIGHTS)
DP = [[0 for _ in range(W + 1)] for _ in range(M + 1)]
for i, (weight, value) in enumerate(WEIGHTS):
for w in range(W + 1):
if w - weight >= 0:
DP[i+1][w] = max(DP[i][w - weight] + value, DP[i][w])
else:
DP[i+1][w] = DP[i][w]
print((DP[M][W])) | N, W = list(map(int, input().split()))
WEIGHTS = list(list(map(int, input().split())) for _ in range(N))
M = len(WEIGHTS)
DP = [[0 for _ in range(W + 1)] for _ in range(M + 1)]
for i, (weight, value) in enumerate(WEIGHTS):
for w in range(W + 1):
if w - weight >= 0:
DP[i+1][w] = max(DP[i][w - weight] + value, DP[i][w])
else:
DP[i+1][w] = DP[i][w]
print((DP[M][W]))
# dp_ij := 1~jまでのアイテムからいくつかを選んで総重量iを超えないようにしたときの最大価値
# 0 1 2 3 4 5 6 7 8
# 0 0 0 0 0 0 0 0 0
# 0 0 0 30 30 30 30 30 30
# 0 0 0 30 50 50 50 80 80
# 0 0 0 30 50 60 60 80 90
| p03163 |
N, W = list(map(int, input().split()))
w = []
v = []
for _ in range(N):
wv = list(map(int, input().split()))
w.append(wv[0])
v.append(wv[1])
dp = [[0, 0]]
for i in range(1, W+1):
max_t = 0
flag = 0
for j in range(N):
if w[j] > i or dp[i-w[j]][1] & (1 << j):
continue
if max_t < dp[i-w[j]][0] + v[j]:
max_t = dp[i-w[j]][0] + v[j]
flag = dp[i-w[j]][1] | (1 << j)
dp += [[max_t, flag]]
print((dp[W][0]))
| N, W = list(map(int, input().split()))
w = []
v = []
for _ in range(N):
wv = list(map(int, input().split()))
w.append(wv[0])
v.append(wv[1])
dp = [[0, 0]]
for i in range(1, W+1):
max_t = dp[i-1][0]
flag = dp[i-1][1]
for j in range(N):
if w[j] > i or dp[i-w[j]][1] & (1 << j):
continue
if max_t < dp[i-w[j]][0] + v[j]:
max_t = dp[i-w[j]][0] + v[j]
flag = dp[i-w[j]][1] | (1 << j)
dp += [[max_t, flag]]
print((dp[W][0]))
| p03163 |
N, W = list(map(int, input().split()))
weight = []
value = []
for i in range(N):
w, v = list(map(int, input().split()))
weight.append(w)
value.append(v)
# print('weight')
# print(weight)
# print('value')
# print(value)
def dfs(index, v, w):
x = 0
if (index >= N):
return v
if (w + weight[index] <= W):
x = dfs(index+1, v+value[index], w+weight[index])
y = dfs(index+1,v,w)
return max(x, y)
# ans = dfs(0, 0, 0)
dp = []
for i in range(N+1):
dp.append([])
for j in range(W+1):
dp[i].append(0)
# print(dp)
# print(weight)
# print(value)
# max value = dp[何個まで見たか][現在の重さ]
for i in range(N):
for j in range(W+1):
# if j+weight[i] <= W:
# dp[i+1][j+weight[i]] = max(dp[i][j+weight[i]], dp[i][j]+value[i])
# else:
# dp[i+1][j] = dp[i][j]
# if
if j >= weight[i]:
dp[i+1][j] = max(dp[i][j-weight[i]]+value[i], dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
weight = []
value = []
for i in range(N):
w, v = list(map(int, input().split()))
weight.append(w)
value.append(v)
def dfs(index, v, w):
x = 0
if (index >= N):
return v
if (w + weight[index] <= W):
x = dfs(index+1, v+value[index], w+weight[index])
y = dfs(index+1,v,w)
return max(x, y)
# ans = dfs(0, 0, 0)
dp = []
for i in range(N+1):
dp.append([])
for j in range(W+1):
dp[i].append(0)
# max value = dp[何個まで見たか][現在の重さ]
for i in range(N):
for j in range(W+1):
# if j+weight[i] <= W:
# dp[i+1][j+weight[i]] = max(dp[i][j+weight[i]], dp[i][j]+value[i])
# else:
# dp[i+1][j] = dp[i][j]
# if
if j >= weight[i]:
dp[i+1][j] = max(dp[i][j-weight[i]]+value[i], dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
| p03163 |
"""memo
numpyでやるときは配列を一気に更新するが(numpy使いたくないのでやらない)，
このやり方は後ろの方から更新することで後の更新に影響を与えない(考え方すごい)．
(参考#9889377)
"""
import sys
input = sys.stdin.readline
def main():
#1:初期化
N,W = list(map(int,input().split()))
dp = [0]*(W+1)
#2:初期値(元からゼロなので記述無し)
#3:dp実行部(貰うDP)
for i in range(N):
w, v = list(map(int,input().split()))
for i in range(W, w-1, -1):
if (dp[i] < (dp[i-w] + v)):
dp[i] = dp[i-w] + v
#print(dp,sep="\n")
#4:出力
print((max(dp)))
if __name__ == '__main__':
main() | """memo
numpyでやるときは配列を一気に更新するが(numpy使いたくないのでやらない)，
このやり方は後ろの方から更新することで後の更新に影響を与えない(考え方すごい)．
(参考#9889377)
"""
import sys
input = sys.stdin.readline
def main():
#1:初期化
N,W = list(map(int,input().split()))
dp = [0]*(W+1)
#2:初期値(元からゼロなので記述無し)
#3:dp実行部(貰うDP)
for i in range(N):
w, v = list(map(int,input().split()))
for i in range(W, w-1, -1):
tmp = dp[i-w] + v
if dp[i] < tmp:
dp[i] = tmp
#print(dp,sep="\n")
#4:出力
print((max(dp)))
if __name__ == '__main__':
main() | p03163 |
"""memo
numpyでやるときは配列を一気に更新するが(numpy使いたくないのでやらない)，
このやり方は後ろの方から更新することで後の更新に影響を与えない(考え方すごい)．
(参考#9889377)
"""
import sys
input = sys.stdin.readline
def main():
#1:初期化
N,W = list(map(int,input().split()))
dp = [0]*(W+1)
#2:初期値(元からゼロなので記述無し)
#3:dp実行部(貰うDP)
for i in range(N):
w, v = list(map(int,input().split()))
for i in range(W, w-1, -1):
tmp = dp[i-w] + v
if dp[i] < tmp:
dp[i] = tmp
#print(dp,sep="\n")
#4:出力
print((max(dp)))
if __name__ == '__main__':
main() |
import sys
input = sys.stdin.readline
def main():
#1:初期化
N,W = list(map(int,input().split()))
wv = []
for _ in range(N):
wv.append(list(map(int,input().split())))
dp = [[0]*(W+1) for i in range(N+1)]
#print(dp)
#print(dp2)
#2:初期値(元からゼロなので記述無し)
#3:dp実行部(貰うDP)
for i in range(1,N+1):
for j in range(1,W+1):
if wv[i-1][0] <= j: #dpの横が重さだが，jが重さ以下ならそもそも入れられない．
dp[i][j] = max(dp[i-1][j], dp[i-1][j-wv[i-1][0]]+wv[i-1][1])
else:
dp[i][j] = dp[i-1][j]
#print(i,j)
#print(*dp,sep="\n")
#4:出力
print((dp[N][W]))
if __name__ == '__main__':
main() | p03163 |
def knapsack01(n, W, weights, values, dp, i, j):
# i = up until item i, j = up until weight j
if i == 0 or j <= 0:
return 0
# start with first item
if dp[i-1][j] == -1:
dp[i-1][j] = knapsack01(n, W, weights, values, dp, i-1, j)
if weights[i-1] > j:
# weights[i] doesn't fit in knapsack
dp[i][j] = dp[i-1][j]
else:
if dp[i-1][j-weights[i-1]] == -1:
dp[i-1][j-weights[i-1]] = knapsack01(n, W, weights, values, dp, i-1, j-weights[i-1])
dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]] + values[i-1])
return dp[i][j]
n,W = [int(x) for x in input().split()]
weights = []
values = []
for i in range(n):
l = [int(x) for x in input().split()]
weights += [l[0]]
values += [l[1]]
# repeatableKnapsack(n, W, weights, values)
dp = [[-1 for _ in range(W+1)] for _ in range(n+1)]
res = knapsack01(n, W, weights, values, dp, n, W)
# print(dp)
print(res) |
def knapsack01iter(n, W, weights, values, dp):
for i in range(1,n+1):
for j in range(0, W+1):
if j < weights[i-1]: # if knapsack cannot fit item i
dp[i][j] = dp[i-1][j]
elif j >= weights[i-1]: # knapsack can fit item i
dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]]+values[i-1])
return dp[-1][-1]
n,W = [int(x) for x in input().split()]
weights = []
values = []
for i in range(n):
l = [int(x) for x in input().split()]
weights += [l[0]]
values += [l[1]]
# repeatableKnapsack(n, W, weights, values)
# dp = [[-1 for _ in range(W+1)] for _ in range(n+1)]
# res = knapsack01rec(n, W, weights, values, dp, n, W)
# print(dp)
dp = [[0 for _ in range(W+1)] for _ in range(n+1)]
res = knapsack01iter(n, W, weights, values, dp)
# print(dp)
print(res) | p03163 |
n, w = list(map(int, input().split()))
wv = []
for i in range(n):
wv_ = list(map(int, input().split()))
wv.append(wv_)
dp = [0]*(w+1)
for i in range(n):
for j in range(w, wv[i][0]-1, -1):
dp_ = dp[j - wv[i][0]] + wv[i][1]
if dp[j] < dp_:
dp[j] = dp_
print((max(dp))) | n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
w_, v_ = wv[i]
for j in range(w+1):
if j < w_:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j-w_]+v_, dp[i][j])
print((dp[n][w])) | p03163 |
N,W = list(map(int,input().split()))
w = [None] * N
v = [None] * N
for i in range(N):
w[i],v[i] = list(map(int,input().split()))
dp = [[-1] * (W + 1) for i in range(N + 1)]
dp[0][0] = 0
for i in range(N):
for j in range(len(dp[i]) - 2, -1, -1):
if dp[i][j] == -1:
continue
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
if j + w[i] >= len(dp[i]):
continue
dp[i + 1][j + w[i]] = max(dp[i + 1][j + w[i]], dp[i][j] + v[i])
print((max(dp[N]))) | N,W = list(map(int,input().split()))
dp = [[-1] * (W + 1) for i in range(N + 1)]
dp[0][0] = 0
for i in range(N):
w,v = list(map(int,input().split()))
for j in range(len(dp[i]) - 2, -1, -1):
if dp[i][j] == -1:
continue
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
if j + w >= len(dp[i]):
continue
dp[i + 1][j + w] = max(dp[i + 1][j + w], dp[i][j] + v)
print((max(dp[N]))) | p03163 |
import sys
input = sys.stdin.readline
def main():
N,W = list(map(int, input().split()))
dp = [0 for _ in range(W+1)]
for _ in range(N):
w,v = list(map(int, input().split()))
for i in range(W,0,-1):
if i>=w:
dp[i] = max(dp[i],dp[i-w]+v)
print((dp[-1]))
if __name__ == '__main__':
main() | import sys
input = sys.stdin.readline
def main():
N,W = list(map(int, input().split()))
dp = [0 for _ in range(W+1)]
for _ in range(N):
w,v = list(map(int, input().split()))
for i in range(W,0,-1):
if i>=w:
a = dp[i]
b = dp[i-w]+v
if a>b:
dp[i] = a
else:
dp[i] = b
print((dp[-1]))
if __name__ == '__main__':
main() | p03163 |
N,W=list(map(int,input().split()))
v=[]
w=[]
for _ in range(N):
ww,vv=list(map(int,input().split()))
v.append(vv)
w.append(ww)
dp=[[0 for _ in range(W)] for _ in range(N)]
for h in range(W):
if h+1>=w[0]:
dp[0][h]=v[0]
for i in range(1,N):
for j in range(W):
if j+1>w[i]:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i])
else:
dp[i][j]=dp[i-1][j]
print((max(dp[-1]))) | N,W=list(map(int,input().split()))
v=[]
w=[]
for _ in range(N):
ww,vv=list(map(int,input().split()))
v.append(vv)
w.append(ww)
dp=[[0 for _ in range(W)] for _ in range(N)]
for h in range(W):
if h+1>=w[0]:
dp[0][h]=v[0]
for i in range(1,N):
for j in range(W):
if j+1>w[i]:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i])
else:
dp[i][j]=dp[i-1][j]
print((dp[-1][-1])) | p03163 |
x,y=list(map(int,input().split()))
yo=[]
yo0=[]
for __ in range(x):
a,b=list(map(int,input().split()))
yo.append(a)
yo0.append(b)
lol=[]
for i in range(x+1):
lol.append([0]*(y+1))
for i in range(1,x+1):
for j in range(1,y+1):
if j<yo[i-1]:
lol[i][j]=lol[i-1][j]
else:
lol[i][j]=max(lol[i-1][j],yo0[i-1]+lol[i-1][j-yo[i-1]])
print((lol[x][y])) | x,y=list(map(int,input().split()))
yo=[]
yo0=[]
for __ in range(x):
a,b=list(map(int,input().split()))
yo.append(a)
yo0.append(b)
lol=[0]*(y+1)
lol0=[0]*(y+1)
k=[0]*(y+1)
#print(lol,lol0)
for i in range(1,x+1):
for j in range(1,y+1):
if j<yo[i-1]:
#print(j,lol0[j],lol[j])
lol0[j]=lol[j]
else:
lol0[j]=max(lol[j],yo0[i-1]+lol[j-yo[i-1]])
lol=lol0[:]
lol0=k[:]
print((lol[y])) | p03163 |
import copy
N, W = list(map(int, input().split()))
WV = [list(map(int,input().split())) for _ in range(N) ]
costs = [(0,0)]
for w, v in WV:
new_costs = copy.deepcopy(costs)
for cw, cv in costs:
if cw + w > W:
continue
new_costs.append((cw + w, cv + v))
costs = new_costs
print(( max(costs,key=lambda item:item[1])[1]))
| import copy
N, W = list(map(int, input().split()))
WV = [list(map(int,input().split())) for _ in range(N) ]
#dp[w] = max cost
costs = [-1 for _ in range(W + 1)]
costs[0] = 0
for w, v in WV:
for index in reversed(list(range(W + 1))):
if costs[index] == -1:
continue
if index + w > W:
continue
costs[index + w] = max(costs[index] + v, costs[index + w])
print((max(costs)))
| p03163 |
N,W=list(map(int,input().split()))
li=[list(map(int,input().split())) for i in range(N)]
dp=[[0]*(W+1) for i in range(N+1)]
for i in range(1,N+1):
for j in range(1,W+1):
if j < li[i-1][0]:
dp[i][j]=dp[i-1][j]
else:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-li[i-1][0]]+li[i-1][1])
print((dp[N][W]))
| import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()
def main():
N,W=list(map(int,input().split()))
w,v=[0]*N,[0]*N
for i in range(N):
w[i],v[i]=list(map(int,input().split()))
dp=[[0]*(W+1) for _ in range(N+1)]
for i in range(N):
for weight in range(W+1):
dp[i+1][weight]=max(dp[i+1][weight],dp[i][weight])
if weight>=w[i]:
dp[i+1][weight]=max(dp[i+1][weight],dp[i][weight-w[i]]+v[i])
print((dp[N][W]))
if __name__ == '__main__':
main()
| p03163 |
#d
n,W=list(map(int,input().split()))
w=[0]
v=[0]
for i in range(n):
x,y=list(map(int,input().split()))
w.append(x)
v.append(y)
dp=[[0]*(W+1) for i in range(110)]
for i in range(1,n+1):
for j in range(W+1):
dp[i][j]=dp[i-1][j]#if文Falseのときの値に困らないように
if j-w[i]>=0:
dp[i][j]=max(dp[i][j],dp[i-1][j-w[i]]+v[i])
print((dp[n][W]))
| n,W=list(map(int,input().split()))
x=[0]+[-1]*W
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W-w,-1,-1):
if x[j]>=0:
x[j+w]=max(x[j+w],x[j]+v)
print((max(x))) | p03163 |
#メモ化したもの(修正版)
n,w=list(map(int,input().split()))
a=[]
dp=[]
for i in range(n):
a.append(list(map(int,input().split())))
for k in range(n+1):
dp.append([])
for l in range(w+1):
dp[k].append(-1)
def rec(i,j):
if dp[i][j]>=0:
return dp[i][j]
if i==n:
res=0
elif j<a[i][0]:
res=rec(i+1,j)
else:
res=max(rec(i+1,j),rec(i+1,j-a[i][0])+a[i][1])
dp[i][j]=res
return res
print((rec(0,w))) | n,w=list(map(int,input().split()))
a=[]
dp=[]
for i in range(n):
a.append(list(map(int,input().split())))
for k in range(n+1):
dp.append([])
for l in range(w+1):
dp[k].append(0)
for i in range(n):
for j in range(w+1):
if j<a[i][0]:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=max(dp[i][j],dp[i][j-a[i][0]]+a[i][1])
print((dp[n][w]))
| p03163 |
from sys import stdin
from functools import lru_cache
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
@lru_cache(None)
def dp(w: 'int', n: 'int') -> 'int':
if w == 0 or n == 0:
return 0
if s[n - 1][0] > w:
return dp(w, n - 1)
else:
return max(dp(w, n - 1), dp(w - s[n - 1][0], n - 1) + s[n - 1][1])
print((dp(W, N)))
| # using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [[0] * (W + 1) for _ in range(N + 1)]
dp[0][0] = 0
for n in range(1, N + 1):
for w in range(0, W + 1):
if w == 0:
dp[n][0] = 0
continue
if w < s[n - 1][0]:
dp[n][w] = dp[n - 1][w]
else:
dp[n][w] = max(dp[n - 1][w],
dp[n - 1][w - s[n - 1][0]] + s[n - 1][1])
print((dp[N][W]))
| p03163 |
# using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [[0] * (W + 1) for _ in range(N + 1)]
dp[0][0] = 0
for n in range(1, N + 1):
for w in range(0, W + 1):
if w == 0:
dp[n][0] = 0
continue
if w < s[n - 1][0]:
dp[n][w] = dp[n - 1][w]
else:
dp[n][w] = max(dp[n - 1][w],
dp[n - 1][w - s[n - 1][0]] + s[n - 1][1])
print((dp[N][W]))
| # using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
next_dp = [0] * (W + 1)
for n in range(1, N + 1):
for w in range(0, W + 1):
if w >= s[n - 1][0]:
next_dp[w] = max(next_dp[w], dp[w],
dp[w - s[n - 1][0]] + s[n - 1][1])
dp = next_dp[:]
print((dp[W]))
| p03163 |
# using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
next_dp = [0] * (W + 1)
for n in range(1, N + 1):
for w in range(0, W + 1):
if w >= s[n - 1][0]:
next_dp[w] = max(next_dp[w], dp[w],
dp[w - s[n - 1][0]] + s[n - 1][1])
dp = next_dp[:]
print((dp[W]))
| # using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
next_dp = [0] * (W + 1)
for n in range(1, N + 1):
for w in range(0, W + 1):
if w >= s[n - 1][0]:
next_dp[w] = max(next_dp[w], dp[w - s[n - 1][0]] + s[n - 1][1])
dp = next_dp[:]
print((dp[W]))
| p03163 |
# using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
next_dp = [0] * (W + 1)
for n in range(1, N + 1):
for w in range(0, W + 1):
if w >= s[n - 1][0]:
next_dp[w] = max(next_dp[w], dp[w - s[n - 1][0]] + s[n - 1][1])
dp = next_dp[:]
print((dp[W]))
| # using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
for n in range(1, N + 1):
w0, v0 = s[n - 1]
for w in range(W, w0 - 1, -1):
dp[w] = max(dp[w], dp[w - w0] + v0)
print((dp[W]))
| p03163 |
# using dp with memoization, TLE
from sys import stdin
N, W = list(map(int, input().split()))
m = stdin.read().splitlines()
s = [[int(i) for i in line.split()] for line in m]
dp = [0] * (W + 1)
for n in range(1, N + 1):
w0, v0 = s[n - 1]
for w in range(W, w0 - 1, -1):
dp[w] = max(dp[w], dp[w - w0] + v0)
print((dp[W]))
| from sys import stdin
N, W = list(map(int, stdin.readline().split()))
dp = [0] * (W + 1)
for i in range(N):
w, v = [int(k) for k in stdin.readline().split()]
for j in range(W, w - 1, -1):
dp[j] = max(dp[j], dp[j - w] + v)
print((dp[W])) | p03163 |
N, W = list(map(int, input().split()))
wv = (list(map(int, input().split())) for _ in range(N))
dp = [0] * (W+1)
for w, v in wv:
for j in range(W, w-1, -1):
DP = dp[j-w] + v
dp[j] = max(dp[j], DP)
print((max(dp)))
| def dp():
n, W = list(map(int, input().split()))
wv = (list(map(int, input().split())) for _ in range(n))
dp = [0] * (W+1)
for w, v in wv:
for j in range(W, w-1, -1):
DP = dp[j-w] + v
if dp[j] < DP:
dp[j] = DP
return max(dp)
print((dp()))
| p03163 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.