input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N, W = list(map(int, input().split()))
ws = [0]*N
vs = [0]*N
for i in range(N):
w, v = list(map(int, input().split()))
ws[i] = w
vs[i] = v
dp = [[0]*(W+1) for i in range(N+1)]
for i in range(1, N+1):
for sum_w in range(W+1):
if sum_w - ws[i-1] >= 0:
dp[i][sum_w] = max(dp[i][sum_w], dp[i-1][sum_w-ws[i-1]]+vs[i-1])
dp[i][sum_w] = max(dp[i][sum_w], dp[i-1][sum_w])
print((max(dp[-1]))) | n, W = list(map(int, input().split()))
ws = [0]*n
vs = [0]*n
for i in range(n):
w, v = list(map(int, input().split()))
ws[i] = w
vs[i] = v
dp = [[0]*(W+1) for _ in range(n+1)]
for i in range(n):
for j in range(W+1):
if j - ws[i] >= 0:
dp[i+1][j] = max(dp[i+1][j], dp[i][j-ws[i]]+vs[i])
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
print((dp[-1][W])) | p03163 |
from collections import namedtuple
Item = namedtuple('Item', 'w v')
N, W = (int(x) for x in input().split())
items = []
for _ in range(N):
w, v = (int(x) for x in input().split())
items.append(Item(w, v))
memo = [[0] * (W + 1) for _ in range(N)]
for i in range(N):
for w in range(W + 1):
if i == 0:
# 1行目を初期化
memo[i][w] = items[i].v if items[i].w <= w else 0
continue
if w < items[i].w:
# 入らなければひとつ上の行の値をそのまま使う
memo[i][w] = memo[i - 1][w]
continue
memo[i][w] = max(memo[i - 1][w], memo[i - 1][w - items[i].w] + items[i].v)
print((memo[N - 1][W])) | from collections import namedtuple
Item = namedtuple('Item', 'w v')
N, W = list(map(int, input().split()))
items = []
for _ in range(N):
w, v = list(map(int, input().split()))
items.append(Item(w, v))
memo = [0] * (W + 1)
for item in items:
for w in range(W, item.w - 1, -1):
memo[w] = max(memo[w], memo[w - item.w] + item.v)
print((memo[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)]
# 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])) | n, W = list(map(int,input().split()))
items = [[0,0] for _ in range(n+1)]
for i in range(n):
items[i+1] = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(n+1)]
for i in range(1,n+1):
weight, value = items[i][0], items[i][1]
for w_limit in range(1,W+1):
if w_limit - weight >= 0:
dp[i][w_limit] = max(dp[i-1][w_limit], dp[i-1][w_limit-weight] + value)
else:
dp[i][w_limit] = dp[i-1][w_limit]
print((dp[n][W]))
| p03163 |
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)]
for i in range(n):
for j in range(w+1):
if wv[i][0] <= j:
dp[i+1][j] = max(dp[i][j-wv[i][0]]+wv[i][1],dp[i][j])
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)]
for i in range(n):
for j in range(w+1):
if j - wv[i][0] >= 0:
dp[i+1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])
else:
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
print((max(dp[-1]))) | p03163 |
n,w = list(map(int,input().split()))
weight = [0 for i in range(n)]
value = [0 for i in range(n)]
for i in range(n):
weight[i],value[i] = list(map(int,input().split()))
#dp[i][j]: i番目の品物までの中から選び、重さがj以下になる時の、価値の総和の最大値
dp = [[0 for i in range(w+1)] for j in range(n+1)]
dp[1][weight[0]] = value[0]
for i in range(1,n):
for j in range(w+1):
if j - weight[i] >= 0:
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 = [0 for i in range(n)]
value = [0 for i in range(n)]
for i in range(n):
weight[i],value[i] = list(map(int,input().split()))
#dp[i][j]: i番目の品物までの中から選び、重さがj以下になる時の、価値の総和の最大値
dp = [[None for i in range(w+1)] for j in range(n+1)]
dp[1][weight[0]] = value[0]
for i in range(1,n):
for j in range(w+1):
if j - weight[i] >= 0:
if dp[i][j-weight[i]] != None and dp[i][j] != None:
dp[i+1][j] = max(dp[i][j-weight[i]]+value[i],dp[i][j])
elif dp[i][j-weight[i]] == None and dp[i][j] != None:
dp[i+1][j] = dp[i][j]
elif dp[i][j-weight[i]] != None and dp[i][j] == None:
dp[i+1][j] = dp[i][j-weight[i]]+value[i]
else:
dp[i+1][weight[i]] = value[i]
else:
dp[i+1][j] = dp[i][j]
print((max(i for i in dp[n] if i is not None)))
| p03163 |
n,w = list(map(int,input().split()))
weight = [0 for i in range(n)]
value = [0 for i in range(n)]
for i in range(n):
weight[i],value[i] = list(map(int,input().split()))
#dp[i][j]: i番目の品物までの中から選び、重さがj以下になる時の、価値の総和の最大値
dp = [[None for i in range(w+1)] for j in range(n+1)]
dp[1][weight[0]] = value[0]
for i in range(1,n):
for j in range(w+1):
if j - weight[i] >= 0:
if dp[i][j-weight[i]] != None and dp[i][j] != None:
dp[i+1][j] = max(dp[i][j-weight[i]]+value[i],dp[i][j])
elif dp[i][j-weight[i]] == None and dp[i][j] != None:
dp[i+1][j] = dp[i][j]
elif dp[i][j-weight[i]] != None and dp[i][j] == None:
dp[i+1][j] = dp[i][j-weight[i]]+value[i]
else:
dp[i+1][weight[i]] = value[i]
else:
dp[i+1][j] = dp[i][j]
print((max(i for i in dp[n] if i is not None)))
| n,w = list(map(int,input().split()))
weight = [0 for i in range(n)]
value = [0 for i in range(n)]
for i in range(n):
weight[i],value[i] = list(map(int,input().split()))
#dp[i][j]: i番目の品物までの中から選び、重さがj以下になる時の、価値の総和の最大値
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(w+1):
dp[i][j] = max(dp[i][j],dp[i-1][j])
if(j - weight[i-1] >= 0):
dp[i][j] = max(dp[i-1][j-weight[i-1]]+value[i-1],dp[i][j])
print((dp[n][w])) | p03163 |
n,wgt=list(map(int,input().split()))
a=[]
v=[]
for i in range(n):
x,y=list(map(int,input().split()))
a.append(x)
v.append(y)
d={}
def dp(wgt,n):
if n==0 or wgt==0:
return 0
if(a[n-1]>wgt):
if((wgt,n-1) in d):
return d[(wgt,n-1)]
return dp(wgt,n-1)
else:
d1=0
if (wgt,n-1) in d:
d1=d[(wgt,n-1)]
else:
d1=dp(wgt,n-1)
d2=0
if (wgt-a[n-1],n-1) in d:
d2=d[(wgt-a[n-1],n-1)]
else:
d2=dp(wgt-a[n-1],n-1)
return max(v[n-1]+d2,d1)
print((dp(wgt,n))) | n,wgt=list(map(int,input().split()))
a=[]
v=[]
for i in range(n):
x,y=list(map(int,input().split()))
a.append(x)
v.append(y)
dp=[[0 for x in range(wgt+1)] for x in range(n+1)]
for i in range(n+1):
for j in range(wgt+1):
if i==0 or j==0:
dp[i][j]=0
elif a[i-1]<=j:
dp[i][j]=max(v[i-1]+dp[i-1][j-a[i-1]],dp[i-1][j])
else:
dp[i][j]=dp[i-1][j]
print((dp[n][wgt])) | p03163 |
N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)]
dp = [[-1 for _ in range(W+1)] for _ in range(N)]
# 1~i-1番目の品物から重さの総和がj以下になるように選んだときの価値を返す
def f(i, j):
# 終了条件
if i == N:
return 0
if dp[i][j] != -1:
return dp[i][j]
w, v = w_v[i]
# これ以上入らないとき
if j - w < 0:
dp[i][j] = f(i+1, j)
# まだ入るときは両方試す
else:
dp[i][j] = max(f(i+1, j), f(i+1, j-w)+v)
return dp[i][j]
print((f(0, W)))
| N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)]
# 1~i-1番目の品物から重さの総和がj以下になるように選んだときの価値
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
w, v = w_v[i]
for j in range(W+1):
if j - w >= 0:
dp[i+1][j] = max(dp[i][j-w]+v, dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((max(dp[N])))
| p03163 |
N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)]
# 1~i-1番目の品物から重さの総和がj以下になるように選んだときの価値
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
w, v = w_v[i]
for j in range(W+1):
if j - w >= 0:
dp[i+1][j] = max(dp[i][j-w]+v, dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((max(dp[N])))
| n, W = list(map(int, input().split()))
data = []
for _ in range(n):
w, v = list(map(int, input().split()))
data.append((w, v))
dp = [[0] * (W+1) for i in range(n+1)]
for i in range(1, n+1):
w, v = data[i-1]
for j in range(W+1):
if j - w >= 0:
dp[i][j] = max(dp[i - 1][j - w] + v, dp[i - 1][j])
else:
dp[i][j] = dp[i - 1][j]
print((dp[-1][W]))
| p03163 |
from collections import Counter
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce
def input():
return sys.stdin.readline().strip()
def iinput():
return int(eval(input()))
def tinput():
return input().split()
def rinput():
return list(map(int, tinput()))
def rlinput():
return list(rinput())
mod = int(1e9)+7
def factors(n):
return set(reduce(list.__add__,
([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))
# ----------------------------------------------------
if __name__ == "__main__":
n, w = rinput()
w_v = []
for i in range(n):
w_v.append(rlinput())
dp = [[0 for i in range(w+1)]for j in range(n+1)]
# print(w_v)
for item in range(1, n+1):
for weight in range(1, w+1):
if weight >= w_v[item-1][0]:
dp[item][weight] = max(dp[item-1][weight-w_v[item-1][0]]+w_v[item-1][1],dp[item-1][weight])
else:
dp[item][weight] =dp[item-1][weight]
print((dp[n][w]))
|
def main():
N,W = list(map(int, input().split()))
dp = [[0]*(W+1) for i in range(N+1)]
weight = [0]
value = [0]
for i in range(N):
w,v=list(map(int, input().split()))
weight.append(w)
value.append(v)
# dp[i][w] is the maximum value got with first i items stored in w weight of knapsack
for i in range(1,N+1):
for w in range(1,W+1):
if w>=weight[i]:
dp[i][w] = max(dp[i-1][w],dp[i-1][w-weight[i]]+value[i])
else:
dp[i][w] = dp[i-1][w]
print((dp[N][W]))
if __name__ == "__main__":
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=[[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]:
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])) | 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):
j=W
while j>=w[i]:
dp[j]=max(dp[j],dp[j-w[i]]+v[i])
j-=1
print((dp[W])) | p03163 |
N,W = list(map(int,input().split()))
dp=[[0]*(W+100) for _ in range(N+10)]
for i in range(N):
w,v= list(map(int,input().split()))
for j in range(W+1):
if j-w>=0:
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])) | N,W = list(map(int,input().split()))
p=[[0]*(W+100) for _ in range(N+10)]
for i in range(N):
w,v= list(map(int,input().split()))
for j in range(W+1):
if j>=w:
p[i+1][j] = max(p[i][j],p[i][j-w]+v)
else:
p[i+1][j]=p[i][j]
print((p[N][W])) | p03163 |
# dp[i][w_sum]: i-1番目までの品物で重さがw_sumを超えないように選んだときの、価値の総和の最大値
N, W = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for i in range(N)]
dp = [[0 for w_sum in range(W+100)] for i in range(N+100)]
for i in range(N):
for w_sum in range(W+1):
# i-1番目の品物を選ぶ場合
# 重量的に入れられるなら入れてみる
if w_sum-items[i][0] >= 0:
dp[i+1][w_sum] = max(dp[i+1][w_sum],
dp[i][w_sum-items[i][0]]+items[i][1])
# i-1番目の品物を選ばない場合
dp[i+1][w_sum] = max(dp[i+1][w_sum], dp[i][w_sum])
print((dp[N][W]))
| # dp[i][w_sum]: i番目までの品物で重さがw_sumを超えないように選んだときの、価値の総和の最大値
N, W = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for i in range(N)]
dp = [[0 for w_sum in range(W+1)] for i in range(N+1)]
for i in range(N):
for w_sum in range(W+1):
# i-1番目の品物を選ぶ場合
# 重量的に入れられるなら入れてみる
if w_sum+items[i][0] <= W:
dp[i+1][w_sum+items[i][0]] = max(dp[i+1][w_sum+items[i][0]],
dp[i][w_sum]+items[i][1])
# i-1番目の品物を選ばない場合
dp[i+1][w_sum] = max(dp[i+1][w_sum], dp[i][w_sum])
ans = 0
for w in range(W+1):
ans = max(ans, dp[N][w])
print(ans)
| p03163 |
N, W, *A = list(map(int, open(0).read().split()))
A = list(zip(*[iter(A)]*2))
# dp[i][j] iまでの品物からいくつか選んで残り容量がjのときの価値の最大値
dp = [[0]*(W+1) for _ in range(N+1)]
for i, (w, v) in enumerate(A):
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], dp[i][j-w]+v)
print((max(dp[N]))) | N, W, *A = list(map(int, open(0).read().split()))
A = list(zip(*[iter(A)]*2))
# dp[i][j] iまでの品物からいくつか選んで重さの総和がjのときの価値の最大値
dp = [[0]*(W+1) for _ in range(N+1)]
for i, (w, v) in enumerate(A):
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], dp[i][j-w]+v)
print((max(dp[N]))) | p03163 |
n, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
w = [wv[i][0] for i in range(n)]
v = [wv[i][1] for i in range(n)]
inf = float('inf')
# dp[i][weight]
# := i-1番目までの品物で重さweightを超えないように選んだときの価値の総和の最大値
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 - 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[n][W]))
| def main():
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
w = [wv[i][0] for i in range(N)]
v = [wv[i][1] for i in range(N)]
vdp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
for weight in range(W+1):
# 品物iを（選べるなら）選ぶ
if weight >= w[i]: vdp[i+1][weight] = max(vdp[i][weight - w[i]] + v[i], vdp[i][weight])
# 品物iを選ばない
vdp[i+1][weight] = max(vdp[i+1][weight], vdp[i][weight])
print((vdp[N][W]))
if __name__ == '__main__':
main() | p03163 |
def main():
n,w=list(map(int,input().split()))
items=[]
dp=[0 for i in range(w+1)]
for i in range(n):
wi,vi=list(map(int,input().split()))
for j in range(w-wi,-1,-1):
dp[j+wi]=max(dp[j+wi],dp[j]+vi)
print((max(dp)))
if __name__=='__main__':
main()
| n,w=list(map(int,input().split()))
items=[]
dp=[0 for i in range(w+1)]
for i in range(n):
wi,vi=list(map(int,input().split()))
for j in range(w-wi,-1,-1):
dp[j+wi]=max(dp[j+wi],dp[j]+vi)
print((max(dp)))
| p03163 |
N,W = [int(s) for s in input().split()]
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(1,N+1):
w, v = [int(s) for s in input().split()]
for sum_w in range(W+1):
if sum_w - w >= 0:
dp[i][sum_w] = max(dp[i-1][sum_w], dp[i-1][sum_w-w] + v)
else:
dp[i][sum_w] = dp[i-1][sum_w]
print((dp[N][W])) | N,W = [int(s) for s in input().split()]
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(N):
w, v = [int(s) for s in input().split()]
for sum_w in range(W+1):
if sum_w - w >= 0:
dp[i+1][sum_w] = max(dp[i][sum_w], dp[i][sum_w-w] + v)
else:
dp[i+1][sum_w] = dp[i][sum_w]
print((dp[N][W])) | p03163 |
N,W = list(map(int,input().split()))
# wv_list = [tuple(map(int,input().split())) for _ in range(N)]
w_list = []
v_list = []
for i in range(N):
w,v = list(map(int,input().split()))
w_list.append(w)
v_list.append(v)
memo = [[None for _ in range(W+1)] for _ in range(N+1)]
def rec(check_item,residual_w):
if memo[check_item][residual_w]:
return memo[check_item][residual_w]
if check_item == N:
res = 0
elif residual_w < w_list[check_item]:
res = rec(check_item+1, residual_w)
else:
# print(check_item,residual_w)
res = max(rec(check_item+1,residual_w),
rec(check_item+1,residual_w-w_list[check_item])+v_list[check_item])
memo[check_item][residual_w] = res
return res
print((rec(0,W))) | N,W = list(map(int,input().split()))
wv_list = [tuple(map(int,input().split())) for _ in range(N)]
memo = [0 for _ in range(W+1)]
for weight,value in wv_list:
for w in range(W+1)[::-1]:
if w >= weight:
memo[w] = max(memo[w], memo[w-weight]+value)
print((memo[W])) | p03163 |
from pprint import pprint
n,w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp_table = [[-float("inf")]*(w+1) for _ in range(n+1)]
dp_table[0][0] = 0
for i in range(1,n+1):
for before_w in range(w):
#i番目の品物を選ばない場合
dp_table[i][before_w] = max(dp_table[i][before_w], dp_table[i-1][before_w])
#i番目の品物を選ぶ場合
if wv[i-1][0]+before_w <= w and dp_table[i-1][before_w] >= 0:
dp_table[i][wv[i-1][0]+before_w] = max(dp_table[i][wv[i-1][0]+before_w], dp_table[i-1][before_w] + wv[i-1][1])
else:
continue
result = 0
for y in range(w+1):
tempresult = max(dp_table[n])
result=max(result,tempresult)
print(result)
#pprint(dp_table)
| from pprint import pprint
n,w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp_table = [[-float("inf")]*(w+1) for _ in range(n+1)]
dp_table[0] = [0]*(w+1)
#sum_w以下の重さの時のvalueの合計の最大を求めていく。
for i in range(1,n+1):
for sum_w in range(w+1):
#i番目の品物を選ばない場合
dp_table[i][sum_w] = max(dp_table[i][sum_w], dp_table[i-1][sum_w])
#i番目の品物を選ぶ場合
if sum_w >= wv[i-1][0]:
dp_table[i][sum_w] = max(dp_table[i][sum_w], dp_table[i-1][sum_w-wv[i-1][0]] + wv[i-1][1])
else:
continue
result = dp_table[n][w]
print(result)
| p03163 |
from pprint import pprint
n,w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp_table = [[-float("inf")]*(w+1) for _ in range(n+1)]
dp_table[0] = [0]*(w+1)
#sum_w以下の重さの時のvalueの合計の最大を求めていく。
for i in range(1,n+1):
for sum_w in range(w+1):
#i番目の品物を選ばない場合
dp_table[i][sum_w] = max(dp_table[i][sum_w], dp_table[i-1][sum_w])
#i番目の品物を選ぶ場合
if sum_w >= wv[i-1][0]:
dp_table[i][sum_w] = max(dp_table[i][sum_w], dp_table[i-1][sum_w-wv[i-1][0]] + wv[i-1][1])
else:
continue
result = dp_table[n][w]
print(result)
| from pprint import pprint
n,w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp_table = [[-float("inf")]*(w+1) for _ in range(n+1)]
dp_table[0] = [0]*(w+1)
#sum_w以下の重さの時のvalueの合計の最大を求めていく。
for i in range(1,n+1):
for sum_w in range(w+1):
#i番目の品物を選ぶ場合
if sum_w >= wv[i-1][0]:
dp_table[i][sum_w] = max(dp_table[i-1][sum_w], dp_table[i-1][sum_w-wv[i-1][0]] + wv[i-1][1])
else:
#i番目の品物を選ばない場合
dp_table[i][sum_w] = dp_table[i-1][sum_w]
result = dp_table[n][w]
print(result)
| p03163 |
n,w = list(map(int,input().split()))
inf = float("inf")
dp = [[-inf]*(w+1) for _ in range(n+1)]
for j in range(w+1):
dp[0][j] = 0
for i in range(n):
s,t = list(map(int,input().split()))
for l in range(w+1):
if l-s >=0:
dp[i+1][l] = max(dp[i][l],dp[i][l-s]+t)
else:
dp[i+1][l] = dp[i][l]
print((dp[-1][w])) | n,w = list(map(int,input().split()))
ls = [list(map(int,input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
for p in range(w+1):
if p >= ls[i][0]:
dp[i+1][p] = max(dp[i][p],dp[i][p-ls[i][0]]+ls[i][1])
else:
dp[i+1][p] = dp[i][p]
print((dp[n][w])) | p03163 |
def knapsack(n,w,wts,vals):
if n==0 or w==0:
return 0
inc,exc=-1,-1
if wts[n-1]<=w:
inc= vals[n-1]+ knapsack(n-1,w-wts[n-1],wts,vals)
exc= knapsack(n-1,w,wts,vals)
return max(inc,exc)
n,w=list(map(int,input().split()))
wts,vals=[],[]
for i in range(n):
a,b=list(map(int,input().split()))
wts.append(a)
vals.append(b)
print((knapsack(n,w,wts,vals)))
| def knapsack_dp(n,w,wts,val):
dp=[[0]*(w+1) for i in range(n+1)]
for i in range(n+1):
for j in range(w+1):
if i==0 or j==0:
dp[i][j]=0
elif wts[i-1]<=j:
dp[i][j]=max(dp[i-1][j],val[i-1]+dp[i-1][j-wts[i-1]])
else:
dp[i][j]=dp[i-1][j]
return dp[n][w]
n,w=list(map(int,input().split()))
wts,vals=[],[]
for i in range(n):
a,b=list(map(int,input().split()))
wts.append(a)
vals.append(b)
print((knapsack_dp(n,w,wts,vals)))
| p03163 |
N, W = list(map(int, input().split()))
weights = [0]*(N+10)
values = [0]*(N+10)
dp = [[0]*(W+10) for i in range(N+10)]
for i in range(N):
weights[i], values[i] = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w >= weights[i]:
dp[i+1][sum_w] = max(dp[i][sum_w-weights[i]]+values[i],
dp[i+1][sum_w])
else:
dp[i+1][sum_w] = max(dp[i][sum_w],
dp[i+1][sum_w])
print((max([max(row) for row in dp]))) | N, W = list(map(int, input().split()))
weights = [0]*(N+5)
values = [0]*(N+5)
dp = [[0]*(W+5) for i in range(N+5)]
for i in range(N):
weights[i], values[i] = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w >= weights[i]:
if dp[i+1][sum_w] < dp[i][sum_w-weights[i]]+values[i]:
dp[i+1][sum_w] = dp[i][sum_w-weights[i]]+values[i]
if dp[i+1][sum_w] < dp[i][sum_w]:
dp[i+1][sum_w] = dp[i][sum_w]
print((max([max(row) for row in dp]))) | 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)]
#wv[i][0]:i番目の品物の重さ
#wv[i][1]:i番目の品物の価値
dp = [0]*(w+1)#dp[i]:重さiにおける最大価値
for i in range(n):#あるi番目の品物について
for j in range(w,wv[i][0]-1, -1):
dp[j] = max( dp[j], dp[j-wv[i][0]]+wv[i][1] )#i番目の品物を使うほうが良い場合は値を更新
print((max(dp))) | n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for i in range(n)]
#wv[i][0]:i番目の品物の重さ
#wv[i][1]:i番目の品物の価値
dp = [0]*(w+1)#dp[i]:重さiにおける最大価値
for i in range(n):#あるi番目の品物について
for j in range(w,wv[i][0]-1, -1):#ある重さjについて
dp[j] = max( dp[j], dp[j-wv[i][0]]+wv[i][1] )#i番目の品物を使うほうが重さjでの価値が高い場合は値を更新
print((max(dp))) | p03163 |
MAX_N = 110
N, W = list(map(int, input().split()))
weight = [0] * MAX_N
value = [0] * MAX_N
for i in range(N):
weight[i], value[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(MAX_N)]
for i in range(N):
for sum_w in range(W + 1):
if sum_w - weight[i] >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight[i]] + value[i])
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
# for l in dp:
# print(l)
print((dp[N][W])) | MAX_N = 110
MAX_W = 10 ** 5 + 100
N, W = list(map(int, input().split()))
w = [0] * MAX_N
v = [0] * MAX_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 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[N][W])) | p03163 |
N,W = list(map(int,input().split()))
dp = [[0 for i in range(W+1)] for j in range(N+1)]
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] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j-w]+v,dp[i][j])
print((dp[N][W])) | 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,-1,-1):
if i-w < 0:
continue
dp[i] = max(dp[i], dp[i-w]+v)
print((max(dp)))
| p03163 |
N, W = list(map(int, input().strip().split()))
values = []
weights = []
for _ in range(N):
w, v = list(map(int, input().strip().split()))
weights.append(w)
values.append(v)
dp = [0]*(W+1)
for i in range(N):
curr_v = values[i]
curr_w = weights[i]
for w in range(W, weights[i] - 1, -1):
dp[w] = max(dp[w], curr_v + dp[w - curr_w])
print((dp[W])) | N, W = list(map(int, input().strip().split()))
values = []
weights = []
for _ in range(N):
w, v = list(map(int, input().strip().split()))
weights.append(w)
values.append(v)
dp = [0]*(W+1)
for i in range(N):
for w in range(W, weights[i] - 1, -1):
dp[w] = max(dp[w], values[i] + dp[w - weights[i]])
print((dp[W])) | p03163 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
INF = 10**11+1
dp = [[-1]*(W+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = A[i-1]
for j in range(W+1):
dp[i][j] = dp[i-1][j]
if j >= w and dp[i-1][j-w] != -1:
dp[i][j] = max(dp[i-1][j-w]+v,dp[i][j])
print((max(dp[-1]))) | N, W = list(map(int, input().split()))
A = [list(map(int, input().split())) for i in range(N)]
dp = [[-1]*(W+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = A[i-1]
for j in range(W+1):
dp[i][j] = dp[i-1][j]
if j >= w and dp[i-1][j-w] != -1:
dp[i][j] = max(dp[i-1][j-w]+v,dp[i][j])
print((max(dp[-1]))) | p03163 |
def solve():
N, W = list(map(int, input().split()))
weight = [0 for i in range(N)]
value = [0 for i in range(N)]
for i in range(N):
weight[i], value[i] = list(map(int, input().split()))
dp = [[0 for w in range(100100)] for i in range(110)]
for i in range(N):
for w in range(W + 1):
if w - weight[i] >= 0:
dp[i + 1][w] = max(dp[i + 1][w], dp[i][w - weight[i]] + value[i])
dp[i + 1][w] = max(dp[i + 1][w], dp[i][w])
return dp[N][W]
print((solve()))
| def solve():
N, W = list(map(int, input().split()))
weight = [0 for i in range(N)]
value = [0 for i in range(N)]
for i in range(N):
weight[i], value[i] = list(map(int, input().split()))
dp = [0 for w in range(W + 1)]
for i in range(N):
wi = weight[i]
vi = value[i]
for w in range(W, -1, -1):
_w = w + wi
_v = dp[w] + vi
if _w > W: continue
if _v <= dp[_w]: continue
dp[_w] = _v
return dp[-1]
print((solve()))
| p03163 |
import sys
from collections import defaultdict, deque
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
MAX_N = 110000
dp = [0] * (W + 1)
for _ in range(N):
w, v = list(map(int, input().split()))
for sum_w in range(W, w-1, -1):
if sum_w - w >= 0:
dp[sum_w] = max(dp[sum_w], dp[sum_w - w] + v)
print((dp[-1]))
if __name__ == '__main__':
main()
| import sys
from collections import defaultdict, deque
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
f_inf = float('inf')
# DP テーブルを初期化 (最小化問題なので INF に初期化)
MAX_N = 110000
dp = [0] * (W + 1)
for _ in range(N):
w, v = list(map(int, input().split()))
for sum_w in range(W, w-1, -1):
tv = dp[sum_w - w] + v
if tv > dp[sum_w]:
dp[sum_w] = tv
print((dp[-1]))
if __name__ == '__main__':
main()
| p03163 |
x, y = list(map(int, input().split()))
dp = [[0]*(y+1) for _ in range(x+1)]
for i in range(1, x+1):
w, v = list(map(int, input().split()))
for j in range(y+1):
num0 = dp[i-1][j]
if j-w >= 0:
num1 = dp[i-1][j-w]+v
if num1 > num0:
dp[i][j] = num1
else:
dp[i][j] = num0
else:
dp[i][j] = num0
print((max(dp[-1])))
| def num():
x, y = list(map(int, input().split()))
dp = [0]*(y+1)
for i in range(x):
w, v = list(map(int, input().split()))
for j in range(y, w-1, -1):
num = dp[j-w]+v
if num > dp[j]:
dp[j] = num
print((dp[-1]))
num()
| p03163 |
n, w = list(map(int, input().split(' ')))
items = [[]] * n
for i in range(n):
weight, val = list(map(int, input().split(' ')))
items[i] = [weight, val]
# print(n, w)
# print(items)
dp = []
for i in range(n+1):
dp.append([])
for j in range(w+1):
dp[i].append(0)
# print(len(dp), len(dp[0]), dp[0][0])
for i in range(n):
weight , val = items[i]
for sum_w in range(w+1):
# i番目のアイテムを選択する
if sum_w - weight >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w - weight] + val)
# i番目のアイテムを選択しない
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().split()))
wl = [0] * n
vl = [0] * n
for i in range(n):
wl[i], vl[i] = list(map(int, input().split()))
dp = [[]] * (n+1)
for i in range(n+1):
dp[i] = [0] * (w+1)
for i in range(n):
for j in range(w+1):
if j >= wl[i]:
dp[i+1][j] = max(dp[i][j], dp[i][j-wl[i]]+vl[i])
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
print((dp[n][w]))
#for i in range(n+1):
# print(dp[i]) | p03163 |
import math
from decimal import *
n, w = list(map(int, input().split()))
cost, weights = [],[]
for i in range(n):
a,b = list(map(int, input().split()))
weights.append(a)
cost.append(b)
def kp(pt, c, ans):
if(pt==-1 or c==0):
return ans
else:
var1, var2 = 0, 0
var1= kp(pt-1, c, ans)
if(c >= weights[pt]):
var2 = cost[pt]+kp(pt-1, c-weights[pt], ans)
ans = max(var1, var2)
return ans
ans = kp(n-1, w, 0)
print(ans) | import math
n, w = list(map(int, input().split()))
weights = []
costs = []
for i in range(n):
a,b = list(map(int, input().split()))
weights.append(a)
costs.append(b)
dp = [[0 for i in range(w+1)] for i in range(n)]
for i in range(w+1):
if(i>= weights[0]):
dp[0][i] = costs[0]
for i in range(1, n):
for j in range(w+1):
if(j >= weights[i]):
val = max(dp[i-1][j], costs[i]+dp[i-1][j-weights[i]])
dp[i][j] = val
else:
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 = [-1 for _ in range(W + 1)] # dp[重量の総和]:= 価値の総和
dp[0] = 0
for i in range(N):
w, v = wv[i]
for j in range(W, -1, -1):
if dp[j] >= 0 and j + w <= W:
dp[j+w] = max(dp[j+w], dp[j]+v)
print((max(dp))) | # 埋める配列
# dp[w] : 入っている重さがwのときの価値の最大値
# 計算方法
# dp[0][0] = 0
# dp[w] = max(dp[w - wi] + vi)
# 埋める順序
# 後ろから
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [0] * (W + 1)
for i in range(N):
wi, vi = wv[i]
for j in range(W, -1, -1):
if j - wi >= 0:
dp[j] = max(dp[j], dp[j - wi] + vi)
print((dp[-1])) | p03163 |
n, s = [int(i) for i in input().split()]
weights = []
values = []
for _ in range(n):
w, v = [int(i) for i in input().split()]
weights.append(w)
values.append(v)
def knapsack(weights, values, limit):
n = len(weights)
# f = [[0 for _ in range(limit+1)] for _ in range(n)]
prev = [0 for _ in range(limit+1)]
if weights[0] <= limit:
for w in range(weights[0], limit+1):
prev[w] = values[0]
for i in range(1, n):
# print prev
current = [0] * (limit+1)
for w in range(1, limit+1):
current[w] = max(prev[w], current[w])
if weights[i] <= w:
current[w] = max(current[w], prev[w-weights[i]] + values[i])
prev = list(current)
return prev[-1]
# weights = [10, 20, 30]
# values = [60, 100, 120]
print((knapsack(weights, values, s))) | n, s = [int(i) for i in input().split()]
weights = []
values = []
for _ in range(n):
w, v = [int(i) for i in input().split()]
weights.append(w)
values.append(v)
def knapsack(weights, values, limit):
n = len(weights)
# f = [[0 for _ in xrange(limit+1)] for _ in xrange(n)]
prev = [0 for _ in range(limit+1)]
if weights[0] <= limit:
for w in range(weights[0], limit+1):
prev[w] = values[0]
for i in range(1, n):
# print prev
current = [0] * (limit+1)
for w in range(1, limit+1):
current[w] = max(prev[w], current[w])
if weights[i] <= w:
current[w] = max(current[w], prev[w-weights[i]] + values[i])
prev = list(current)
return prev[-1]
# weights = [10, 20, 30]
# values = [60, 100, 120]
print((knapsack(weights, values, s))) | p03163 |
INF = float('inf')
N, capW = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
dp = {0: 0}
for wi, vi in items:
for w, v in list(dp.items()):
if w+wi <= capW:
dp[w+wi] = max(dp.get(w+wi, 0), v+vi)
print((max(dp.values())))
| N, capW = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
def knapsack01(items, capW):
dp = [0] * (capW+1)
for wi, vi in items:
for w in reversed(list(range(wi, capW+1))):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
return max(dp)
print((knapsack01(items, capW)))
| p03163 |
N, capW = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
def knapsack01(items, capW):
dp = [0] * (capW+1)
for wi, vi in items:
for w in reversed(list(range(wi, capW+1))):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
return max(dp)
print((knapsack01(items, capW)))
| N, capW = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
def knapsack01(items, capW):
dp = [0] * (capW+1)
for wi, vi in items:
dp = [v1 if v1 >= v2 else v2 for v1, v2 in zip(dp, [0]*wi + [v+vi for v in dp[:capW-wi+1]])]
return max(dp)
print((knapsack01(items, capW)))
| p03163 |
import sys
import math
from collections import defaultdict
sys.setrecursionlimit(1000000000)
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
def solve(test):
n, w = list(map(int, input().split()))
val = [None] * n
wgt = [None] * n
for i in range(n):
wgt[i], val[i] = list(map(int, input().split()))
dp = {}
ans = knapsack(wgt, val, 0, n, dp, w)
print(ans)
def knapsack(wgt, val, i, n, dp, w):
if (i, w) in dp:
return dp[(i, w)]
elif i >= n:
return 0
else:
dp[(i, w)] = knapsack(wgt, val, i + 1, n, dp, w)
if wgt[i] <= w:
dp[(i, w)] = max(dp[(i, w)], val[i] + knapsack(wgt, val, i + 1, n, dp, w - wgt[i]))
return dp[(i, w)]
if __name__ == "__main__":
test_cases = 1
for t in range(1, test_cases + 1):
solve(t)
| import sys
import math
from collections import defaultdict
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
def solve(test):
n, w = list(map(int, input().split()))
val = [None] * n
wgt = [None] * n
for i in range(n):
wgt[i], val[i] = list(map(int, input().split()))
dp = [[0 for j in range(w + 1)] for i in range(n + 1)]
for i in range(1, n + 1):
for j in range(1, w + 1):
dp[i][j] = dp[i - 1][j]
if wgt[i - 1] <= j:
dp[i][j] = max(dp[i][j], val[i - 1] + dp[i - 1][j - wgt[i - 1]])
ans = dp[-1][-1]
print(ans)
if __name__ == "__main__":
test_cases = 1
for t in range(1, test_cases + 1):
solve(t)
| p03163 |
def main():
import sys
input = sys.stdin.readline
N, W = (int(i) for i in input().split())
weight = [0] * (N+1)
value = [0] * (N+1)
for i in range(1, N+1):
w, v = (int(i) for i in input().split())
weight[i] = w
value[i] = v
memo = [[-1] * (W + 1) for _ in range(N + 1)]
def rec(i, w):
if i == 0:
return 0
if memo[i][w] != -1:
return memo[i][w]
res = 0
if w - weight[i] >= 0:
res = max(rec(i-1, w), rec(i-1, w-weight[i])+value[i])
else:
res = rec(i-1, w)
memo[i][w] = res
return res
print((rec(N, W)))
if __name__ == '__main__':
main()
| def main():
N, W = (int(i) for i in input().split())
VW = [[int(i) for i in input().split()] for j 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 - VW[i][0]:
dp[i+1][j] = max(dp[i][j], dp[i][j - VW[i][0]] + VW[i][1])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
if __name__ == '__main__':
main()
| p03163 |
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):
x = dp[j-w] + v
if x > dp[j]:
dp[j] = x
print(dp[-1]) | def main():
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):
x = dp[j-w] + v
if x > dp[j]:
dp[j] = x
print(dp[-1])
main() | p03163 |
def main():
n, m = list(map(int, input().split()))
w = [0] * n
v = [0] * n
for i in range(n):
wt, vt = list(map(int, input().split()))
w[i] = wt
v[i] = vt
l = [0] * (m + 1)
for i in range(n):
for j in range(m, -1, -1):
l[j] = max(v[i] + l[j-w[i]], l[j]) if j - w[i] >= 0 else l[j]
print((l[-1]))
main()
| def main():
n, m = 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()))
l = [0] * (m + 1)
for i in range(n):
for j in range(m, w[i] - 1, -1):
x = v[i] + l[j-w[i]]
if x > l[j]:
l[j] = x
print((l[-1]))
main()
| p03163 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wlimit):
# dp[i][w]
# i番目の品物までで w を超えないように選んだ最大価値
dp = { 0: 0 } # { <sum weight>: <sum value> }
for i in range(1, n + 1):
dp_ = {}
wi, vi = list(map(int, input().rstrip().split()))
for w, v in list(dp.items()):
w_ = w + wi
v_ = v + vi
if w_ <= wlimit and (w_ not in dp or dp[w_] < v_):
dp_[w_] = v_
dp.update(dp_)
return(max(dp.values()))
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wlimit):
dp = [-1] * (wlimit + 1)
dp[0] = 0
for i in range(1, n + 1):
wi, vi = list(map(int, input().rstrip().split()))
dp_ = list(dp)
for w in range(wlimit + 1):
if dp[w] >= 0:
w_ = w + wi
v_ = dp[w] + vi
if w_ <= wlimit and dp[w_] < v_:
dp_[w_] = v_
dp = dp_
return(max(dp))
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| p03163 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wlimit):
dp = [0] * (wlimit + 1)
wv = [list(map(int, input().rstrip().split())) for _ in range(n)]
for wi, vi in wv:
dp_ = list(dp)
for w in range(wlimit + 1):
v_ = dp[w] if w - wi < 0 else dp[w - wi] + vi
dp_[w] = max(dp[w], v_)
dp = dp_
return(dp[-1])
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wlimit):
dp = [-1] * (wlimit + 1)
dp[0] = 0
for i in range(1, n + 1):
wi, vi = list(map(int, input().rstrip().split()))
dp_ = list(dp)
for w in range(wlimit + 1):
if dp[w] >= 0:
w_ = w + wi
v_ = dp[w] + vi
if w_ <= wlimit and dp[w_] < v_:
dp_[w_] = v_
dp = dp_
return(max(dp))
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| p03163 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wv, W):
dp = [0] * (W + 1)
for wi, vi in wv:
for w in range(W, wi - 1, -1):
dp[w] = max(dp[w], dp[w - wi] + vi)
return(dp[-1])
n, w = list(map(int, input().split())) # 1 <= n <= 100, 1 <= w <= 10^5
wv = [[int(x) for x in input().split()] for _ in range(n)]
print((f(n, wv, w)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f(n, wlimit):
dp = [-1] * (wlimit + 1)
dp[0] = 0
for i in range(1, n + 1):
wi, vi = list(map(int, input().rstrip().split()))
dp_ = list(dp)
for w in range(wlimit + 1):
if dp[w] >= 0:
w_ = w + wi
v_ = dp[w] + vi
if w_ <= wlimit and dp[w_] < v_:
dp_[w_] = v_
dp = dp_
return(max(dp))
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| p03163 |
# coding: utf-8
import sys
input = sys.stdin.readline
def f(n, W):
dp = [-1] * (W + 1)
dp[0] = 0
for i in range(n):
wi, vi = list(map(int, input().split()))
dp_ = list(dp)
for w in range(W + 1):
if dp[w] >= 0:
w_ = w + wi
v_ = dp[w] + vi
if w_ <= W and dp[w_] < v_:
dp_[w_] = v_
dp = dp_
return(max(dp))
n, w = list(map(int, input().rstrip().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| # coding: utf-8
import sys
input = sys.stdin.readline
def f(n, W):
dp = [0] * (W + 1)
for i in range(n):
wi, vi = list(map(int, input().split()))
for w in range(W, wi - 1, -1):
v_ = dp[w - wi] + vi
if dp[w] < v_:
dp[w] = v_
return(dp[-1])
n, w = list(map(int, input().split())) # 1 <= n <= 100, 1 <= w <= 10^5
print((f(n, w)))
| p03163 |
def main():
n,w=list(map(int,input().split()))
wv=[]
for _ in range(n):
wv.append(list(map(int,input().split())))
dp=[]
temp=[]
for i in range(0,w+1):
if i < wv[0][0]:
temp.append(0)
else:
temp.append(wv[0][1])
# print(temp)
dp.append(temp)
# print(dp)
for i in range(1,n):
temp=[]
for j in range(0,w+1):
if j < wv[i][0]:
temp.append(dp[i-1][j])
else:
if j-wv[i][0] >=0:
temp.append(max(dp[i-1][j],dp[i-1][j-wv[i][0]] + wv[i][1]))
else:
temp.append(dp[i-1][j])
# print('temp')
# print(temp)
dp.append(temp)
# print('dp')
# print(dp)
print((dp[n-1][w]))
if __name__=='__main__':
main()
| def main():
n,lim_w=list(map(int,input().split()))
wv = []
for _ in range(n):
tmp = list(map(int,input().split()))
wv.append(tmp)
dp = [[0] * (lim_w+1) for i in range(n+1)]
for i in range(0, n):
for w in range(0,lim_w+1):
if w >= wv[i][0]:
dp[i+1][w] = max(dp[i][w], dp[i][w-wv[i][0]] + wv[i][1])
else:
dp[i+1][w] = dp[i][w]
print((dp[n][lim_w]))
if __name__=='__main__':
main()
| p03163 |
N,W=list(map(int,input().split()))
w=[0]*(N+1)
v=[0]*(N+1)
for i in range(1,N+1):
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(1,N+1):
for j in range(1,W+1):
#print("i=",i,"j=",j)
#dp[i][j]=max(dp[i][j],dp[i-1][j])
#if j-w[i]<0: continue
#dp[i][j]=max(dp[i][j],dp[i-1][j-w[i]]+v[i])
if j-w[i]<0:
dp[i][j]=max(dp[i][j],dp[i-1][j])
else:
dp[i][j]=max(dp[i][j],dp[i-1][j],dp[i-1][j-w[i]]+v[i])
#print(dp)
print((dp[N][W]))
| N,W=list(map(int,input().split()))
w=[0]*(N+1)
v=[0]*(N+1)
for i in range(1,N+1):
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(1,N+1):
for j in range(1,W+1):
#print("i=",i,"j=",j)
dp[i][j]=max(dp[i][j],dp[i-1][j])
if j-w[i]<0: continue
dp[i][j]=max(dp[i][j],dp[i-1][j-w[i]]+v[i])
#print(dp)
print((dp[N][W]))
| p03163 |
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import sys
EMPTY = (0, 0, frozenset())
def solve(values, _nb, max_capacity):
dp = [0] * (max_capacity + 1)
for w, v in values:
# dp = dp[:w] + [max(dp[j], dp[j - w] + v) for j in range(w, max_capacity + 1)]
dp[w:] = [max(dpj, dpjw + v) for dpj, dpjw in zip(dp[w:], dp[:-w])]
return dp[-1]
def solve_slow(values, nb, max_capacity):
dp = [[0 for _ in range(max_capacity + 1)] for _ in range(nb + 1)]
for i in range(1, nb + 1):
w, v = values[i - 1]
for j in range(1, max_capacity + 1):
if w <= j:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
# print("\n".join(map(str, dp)))
return dp[nb][max_capacity]
def do_job():
"Do the work"
# first line is number of test cases
N, W = list(map(int, input().split()))
values = []
for _ in range(N):
values.append(list(map(int, input().split())))
result = solve(values, N, W)
print(result)
def print_output(testcase, result) -> None:
"Formats and print result"
if result is None:
result = "IMPOSSIBLE"
print(("Case #{}: {}".format(testcase + 1, result)))
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
| # DP
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:
continue
if dp[i + w] < dp[i] + v:
dp[i + w] = dp[i] + v
print((max(dp)))
main()
| p03163 |
#!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import sys
EMPTY = (0, 0, frozenset())
def solve(values, _nb, max_capacity):
dp = [0] * (max_capacity + 1)
for w, v in values:
for j in range(max_capacity, w - 1, -1):
if dp[j] < dp[j - w] + v:
dp[j] = dp[j - w] + v
return dp[max_capacity]
def solve_better(values, _nb, max_capacity):
dp = [0] * (max_capacity + 1)
for w, v in values:
# dp = dp[:w] + [max(dp[j], dp[j - w] + v) for j in range(w, max_capacity + 1)]
dp[w:] = [max(dpj, dpjw + v) for dpj, dpjw in zip(dp[w:], dp[:-w])]
return dp[max_capacity]
def solve_slow(values, nb, max_capacity):
dp = [[0 for _ in range(max_capacity + 1)] for _ in range(nb + 1)]
for i in range(1, nb + 1):
w, v = values[i - 1]
for j in range(1, max_capacity + 1):
if w <= j:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
# print("\n".join(map(str, dp)))
return dp[nb][max_capacity]
def do_job():
"Do the work"
# first line is number of test cases
N, W = list(map(int, input().split()))
values = []
for _ in range(N):
values.append(list(map(int, input().split())))
result = solve(values, N, W)
print(result)
def print_output(testcase, result) -> None:
"Formats and print result"
if result is None:
result = "IMPOSSIBLE"
print(("Case #{}: {}".format(testcase + 1, result)))
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
| #!/usr/bin/env python3
# vim: set fileencoding=utf-8
# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation
"""Module docstring
"""
import sys
EMPTY = (0, 0, frozenset())
def solve(values, _nb, max_capacity):
dp = [0] * (max_capacity + 1)
for w, v in values:
for j in range(max_capacity, w - 1, -1):
tmp = dp[j - w] + v
if dp[j] < tmp:
dp[j] = tmp
return dp[max_capacity]
def solve_better(values, _nb, max_capacity):
dp = [0] * (max_capacity + 1)
for w, v in values:
# dp = dp[:w] + [max(dp[j], dp[j - w] + v) for j in range(w, max_capacity + 1)]
dp[w:] = [max(dpj, dpjw + v) for dpj, dpjw in zip(dp[w:], dp[:-w])]
return dp[max_capacity]
def solve_slow(values, nb, max_capacity):
dp = [[0 for _ in range(max_capacity + 1)] for _ in range(nb + 1)]
for i in range(1, nb + 1):
w, v = values[i - 1]
for j in range(1, max_capacity + 1):
if w <= j:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
# print("\n".join(map(str, dp)))
return dp[nb][max_capacity]
def do_job():
"Do the work"
# first line is number of test cases
N, W = list(map(int, input().split()))
values = []
for _ in range(N):
values.append(list(map(int, input().split())))
result = solve(values, N, W)
print(result)
def print_output(testcase, result) -> None:
"Formats and print result"
if result is None:
result = "IMPOSSIBLE"
print(("Case #{}: {}".format(testcase + 1, result)))
def main(argv=None):
"Program wrapper."
if argv is None:
argv = sys.argv[1:]
do_job()
return 0
if __name__ == "__main__":
import doctest
doctest.testmod()
sys.exit(main())
| p03163 |
N, W = list(map(int, input().split()))
dp = [[0] * (W+1) for _ in range(N+1)]
w, v = [0]*N, [0]*N
for i in range(N):
w[i], v[i] = list(map(int,input().split()))
for i in range(N):
for k in range(W+1):
if w[i] <= k:
dp[i+1][k] = max(dp[i][k-w[i]]+v[i], dp[i][k])
else:
dp[i+1][k] = dp[i][k]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(N)]
w, v = [0]*N, [0]*N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
for i in range(N):
for k in range(1,W+1):
if w[i] <= k:
dp[i][k] = max(dp[i-1][k-w[i]]+v[i],dp[i-1][k])
else:
dp[i][k] = dp[i-1][k]
print((dp[N-1][W])) | p03163 |
#!/usr/bin/env python3
import sys
def solve(N: int, W: int, w: "List[int]", v: "List[int]"):
dp = [[0] * (N + 1) for _ in range(W+1)]
for i in range(1, W+1):
for j in range(N):
if i - w[j] >= 0:
dp[i][j+1] = max(dp[i][j], dp[i-1][j], dp[i-w[j]][j] + v[j])
else:
dp[i][j+1] = max(dp[i][j], dp[i-1][j])
print((dp[-1][-1]))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
w = [int()] * (N) # type: "List[int]"
v = [int()] * (N) # type: "List[int]"
for i in range(N):
w[i] = int(next(tokens))
v[i] = int(next(tokens))
solve(N, W, w, v)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
def solve(N: int, W: int, w: "List[int]", v: "List[int]"):
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(N):
for j in range(1, W+1):
if j - w[i] >= 0:
dp[i+1][j] = max(
dp[i][j],
dp[i+1][j-1],
dp[i][j-w[i]] + v[i]
)
else:
dp[i+1][j] = max(dp[i][j], dp[i+1][j-1])
print((dp[-1][-1]))
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
W = int(next(tokens)) # type: int
w = [int()] * (N) # type: "List[int]"
v = [int()] * (N) # type: "List[int]"
for i in range(N):
w[i] = int(next(tokens))
v[i] = int(next(tokens))
solve(N, W, w, v)
if __name__ == '__main__':
main()
| p03163 |
[n,w] = [int(i) for i in input().split()]
wei_val = []
for i in range(n):
wei_val.append([int(j) for j in input().split()])
"""
dp[i][w_zantei] = v
i : i番目までの品物
w_zantei : 合計の重さがこれになる
v : 価値
更新式
dp[i][w_zantei] = max(dp[i][w_zantei],dp[i - 1][w_zantei - wei_val[0]] + wei_val[1]) (if w >= w_zantei+wei_val[i][0])
dp[i][w_zantei] = dp[i-1][w_zantei] (if w < w_zantei+wei_val[0])
"""
dp = [[0]* (w+1) for i in range(n)]
for i in range(n):
for w_zantei in range(w+1):
if w_zantei >= wei_val[i][0]:
dp[i][w_zantei] = max(dp[i-1][w_zantei],dp[i - 1][w_zantei - wei_val[i][0]] + wei_val[i][1])
else:
dp[i][w_zantei] = dp[i-1][w_zantei]
print((dp[n-1][w]))
| [n,w] = [int(i) for i in input().split()]
dp = [[0]*(w+1) for i in range(n)]
wv = []
for i in range(n):
wv.append([int(j) for j in input().split()])
"""
dp[i][w] = v
i : i番目まで
w : それまでの合計
"""
for i in range(n):
for j in range(w+1):
if i == 0:
dp[i][wv[i][0]] = wv[i][1]
else:
if j - wv[i][0] >= 0:
dp[i][j] = max(dp[i-1][j],dp[i-1][j - wv[i][0]]+wv[i][1])
else:
dp[i][j] = dp[i-1][j]
print((max(dp[n-1])))
#print(dp)
| p03163 |
import sys
input =sys.stdin.readline
number, weight = input().rstrip().split()
number = int(number)
weight = int(weight)
items = [list(map(int,input().rstrip().split())) for _ in range(number)]
#print(items)
dp = [[0]*(weight+1) for _ in range(number+1)]
for i in range(number):
for j in range(weight+1):
if j < items[i][0]:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j], dp[i][j-items[i][0]] + items[i][1])
print((dp[number][weight]))
| import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
wv = [None] * N
for i in range(N):
wv[i] = tuple(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i, (w, v) in enumerate(wv, start=1):
dp_i = dp[i]
dp_im = dp[i - 1]
for j in range(1, W + 1):
if j < w:
dp_i[j] = dp_im[j]
else:
a = dp_im[j - w] + v
b = dp_im[j]
if a > b:
dp_i[j] = a
else:
dp_i[j] = b
ans = dp[-1][-1]
print(ans)
if __name__ == "__main__":
main() | p03163 |
import sys
sys.setrecursionlimit(10**8)
N,W=list(map(int,input().split()))
wv=[list(map(int,input().split())) for i in range(N)]
dp=[[-1]*(W+1) for i in range(N+1)]
def calc(n,w):
if n<0:
return 0
if dp[n][w]>=0:
return dp[n][w]
cw,cv=wv[n]
r1,r2=0,0
r1=calc(n-1,w)
if (cw+w)<=W:
r2=calc(n-1,cw+w)+cv
dp[n][w]= max([r1,r2])
return dp[n][w]
print((calc(N-1,0))) | import sys
sys.setrecursionlimit(10**8)
N,W=list(map(int,input().split()))
wv=[list(map(int,input().split())) for i in range(N)]
dp=[[0]*(W+1) for i in range(N+1)]
for i in range(N):
for j in range(0,W+1):
if (j-wv[i][0])>=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 |
import sys
def main():
input = sys.stdin.readline
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
WV = (list(map(int, input().split())) for _ in range(N))
for w, v in WV:
for j in range(W, w - 1, -1):
dp[j] = max(dp[j], dp[j - w] + v)
print((dp[-1]))
main()
| import sys
def main():
input = sys.stdin.readline
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
WV = (list(map(int, input().split())) for _ in range(N))
for w, v in WV:
for j in range(W, w - 1, -1):
tmp = dp[j - w] + v
if tmp > dp[j]:
dp[j] = tmp
print((dp[-1]))
main()
| p03163 |
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, W = list(map(int, input().split()))
item = []
for _ in range(N):
w, v = list(map(int, input().split()))
item.append((w, v))
dp = [0] * (W + 1)
for w, v in item:
for i in range(W + 1)[::-1]:
if i - w >= 0:
tmp = dp[i - w] + v
if tmp > dp[i]:
dp[i] = tmp
print((max(dp)))
if __name__ == "__main__":
main()
| import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, W = list(map(int, input().split()))
item = []
for _ in range(N):
w, v = list(map(int, input().split()))
item.append((w, v))
dp = [0] * (W + 1)
for w, v in item:
for i in range(w, W + 1)[::-1]:
tmp = dp[i - w] + v
if tmp > dp[i]:
dp[i] = tmp
print((max(dp)))
if __name__ == "__main__":
main()
| p03163 |
from functools import cmp_to_key
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
d.sort(key = cmp_to_key(lambda x, y: x[1] / x[0] - y[1] / y[0]))
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw in t:
if nv > t[nw]:
t[nw] = nv
else:
t[nw] = nv
print((max(t.values())))
| from functools import cmp_to_key
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
d.sort(key = cmp_to_key(lambda x, y: x[1] / x[0] - y[1] / y[0]))
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw not in t or nv > t[nw]:
t[nw] = nv
print((max(t.values())))
| p03163 |
from functools import cmp_to_key
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
d.sort(key = cmp_to_key(lambda x, y: x[1] / x[0] - y[1] / y[0]))
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
updates = []
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw not in t or nv > t[nw]:
updates.append([nw, nv])
for u in updates:
t[u[0]] = u[1]
print((max(t.values())))
| from functools import cmp_to_key
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
d.sort(key = cmp_to_key(lambda x, y: y[1] / y[0] - x[1] / x[0]))
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
updates = []
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw not in t or nv > t[nw]:
updates.append([nw, nv])
for u in updates:
t[u[0]] = u[1]
print((max(t.values())))
| p03163 |
from functools import cmp_to_key
def main():
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
d.sort(key = cmp_to_key(lambda x, y: y[1] / y[0] - x[1] / x[0]))
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw in t:
if nv > t[nw]:
for k in list(t.keys()):
if k < nw and t[k] <= nv:
del t[k]
t[nw] = nv
else:
Flag = False
for k in t:
if nw < k and nv <= t[k]:
Flag = True
break
if Flag:
continue
for k in list(t.keys()):
if k < nw and t[k] <= nv:
del t[k]
t[nw] = nv
print((max(t.values())))
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 |
def main():
n, w = [int(e) for e in input().split()]
d = [[int(e) for e in input().split()] for i in range(n)]
t = {}
t[w] = 0
for i in range(n):
keys = list(sorted(t.keys())) # sort しないと品物iを複数回ナップサックに詰める可能性がある
tw, tv = d[i]
for j in keys:
nw = j - tw
if nw < 0:
continue
nv = t[j] + tv
if nw in t:
if nv > t[nw]:
t[nw] = nv
else:
t[nw] = nv
print((max(t.values())))
main()
| from sys import stdin
def main():
from builtins import int, range
readline = stdin.readline
n, w = [int(e) for e in readline().split()]
t = [-1 for i in range(w + 1)]
t[w] = 0
for _ in range(n):
nw, nv = [int(e) for e in readline().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 |
from sys import stdin
def main():
from builtins import int, range
readline = stdin.readline
n, w = [int(e) for e in readline().split()]
t = [-1 for i in range(w + 1)]
t[w] = 0
for _ in range(n):
nw, nv = [int(e) for e in readline().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() | from sys import stdin
def main():
from builtins import int, range
readline = stdin.readline
n, w = list(map(int, readline().split()))
t = [-1 for i in range(w + 1)]
t[w] = 0
for _ in range(n):
nw, nv = list(map(int, readline().split()))
for i in range(nw, w + 1):
ti = t[i]
if ti == -1:
continue
if t[i - nw] < ti + nv:
t[i - nw] = ti + nv
print((max(t)))
main() | p03163 |
# DP
def main():
from builtins import int, map, max, min, range
from sys import stdin
readline = stdin.readline
N, W = list(map(int, readline().split()))
dp = [-1] * (W + 1)
dp[0] = 0
max_w = 0
for _ in range(N):
w, v = list(map(int, readline().split()))
for j in range(min(max_w, W - w), -1, -1):
dpj = dp[j]
if dpj != -1:
jw = j + w
if dpj + v > dp[jw]:
dp[jw] = dpj + v
if jw > max_w:
max_w = jw
print((max(dp)))
main()
| # DP
def main():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[W] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(w, W + 1):
dpi = dp[i]
if dpi == -1:
continue
if dp[i - w] < dpi + v:
dp[i - w] = dpi + v
print((max(dp)))
main()
| p03163 |
# DP
def main():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[W] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(w, W + 1):
dpi = dp[i]
if dpi == -1:
continue
if dp[i - w] < dpi + v:
dp[i - w] = dpi + v
print((max(dp)))
main()
| # DP
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):
dpi = dp[i]
if dpi == -1:
continue
if dp[i + w] < dpi + v:
dp[i + w] = dpi + v
print((max(dp)))
main()
| p03163 |
# 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 - w, -1, -1):
if dp[i] == -1:
continue
if dp[i + w] < dp[i] + v:
dp[i + w] = dp[i] + v
print((max(dp)))
| # DP
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:
continue
if dp[i + w] < dp[i] + v:
dp[i + w] = dp[i] + v
print((max(dp)))
main()
| p03163 |
import sys
input = sys.stdin.readline
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
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 |
import sys
input=sys.stdin.readline
n, cap = list(map(int, input().split()))
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
print((val[-1]))
| import sys
input=sys.stdin.readline
n, cap = list(map(int, input().split()))
val =[0]*(cap+1)
def nap(n,cap):
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)
print((nap(n,cap)))
| p03163 |
import sys
input=sys.stdin.readline
n, cap = list(map(int, input().split()))
val =[0]*(cap+1)
def nap(n,cap):
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)
print((nap(n,cap)))
| import sys
input = sys.stdin.readline
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 |
import sys
input=sys.stdin.readline
def f(n,W):
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [[0] * (W + 1) for _ in range(n + 1)]
for i, (w, v) in enumerate(wv):
dp[i + 1][:w] = dp[i][:w]
for j, (v1, v2) in enumerate(zip(dp[i], dp[i][w:])):
nv = v1 + v
if nv > v2:
dp[i + 1][j + w] = nv
else:
dp[i + 1][j + w] = v2
print((dp[-1][-1]))
n, W = list(map(int, input().split()))
f(n,W)
| import sys
input=sys.stdin.readline
def f(n,W):
wv = [list(map(int, input().split())) for _ 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] == -1: continue
nv = dp[i] + v
if nv > dp[i + w]:
dp[i + w] = nv
print((max(dp)))
n,W=list(map(int,input().split()))
f(n,W)
| p03163 |
n,w = list(map(int, input().split()))
wv = []
for _ in range(n):
data = list(map(int,input().split()))
wv.append(data)
from functools import lru_cache
@lru_cache(maxsize=None)
def solve(i,j):
if i>=n:
return 0
weight=wv[i][0]
value =wv[i][1]
if j<weight: # can't push this item
val = solve(i+1,j)
else:# push or not push
val = max(solve(i+1,j-weight)+value, solve(i+1,j))
return val
print((solve(0,w))) | n,w = list(map(int, input().split()))
wv = []
for _ in range(n):
data = list(map(int,input().split()))
wv.append(data)
dp = [[0 for i in range(w+1)] for j in range(n+1)]
for item in range(n):
now_w=wv[item][0]
now_v=wv[item][1]
for weight in range(w+1):
ans1=dp[item][weight]
ans2=-1
if weight - now_w >= 0:
ans2=dp[item][weight-now_w]+now_v
dp[item+1][weight] = max(ans1,ans2)
print((dp[n][w])) | p03163 |
def main():
N, W = list(map(int, input().split()))
wl = []
vl = []
for _ in range(N):
w, v = list(map(int, input().split()))
wl.append(w)
vl.append(v)
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if wl[i] > j:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = max(dp[i][j], dp[i][j - wl[i]] + vl[i])
print((dp[N][W]))
main()
| def main():
N, W = list(map(int, input().split()))
WV = []
for _ in range(N):
w, v = list(map(int, input().split()))
WV.append((w, v))
dp = [[0] * (W + 1) for _ in range(N + 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[-1][-1]))
main()
| p03163 |
n, w = list(map(int, input().split()))
lis = [[0, 0]]
for i in range(n):
lis.append(list(map(int, input().split())))
dp = [[0 for i in range(w+1)] for i in range(n+1)]
#print(dp)
#print(lis)
for i in range(1, n+1):
for j in range(w+1):
if j - lis[i][0] < 0:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j],dp[i-1][j-lis[i][0]] + lis[i][1])
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)]
for i in range(n):
for j in range(W+1):
if j - w[i] < 0:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])
#print(dp)
print((dp[n-1][W])) | p03163 |
from sys import stdin
n,W=list(map(int,input().split()))
k=[[0 for i in range(W+1)] for i in range(n+1)]
for i in range(1,n+1):
w,v=list(map(int,stdin.readline().split()))
for j in range(1,W+1):
if w<=j:
k[i][j]=max(v+k[i-1][j-w],k[i-1][j])
else:
k[i][j]=k[i-1][j]
print((k[n][W]))
| from sys import stdin
n,W=list(map(int,input().split()))
k=[[0 for i in range(W+1)] for i in range(2)]
for i in range(1,n+1):
w,v=list(map(int,stdin.readline().split()))
for j in range(1,W+1):
if w<=j:
k[1][j]=max(v+k[0][j-w],k[0][j])
else:
k[1][j]=k[0][j]
k[0]=[i for i in k[1]]
k[1]=[0]*(W+1)
print((k[0][-1])) | p03163 |
from sys import stdin
n,W=list(map(int,input().split()))
k=[[0 for i in range(W+1)] for i in range(2)]
for i in range(1,n+1):
w,v=list(map(int,stdin.readline().split()))
for j in range(1,W+1):
if w<=j:
k[1][j]=max(v+k[0][j-w],k[0][j])
else:
k[1][j]=k[0][j]
k[0]=[i for i in k[1]]
k[1]=[0]*(W+1)
print((k[0][-1])) | from sys import stdin
n,W=list(map(int,input().split()))
dp=[0 for i in range(W+1)]
for i in range(n):
w,v=list(map(int,stdin.readline().split()))
for j in range(W-w,-1,-1):
dp[j+w]=max(dp[j]+v,dp[j+w])
print((dp[-1])) | p03163 |
#####################################################################################################
##### ナップサック問題 http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_1_C&lang=ja
#####################################################################################################
import sys
input = sys.stdin.readline
M, W = list(map(int, input().split())) # M: 品物の種類 W: 重量制限
dp_min = 0 # 総和価値の最小値
price_list = [0]
weight_list = [0]
for _ in range(M):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
# price_list = [0] + list(map(int, input().split())) # item = 0 は 0 種類の品物を用いた場合に対応するため、参照されることはない。item = 1 で品物の 0 番目に対応させるためにインクリメントが必要となる。
# weight_list = [0] + list(map(int, input().split())) # item = 0 は 0 種類の品物を用いた場合に対応するため、参照されることはない。item = 1 で品物の 0 番目に対応させるためにインクリメントが必要となる。
# dp[item <= M ][weight <= W]
dp = [[dp_min] * (W + 1) for _ in range(M + 1)] # 左端と上端の境界条件で W, M を一個ずつ多めに取る
for item in range(M+1): # 左端の境界条件
dp[item][0] = 0 # 重さ 0 を実現するのに必要な品物の個数は 0 個
# for weight in range(W+1): # 上端の境界条件
# dp[0][weight] = dp_max # 0 種類の品物で実現できる重量は存在しない （dpの初期化で自動的に課せる場合が多い）
for item in range(1,M+1): # 境界条件を除いた M 回のループ（※ f[item] = g.f[item-i] の漸化式なので、list index out of range となる）
for weight in range(1, W + 1):
if weight < weight_list[item]: # weight (重量価値) < weight_list[item] (品物の重量) の時は無視してよい
dp[item][weight] = dp[item - 1][weight]
else:
dp[item][weight] = max(dp[item-1][weight], dp[item-1][weight - weight_list[item]] + price_list[item]) # 重複なし: dp[item][weight - weight_list[item]] ⇒ dp[item-1][weight - weight_list[item]]
print((dp[M][W])) | import sys
input = sys.stdin.readline
M, W = list(map(int, input().split())) # M: 品物の種類 W: 重量制限
single = True # True = 重複なし
price_list = [0]
weight_list = [0]
for _ in range(M):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
################################################################################################################################################
dp_min = 0 # 総和価値の最小値
""" dp[item <= M ][weight <= W] = 重さ上限を固定した時の"最大"価値 """
dp = [[dp_min] * (W + 1) for _ in range(M + 1)] # 左端と上端の境界条件で W, M を一個ずつ多めに取る
""" 重さ 0 の時の境界条件 """
for item in range(M+1):
dp[item][0] = 0 # 重さ 0 を実現するのに必要な品物の個数は 0 個
""" 品物 0 個の時の境界条件 """
# for weight in range(W+1):
# dp[0][weight] = dp_min # 0 種類の品物で実現できる重量は存在しない （dpの初期化で自動的に課せる場合が多い）
for item in range(1,M+1): # 境界条件を除いた M 回のループ（※ f[item] = g.f[item-i] の漸化式なので、list index out of range となる）
for weight in range(1, W + 1):
if weight < weight_list[item]: # weight (重量価値) < weight_list[item] (品物の重量) の時は無視してよい
dp[item][weight] = dp[item - 1][weight]
else:
temp = dp[item - single][weight - weight_list[item]] + price_list[item] # single = True: 重複なし
if temp > dp[item-1][weight]: # max(dp[item-1][weight], temp)
dp[item][weight] = temp
else:
dp[item][weight] = dp[item-1][weight]
print((dp[M][W])) | p03163 |
import sys
input = sys.stdin.readline
M, W = list(map(int, input().split())) # M: 品物の種類 W: 重量制限
single = True # True = 重複なし
price_list = [0]
weight_list = [0]
for _ in range(M):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
################################################################################################################################################
dp_min = 0 # 総和価値の最小値
""" dp[item <= M ][weight <= W] = 重さ上限を固定した時の"最大"価値 """
dp = [[dp_min] * (W + 1) for _ in range(M + 1)] # 左端と上端の境界条件で W, M を一個ずつ多めに取る
""" 重さ 0 の時の境界条件 """
for item in range(M+1):
dp[item][0] = 0 # 重さ 0 を実現するのに必要な品物の個数は 0 個
""" 品物 0 個の時の境界条件 """
# for weight in range(W+1):
# dp[0][weight] = dp_min # 0 種類の品物で実現できる重量は存在しない （dpの初期化で自動的に課せる場合が多い）
for item in range(1,M+1): # 境界条件を除いた M 回のループ（※ f[item] = g.f[item-i] の漸化式なので、list index out of range となる）
for weight in range(1, W + 1):
if weight < weight_list[item]: # weight (重量価値) < weight_list[item] (品物の重量) の時は無視してよい
dp[item][weight] = dp[item - 1][weight]
else:
temp = dp[item - single][weight - weight_list[item]] + price_list[item] # single = True: 重複なし
if temp > dp[item-1][weight]: # max(dp[item-1][weight], temp)
dp[item][weight] = temp
else:
dp[item][weight] = dp[item-1][weight]
print((dp[M][W])) | import sys
input = sys.stdin.readline
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
################################################################################################################################################
def max2(x,y):
""" pythonの組み込み関数 max は２変数に対しては遅い！！ """
if x>y:
return x
else:
return y
dp_min = 0 # 総和価値の最小値
""" dp[weight <= W] = 重さ上限を固定した時の"最大"価値 """
dp = [dp_min] * (W + 1)
for item in range(N):
for weight in reversed(list(range(weight_list[item], W + 1))):
dp[weight] = max2(dp[weight], dp[weight - weight_list[item]] + price_list[item])
print((dp[W])) | p03163 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
################################################################################################################################################
def max2(x,y):
""" pythonの組み込み関数 max は２変数に対しては遅い！！ """
if x>y:
return x
else:
return y
dp_min = 0 # 総和価値の最小値
""" dp[weight <= W] = 重さ上限を固定した時の"最大"価値 """
dp = [dp_min] * (W + 1)
for item in range(N):
for weight in reversed(list(range(weight_list[item], W + 1))):
dp[weight] = max2(dp[weight], dp[weight - weight_list[item]] + price_list[item])
print((dp[W])) | import sys
input = sys.stdin.readline
def max2(x, y):
""" pythonの組み込み関数 max は2変数に対しては遅い！！ """
if x > y:
return x
else:
return y
def knapsack_weight(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
""" dp[weight <= W] = 重さ上限を固定した時の最大価値 """
dp_min = 0 # 総和価値の最小値
dp = [dp_min] * (W + 1)
for item in range(N):
if single:
S = reversed(list(range(weight_list[item], W + 1)))
else:
S = list(range(weight_list[item], W + 1))
for weight in S:
dp[weight] = max2(dp[weight], dp[weight - weight_list[item]] + price_list[item])
return dp[W]
#######################################################################################################
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
print((knapsack_weight(single=True)))
################################################################################################################################################
| p03163 |
import sys
input = sys.stdin.readline
def max2(x, y):
""" pythonの組み込み関数 max は2変数に対しては遅い！！ """
if x > y:
return x
else:
return y
def knapsack_weight(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
""" dp[weight <= W] = 重さ上限を固定した時の最大価値 """
dp_min = 0 # 総和価値の最小値
dp = [dp_min] * (W + 1)
for item in range(N):
if single:
S = reversed(list(range(weight_list[item], W + 1)))
else:
S = list(range(weight_list[item], W + 1))
for weight in S:
dp[weight] = max2(dp[weight], dp[weight - weight_list[item]] + price_list[item])
return dp[W]
#######################################################################################################
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
print((knapsack_weight(single=True)))
################################################################################################################################################
| import sys
input = sys.stdin.readline
def max2(x, y):
""" pythonの組み込み関数 max は2変数に対しては遅い！！ """
if x > y:
return x
else:
return y
def knapsack_weight(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
""" dp[weight <= W] = 重さ上限を固定した時の最大価値 """
dp_min = 0 # 総和価値の最小値
dp = [dp_min] * (W + 1)
for _ in range(N):
w, price = list(map(int, input().split()))
if single:
S = reversed(list(range(w, W + 1)))
else:
S = list(range(w, W + 1))
for weight in S:
dp[weight] = max2(dp[weight], dp[weight - w] + price)
return dp[W]
#######################################################################################################
print((knapsack_weight(single=True)))
| p03163 |
def knapsack_weight(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
""" dp[weight <= W] = 重さ上限を固定した時の最大価値 """
dp_min = 0 # 総和価値の最小値
dp = [dp_min] * (W + 1)
for item in range(N):
if single:
S = list(range(W, weight_list[item] - 1, -1))
else:
S = list(range(weight_list[item], W + 1))
for weight in S:
if dp[weight] < dp[weight - weight_list[item]] + price_list[item]:
dp[weight] = dp[weight - weight_list[item]] + price_list[item]
return dp[W]
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
print((knapsack_weight(single=True))) | def knapsack_weight(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
""" dp[weight <= W] = 重さ上限を固定した時の最大価値 """
dp_min = 0 # 総和価値の最小値
dp = [dp_min] * (W + 1)
for item in range(N):
S = list(range(W, weight_list[item] - 1, -1))
for weight in S:
if dp[weight] < dp[weight - weight_list[item]] + price_list[item]:
dp[weight] = dp[weight - weight_list[item]] + price_list[item]
return dp[W]
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
print((knapsack_weight(single=True)))
| p03163 |
inf = 2**60
'''
def table(size, init): #配列生成
x = len(size)
l = [init for i in range(size[x-1])]
for i in range(x-1):
l = [l for k in range(size[x-2-i])]
return l
'''
n, W = list(map(int, input().split()))
w, v = [[0]*n for i in range(2)]
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(W+1):
if dp[i][j] != -1:
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
if j+w[i] <= W:
dp[i+1][j+w[i]] = max(dp[i][j] + v[i], dp[i+1][j+w[i]])
print((max(dp[n]))) | inf = 2**60
'''
def table(size, init): #配列生成
x = len(size)
l = [init for i in range(size[x-1])]
for i in range(x-1):
l = [l for k in range(size[x-2-i])]
return l
'''
n, W = list(map(int, input().split()))
w, v = [[0]*n for i in range(2)]
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(n):
for j in range(W+1):
if j>=w[i]:
dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]]+v[i])
else:
dp[i+1][j] = dp[i][j]
print((max(dp[n]))) | p03163 |
(N, W), *D = [list(map(int, o.split())) for o in open(0)]
w, v = 0, 1
dp = [[0]*-~W for _ in [0]*-~N]
for i in range(N):
for j in range(W + 1):
dp[i + 1][j] = max(dp[i][j], (dp[i][j - D[i][w]] + D[i][v])*(j >= D[i][w]))
print((dp[N][W])) | N, W = list(map(int,input().split()))
dp = [0]*-~W
for _ in [None]*N:
w, v = list(map(int,input().split()))
for j in range(W, w-1, -1):
dp[j] = max(dp[j], dp[j - w] + v)
print((max(dp))) | p03163 |
import sys
import math
from collections import deque
import copy
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[-1 for _ in range(W + 1)] for _ in range(N + 1)]
for i in dp:
i[0] = 0
dp[0] = [0 for _ in range(W + 1)]
for i in range(1, N + 1):
for l in range(1, W + 1):
if l - wv[i - 1][0] < 0:
dp[i][l] = dp[i - 1][l]
else:
dp[i][l] = max(dp[i - 1][l], dp[i - 1][l - wv[i - 1][0]] + wv[i - 1][1])
print((dp[N][W]))
| N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[-1 for _ in range(W + 1)] for _ in range(N + 1)]
for i in dp:
i[0] = 0
dp[0] = [0 for _ in range(W + 1)]
for i in range(1, N + 1):
for l in range(1, W + 1):
if l - wv[i - 1][0] < 0:
dp[i][l] = dp[i - 1][l]
else:
dp[i][l] = max(dp[i - 1][l], dp[i - 1][l - wv[i - 1][0]] + wv[i - 1][1])
print((dp[N][W]))
| p03163 |
n, we = list(map(int, input().split()))
cf=[(0, 0)]*(n+1)
for i in range(1, n+1):
cf[i] = tuple( map(int, input().split()) )
dp=[0]*(we+1)
best=0
for i in range(1, n+1):
for j in reversed(list(range(cf[i][0], we+1))):
dp[j]=max( dp[j], dp[j-cf[i][0]]+ cf[i][1] )
best=max(best, dp[we])
print(best)
# for i in range(1, n+1): print( dp[i], '\n' ) | import sys
n, we = list(map(int, input().split()))
cf=[(0, 0)]*(n+1)
for i in range(1, n+1):
cf[i] = tuple( map(int, sys.stdin.readline().split()) )
dp=[0]*(we+1)
best=0
for i in range(1, n+1):
for j in reversed(list(range(cf[i][0], we+1))):
dp[j]=max( dp[j], dp[j-cf[i][0]]+ cf[i][1] )
best=max(best, dp[we])
print(best)
# for i in range(1, n+1): print( dp[i], '\n' ) | p03163 |
import sys
n, we = list(map(int, input().split()))
cf=[(0, 0)]*n
cf = sorted(tuple( int(x) for x in sys.stdin.readline().split()) for _ in range(n))
dp=[0]*(we+1)
best=0
for w,c in cf:
for j in reversed(list(range(w, we+1))):
if dp[j]<dp[j-w]+ c : dp[j]=dp[j-w]+ c
# print(dp)
best=max(best, dp[we])
print(best) | n, we = list(map(int, input().split()))
cf=[(0, 0)]*n
cf = sorted(tuple( int(x) for x in input().split()) for _ in range(n))
dp=[0]*(we+1)
best=0
cnt=1
lim=0
for w,c in cf:
cnt=cnt+w
lim=min(cnt, we-w)
for j in range(lim, -1, -1):
if dp[j+w]<(dp[j] + c) : dp[j+w]=dp[j] + c
print((max(dp))) | p03163 |
import sys
n, we = list(map(int, input().split()))
cf=[(0, 0)]*n
cf = sorted(tuple( int(x) for x in sys.stdin.readline().split()) for _ in range(n))
dp=[0]*(we+1)
best=0
cnt=1
lim=0
for w,c in cf:
cnt=cnt+w
lim=min(cnt, we-w)
for j in range(lim, -1, -1):
if dp[j+w]<(dp[j] + c) : dp[j+w]=dp[j] + c
print((max(dp))) | import sys
n, we = list(map(int, input().split()))
cf=[(0, 0)]*n
cf = sorted( [[int(x) for x in sys.stdin.readline().split()] for _ in range(n)] )
dp=[0]*(we+1)
best=0
cnt=1
lim=0
for w,c in cf:
cnt=cnt+w
lim=min(cnt, we-w)
for j in range(lim, -1, -1):
if dp[j+w]<(dp[j] + c) : dp[j+w]=dp[j] + c
print((max(dp))) | p03163 |
import sys
n, W = list(map(int, sys.stdin.readline().split()))
#L = [[map(int, sys.stdin.readline().split())] for _ in range(n)]
dp = [[0 for _ in range(W+1)] for _ in range(n)]
for i in range(n):
w, v =list(map(int, sys.stdin.readline().split()))
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+w<=W:
dp[i][j+w] = max(dp[i-1][j+w], v+ dp[i-1][j])
#print(dp, i)
dp[i][w] = max(dp[i-1][w], v)
#print(dp)
print((max(dp[-1]))) | import sys
n, W = list(map(int, sys.stdin.readline().split()))
dp = [[0 for _ in range(W+1)] for _ in range(n)]
for i in range(n):
w, v =list(map(int, sys.stdin.readline().split()))
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+w<=W:
dp[i][j+w] = max(dp[i-1][j+w], v+ dp[i-1][j])
#print(dp, i)
dp[i][w] = max(dp[i-1][w], v)
#print(dp)
print((max(dp[-1]))) | p03163 |
N, W = list(map(int, input().split()))
wv = [[0 for i in range(2)] for j in range(N)]
dp = [[0 for i in range(N+1)] for j in range(W+1)]
for i in range(N):
wv[i] = list(map(int, input().split()))
for i in range(N):
for w in range(1,W+1):
if w < wv[i][0]:
dp[w][i+1] = dp[w][i]
else:
dp[w][i+1] = max(dp[w-wv[i][0]][i]+wv[i][1], dp[w][i])
print((dp[-1][-1]))
| N,W=list(map(int,input().split()))
wv = [tuple(map(int,input().split())) for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(1,N+1):
for j in range(1, W+1):
if j >= wv[i-1][0]:
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((dp[-1][-1])) | p03163 |
import sys
#import numpy as np
#from collections import defaultdict
import math
#from collections import deque
input = sys.stdin.readline
#import numpy as np
def main():
N,W = list(map(int,input().split()))
dp = [0] * (W+2)
for _ in range(N):
w,v = list(map(int,input().split()))
for j in range(W+1,w-1,-1):
dp[j] =max(dp[j-w] +v ,dp[j])
print((dp[W]))
# print(dp)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
#import numpy as np
def main():
N,W = list(map(int,input().split()))
dp = [0] * (W+2)
for _ in range(N):
w,v = list(map(int,input().split()))
for j in range(W+1,w-1,-1):
dp[j] =max(dp[j-w] +v ,dp[j])
print((dp[W]))
if __name__ == "__main__":
main()
| p03163 |
import sys
def input():
return sys.stdin.readline().rstrip()
def main():
N, W = list(map(int, input().split()))
dp = [[0] * (N + 1) for _ in range(W + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(W + 1):
if j >= w:
dp[j][i] = max(dp[j][i - 1], dp[j - w][i-1] + v)
else:
dp[j][i] = dp[j][i - 1]
print((dp[W][N]))
if __name__ == "__main__":
main()
| import sys
import math
import itertools
# \n
def input():
return sys.stdin.readline().rstrip()
def main():
N, WW = list(map(int, input().split()))
W = []
V = []
for i in range(N):
w, v = list(map(int, input().split()))
W.append(w)
V.append(v)
dp = [[0] * (WW+1) for _ in range(N)]
for i in range(N):
w = W[i]
v = V[i]
for j in range(WW+1):
if w<=j:
dp[i][j] =max(dp[i-1][j],dp[i-1][j-w]+v)
else:
dp[i][j] =dp[i-1][j]
print((max(dp[N-1])))
if __name__ == "__main__":
main()
| p03163 |
import sys
import math
import itertools
# \n
def input():
return sys.stdin.readline().rstrip()
def main():
N, WW = list(map(int, input().split()))
dp = [[0] * (WW+1) for _ in range(N)]
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(WW+1):
if w<=j:
dp[i][j] =max(dp[i-1][j],dp[i-1][j-w]+v)
else:
dp[i][j] =dp[i-1][j]
print((max(dp[N-1])))
if __name__ == "__main__":
main()
| import sys
# \n
def input():
return sys.stdin.readline().rstrip()
def main():
N, W = list(map(int, input().split()))
dp =[0] *(W+1)
for i in range(N):
w,v =list(map(int,input().split()))
for i in range(W,w-1,-1):
dp[i] =max(dp[i],dp[i-w]+v)
print((max(dp)))
if __name__ == "__main__":
main()
| p03163 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
dpt = [0] * (W+1)
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W, w-1, -1):
a = dpt[j]
b = dpt[j-w]+v
if a > b:
dpt[j] = a
else:
dpt[j] = b
print((dpt[W])) | import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
dpt = [0] * (W+1)
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W, w-1, -1):
a = dpt[j]
b = dpt[j-w]+v
if a > b:
dpt[j] = a
else:
dpt[j] = b
print((dpt[W]))
if __name__ == '__main__':
main() | p03163 |
# atcoder https://atcoder.jp/contests/dp/tasks/dp_d
def main():
N, W = list(map(int, input().split()))
w, v = [], []
for _ in range(N):
wi, vi = list(map(int, input().split()))
w.append(wi)
v.append(vi)
dp = [[0 for j in range(W+1)] for i 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] = max(dp[i-1][j], dp[i-1][j-w[i-1]]+v[i-1])
else:
dp[i][j] = dp[i-1][j]
print((dp[N][W]))
main() | # https://atcoder.jp/contests/dp/tasks/dp_d
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
N, W = MAP()
w, v = [], []
for _ in range(N):
wi, vi = MAP()
w.append(wi)
v.append(vi)
DP = [[0] * (N+1) for _ in range(W+1)]
for i in range(1, W+1):
for j in range(1, N+1):
if i < w[j-1]:
DP[i][j] = max(
DP[i][j-1],
DP[i-1][j])
else:
DP[i][j] = max(
DP[i][j-1],
DP[i-w[j-1]][j-1] + v[j-1],
DP[i-1][j])
print((DP[-1][-1]))
| p03163 |
N, W = list(map(int, input().split()))
dp = [[0 for i in range(W + 1)] for j in range(N+1)]
for j in range(N):
w, v = list(map(int, input().split()))
for k in range(W + 1):
if k >= w:
dp[j+1][k] = max(dp[j][k-w] + v, dp[j][k])
else:
dp[j+1][k] = dp[j][k]
ans = 0
for i in range(W + 1):
ans = max(ans, dp[N][i])
print((dp[N][W]))
| N, W = list(map(int, input().split()))
dp = [[0 for i in range(W + 1)] for j in range(N+1)]
for j in range(N):
w, v = list(map(int, input().split()))
for k in range(W + 1):
if k >= w:
dp[j+1][k] = max(dp[j][k-w] + v, dp[j][k])
else:
dp[j+1][k] = dp[j][k]
print((dp[N][W]))
| p03163 |
N, W = list(map(int, input().split()))
dp = [[0 for i in range(W + 1)] for j in range(N+1)]
for j in range(N):
w, v = list(map(int, input().split()))
for k in range(W + 1):
if k >= w:
dp[j+1][k] = max(dp[j][k-w] + v, dp[j][k])
else:
dp[j+1][k] = dp[j][k]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
dp = [[0]*(W+1) for i in range(N+1)]
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W+1):
if w + j <= W:
dp[i+1][j+w] = max(dp[i][j+w], dp[i][j]+v)
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
else:
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
print((max(dp[N])))
| p03163 |
n,W=list(map(int,input().split()))
w=[]
val=[]
for i in range(n):
p=list(map(int,input().split()))
w.append(p[0])
val.append(p[1])
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]]+val[i])
print(dp[-1]) | n,W=list(map(int,input().split()))
w=[]
val=[]
for i in range(n):
p=list(map(int,input().split()))
w.append(p[0])
val.append(p[1])
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]]+val[i])
print((dp[-1])) | p03163 |
N, W = list(map(int, input().split()))
items = [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(N):
for j in range(W+1):
if j - items[i][0] >= 0:
dp[i+1][j] = max(dp[i][j], dp[i][j - items[i][0]] + items[i][1])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
| N, W = list(map(int, input().split()))
items = []
for _ in range(N):
items.append(tuple(map(int, input().split())))
dp = [[0] * (W + 1) for _ in range(N+1)]
for i in range(N):
for w in range(W + 1):
if w - items[i][0] >= 0:
dp[i+1][w] = max(dp[i][w], dp[i][w - items[i][0]] + items[i][1])
else:
dp[i+1][w] = dp[i][w]
print((dp[N][W]))
| p03163 |
cache={}
def dp(n,W,w,p):
if n==0 or W==0:
return 0
elif (n,W) in cache:
return cache[(n,W)]
else:
if w[n-1]<=W:
cache[(n,W)]=max(p[n-1]+dp(n-1,W-w[n-1],w,p),dp(n-1,W,w,p))
else:
cache[(n,W)]=dp(n-1,W,w,p)
return cache[(n,W)]
n,W=list(map(int,input().split()))
weight,profit=[],[]
for _ in range(n):
w,p=list(map(int,input().split()))
weight.append(w)
profit.append(p)
print((dp(n,W,weight,profit))) | n,W=list(map(int,input().split()))
t = [[-1 for i in range(W + 1)] for j in range(n + 1)]
def dp(n,W,w,p):
if n==0 or W==0:
return 0
elif t[n][W]!=-1:
return t[n][W]
else:
if w[n-1]<=W:
t[n][W]=max(p[n-1]+dp(n-1,W-w[n-1],w,p),dp(n-1,W,w,p))
else:
t[n][W]=dp(n-1,W,w,p)
return t[n][W]
weight,profit=[],[]
for _ in range(n):
w,p=list(map(int,input().split()))
weight.append(w)
profit.append(p)
print((dp(n,W,weight,profit))) | p03163 |
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from builtins import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
def knapsack(W,n):
if n==0 or W==0 :
return 0
elif cache.get((W,n)):
return cache[(W,n)]
else:
if wt[n-1]<=W:
cache[(W,n)]=max(knapsack(W,n-1),p[n-1]+knapsack(W-wt[n-1],n-1))
return cache[(W,n)]
else:
cache[(W,n)]=knapsack(W,n-1)
return cache[(W,n)]
wt,p=[],[]
cache={}
def main():
n,w=map(int,input().split())
for _ in range(n):
temp_wt,temp_pr=map(int,input().split())
wt.append(temp_wt)
p.append(temp_pr)
print(knapsack(w,n))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main() | # what is dp relation
# dp[n][w]=max(dp[n-1][w-wt[n]]+p[n],dp[n-1][w])
n,W=list(map(int,input().split()))
wt,p=[],[]
for _ in range(n):
a,b=list(map(int,input().split()))
wt.append(a)
p.append(b)
dp=[[0 for i in range(W+1)]for j in range(n+1)]
for x in range(1,n+1):
for y in range(1,W+1):
if wt[x-1]<=y:
dp[x][y]=max(dp[x-1][y-wt[x-1]]+p[x-1],dp[x-1][y])
else:
dp[x][y]=dp[x-1][y]
print((dp[-1][-1])) | p03163 |
# what is dp relation
# dp[n][w]=max(dp[n-1][w-wt[n]]+p[n],dp[n-1][w])
n,W=list(map(int,input().split()))
wt,p=[],[]
for _ in range(n):
a,b=list(map(int,input().split()))
wt.append(a)
p.append(b)
dp=[[0 for i in range(W+1)]for j in range(n+1)]
for x in range(1,n+1):
for y in range(1,W+1):
if wt[x-1]<=y:
dp[x][y]=max(dp[x-1][y-wt[x-1]]+p[x-1],dp[x-1][y])
else:
dp[x][y]=dp[x-1][y]
print((dp[-1][-1])) | n,W=list(map(int,input().split()))
wt,p=[],[]
for _ in range(n):
a,b=list(map(int,input().split()))
wt.append(a)
p.append(b)
dp=[0 for i in range(W+1)]
for x in range(1,n+1):
for y in range(W,0,-1):
if wt[x-1]<=y:
dp[y]=max(dp[y-wt[x-1]]+p[x-1],dp[y])
else:
dp[y]=dp[y]
print((dp[-1])) | p03163 |
n,w = list(map(int,input().split()))
dp = [[0 for i in range(w+1)]for j in range(n+1)]
for i in range(n):
weight,value = list(map(int,input().split()))
for j in range(w+1):
if j >= weight:
dp[i+1][j] = max(dp[i][j-weight]+value,dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((dp[n][w]))
| N,W=list(map(int,input().split()))
dp=[[0]*(W+1) for i in range(N+1)]
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-w]+v,dp[i][j])
else:
dp[i+1][j]=dp[i][j]
print((dp[N][W])) | p03163 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
def make_v(*args,e=0):
from copy import deepcopy
A=e
for i in args[::-1]: A=[deepcopy(A) for _ in range(i)]
return A
input=lambda :sys.stdin.buffer.readline().rstrip()
def resolve():
n,w=list(map(int,input().split()))
W=[0]*(n+1)
V=[0]*(n+1)
for i in range(n):
W[i+1],V[i+1]=list(map(int,input().split()))
dp=make_v(n+1,w+1)
for i in range(1,n+1):
for k in range(w+1):
if(k-W[i]>=0):
dp[i][k]=max(dp[i-1][k-W[i]]+V[i],dp[i-1][k])
else:
dp[i][k]=dp[i-1][k]
print((dp[n][w]))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.buffer.readline().rstrip()
def resolve():
n,w=list(map(int,input().split()))
W=[0]*(n+1)
V=[0]*(n+1)
for i in range(n):
W[i+1],V[i+1]=list(map(int,input().split()))
dp=[[0]*(w+1) for _ in range(n+1)]
for i in range(1,n+1):
for k in range(w+1):
if(k-W[i]>=0):
dp[i][k]=max(dp[i-1][k-W[i]]+V[i],dp[i-1][k])
else:
dp[i][k]=dp[i-1][k]
print((dp[n][w]))
resolve() | p03163 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.