input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
x = int(eval(input()))
nums = [i for i in range(2, 100004)]
while nums:
primal = nums.pop(0)
if primal >= x:
print(primal)
break
nums = [num for num in nums if num % primal != 0]
| import sys
x = int(eval(input()))
nums = [i for i in range(1, 100004, 2)]
del nums[0]
if x == 2:
print((2))
sys.exit()
while nums:
primal = nums.pop(0)
if primal >= x:
print(primal)
break
nums = [num for num in nums if num % primal != 0]
| p02819 |
import sys
x = int(eval(input()))
nums = [i for i in range(1, 100004, 2)]
del nums[0]
if x == 2:
print((2))
sys.exit()
while nums:
primal = nums.pop(0)
if primal >= x:
print(primal)
break
nums = [num for num in nums if num % primal != 0]
| def check_primal(num):
'''素数だったら0を、違ったら1を返す'''
for mod in range(2, int(num**0.5+1)):
if num % mod == 0:
return 1
return 0
x = int(eval(input()))
for i in range(x, 100004):
if check_primal(i) == 0:
print(i)
break
| p02819 |
X = int(eval(input()))
sosu = [2]
for i in range(3, 10**5+100, 2):
if(all(i % num != 0 for num in sosu)):
sosu.append(i)
if(i >= X):
print((i if X > 2 else 2))
break | import math
X = int(eval(input()))
def isprime(num):
if(num==2):
return True
elif(num%2 == 0):
return False
for i in range(3, int(math.sqrt(num)+1), 2):
if(num%i == 0):
return False
return True
def prime(n):
ans = 2
for i in range(n, 10**5+4):
if(isprime(i)):
ans = i
break
return ans
print((prime(X))) | p02819 |
nn=int(eval(input()))
n=10**5+100
ar=[0]*(n)
ar[1]=0
ans=0
pre=1
for i in range(2,n):
if ar[i]==0:
for j in range(2*i,n,i):
ar[j]=1
ans=1
if ar[nn]==0:
print(nn)
else:
for i in range(nn,n):
if ar[i]==0:
print(i)
break
| nn=int(eval(input()))
n=10**5+100
ar=[0]*(n)
ar[1]=0
ans=0
pre=1
for i in range(2,int((n**0.5))+1):
if ar[i]==0:
for j in range(2*i,n,i):
ar[j]=1
ans=1
if ar[nn]==0:
print(nn)
else:
for i in range(nn,n):
if ar[i]==0:
print(i)
break
| p02819 |
n, w = list(map(int, input().split()))
V, W = [], []
for i in range(n):
wi, vi = list(map(int, input().split()))
W.append(wi)
V.append(vi)
max_sumv = sum(V)
# dp[i][sum_v] := i-1 番目までの品物から価値がsum_v以上を達成するように選んだときの、重さの総和の最小値
dp = [[10 ** 9] * (max_sumv + 1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for sum_v in range(max_sumv + 1):
#i番目の商品を選ぶ場合
if sum_v - V[i] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v - V[i]] + W[i])
#i番目の商品を選ばない場合
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
ans = 0
for i in range(max_sumv + 1):
if dp[n][i] <= w:
ans = i
print(ans) | n, w = list(map(int, input().split()))
W, V = [], []
sum_v = 0
for i in range(n):
wi, vi = list(map(int ,input().split()))
W.append(wi)
V.append(vi)
sum_v += vi
memo = [[10**9] * (sum_v + 1) for _ in range(n+1)]
memo[0][0] = 0
for i in range(n):
for v_i in range(sum_v + 1):
memo[i+1][v_i] = min(memo[i+1][v_i], memo[i][v_i])
if v_i - V[i] >= 0:
memo[i+1][v_i] = min(memo[i+1][v_i], memo[i][v_i-V[i]] + W[i])
ans = 0
for i in range(sum_v + 1):
if memo[-1][i] <= w:
ans = i
print(ans) | p03164 |
n,wmax=list(map(int,input().split()))
v=[0]*n
w=[0]*n
for i in range(n):
w[i],v[i]=list(map(int,input().split()))
sv=sum(v)+1
dp=[[float('inf')]*sv for _ in range(n)]
dp[0][v[0]-1]=w[0]
for i in range(n):
dp[i][0]=0
for i in range(n):
for j in range(sv):
dp[i][j]=min(dp[i-1][j],dp[i-1][j-v[i]]+w[i])
if dp[i][j]>wmax:
dp[i][j]=float('inf')
ans=float('inf')
for p in range(sv-1,-1,-1):
if dp[n-1][p]!=ans:
ans=p
break
print(ans) | n,wmax=list(map(int,input().split()))
v=[0]*n
w=[0]*n
for i in range(n):
w[i],v[i]=list(map(int,input().split()))
sv=sum(v)+1
dp=[[float('inf')]*sv for _ in range(n)]
dp[0][v[0]-1]=w[0]
for i in range(n):
dp[i][0]=0
for i in range(n):
for j in range(sv):
dp[i][j]=min(dp[i-1][j],dp[i-1][j-v[i]]+w[i])
ans=float('inf')
for p in range(sv-1,-1,-1):
if dp[n-1][p]!=ans and dp[n-1][p]<=wmax:
ans=p
break
print(ans) | p03164 |
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)
inf = float('inf')
dp = [[inf for _ in range(10**3*N+10)] for _ in range(N+10)]
maxv = sum(value)
#初期化
dp[0][0] =0
for i in range(N):
for sum_v in range(maxv+1):
if sum_v-value[i] >=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-value[i]] + weight[i])
dp[i + 1][sum_v] = min(dp[i + 1][sum_v], dp[i][sum_v])
res =0
for sum_v in range(maxv+1):
if dp[N][sum_v] <=W:
res = sum_v
print(res) | N,maxW = list(map(int,input().split()))
w,v = [],[]
for i in range(N):
weight,value = list(map(int,input().split()))
w.append(weight)
v.append(value)
maxV=sum(v)
inf = float('inf')
dp = [[inf for _ in range(maxV+1)] for _ in range(N+1)]
dp[0][0] =0
for i in range(N):
for sum_v in range(maxV+1):
if (sum_v -v[i]>=0):
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-v[i]]+w[i])
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v])
res = 0
for i in range(maxV+1):
if dp[N][i] <= maxW:
res = i
print(res) | p03164 |
n,w = list(map(int,input().split()))
item = [list(map(int,input().split())) for i in range(n)]
dp = [[float('inf')]*(10**5+1) for i in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
for j in range(10**5+1):
if j >= item[i-1][1]:
dp[i][j] = min(dp[i-1][j],dp[i-1][j-item[i-1][1]]+item[i-1][0])
else:
dp[i][j] = dp[i-1][j]
for j in range(10**5+1):
if dp[n][j] <= w:
ans = j
print(ans) | INF = 10**18
N, W = list(map(int, input().split()))
dp = [[INF for i in range(10**5 + 1)] for j in range(N + 1)]
dp[0][0] = 0
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(10**5 + 1):
if j - v >= 0:
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v] + w)
else:
dp[i][j] = dp[i - 1][j]
res = 0
for j in range(10**5 + 1):
if dp[N][j] <= W:
res = j
print(res) | p03164 |
import sys
input=sys.stdin.readline
import collections
def main():
N,W = list(map(int, input().split()))
I = collections.deque()
for _ in range(N):
I.append(tuple(map(int, input().split())))
MV = N*(10**3) + 1
dp = [[0]*MV for _ in range(N+1)]
inf = 2*10**9
for j in range(MV):
dp[0][j] = inf
dp[0][0] = 0
for i in range(N):
w,v = I.popleft()
for j in range(MV):
if j < v:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = min(dp[i][j], dp[i][j-v] + w)
ans = 0
for j in range(MV):
if dp[N][j] <= W:
ans = j
print(ans)
if __name__ == '__main__':
main()
| import sys
input=sys.stdin.readline
import collections
def main():
N,W = list(map(int, input().split()))
I = collections.deque()
for _ in range(N):
I.append(tuple(map(int, input().split())))
MV = 1 + N*(10**3)
dp = [[0]*MV for _ in range(N+1)]
inf = 2*10**9
for j in range(MV):
dp[0][j] = inf
dp[0][0] = 0
for i in range(N):
w,v = I.popleft()
for j in range(MV):
if j < v:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = min(dp[i][j], dp[i][j-v] + w)
ans = 0
for v,w in enumerate(dp[N]):
if w <= W:
ans = v
print(ans)
if __name__ == '__main__':
main()
| p03164 |
# temp
n,w = list(map(int,input().split()))
wv = [tuple(map(int,input().split())) for i in range(n)]
dp = [0] + [float("inf")]*(10**5)
for i in range(n):
for j in range(10**5,wv[i][1]-1,-1):
dp[j] = min(dp[j],dp[j-wv[i][1]]+wv[i][0])
res = 0
for v,e in enumerate(dp):
if e <= w:
res = v
print(res) | # dpE - Knapsack 2
import sys
input = sys.stdin.readline
def main():
n, W = tuple(map(int, input().rstrip().split()))
A = tuple(tuple(map(int, input().rstrip().split())) for _ in range(n))
_, v = list(zip(*A))
lim = sum(v)
dp = [0] + [float("inf")] * lim
for i in range(n):
for j in range(lim, A[i][1] - 1, -1):
dp[j] = min(dp[j], dp[j - A[i][1]] + A[i][0])
ans = max(v for v, w in enumerate(dp) if w <= W)
print(ans)
if __name__ == "__main__":
main() | p03164 |
# dpE
import sys
input = sys.stdin.readline
def main():
N, W = tuple(map(int, input().rstrip().split()))
A = tuple(tuple(map(int, input().rstrip().split())) for _ in range(N))
lim = 10 ** 5
dp = [0] + [float("inf")] * lim
for i in range(N):
for j in range(lim, A[i][1] - 1, -1):
dp[j] = min(dp[j], dp[j - A[i][1]] + A[i][0])
ans = [i for i, j in enumerate(dp) if j <= W]
print((max(ans)))
if __name__ == "__main__":
main() | # dpE - Knapsack 2
import sys
input = sys.stdin.readline
def heavy_knapsack(W: int, weight: "Array[int]", value: "Array[int]") -> int:
lim = sum(value)
dp = [0] + [float("inf")] * lim # dp[i] := minimum weight of value i
for w, v in zip(weight, value):
for cur_v in range(lim, v - 1, -1):
dp[cur_v] = min(dp[cur_v], dp[cur_v - v] + w)
ret = max(v for v, w in enumerate(dp) if w <= W)
return ret
def main():
N, W = tuple(map(int, input().split()))
A = tuple(tuple(map(int, input().split())) for _ in range(N))
w, v = list(zip(*A))
ans = heavy_knapsack(W, w, v)
print(ans)
if __name__ == "__main__":
main() | p03164 |
# E - Knapsack 2
from collections import defaultdict
def main():
INF = 1 << 30
N, W, *WV = list(map(int, open(0).read().split()))
dp = defaultdict(lambda: INF) # dp[i] := minimum weight at value i
dp[0] = 0
for w, v in zip(*[iter(WV)] * 2):
for cur_v, cur_w in tuple(dp.items()):
if w + cur_w <= W:
dp[v + cur_v] = min(dp[v + cur_v], w + cur_w)
print((max(dp.keys())))
if __name__ == "__main__":
main()
| # E - Knapsack 2
def knapsack_heavy(limit: int, weight: list, value: list) -> int:
lim = sum(value)
dp = [0] + [1 << 30] * lim # dp[i] := minimum weight at value i
for w, v in zip(weight, value):
for cur_v in range(lim, v - 1, -1):
dp[cur_v] = min(dp[cur_v], dp[cur_v - v] + w)
ret = max(v for v, w in enumerate(dp) if w <= limit)
return ret
def main():
N, W, *WV = list(map(int, open(0).read().split()))
print((knapsack_heavy(W, WV[::2], WV[1::2])))
if __name__ == "__main__":
main()
| p03164 |
# E - Knapsack 2
from collections import defaultdict
def knapsack_heavy(limit: int, weight: list, value: list) -> int:
dp = defaultdict(lambda: 1 << 30) # dp[i] := minimum weight at value i
dp[0] = 0
for w, v in zip(weight, value):
for cur_v, cur_w in tuple(dp.items()):
if w + cur_w <= limit:
dp[v + cur_v] = min(dp[v + cur_v], w + cur_w)
return max(dp.keys())
def main():
N, W, *WV = list(map(int, open(0).read().split()))
print((knapsack_heavy(W, WV[::2], WV[1::2])))
if __name__ == "__main__":
main()
| # E - Knapsack 2
def knapsack_heavy(weight_limit: int, weights: list, values: list) -> int:
max_value = sum(values)
dp = [0] + [1 << 30] * max_value # dp[i] := minimum weight at value i
for w, v in zip(weights, values):
for cur_v in range(max_value, v - 1, -1):
if dp[cur_v - v] + w < dp[cur_v]:
dp[cur_v] = dp[cur_v - v] + w
return max(v for v, w in enumerate(dp) if w <= weight_limit)
def main():
N, W, *WV = list(map(int, open(0).read().split()))
print((knapsack_heavy(W, WV[::2], WV[1::2])))
if __name__ == "__main__":
main()
| p03164 |
#!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N, W = list(map(int, input().split()))
V = N * 10**3
INF = 10**12
dp = [INF] * (V+1)# dp[i]: 価値の総和をiにするための重さの最小値
dp[0] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for j in range(V,-1,-1):
if j-v >= 0:
dp[j] = min(dp[j],dp[j-v]+w)
# print(dp)
ans = -1
for i in range(V+1):
if dp[i] <= W:
ans = i
print(ans)
if __name__ == "__main__":
main()
| #!/usr/bin/env python3
def main():
N, W = list(map(int, input().split()))
V = N * 10**3
INF = 10**12
dp = [INF] * (V+1)# dp[i]: 価値の総和をiにするための重さの最小値
dp[0] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for j in range(V,-1,-1):
if j-v >= 0:
dp[j] = min(dp[j],dp[j-v]+w)
# print(dp)
ans = -1
for i in range(V+1):
if dp[i] <= W:
ans = i
print(ans)
if __name__ == "__main__":
main()
| p03164 |
n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
lim=n*10**3+1
dp=[[float('inf') for i in range(lim)] for i in range(n+1)]
for i in range(n+1):
dp[i][0]=0
for i in range(n):
for sum_v in range(lim):
if sum_v-l[i][1]>=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-l[i][1]]+l[i][0])
dp[i+1][sum_v]=min(dp[i+1][sum_v],dp[i][sum_v])
ans=0
for i in range(lim):
if dp[-1][i]<=w:
ans=max(ans,i)
print(ans) | n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
lim=n*10**3+1
#dp=[[float('inf') for i in range(lim)] for i in range(n+1)]
dp=[[10**15 for i in range(lim)] for i in range(n+1)]
'''
for i in range(n+1):
dp[i][0]=0
'''
dp[0][0]=0
for i in range(n):
for sum_v in range(lim):
if sum_v-l[i][1]>=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-l[i][1]]+l[i][0])
dp[i+1][sum_v]=min(dp[i+1][sum_v],dp[i][sum_v])
ans=0
for i in range(lim):
if dp[-1][i]<=w:
ans=max(ans,i)
print(ans) | p03164 |
n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
lim=n*10**3+1
#dp=[[float('inf') for i in range(lim)] for i in range(n+1)]
dp=[[10**15 for i in range(lim)] for i in range(n+1)]
'''
for i in range(n+1):
dp[i][0]=0
'''
dp[0][0]=0
for i in range(n):
for sum_v in range(lim):
if sum_v-l[i][1]>=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-l[i][1]]+l[i][0])
dp[i+1][sum_v]=min(dp[i+1][sum_v],dp[i][sum_v])
ans=0
for i in range(lim):
if dp[-1][i]<=w:
ans=max(ans,i)
print(ans) | n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
lim=n*10**3+1
#dp=[[float('inf') for i in range(lim)] for i in range(n+1)]
dp=[[10**15 for i in range(lim)] for i in range(n+1)]
for i in range(n+1):
dp[i][0]=0
#dp[0][0]=0
for i in range(n):
for sum_v in range(lim):
if sum_v-l[i][1]>=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v],dp[i][sum_v-l[i][1]]+l[i][0])
dp[i+1][sum_v]=min(dp[i+1][sum_v],dp[i][sum_v])
ans=0
for i in range(lim):
if dp[-1][i]<=w:
ans=max(ans,i)
print(ans) | p03164 |
import sys
input = sys.stdin.readline
def main():
N, W = [int(x) for x in input().split()]
WV = [[int(x) for x in input().split()] for _ in range(N)]
sumv = 0
for w, v in WV:
sumv += v
dp = [[float("inf")] * (sumv + 1) for j in range(N + 1)]
for i in range(1, N + 1):
for j in range(sumv + 1):
w, v = WV[i - 1]
if j <= v:
dp[i][j] = min(w, dp[i - 1][j])
else:
dp[i][j] = min(dp[i - 1][j], w + dp[i - 1][j - v])
ans = 0
for i in range(sumv + 1):
if dp[N][i] > W:
break
else:
ans = i
print(ans)
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
def main():
N, W = [int(x) for x in input().split()]
WV = [[int(x) for x in input().split()] for _ in range(N)]
sumv = 0
for w, v in WV:
sumv += v
dp = [[10 ** 9 + 1] * (sumv + 1) for j in range(N + 1)]
for i in range(1, N + 1):
for j in range(sumv + 1):
w, v = WV[i - 1]
if j <= v:
dp[i][j] = min(w, dp[i - 1][j])
else:
dp[i][j] = min(dp[i - 1][j], w + dp[i - 1][j - v])
ans = 0
for i in range(sumv + 1):
if dp[N][i] > W:
break
else:
ans = i
print(ans)
if __name__ == '__main__':
main()
| p03164 |
import sys
# input処理を高速化する
input = sys.stdin.readline
# 入力
N, W = list(map(int, input().split()))
# sum_vの取りうる上限値
MAX_V = (10**3+1) * N
# 最小値を求めるので無限大の値
f_inf = float('inf')
def chmin(a, b):
if a <= b:
return a
else:
return b
def knapsack(n, w):
# dpの初期化 dp[i][sum_v]は重さの総和の最小値
dp = [[f_inf for i in range(MAX_V)] for j in range(N+1)]
# 初期条件
dp[0][0] = 0
# forは全て関数の中で回す。
# 入力
for i in range(N):
w, v = list(map(int, input().split()))
for sum_v in range(MAX_V):
# i番目の品物を選ぶ場合
if (sum_v -v >= 0):
dp[i + 1][sum_v] = chmin(dp[i + 1][sum_v], dp[i][sum_v - v] + w)
# i番目の品物を選ばない場合
dp[i + 1][sum_v] = chmin(dp[i + 1][sum_v], dp[i][sum_v])
#dp[N][sum_v]の値が、W以下であるsum_vの値の最大値
ans = 0
for sum_v in range(MAX_V):
if dp[N][sum_v] <= W:
ans = sum_v
print(ans)
knapsack(N, W)
| import sys
# input処理を高速化する
input = sys.stdin.readline
# 入力
N, W = list(map(int, input().split()))
# sum_vの取りうる上限値
MAX_V = (10**3) * N +1
# 最小値を求めるので無限大の値
f_inf = float('inf')
def knapsack(n, w):
# dpの初期化 dp[sum_v]は重さの総和の最小値
dp = [f_inf] * MAX_V
# 初期条件
dp[0] = 0
sum_v = 0
# forは全て関数の中で回す。
# 入力
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(MAX_V, v-1, -1):
new_weight = dp[j - v] + w
if new_weight > W:
continue
if dp[j] > new_weight:
dp[j] = new_weight
ans = 0
for sum_v in range(MAX_V):
if dp[sum_v] <= W:
ans = sum_v
print(ans)
knapsack(N, W)
| p03164 |
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 21 18:19:39 2020
@author: matsui
"""
N,W=list(map(int,input().split()))
vi,wi=[],[]
for i in range(N):
w,v=list(map(int,input().split()))
wi.append(w)
vi.append(v)
#L = sorted([list(map(int,input().split())) for i in range(N)])
M=int(sum(vi))
dp1=[sum(wi)+1]*(M+1)
#dp2=[sum(wi)+1]*(M+1)
dp1[0]=0
#L = sorted([list(map(int,input().split())) for i in range(N)])
s=0
for w, v in zip(wi,vi):
s+=v
for j in range(min(s,M),v-1,-1):
if j >= v:
if dp1[j] > dp1[j-v]+w: dp1[j]=dp1[j-v]+w
if dp1[j] > dp1[j]: dp1[j]=dp1[j]
#print(dp1)
#print(dp2)
#dp1=[dp2[i] for i in range(M+1)]
#print(max(dp))
m=0
for i in range(M+1):
if dp1[i]<=W:
m=i
print(m)
| # -*- coding: utf-8 -*-
"""
Created on Tue Jan 21 18:19:39 2020
@author: matsui
"""
N,W=list(map(int,input().split()))
vi,wi=[],[]
for i in range(N):
w,v=list(map(int,input().split()))
wi.append(w)
vi.append(v)
#L = sorted([list(map(int,input().split())) for i in range(N)])
M=int(sum(vi))
dp=[W+1]*(M+1)
dp[0]=0
#L = sorted([list(map(int,input().split())) for i in range(N)])
s=0
for w, v in zip(wi,vi):
s+=v
for j in range(min(s,M),v-1,-1):
if dp[j] > dp[j-v]+w: dp[j]=dp[j-v]+w
#print(dp)
m=0
for i in range(M+1):
if dp[i]<=W:
m=i
print(m)
| p03164 |
N,W = list(map(int,input().split()))
c = [tuple(map(int,input().split())) for i in range(N)]
DP = [[float('inf') for i in range(10**3*N+1)] for i in range(N+1)]
DP[0][0] = 0
for i in range(N):
for v in range(10**3*N+1):
if v-c[i][1] < 0:
DP[i+1][v] = DP[i][v]
else:
DP[i+1][v] = min(DP[i][v-c[i][1]]+c[i][0],DP[i][v])
ans = 0
DP = DP[N]
for v in range(10**3*N,-1,-1):
if DP[v] <= W:
ans = v
break
print(ans) | INF = float('inf')
N,W = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(N)]
V = 1000*N
dp = [[INF]*(V+1) for _ in range(N+1)]
dp[0][0]=0
for i in range(N):
for j in range(V+1):
if j-wv[i][1] >= 0:
dp[i+1][j] = min(dp[i][j-wv[i][1]]+wv[i][0],dp[i][j])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for i in range(N+1):
for j in range(V+1):
if dp[i][j] <= W:
ans = max(ans,j)
print(ans) | p03164 |
import sys
input = sys.stdin.readline
def main():
# input
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()))
# init dp
v_max = sum(v)
dp = [[float("inf") for i in range(v_max+1)] for _ in range(N)]
dp[0][v[0]] = w[0]
for i in range(N):
dp[i][0] = 0
for i in range(1,N):
for j in range(v_max+1):
if j<v[i]:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = min(dp[i-1][j],dp[i-1][j-v[i]]+w[i])
ans = 0
for i in range(v_max+1):
if dp[-1][i]==float("inf"):
pass
elif dp[-1][i]<=W:
ans = i
print(ans)
if __name__ == "__main__":
main() | import sys
input = sys.stdin.readline
def main():
# input
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()))
# init dp
v_max = sum(v)
dp = [[float("inf") for i in range(v_max+1)] for _ in range(N)]
dp[0][v[0]] = w[0]
for i in range(N):
dp[i][0] = 0
for i in range(1,N):
for j in range(v_max+1):
if j<v[i]:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = min(dp[i-1][j],dp[i-1][j-v[i]]+w[i])
ans = 0
for i in range(v_max+1):
if dp[-1][i]<=W:
ans = i
else:
pass
print(ans)
if __name__ == "__main__":
main() | p03164 |
import sys
from _operator import itemgetter
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
N, W = na()
maxV = 10 ** 5
dp = [[10**9+7] * (maxV+1) for i in range(N+1)] # dp[i][v] i番目までで価値がvの時の重さの合計の最小値
dp[0][0] = 0
tp = [na() for i in range(N)]
list.sort(tp, key=itemgetter(0))
for i in range(1, N+1):
wi, vi = tp[i - 1]
for v in range(1, maxV+1):
if v - vi >= 0:
dp[i][v] = min(dp[i - 1][v], dp[i - 1][v - vi] + wi)
else:
dp[i][v] = dp[i - 1][v]
ans = -1
for i in range(1, N + 1):
for v in range(1, maxV+1):
if dp[i][v] <= W:
ans = max(ans, v)
print(ans) | import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
N, W = na()
maxV = 10 ** 5
dp = [[10**9+7] * (maxV+1) for i in range(N+1)] # dp[i][v] i番目までで価値がvの時の重さの合計の最小値
dp[0][0] = 0
tp = [na() for i in range(N)]
list.sort(tp, key=lambda x:x[0])
for i in range(1, N+1):
wi, vi = tp[i - 1]
for v in range(1, maxV+1):
if v - vi >= 0:
dp[i][v] = min(dp[i - 1][v], dp[i - 1][v - vi] + wi)
else:
dp[i][v] = dp[i - 1][v]
ans = -1
for i in range(1, N + 1):
for v in range(1, maxV+1):
if dp[i][v] <= W:
ans = max(ans, v)
print(ans) | p03164 |
N,W=list(map(int,input().split()))
w=[]
v=[]
for _ in range(N):
ww,vv=list(map(int,input().split()))
w.append(ww)
v.append(vv)
INF=float("inf")
max_v=10**5+1
dp=[[INF for i in range(max_v)] for j in range(N+1)]
dp[0][0]=0
for i in range(N):
for j in range(max_v):
if j - v[i]>=0:
dp[i+1][j]=min(dp[i+1][j],dp[i][j-v[i]]+w[i])
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
for i in range(max_v):
if dp[N][i] <=W:
ans=i
print(ans)
| N,W=list(map(int,input().split()))
w=[]
v=[]
for _ in range(N):
ww,vv=list(map(int,input().split()))
w.append(ww)
v.append(vv)
INF=float("inf")
max_v=max(v)*N +1
dp=[[INF for i in range(max_v)] for j in range(N+1)]
dp[0][0]=0
for i in range(N):
for j in range(max_v):
if j - v[i]>=0:
dp[i+1][j]=min(dp[i+1][j],dp[i][j-v[i]]+w[i])
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
for i in range(max_v):
if dp[N][i] <=W:
ans=i
print(ans)
| p03164 |
n, m = list(map(int, input().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
| import sys
readline = sys.stdin.buffer.readline
def main():
n, m = list(map(int, readline().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
if __name__ == "__main__":
main() | p03164 |
def args():
N, W = tuple(map(int, input().split()))
Wi, Vi = [], []
for _ in range(N):
w, v = tuple(map(int, input().split()))
Wi.append(w)
Vi.append(v)
# print(N, W)
# print(Wi, Vi)
return N, W, Wi, Vi
def solve(N, W, Wi, Vi):
if N == 1:
return Vi[0]
x, y = N + 1, max(Vi) * N + 1
DP = [[float("inf") for _ in range(y)] for _ in range(x)]
# print(len(DP[0]))
DP[0][0] = 0
for i in range(N):
value = Vi[i]
w_max = max(Vi) * N
for v in range(w_max):
remain = v - value
if 0 <= remain:
# 選ぶ
DP[i + 1][v] = min(DP[i + 1][v], DP[i][remain] + Wi[i])
# 選ばない
DP[i + 1][v] = min(DP[i + 1][v], DP[i][v])
# print(DP)
ans = 0
for line in DP:
for v, e in enumerate(line):
if not e == float("inf") and e <= W:
# print(v, e)
ans = max(ans, v)
# print(DP)
return ans
if __name__ == '__main__':
res = solve(*args())
print(res)
| def args():
N, W = tuple(map(int, input().split()))
Wi, Vi = [], []
for _ in range(N):
w, v = tuple(map(int, input().split()))
Wi.append(w)
Vi.append(v)
# print(N, W)
# print(Wi, Vi)
return N, W, Wi, Vi
def solve(N, W, Wi, Vi):
DP = [[float("inf")] * (sum(Vi) + 1) for _ in range(N + 1)]
DP[0][0] = 0
for i in range(N):
value = Vi[i]
w_max = sum(Vi) + 1
for v in range(w_max):
remain = v - value
if 0 <= remain:
# 選ぶ
DP[i + 1][v] = min(DP[i + 1][v], DP[i][remain] + Wi[i])
# 選ばない
DP[i + 1][v] = min(DP[i + 1][v], DP[i][v])
# print(DP)
ans = 0
for line in DP:
for v, e in enumerate(line):
if not e == float("inf") and e <= W:
# print(v, e)
ans = max(ans, v)
# print(DP)
return ans
if __name__ == '__main__':
res = solve(*args())
print(res)
| p03164 |
#!/usr/bin/env python3
#dp5 #Knapsack 2
#個数制限ありナップサック
#1≤W≤10**9
def e():
n,W = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
#横:価値 縦:品物
dp = [[float("inf") for _ in range(10**5+1)] for _ in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
for j in range(10**5+1):
#i番目の品物の価値より価値の制限が小さいとき(i番目の品物が使えないとき)
if j < wv[i-1][1]:
#i-1番目の品物の重さと同じ
dp[i][j] = dp[i-1][j]
else:
#i番目の品物を使い、重さを追加する場合と使わない場合の重さを比較
dp[i][j] = min(dp[i-1][j],dp[i-1][j - wv[i-1][1]] + wv[i-1][0])
ans = 0
#重さWまでの価値最大値
for i in range(10**5+1):
if dp[n][i] <= W:
ans = i
print(ans)
if __name__ == '__main__':
e()
| #!/usr/bin/env python3
#dp5 #Knapsack 2
#個数制限ありナップサック
#1≤W≤10**9
import sys
def LI(): return list(map(int, sys.stdin.readline().split()))
def LIR(n): return [LI() for _ in range(n)]
def e():
n,W = LI()
wv = LIR(n)
#横:価値 縦:品物
dp = [[float("inf") for _ in range(10**5+1)] for _ in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
for j in range(10**5+1):
#i番目の品物の価値より価値の制限が小さいとき(i番目の品物が使えないとき)
if j < wv[i-1][1]:
#i-1番目の品物の重さと同じ
dp[i][j] = dp[i-1][j]
else:
#i番目の品物を使い、重さを追加する場合と使わない場合の重さを比較
dp[i][j] = min(dp[i-1][j],dp[i-1][j - wv[i-1][1]] + wv[i-1][0])
ans = 0
#重さWまでの価値最大値
for i in range(10**5+1):
if dp[n][i] <= W:
ans = i
print(ans)
if __name__ == '__main__':
e()
| p03164 |
#!/usr/bin/env python3
#dp5 #Knapsack 2
#個数制限ありナップサック
#1≤W≤10**9
import sys
def LI(): return list(map(int, sys.stdin.readline().split()))
def LIR(n): return [LI() for _ in range(n)]
def e():
n,W = LI()
wv = LIR(n)
#横:価値 縦:品物
dp = [[float("inf") for _ in range(10**5+1)] for _ in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
for j in range(10**5+1):
#i番目の品物の価値より価値の制限が小さいとき(i番目の品物が使えないとき)
if j < wv[i-1][1]:
#i-1番目の品物の重さと同じ
dp[i][j] = dp[i-1][j]
else:
#i番目の品物を使い、重さを追加する場合と使わない場合の重さを比較
dp[i][j] = min(dp[i-1][j],dp[i-1][j - wv[i-1][1]] + wv[i-1][0])
ans = 0
#重さWまでの価値最大値
for i in range(10**5+1):
if dp[n][i] <= W:
ans = i
print(ans)
if __name__ == '__main__':
e()
| #!/usr/bin/env python3
#EDPC E
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n,W = LI()
wv = [LI() for _ in range(n)]
V = 0
for i in range(n):
w,v = wv[i]
V += v
dp = [[inf]*(V+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
w,v = wv[i]
for j in range(V+1):
if j < v:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = min(dp[i][j],dp[i][j-v] + w)
res = 0
for i in range(V+1):
if dp[-1][i] <= W:
res = i
print(res)
| p03164 |
n,w = list(map(int,input().split()))
w_ls, v_ls = [0] * n, [0] * n
for i in range(n):
w_ls[i], v_ls[i] = list(map(int,input().split()))
V = sum(v_ls)
dp = [[float("inf")] * (V+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(V+1):
if j - v_ls[i] >= 0:
dp[i+1][j] = min(dp[i+1][j], dp[i][j-v_ls[i]] + w_ls[i])
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
ans = 0
for j in range(V+1):
if dp[n][j] <= w:
ans = j
print(ans) | n,w_limit = list(map(int,input().split()))
item_ls = [[0,0]]
total_value = 0
for i in range(n):
cost, value = list(map(int,input().split()))
item_ls.append([cost, value])
total_value += value
dp = [[float('inf')] * (total_value+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(1,n+1):
item_cost, item_value = item_ls[i]
for sum_value in range(0,total_value+1):
if sum_value-item_value >= 0:
dp[i][sum_value] = min(dp[i][sum_value], dp[i-1][sum_value-item_value] + item_cost)
dp[i][sum_value] = min(dp[i][sum_value], dp[i-1][sum_value])
ans = 0
for value, cost in enumerate(dp[n]):
if cost <= w_limit:
ans = max(ans, value)
print(ans)
| p03164 |
from pprint import pprint
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
lim = 1
for i in range(n):
lim += wv[i][1]
dp = [[float('inf')] * lim for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(lim):
if j - wv[i][1] >= 0:
dp[i+1][j] = min(dp[i][j - wv[i][1]] + wv[i][0], dp[i][j])
else:
dp[i+1][j] = min((dp[i][j], dp[i+1][j]))
ans = float('inf')
for i in reversed(list(range(lim))):
if dp[-1][i] <= w:
ans = min(i, ans)
break
print(ans) | from pprint import pprint
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
lim = 1
for i in range(n):
lim += wv[i][1]
dp = [[float('inf')] * lim for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for j in range(lim):
if j - wv[i][1] >= 0:
dp[i+1][j] = min(dp[i][j - wv[i][1]] + wv[i][0], dp[i][j])
else:
dp[i+1][j] = min((dp[i][j], dp[i+1][j]))
for i in reversed(list(range(lim))):
if dp[-1][i] <= w:
ans = i
break
print(ans) | p03164 |
#!/usr/bin/env python3
import sys
from collections.abc import Iterable
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
from math import gcd
except Exception:
from fractions import gcd
def solve(N: int, W: int, w: "List[int]", v: "List[int]"):
dp = [[float('inf')] * (N * 1000 + 1) for _ in range(N+1)]
dp[0][0] = 0
for i, (cw, cv) in enumerate(zip(w, v)):
for j in range(N * 1000 + 1):
dp[i+1][j] = dp[i][j]
if 0 <= (j - cv) and (dp[i][j - cv] + cw) <= W:
dp[i+1][j] = min(dp[i+1][j], dp[i][j - cv] + cw)
return max([cv for cv, cw in enumerate(dp[-1]) if isfinite(cw)])
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))
result = solve(N, W, w, v)
if isinstance(result, Iterable) and not isinstance(result, str):
result = '\n'.join([str(v) for v in result])
print(result)
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
import sys
from math import *
from itertools import *
from collections import *
from functools import *
from operator import *
try:
from math import gcd
except Exception:
from fractions import gcd
def solve(N: int, W: int, w: "List[int]", v: "List[int]"):
dp = [[float('inf')] * (N * 1000 + 1) for _ in range(N+1)]
dp[0][0] = 0
for i, (cw, cv) in enumerate(zip(w, v)):
for j in range(N * 1000 + 1):
dp[i+1][j] = dp[i][j]
if 0 <= (j - cv) and (dp[i][j - cv] + cw) <= W:
dp[i+1][j] = min(dp[i+1][j], dp[i][j - cv] + cw)
return max([cv for cv, cw in enumerate(dp[-1]) if isfinite(cw)])
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))
result = solve(N, W, w, v)
print(result)
if __name__ == '__main__':
main() | p03164 |
N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)]
V = max(w_v, key=lambda x: x[1])[1] * N
# 1~i-1番目の品物から価値の総和がj以下になるように選んだときの重さ
dp = [[float('inf') for _ in range(V+1)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
w, v = w_v[i]
for j in range(V+1):
if j - v >= 0:
dp[i+1][j] = min(dp[i][j-v]+w, dp[i][j])
else:
#dp[i+1][j] = min(dp[i][j], dp[i+1][j])
dp[i+1][j] = dp[i][j]
r = 0
for v in range(V+1):
if dp[N][v] <= W:
r = v
print(r) | n, W = list(map(int, input().split()))
data = []
for _ in range(n):
w, v = list(map(int, input().split()))
data.append((w, v))
V = sum([v for _, v in data])
dp = [[float("inf")] * (V + 1) for i in range(n + 1)]
dp[0][0]= 0
for i in range(1, n+1):
w, v = data[i-1]
for j in range(V + 1):
if j - v >= 0:
dp[i][j] = min(dp[i - 1][j - v] + w, dp[i - 1][j])
else:
dp[i][j] = dp[i - 1][j]
print((max([i for i, x in enumerate(dp[-1]) if x != "inf" and x <= W])))
| p03164 |
N, M = list(map(int, input().split()))
L = 1000000
dp = [[10000000010 for _ in range(L+1)] for _ in range(N+1)]
W, V = [], []
for _ in range(N):
w, v = list(map(int, input().split()))
W.append(w)
V.append(v)
dp[0][0] = 0
for i in range(N):
for j in range(L):
if j + V[i] <= L:
dp[i+1][j] = min(dp[i][j], dp[i][j-V[i]] + W[i])
else:
dp[i+1][j] = dp[i][j]
for i, d in enumerate(dp[N]):
if d <= M:
maxv = i
print(maxv) | N, M = list(map(int, input().split()))
L = 100000
dp = [[1000000001 for _ in range(L+1)] for _ in range(N+1)]
W, V = [], []
for _ in range(N):
w, v = list(map(int, input().split()))
W.append(w)
V.append(v)
dp[0][0] = 0
for i in range(N):
for j in range(L+1):
if j - V[i] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-V[i]] + W[i])
else:
dp[i+1][j] = dp[i][j]
for i, d in enumerate(dp[N]):
if d <= M:
maxv = i
print(maxv) | p03164 |
"""
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=W<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF = 2000000000
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()))
V = sum(v)
dp = [[INF for i in range(V + 1)] for j in range(n + 1)]
#ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(V + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
ans = 0
for i in range(V + 1):
if dp[n][i] <= W:
ans = i
print(ans)
| """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=limit_w<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF = 2000000000
"""
メモ : Pythonでは無限大を表す float('inf') があるが, 処理がかなり重たいので
代わりにsum(v)より真に大きい 2*10^9 を INFとする.
(https://atcoder.jp/contests/dp/tasks/dp_e において,PyPyを使用して,
前者だと1060ms, 後者だと570msで2倍近く差が出ている.)
"""
n ,limit_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()))
sum_v = sum(v)
dp = [[INF for i in range(sum_v + 1)] for j in range(n + 1)]
# dp[i][j]には重さが入る.
# dp[i][j]=(i番目までの品物から価値がちょうどｊになるための重さの最小値)
# ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(sum_v + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
# n個まで使って,重さがlimit_wを超えないで価値が最大のものを求める.
ans = 0
for i in range(sum_v + 1):
if dp[n][i] <= limit_w:
ans = i
print(ans)
| p03164 |
"""
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=limit_w<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF = 2000000000
"""
メモ : Pythonでは無限大を表す float('inf') があるが, 処理がかなり重たいので
代わりにsum(v)より真に大きい 2*10^9 を INFとする.
(https://atcoder.jp/contests/dp/tasks/dp_e において,PyPyを使用して,
前者だと1060ms, 後者だと570msで2倍近く差が出ている.)
"""
n ,limit_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()))
sum_v = sum(v)
dp = [[INF for i in range(sum_v + 1)] for j in range(n + 1)]
# dp[i][j]には重さが入る.
# dp[i][j]=(i番目までの品物から価値がちょうどｊになるための重さの最小値)
# ここからメイン
dp[0][0] = 0
for i in range(n):
for j in range(sum_v + 1):
if j < v[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i])
# n個まで使って,重さがlimit_wを超えないで価値が最大のものを求める.
ans = 0
for i in range(sum_v + 1):
if dp[n][i] <= limit_w:
ans = i
print(ans)
| """
重さと価値がそれぞれw_i,v_iであるようなn個の品物がある.
これらの品物の中から, 重さの総和がWを超えないように選んだ時の,
価値の総和の最大値を求めよ.
1<=n<=100, 1<=w_i<=10^7, 1<=v_i<=100, 1<=limit_w<=10^9
"""
#-------------------------------------------------------------------------------
#入力
INF = 2000000000
"""
メモ : Pythonでは無限大を表す float('inf') があるが, 処理がかなり重たいので
代わりにsum(v)より真に大きい 2*10^9 を INFとする.
(https://atcoder.jp/contests/dp/tasks/dp_e において,PyPyを使用して,
前者だと1060ms, 後者だと570msで2倍近く差が出ている.)
"""
n ,limit_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()))
sum_v = sum(v)
dp = [INF for i in range(sum_v + 1)]
# dp[i][j]には重さが入る.
# dp[i][j]=(i番目までの品物から価値がちょうどｊになるための重さの最小値)
# ここからメイン
dp[0] = 0
for i in range(n):
for j in range(sum_v ,-1,-1):
if j >= v[i]:
dp[j] = min(dp[j], dp[j - v[i]] + w[i])
# n個まで使って,重さがlimit_wを超えないで価値が最大のものを求める.
ans = 0
for i in range(sum_v + 1):
if dp[i] <= limit_w:
ans = i
print(ans)
| p03164 |
n, w = list(map(int, input().split()))
item = [list(map(int, input().split())) for i in range(n)]
max_v = 100005
dp = [[float('inf') for i in range(max_v)] for j in range(n + 1)]
dp[0][0] = 0
for i in range(n):
for sum_v in range(max_v):
if sum_v - item[i][1] >= 0:
dp[i + 1][sum_v] = min(dp[i + 1][sum_v], dp[i][sum_v - item[i][1]] + item[i][0])
dp[i + 1][sum_v] = min((dp[i + 1][sum_v], dp[i][sum_v]))
ans = 0
for sum_v in reversed(list(range(max_v))):
if dp[-1][sum_v] <= w:
print(sum_v)
break | n, w = list(map(int, input().split()))
item = [list(map(int, input().split())) for i in range(n)]
max_v = 100005
dp = [[float('inf')] * max_v for j in range(n + 1)]
dp[0][0] = 0
for i in range(n):
for sum_v in range(max_v):
if sum_v - item[i][1] >= 0:
dp[i + 1][sum_v] = min(dp[i + 1][sum_v], dp[i][sum_v - item[i][1]] + item[i][0])
dp[i + 1][sum_v] = min((dp[i + 1][sum_v], dp[i][sum_v]))
for sum_v in reversed(list(range(max_v))):
if dp[-1][sum_v] <= w:
print(sum_v)
break
| p03164 |
N, W = list(map(int, input().split()))
table = []
for i in range(N):
w,v = list(map(int, input().split()))
table.append((w,v))
INF = W+1
dp = [[INF]*(10**3*N+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
for k in range(10**3*N+1):
w,v = table[i-1]
dp[i][k] = dp[i-1][k]
if v<=k and dp[i-1][k-v] <= INF:
dp[i][k] = min(dp[i][k],dp[i-1][k-v]+w)
for i in range(10**3*N,-1,-1):
if 0<= dp[-1][i] <= W:
print(i)
exit()
| import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
table = []
for i in range(N):
w,v = list(map(int, input().split()))
table.append((w,v))
INF = W+1
dp = [[INF]*(10**3*N+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
for k in range(10**3*N+1):
w,v = table[i-1]
dp[i][k] = dp[i-1][k]
if v<=k and dp[i-1][k-v] <= INF:
dp[i][k] = min(dp[i][k],dp[i-1][k-v]+w)
for i in range(10**3*N,-1,-1):
if 0<= dp[-1][i] <= W:
print(i)
exit()
| p03164 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
table = []
for i in range(N):
w,v = list(map(int, input().split()))
table.append((w,v))
INF = W+1
dp = [[INF]*(10**3*N+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
for k in range(10**3*N+1):
w,v = table[i-1]
dp[i][k] = dp[i-1][k]
if v<=k and dp[i-1][k-v] <= INF:
dp[i][k] = min(dp[i][k],dp[i-1][k-v]+w)
for i in range(10**3*N,-1,-1):
if 0<= dp[-1][i] <= W:
print(i)
exit()
| import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
table = []
for i in range(N):
w,v = list(map(int, input().split()))
table.append((w,v))
dp = [[W+1]*(10**3*N+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = table[i-1]
for j in range(10**3*N+1):
dp[i][j] = dp[i-1][j]
if j>=v:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
for i in range(10**3*N,-1,-1):
if dp[-1][i] <= W:
print(i)
exit() | p03164 |
n=0
W=0
n,W=list(map(int,input().split()))
dp=[W+1]*(101010)
dp[0]=0
for i in range(n):
w,v=list(map(int,input().split()))
j=100000
while j>=0:
if dp[j+v]>dp[j]+w:
dp[j+v]=dp[j]+w
j-=1
ans=0
for v in range(len(dp)):
if dp[v]<=W:
ans=v
print(ans) | n=0
W=0
n,W=list(map(int,input().split()))
dp=[W+1]*101010
dp[0]=0
for i in range(n):
w,v=list(map(int,input().split()))
j=100000
while j>=0:
if dp[j+v]>dp[j]+w:
dp[j+v]=dp[j]+w
j-=1
ans=0
for v in range(len(dp)):
if dp[v]<=W:
ans=v
print(ans) | p03164 |
def recur(n,w):
if n==0 or w==0:
return 0
elif (n,w) in dp:
return dp[(n,w)]
elif l[n-1][0]<=w:
k=max(recur(n-1,w-l[n-1][0])+l[n-1][1],recur(n-1,w))
dp[(n,w)]=k
return k
else:
k=recur(n-1,w)
dp[(n,w)]=k
return k
n,w=list(map(int,input().split()))
l=[]
for _ in range(n):
a,b=list(map(int,input().split()))
l.append((a,b))
dp=dict()
print((recur(n,w)))
| n,w=list(map(int,input().split()))
l=[]
weight=[0]
value=[0]
for _ in range(n):
a,b=list(map(int,input().split()))
value.append(b)
weight.append(a)
maxvalue=sum(value)
dp=[[10**10 for i in range(maxvalue+1)]for i in range(n+1)]
for i in range(n+1):
dp[i][0]=0
for i in range(1,n+1):
for j in range(1,maxvalue+1):
if value[i]<=j:
dp[i][j]=min(dp[i-1][j],dp[i-1][j-value[i]]+weight[i])
else:
dp[i][j]=dp[i-1][j]
for i in range(maxvalue+1):
if dp[-1][i]<=w:
ans=i
print(ans)
| p03164 |
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()))
t = sum(v) + 1
l = [m + 1] * (t + 1)
for i in range(n):
for j in range(t, v[i] - 1, -1):
k = l[j - v[i]] + w[i]
if j == v[i] and w[i] < l[j]:
l[j] = w[i]
elif k < l[j]:
l[j] = k
for i in range(t, 0, -1):
if l[i] <= m:
print(i)
break
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()))
t = sum(v)
l = [m + 1] * (t + 1)
l[0] = 0
for i in range(n):
for j in range(t, v[i] - 1, -1):
k = l[j - v[i]] + w[i]
if k < l[j]:
l[j] = k
for i in range(t, 0, -1):
if l[i] <= m:
print(i)
break
main()
| p03164 |
# -*- coding: utf-8 -*-
v_max = 100010
INF = 1000000100
n, w = list(map(int, input().split()))
weight = [0]*n
value = [0]*n
dp = [[INF for i in range(v_max+1)] for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
weight[i], value[i] = list(map(int, input().split()))
for i in range(n):
for j in range(v_max+1):
if j - value[i] >= 0:
dp[i+1][j] = min(dp[i+1][j], dp[i][j - value[i]] + weight[i])
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
result = 0
for j in range(v_max+1):
# print("v_sum: " + str(j) + " , weight: " + str(dp[n][j]))
if dp[n][j] <= w:
result = j
print(result)
| # -*- coding: utf-8 -*-
v_max = 100010
INF = 1000000100
n, w = list(map(int, input().split()))
weight = [0]*n
value = [0]*n
dp = [[INF for i in range(v_max+1)] for i in range(n+1)]
dp[0][0] = 0
for i in range(n):
weight[i], value[i] = list(map(int, input().split()))
for i in range(n):
for j in range(v_max+1):
if j - value[i] >= 0:
dp[i+1][j] = min(dp[i+1][j], dp[i][j - value[i]] + weight[i])
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
result = 0
for j in range(v_max+1):
if dp[n][j] <= w:
result = j
print(result)
| p03164 |
def main():
n, w = [int(e) for e in input().split()]
maxv = 10 ** 3 * n + 1
t = [-1 for i in range(maxv)]
t[0] = w
for _ in range(n):
nw, nv = [int(e) for e in input().split()]
for i in range(maxv - 1, -1, -1):
if t[i] == -1:
continue
if t[i + nv] < t[i] - nw:
t[i + nv] = t[i] - nw
for i in range(maxv - 1, 0, -1):
if t[i] == -1:
continue
print(i)
break
main() | def main():
n, w = [int(e) for e in input().split()]
maxv = 10 ** 3 * n + 1
t = [-1 for i in range(maxv)]
t[0] = w
cmaxv = 0
for _ in range(n):
nw, nv = [int(e) for e in input().split()]
for i in range(cmaxv, -1, -1):
if t[i] == -1:
continue
if t[i + nv] < t[i] - nw:
t[i + nv] = t[i] - nw
if cmaxv < i + nv:
cmaxv = i + nv
print(cmaxv)
main() | p03164 |
def main():
n, w = [int(e) for e in input().split()]
maxv = 10 ** 3 * n + 1
t = [-1 for i in range(maxv)]
t[0] = w
cmaxv = 0
for _ in range(n):
nw, nv = [int(e) for e in input().split()]
for i in range(cmaxv, -1, -1):
if t[i] == -1:
continue
if t[i + nv] < t[i] - nw:
t[i + nv] = t[i] - nw
if cmaxv < i + nv:
cmaxv = i + nv
print(cmaxv)
main() | from sys import stdin
def main():
from builtins import int, range
readline = stdin.readline
n, w = list(map(int, readline().split()))
maxv = 10 ** 3 * n + 1
t = [-1] * maxv
t[0] = w
cmaxv = 0
for _ in range(n):
nw, nv = list(map(int, readline().split()))
for i in range(cmaxv, -1, -1):
ti = t[i]
if ti == -1:
continue
if t[i + nv] < ti - nw:
t[i + nv] = ti - nw
if cmaxv < i + nv:
cmaxv = i + nv
print(cmaxv)
main()
| p03164 |
def dp_fn():
N, W = list(map(int, input().split()))
WV = (list(map(int, input().split())) for _ in range(N))
DP = {0:0}
for w, v in WV:
keys = sorted(list(DP.keys()), reverse=True)
for i in keys:
if i + w <= W:
if i+w in DP:
DP[i+w] = max(DP[i] + v, DP[i+w])
else:
DP[i+w] = DP[i] + v
return max(DP.values())
print((dp_fn()))
| import sys
input = sys.stdin.readline
def dp_fn():
N, W = list(map(int, input().split()))
WV = (list(map(int, input().split())) for _ in range(N))
DP = {0:0}
for w, v in WV:
keys = sorted(list(DP.keys()), reverse=True)
for i in keys:
j = DP[i]
if j+w <= W:
if i+v in DP:
DP[i+v] = min(DP[i+v], j+w)
else:
DP[i+v] = j+w
return max(DP.keys())
print((dp_fn()))
| p03164 |
n,w = list(map(int, input().split()))
wv = []
vsum=0
for _ in range(n):
tmp = list(map(int,input().split()))
wv.append(tmp)
vsum += tmp[1]
dp = [[float("inf") for i in range(vsum+1)] for j in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
now_w,now_v =wv[i-1]
for v in range(vsum+1):
dp[i][v] = dp[i-1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v],dp[i-1][v-now_v] + now_w)
ans=0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans=val
print(ans) | n,w = list(map(int, input().split()))
wv = []
vsum=0
for _ in range(n):
tmp = list(map(int,input().split()))
wv.append(tmp)
vsum += tmp[1]
INF = 1 << 30
dp = [[INF for i in range(vsum+1)] for j in range(n+1)]
dp[0][0]=0
for i in range(1,n+1):
now_w,now_v =wv[i-1]
for v in range(vsum+1):
dp[i][v] = dp[i-1][v]
if v - now_v >= 0:
dp[i][v] = min(dp[i][v],dp[i-1][v-now_v] + now_w)
ans=0
for val in range(len(dp[-1])):
if dp[-1][val] <= w:
ans=val
print(ans) | p03164 |
#####################################################################################################
##### ナップサック問題 （価値が小さい場合）
#####################################################################################################
"""
経路を状態の添え字に取るような事は無い
経路の末端の情報のみを横軸の添え字に取ることが多い
例：一年生 ⇒ k項目までの総和
パスタ ⇒ k日目に食べたパスタ
暑い日々⇒ k日目に着た服
DPテーブルにおいて、ある値以降の全てで 1 となる場合、
その値でDPテーブルを切ってしまって、
indexがその値を超えるごとに、DPテーブルの上限に +1 をしていくというアイデアで計算量を減らせる
例: https://atcoder.jp/contests/tdpc/submissions/14958104
初期条件を常に意識するように！
ベンチマーク
（重複なし）
http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=4641577#1
(重複あり)
http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=4641577#1
"""
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)
################################################################################################################################################
V = sum(price_list)
dp_max = W + 1 # 総和重量の最大値
dp = [[dp_max] * (V + 1) for _ in range(M + 1)] # 左端と上端の境界条件で W, M を一個ずつ多めに取る
""" dp[item <= M ][weight <= V] = 価値を固定した時の"最小"重量 """
for item in range(M+1): # 左端の境界条件
dp[item][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 price in range(1, V+1):
if price < price_list[item]: # price (総価値) < price_list[item] (品物の価値) の時は無視してよい
dp[item][price] = dp[item - 1][price]
else:
temp = dp[item - single][price - price_list[item]] + weight_list[item] # single = True: 重複なし
if temp < dp[item-1][price]: # min(dp[item-1][price], temp)
dp[item][price] = temp
else:
dp[item][price] = dp[item-1][price]
print((max(price for price in range(V+1) if dp[M][price] <= W))) | def knapsack_price(single=True):
"""
重さが小さい時のナップサックDP
:param single: True = 重複なし
"""
""" dp[price <= V] = 価値を固定した時の最小重量 """
V = sum(price_list)
dp_max = W+1
dp = [dp_max] * (V + 1)
dp[0] = 0 # 境界条件： 価値0 の時は重さは0
for item in range(N):
if single:
S = reversed(list(range(price_list[item], V + 1)))
else:
S = list(range(price_list[item], V + 1))
for price in S:
dp[price] = min2(dp[price], dp[price - price_list[item]] + weight_list[item])
return max(price for price in range(V+1) if dp[price] <= W)
#######################################################################################################
import sys
input = sys.stdin.readline
def max2(x, y):
""" pythonの組み込み関数 max は2変数に対しては遅い！！ """
if x > y:
return x
else:
return y
def min2(x, y):
""" pythonの組み込み関数 min は2変数に対しては遅い！！ """
if x < y:
return x
else:
return y
N, W = list(map(int, input().split())) # N: 品物の種類 W: 重量制限
price_list = []
weight_list = []
for _ in range(N):
""" price と weight が逆転して入力されている場合有り """
weight, price = list(map(int, input().split()))
price_list.append(price)
weight_list.append(weight)
print((knapsack_price(single=True))) | p03164 |
n,mw=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[float('inf') for _ in range(10**5+10)]for _ in range(n+1)]
#dp[i][j]=i個目までの品物を選んだとき、価値をjにする最小の重さ
dp[0][0]=0
for i in range(n):
w,v=l[i]
for j in range(10**5+10):
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
if j+v<10**5+10:
dp[i+1][j+v]=min(dp[i+1][j+v],dp[i][j]+w)
for j in range(10**5+9):
dp[i+1][-2-j]=min(dp[i+1][-2-j],dp[i+1][-1-j])
for i in range(10**5+10):
if dp[-1][i]>mw:
print((i-1))
break | n,W=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
m=sum([a[i][1] for i in range(n)])
dp=[[float('inf') for _ in range(m+1)] for _ in range(n+1)]
dp[0][0]=0
for i in range(n):
weight,value=a[i]
for j in range(m+1):
dp[i+1][j]=min(dp[i][j],dp[i+1][j])
if j+value<=m:
dp[i+1][j+value]=min(dp[i][j+value],dp[i][j]+weight)
for i in range(m+1):
if dp[-1][-i-1]<=W:
print((m-i))
break | p03164 |
import sys
import math
from collections import deque
import copy
INF = float("inf")
N, W = list(map(int, input().split()))
weight = []
value = []
for i in range(N):
tempW, tempV = list(map(int, input().split()))
weight.append(tempW)
value.append(tempV)
dp = [[INF for _ in range(N * 1000 + 1)] for _ in range(N + 1)]
dp[0][0] = 0
for i in range(1, N + 1):
for l in range(N * 1000 + 1):
if l - value[i - 1] >= 0:
dp[i][l] = min(dp[i - 1][l], dp[i - 1][l - value[i - 1]] + weight[i - 1])
else:
dp[i][l] = dp[i - 1][l]
for i in range(N * 1000 + 1):
if dp[N][i] <= W:
ans = i
print(ans)
| import sys
import math
from collections import deque
import copy
input = sys.stdin.readline
INF = 10**9+7
N, W = list(map(int, input().split()))
weight = []
value = []
for i in range(N):
tempW, tempV = list(map(int, input().split()))
weight.append(tempW)
value.append(tempV)
dp = [[INF for _ in range(N * 1000 + 1)] for _ in range(N + 1)]
dp[0][0] = 0
for i in range(1, N + 1):
for l in range(N * 1000 + 1):
if l - value[i - 1] >= 0:
dp[i][l] = min(dp[i - 1][l], dp[i - 1][l - value[i - 1]] + weight[i - 1])
else:
dp[i][l] = dp[i - 1][l]
for i in range(N * 1000 + 1):
if dp[N][i] <= W:
ans = i
print(ans)
| p03164 |
N,W = list(map(int,input().split()))
INF = 10**12
V = 1000 * N
Data = []
Data.append([0,0])
for _ in range(N):
Data.append(list(map(int,input().split())))
#DP[n][v]: n番目までの品物で 価値vの品物を選んだ場合の重さの最小
DP = [[INF]*(V+1) for _ in range(N+1)]
for n in range(N+1):
DP[n][0] = 0
for n in range(1,N+1):
for v in range(1,V+1):
wi,vi = Data[n]
if v >= vi:
DP[n][v] = min(DP[n][v],DP[n-1][v-vi]+wi)
DP[n][v] = min(DP[n][v],DP[n-1][v])
ans = 0
for v in range(V+1):
if DP[N][v] <= W:
ans = v
print(ans) | N,W = list(map(int,input().split()))
INF = 10**12
V = 1000 * N
Data = []
Data.append([0,0])
for _ in range(N):
Data.append(list(map(int,input().split())))
DP = [[INF]*(V+1) for _ in range(N+1)]
for n in range(N+1):
DP[n][0] = 0
for n in range(1,N+1):
for v in range(1,V+1):
wi,vi = Data[n]
if v >= vi:
DP[n][v] = min(DP[n][v],DP[n-1][v-vi]+wi)
DP[n][v] = min(DP[n][v],DP[n-1][v])
ans = 0
for v in range(V+1):
if DP[N][v] <= W:
ans = v
print(ans) | p03164 |
import sys
sys.setrecursionlimit(10000000)
def input():
return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *
from math import *
from itertools import *
from copy import *
N, W = list(map(int, input().split()))
MV = N * 10**3 + 1
INF = float('inf')
dp1 = [INF] * MV
dp1[0] = 0
for i in range(N):
dp2 = [INF] * MV
w, v = list(map(int, input().split()))
for j in range(MV):
dp2[j] = min(dp1[j], dp1[j-v]+w)
dp1 = deepcopy(dp2)
for i in range(MV-1, -1, -1):
if dp1[i] <= W:
print(i)
break
| import sys
sys.setrecursionlimit(10000000)
def input():
return sys.stdin.readline()[:-1]
from bisect import *
from collections import *
from heapq import *
from math import *
from itertools import *
from copy import *
N, W = list(map(int, input().split()))
MV = N * 10**3 + 1
INF = float('inf')
dp = [[INF] * MV 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(MV):
if v <= j:
dp[i+1][j] = min(dp[i][j], dp[i][j-v]+w)
else:
dp[i+1][j] = dp[i][j]
dp = dp[N]
for i in range(0, MV)[::-1]:
if dp[i] <= W:
print(i)
break
| p03164 |
import sys
#from collections import defaultdict
n, limit= list(map(int, sys.stdin.readline().split()))
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
#各重さとi番目の荷物を入れ終わった状態のテーブルをつくる
d = {}
dp = [d.copy() for _ in range(n)]
#初期状態
for w in range(L[0][0], limit+1):
dp[0][w] = L[0][1]
#print(dp)
for i in range(1, n):
for w in range(1, limit+1):
if dp[i-1].get(w-L[i][0]) and dp[i-1].get(w): #キーが存在するなら
dp[i][w] = max(dp[i-1][w-L[i][0]] + L[i][1], dp[i-1][w])
elif dp[i-1].get(w) and w==L[i][0]:
dp[i][w] = max(L[i][1], dp[i-1][w])
elif dp[i-1].get(w):
dp[i][w] = dp[i-1][w]
elif w==L[i][0]:
dp[i][w] = L[1][1]
#print(dp)
print((max(dp[-1].values()))) | import sys
n, limit = list(map(int, sys.stdin.readline().split()))
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
dp = [dict() for i in range(n)]
#print(dp)
dp[0][L[0][1]] = L[0][0]
for i in range(1, n):
dp[i][L[i][1]] = min(L[i][0], dp[i-1].get(L[i][1], float('inf')))
for v, w in list(dp[i-1].items()):
dp[i][v] = min(dp[i-1][v], dp[i].get(v, float('inf')))
dp[i][L[i][1] + v] = min(L[i][0] + dp[i-1][v], dp[i-1].get(L[i][1] + v, float('inf')))
ans = 0
for v, w in list(dp[-1].items()):
if w <=limit:
if ans < v:
ans = v
#print(dp)
print(ans) | p03164 |
import sys
n, limit = list(map(int, sys.stdin.readline().split()))
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
#print(L)
dp = [{} for i in range(n+1)]
for i in range(n):
Lw, Lv =L[i][0], L[i][1] #①i番目の価値を重さテーブルに代入
dp[i+1][Lw] = Lv
for w, v in list(dp[i].items()):
dp[i+1][w] = max(dp[i+1].get(w, 0), v) #② 一つ上の行の価値と比べて大きい方を代入
if w + Lw <=limit:
dp[i+1][w+Lw] = max(dp[i].get(w+ Lw, 0), Lv + v) #③一つ上の行の価値をループで1つづつ取り出し、i番目の価値と足し合わせる
print((max(dp[-1].values()))) | import sys
n, limit = list(map(int, sys.stdin.readline().split()))
L = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
#print(L)
dp = [{} for i in range(n+1)]
for i in range(n):
Lw, Lv = L[i][0], L[i][1]
dp[i+1][Lv] = min(Lw, dp[i].get(Lv, Lw)) #価値テーブルに重量を入れる
for v, w in list(dp[i].items()):
dp[i+1][v] = min(w, dp[i+1].get(v, w)) #上下比較
tmp_w= min(Lw+ w, dp[i+1].get(Lv+v, Lw+w))
if tmp_w <=limit:
dp[i+1][Lv+ v] = tmp_w
print((max(dp[-1].keys()))) | p03164 |
import sys
import bisect
def input():
return sys.stdin.readline().rstrip()
def main():
N, W = list(map(int, input().split()))
vsup = 10 ** 3 * N + 2
dp = [10 ** 12 + 1] * (vsup) # 価値の総和を i (以上にするための重さの最小値
dp[0] = 0
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(vsup-2, -1, -1):
if j - v >= 0:
dp[j] = min(dp[j], dp[j - v] + w)
dp[j] = min(dp[j],dp[j+1])
print((bisect.bisect_right(dp,W)-1))
if __name__ == "__main__":
main()
| import sys
import bisect
def input():
return sys.stdin.readline().rstrip()
def main():
N, W = list(map(int, input().split()))
vsup = 10 ** 3 * N + 2
dp = [10 ** 12 + 1] * (vsup) # 価値の総和を i (以上にするための重さの最小値
dp[0] = 0
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(vsup - 2, -1, -1):
if j - v >= 0:
dp[j] = min(dp[j], dp[j - v] + w, dp[j + 1])
else:
dp[j] = min(dp[j], dp[j + 1])
print((bisect.bisect_right(dp, W) - 1))
if __name__ == "__main__":
main()
| p03164 |
from copy import deepcopy
n,W = list(map(int,input().split()))
dp = [10**12] * (10**5+1)
dp[0] = 0
for i in range(n):
w,v = list(map(int,input().split()))
pdp = deepcopy(dp)
for j in range(v,10**5+1):
dp[j] = min(pdp[j-v]+w,dp[j])
m = 0
for i in range(10**5+1):
if dp[i] <= W:
m = i
print(m) | n,W = list(map(int,input().split()))
dp = [[10**12] * (10**5+1) for i in range(n+1)]
dp[0][0] = 0
ma = 0
for i in range(1,n+1):
w,v = list(map(int,input().split()))
ma += v
for j in range(v):
dp[i][j] = dp[i-1][j]
for j in range(v,ma+1):
dp[i][j] = min(dp[i-1][j-v]+w,dp[i-1][j])
m = 0
for i in range(ma+1):
if dp[-1][i] <= W:
m = i
print(m) | p03164 |
N, W = list(map(int, input().split()))
goods = [list(map(int, input().split())) for i in range(N)]
v_sum = sum([i[1] for i in goods])
dp = [float("inf") for i in range(v_sum + 1)]
dp[0] = 0
for i in range(N):
for j in range(v_sum, -1, -1):
dp[j] = min(dp[j - goods[i][1]] + goods[i][0], dp[j])
for i in range(v_sum, -1, -1):
if dp[i] <= W:
print(i)
break
| N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(N)]
v_sum = sum([item[1] for item in items])
inf = float("inf")
dp = [inf for _ in range(v_sum + 1)]
dp[0] = 0
for i in range(N):
for j in range(v_sum, -1, -1):
if dp[j] > dp[j - items[i][1]] + items[i][0]:
dp[j] = dp[j - items[i][1]] + items[i][0]
for i in range(v_sum, -1, -1):
if dp[i] <= W:
print(i)
exit()
| p03164 |
N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(N)]
sum_v = sum([item[1] for item in items])
inf = float("inf")
dp = [[inf for _ in range(sum_v+1)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(sum_v+1):
if j - items[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j - items[i][1]] + items[i][0])
else:
dp[i+1][j] = dp[i][j]
for v in range(sum_v, -1, -1):
if dp[N][v] <= W:
print(v)
exit()
| N, W = list(map(int, input().split()))
items = [list(map(int, input().split())) for _ in range(N)]
sum_v = sum([item[1] for item in items])
inf = float("inf")
dp = [inf for _ in range(sum_v+1)]
dp[0] = 0
for i in range(N):
for j in range(sum_v, -1, -1):
if j - items[i][1] >= 0:
dp[j] = min(dp[j], dp[j - items[i][1]] + items[i][0])
for v in range(sum_v, -1, -1):
if dp[v] <= W:
print(v)
exit()
| p03164 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
# https://qiita.com/drken/items/dc53c683d6de8aeacf5a#e-問題---knapsack-2
# N個の荷物、ナップザックの容量はW
N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
a, b = list(map(int, input().split()))
w[i] = a
v[i] = b
# 1 <= W <= 10^9なので横軸をWにするとテーブルがでかすぎる
# そのかわりにVの方を横軸にする
# 価値の総合計はまだ不明なので、適当にでかい値にしとく
# 最上部と最左部に0が入るので、その分を+1
V = 10**5
#dp = [ [0 for _ in range(W+1)] for _ in range(N+1) ]
dp = [ [float('inf') for _ in range(V+1)] for _ in range(N+1) ]
# 最小値を求めるので、上記でinfが入ってるので、初期値は0をいれる必要がある
dp[0][0] = 0
# dp[i][sum_v] = これまで(i-1)番目までの品物から価値がsum_v以上になるように選んだときの、重さの総和の最小値
for i in range(N):
for sum_v in range(V):
if sum_v - v[i] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v-v[i]]+w[i])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
# 中身がWなので、W以下であるうちのsum_vの最大値を求めればいい
for sum_v in range(V):
# 最終行だけ見ればいいので、端からsum_vの最大値をなめるだけ
if dp[N][sum_v] <= W:
ans = sum_v
print(ans)
|
# N個の荷物、ナップザックの容量はW
N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
a, b = list(map(int, input().split()))
w[i] = a
v[i] = b
# 1 <= W <= 10^9なので横軸をWにするとテーブルがでかすぎる
# そのかわりにVの方を横軸にする
# 価値の総合計はまだ不明なので、適当にでかい値にしとく
# 最上部と最左部に0が入るので、その分を+1
V = N*1000+1
dp = [ [float('inf') for _ in range(V+1)] for _ in range(N+1) ]
# 最小値を求めるので、上記でinfが入ってるので、初期値は0をいれる必要がある
dp[0][0] = 0
# dp[i][sum_v] = これまで(i-1)番目までの品物から価値がsum_v以上になるように選んだときの、重さの総和の最小値
for i in range(N):
for sum_v in range(V):
if sum_v - v[i] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v-v[i]]+w[i])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
# 中身がWなので、W以下であるうちのsum_vの最大値を求めればいい
for sum_v in range(V):
# 最終行だけ見ればいいので、端からsum_vの最大値をなめるだけ
if dp[N][sum_v] <= W:
ans = sum_v
print(ans) | p03164 |
# N個の荷物、ナップザックの容量はW
N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
a, b = list(map(int, input().split()))
w[i] = a
v[i] = b
# 1 <= W <= 10^9なので横軸をWにするとテーブルがでかすぎる
# そのかわりにVの方を横軸にする
# 価値の総合計はまだ不明なので、適当にでかい値にしとく
# 最上部と最左部に0が入るので、その分を+1
V = N*1000+1
dp = [ [float('inf') for _ in range(V+1)] for _ in range(N+1) ]
# 最小値を求めるので、上記でinfが入ってるので、初期値は0をいれる必要がある
dp[0][0] = 0
# dp[i][sum_v] = これまで(i-1)番目までの品物から価値がsum_v以上になるように選んだときの、重さの総和の最小値
for i in range(N):
for sum_v in range(V):
if sum_v - v[i] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v-v[i]]+w[i])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
# 中身がWなので、W以下であるうちのsum_vの最大値を求めればいい
for sum_v in range(V):
# 最終行だけ見ればいいので、端からsum_vの最大値をなめるだけ
if dp[N][sum_v] <= W:
ans = sum_v
print(ans) |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# A = [ int(input()) for _ in range(N) ]
##############################
N, W = list(map(int, input().split()))
w = []
v = []
for i in range(N):
a, b = list(map(int, input().split()))
w.append(a)
v.append(b)
V = sum(v)
dp = [ [INF for _ in range(V+1)] for _ in range(N+1) ]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - v[i] < 0:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = min(dp[i][j], dp[i][j-v[i]]+w[i])
#print(dp[N])
ans = 0
for v in range(V+1):
if dp[N][v] <= W:
ans = v
print(ans)
| p03164 |
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)]
V=100000
dp=[INF]*(V+1)
dp[0]=0
for w,v in WV:
for x in range(V,-1,-1):
if(x+v<=V):
dp[x+v]=min(dp[x+v],dp[x]+w)
for x in range(V,-1,-1):
if(dp[x]<=W):
print(x)
return
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] * (n * 1001 + 1)
dp[0] = 0
for _ in range(n):
w, v = list(map(int, input().split()))
for v0 in range(n * 1001, -1, -1):
if dp[v0] == INF:
continue
if v + v0 <= n * 1001:
dp[v + v0] = min(dp[v + v0], dp[v0] + w)
for v in range(n * 1001, -1, -1):
if dp[v] <= W:
print(v)
return
resolve() | p03164 |
N,W = list(map(int,input().split(" ")))
INF = 1e11
v = [INF]*100010
v[0] = 0
for i in range(N):
weight,value = list(map(int,input().split(" ")))
for j in range(100001,0,-1):
if j < value:
break
v[j] = min(v[j],v[j-value]+weight)
for i in range(100001,0,-1):
if v[i] <= W:
print(i)
break
| N,W = list(map(int,input().split(" ")))
INF = 1e11
v = [INF]*100010
v[0] = 0
for i in range(N):
weight,value = list(map(int,input().split(" ")))
for j in range(100001,0,-1):
if j < value:
break
v[j] = min(v[j],v[j-value]+weight)
ans = 0
for i in range(100001,0,-1):
if v[i] <= W:
ans = i
break
print(ans)
| p03164 |
N, W = list(map(int, input().split()))
DP = dict()
DP[W] = 0
def maxv(i, v):
if not DP.get(i):
DP[i] = v
else:
if v > DP[i]:
DP[i] = v
for w, v in (list(map(int, input().split())) for _ in range(N)):
DPpre = DP.copy()
for i in DPpre:
if i - w >= 0:
maxv(i-w, DPpre[i]+v)
print((max((DP[x] for x in DP))))
| N, W = list(map(int, input().split()))
IN = list(list(map(int, input().split())) for _ in range(N))
sumw = 0
sumv = 0
for w, v in IN:
sumw += w
sumv += v
DP = dict()
DP[sumv] = sumw
def minv(i, v):
if not DP.get(i):
DP[i] = v
else:
if v < DP[i]:
DP[i] = v
for w, v in IN:
DPpre = DP.copy()
for i in DPpre:
minv(i-v, DPpre[i]-w)
for v in sorted(DP, reverse=True):
if DP[v] <= W:
print(v)
break
| p03164 |
N, W = list(map(int, input().split()))
IN = list(list(map(int, input().split())) for _ in range(N))
sumw = 0
sumv = 0
for w, v in IN:
sumw += w
sumv += v
DP = dict()
DP[sumv] = sumw
def minv(i, v):
if not DP.get(i):
DP[i] = v
else:
if v < DP[i]:
DP[i] = v
if sumw <= W:
ans = sumv
else:
ans = 0
for w, v in IN:
DPpre = DP.copy()
for i in DPpre:
answ = i - v
minv(answ, DPpre[i]-w)
if answ > ans:
if DP[answ] <= W:
ans = answ
continue
print(ans)
| N, W = list(map(int, input().split()))
IN = list(list(map(int, input().split())) for _ in range(N))
sumw = 0
sumv = 0
for w, v in IN:
sumw += w
sumv += v
DP = dict()
DP[sumv] = sumw
def minv(i, v):
if not DP.get(i):
DP[i] = v
else:
if v < DP[i]:
DP[i] = v
for w, v in IN:
DPpre = DP.copy()
for i in DPpre:
minv(i-v, DPpre[i]-w)
for v in sorted(DP, reverse=True):
if DP[v] <= W:
print(v)
break
| p03164 |
N,W=list(map(int,input().split()))
lwv=[]
for i in range(N):
lwv.append(list(map(int,input().split())))
ldp=[[float("inf") for j in range(10**5)] for i in range(N)]
for j in range(10**5):
if lwv[0][1]>=j+1:
ldp[0][j]=lwv[0][0]
for i in range(1,N):
for j in range(10**5):
comp=ldp[i-1][j+1-lwv[i][1]-1]+lwv[i][0] if j+1-lwv[i][1]>0 else lwv[i][0]
ldp[i][j]=min(ldp[i-1][j],comp)
for j in range(10**5-1,-1,-1):
if ldp[N-1][j]<=W:
print((j+1))
break
| N,W=list(map(int,input().split()))
lw=[]
lv=[]
for i in range(N):
w,v=list(map(int,input().split()))
lw.append(w)
lv.append(v)
ldp=[[float("inf") for j in range(10**5)] for i in range(N)]
for j in range(10**5):
if lv[0]>=j+1:
ldp[0][j]=lw[0]
for i in range(1,N):
for j in range(10**5):
ldp[i][j]=min(ldp[i-1][j],ldp[i-1][j+1-lv[i]-1]+lw[i] if j+1-lv[i]>0 else lw[i])
for j in range(10**5-1,-1,-1):
if ldp[N-1][j]<=W:
print((j+1))
break
| p03164 |
n,w=list(map(int, input().split()))
m=10**5+1
x=[list(map(int, input().split())) for i in range(n)]
dp=[[float('inf')]*m for i in range(n+1)]
dp[0][0]=0
for i in range(n):
for j in range(m):
if j>=x[i][1]:
dp[i+1][j]=min(dp[i][j],dp[i][j-x[i][1]]+x[i][0])
else:
dp[i+1][j]=dp[i][j]
ans=0
for i in range(m):
if dp[-1][i]<=w:ans=max(ans,i)
print(ans) | N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[float('inf')] * (V + 1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - L[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-L[i][1]] + L[i][0])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for j in range(V+1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans) | p03164 |
N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[float('inf')] * (V + 1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - L[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-L[i][1]] + L[i][0])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for j in range(V+1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans) | N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[10**9+1] * (V + 1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - L[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-L[i][1]] + L[i][0])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for j in range(V+1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans) | p03164 |
N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[10**9+1] * (V + 1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - L[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-L[i][1]] + L[i][0])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for j in range(V+1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans) | N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [10**9+1] * (V + 1)
dp[0] = 0
for i in range(N):
for j in range(V, -1, -1):
dp[j] = min(dp[j], dp[j-L[i][1]] + L[i][0])
ans = 0
for j in range(V+1):
if W >= dp[j]:
ans = max(ans, j)
print(ans) | p03164 |
N,W=list(map(int,input().split()))
w=[]
v=[]
for i in range(N):
a,b=list(map(int,input().split()))
w.append(a)
v.append(b)
V=sum(v)
dp=[[float("inf") for i in range(V+1)] for _ in range(110)]
dp[0][0]=0
for i in range(0,N):
for j in range(V+1):
if j-v[i]>=0:
dp[i+1][j]=min(dp[i+1][j],dp[i][j-v[i]]+w[i])
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
ans=0
for j in range(V+1):
if dp[N][j]<=W:
ans=j
print(ans)
| 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()))
V=sum(v)
dp=[[float("inf") ]*(V+1) for _ in range(110)]
dp[0][0]=0
for i in range(0,N):
for j in range(V+1):
if j-v[i]>=0:
dp[i+1][j]=min(dp[i+1][j],dp[i][j-v[i]]+w[i])
dp[i+1][j]=min(dp[i+1][j],dp[i][j])
ans=0
for j in range(V+1):
if dp[N][j]<=W:
ans=j
print(ans)
| p03164 |
import sys
input = sys.stdin.readline
n, w = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(n)]
V_MAX = 10**5
dp = [[w + 1] * (V_MAX + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i, (wi, vi) in enumerate(items):
for j in range(V_MAX + 1):
if j >= vi:
dp[i + 1][j] = min(dp[i][j], dp[i][j - vi] + wi)
else:
dp[i + 1][j] = dp[i][j]
ans = 0
for i in range(n + 1):
for j in range(V_MAX + 1):
if dp[i][j] <= w:
ans = max(ans, j)
print(ans)
| import sys
input = sys.stdin.readline
n, w = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(n)]
V_MAX = 10**5
dp = [[w + 1] * (V_MAX + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i, (wi, vi) in enumerate(items):
for j in range(V_MAX + 1):
if j >= vi:
dp[i + 1][j] = min(dp[i][j], dp[i][j - vi] + wi)
else:
dp[i + 1][j] = dp[i][j]
ans = 0
for j in range(V_MAX + 1):
if dp[n][j] <= w:
ans = max(ans, j)
print(ans)
| p03164 |
N,W = list(map(int, input().split()))
m = []
v = []
for i in range(N):
a,b = list(map(int, input().split()))
m.append(a)
v.append(b)
sum_v = sum(v)
dp = [[float('inf') for i in range(sum_v+1001)]for j in range(N+1)]
for i in range(N):
for j in range(sum_v+1):
if j == 0:
dp[i][j] = 0
if j != float('inf'):
dp[i+1][j+v[i]] = min(dp[i][j+v[i]],dp[i][j] + m[i])
dp[i+1][j] = min(dp[i+1][j],dp[i][j])
for i in range(sum(v)+1):
if dp[-1][sum(v)-i] <= W:
print((sum(v)-i))
break
| N,W = list(map(int, input().split()))
m = []
v = []
for i in range(N):
a,b = list(map(int, input().split()))
m.append(a)
v.append(b)
sum_v = sum(v)
dp = [[10**15 for i in range(sum_v+1001)]for j in range(N+1)]
for i in range(N):
dp[i][0] = 0
for j in range(sum_v+1):
if j != 10**15:
dp[i+1][j+v[i]] = min(dp[i][j+v[i]],dp[i][j] + m[i])
dp[i+1][j] = min(dp[i+1][j],dp[i][j])
for i in range(sum(v)+1):
if dp[-1][sum(v)-i] <= W:
print((sum(v)-i))
break | p03164 |
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()))
V = sum(v)
# dp[i][j]:i番目までの品物から価値がj以上になるよう選んだときの重さの総和の最小値
dp = [[float("inf")] * (V + 1) for _ in range(N + 1)]
dp[0][0] = 0
for i in range(N):
for j in range(V + 1):
# i+1番目を選ぶ場合
if j - v[i] >= 0:
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - v[i]] + w[i])
# i+1番目を選ばない場合
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j])
# dp[N][j]がW以下であるようなjの最大値が答えになる
ans = 0
for j in range(V + 1):
if dp[N][j] <= W:
ans = j
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=[[float('inf')]*(sum(v)+1) for i in range(N+1)]
dp[0][0]=0
for i in range(1,N+1):
for j in range(len(dp[0])):
if j>=v[i-1]:
dp[i][j]=w[i-1]+dp[i-1][j-v[i-1]]
dp[i][j]=min(dp[i][j],dp[i-1][j])
ans=0
for i in range(len(dp[0])):
if dp[N][i]<=W:
ans=i
print(ans) | p03164 |
n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V+1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
#print(dp)
ans = 0
for i in range(MAX_V, -1, -1):
if dp[i] <= w:
print(i)
exit()
#print(ans)
| n, w = list(map(int, input().split()))
wv = [tuple(map(int, input().split())) for _ in range(n)]
INF = 10**9 + 100
MAX_V = 10**5 + 100
dp = [INF] * (MAX_V + 1)
dp[0] = 0
for wi, vi in wv:
for sum_v in reversed(list(range(vi, MAX_V+1))):
dp[sum_v] = min(dp[sum_v - vi] + wi, dp[sum_v])
#print(dp)
ans = 0
for i in reversed(list(range(MAX_V+1))):
if dp[i] <= w:
print(i)
exit()
#print(ans)
| p03164 |
inf = float('inf')
n, w = list(map(int, input().split()))
wv = tuple(tuple(map(int, input().split())) for _ in range(n))
dp = tuple([inf] * (pow(10, 3) * n + 1) for _ in range(n + 1))
dp[0][0] = 0
for ind, (wi, vi) in enumerate(wv, 1):
for v in range(pow(10, 3) * n + 1):
if vi <= v:
dp[ind][v] = min(dp[ind - 1][v], dp[ind - 1][v - vi] + wi)
else:
dp[ind][v] = dp[ind - 1][v]
for v in range(pow(10, 3) * n, 0, -1):
if dp[n][v] <= w:
print(v)
exit()
| inf = float('inf')
n, w = list(map(int, input().split()))
e = tuple(list(map(int, input().split())) for _ in range(n))
wt, vt = list(zip(*e))
sv = sum(vt)
dp = tuple([inf] * (sv + 1) for _ in range(n + 1))
dp[0][0] = 0
for i in range(n):
dp[i + 1][:vt[i]] = dp[i][:vt[i]]
for j in range(vt[i], sv + 1):
dp[i + 1][j] = min(dp[i][j], dp[i][j - vt[i]] + wt[i])
res = -1
for j in range(sv, -1, -1):
if dp[n][j] <= w:
res = j
break
print(res)
| p03164 |
n,w=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(n)]
dp=[float("inf")]*(10**5+1)
dp[0]=0
for i in range(n):
for j in range(10**5,A[i][1]-1,-1):
dp[j]=min(dp[j],dp[j-A[i][1]]+A[i][0])
ans=0
for v,e in enumerate(dp):
if e<=w:
ans=v
print(ans) | import sys
input=sys.stdin.readline
n,w=list(map(int,input().split()))
A=[list(map(int,input().split())) for i in range(n)]
dp=[float("inf")]*(10**5+1)
dp[0]=0
for i in range(n):
for j in range(10**5,A[i][1]-1,-1):
dp[j]=min(dp[j],dp[j-A[i][1]]+A[i][0])
ans=0
for v,e in enumerate(dp):
if e<=w:
ans=v
print(ans) | p03164 |
import sys
input=sys.stdin.readline
from collections import defaultdict as dd
n,w=list(map(int,input().split()))
we=[0]*n
val=[0]*n
for i in range(n):
ww,v=list(map(int,input().split()))
we[i]=ww
val[i]=v
dp=dd(lambda:-1)
def solve(i,w,we,val):
if(i==0 or w==0):
return 0
if(dp[(i,w)]!=-1):
return dp[(i,w)]
if(we[i-1]<=w):
if(dp[(i-1,w-we[i-1])]!=-1):
x=dp[(i-1,w-we[i-1])]
else:
x=dp[(i-1,w-we[i-1])]=solve(i-1,w-we[i-1],we,val)
if(dp[(i-1,w)]!=-1):
y=dp[(i-1,w)]
else:
y=dp[(i-1,w)]=solve(i-1,w,we,val)
dp[(i,w)]=max(val[i-1]+x,y)
return dp[(i,w)]
else:
if(dp[(i-1,w)]!=-1):
y=dp[(i-1,w)]
else:
y=dp[(i-1,w)]=solve(i-1,w,we,val)
dp[(i,w)]=y
return dp[(i,w)]
print((solve(n,w,we,val)))
#print(dp)
| import sys
input=sys.stdin.readline
from collections import defaultdict as dd
n,w=list(map(int,input().split()))
maxn=10000000000000000
we=[0]*n
val=[0]*n
su=0
for i in range(n):
ww,v=list(map(int,input().split()))
we[i]=ww
val[i]=v
su+=v
dp=[maxn]*(su+1)
dp[0]=0
for i in range(n):
for j in range(su-val[i],-1,-1):
dp[j+val[i]]=min(dp[j+val[i]],we[i]+dp[j])
ans=0
for i in range(len(dp)):
if(dp[i]<=w):
ans=max(ans,i)
print(ans) | p03164 |
import itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = N*10**3
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i,j in itertools.product(list(range(1,N+1)),list(range(V+1))):
w,v = wv[i-1]
if j-v>=0:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
ans = 0
for k in range(V+1):
if dp[-1][k]<=W:
ans = max(ans,k)
print(ans)
| import itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = N*10**3
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i,j in itertools.product(list(range(1,N+1)),list(range(V+1))):
w,v = wv[i-1]
if j-v>=0 and dp[i-1][j-v]+w<=W:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
print((max([i for i in range(V+1) if dp[-1][i]<=W])))
| p03164 |
import itertools,sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = 10**5
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i,j in itertools.product(list(range(1,N+1)),list(range(V+1))):
w,v = wv[i-1]
if j-v>=0 and dp[i-1][j-v]+w<=W:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
print((max([i for i in range(V+1) if dp[-1][i]<=W])))
| import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N,W = LI()
wv = [LI() for _ in range(N)]
V = N*10**3
dp = [[float('INF')]*(V+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = wv[i-1]
for j in range(V+1):
if j-v>=0 and dp[i-1][j-v]+w<=W:
dp[i][j] = min(dp[i][j],dp[i-1][j-v]+w)
dp[i][j] = min(dp[i][j],dp[i-1][j])
print((max([i for i in range(V+1) if dp[-1][i]<=W])))
| p03164 |
n,w=list(map(int,input().split()))
dp=[999999999999999]*(100001)
dp[0]=0
for i in range(n):
wt,val=list(map(int,input().split()))
for j in range(100000,val-1,-1):
dp[j]=min(dp[j],dp[j-val]+wt)
for i in range(100000,-1,-1):
if dp[i]<=w:
print(i)
exit() | n,w=list(map(int,input().split()))
l=(n*1000)+1
dp=[9999999999]*(l)
dp[0]=0
for i in range(n):
wt,val=list(map(int,input().split()))
for j in range(l-1,val-1,-1):
dp[j]=min(dp[j],dp[j-val]+wt)
for i in range(l-1,-1,-1):
if dp[i]<=w:
print(i)
exit() | p03164 |
import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, log2, factorial
from pprint import pprint
sys.setrecursionlimit(1000000)
# MOD = 10 ** 9 + 7
# N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
# A = [int(input()) for _ in range(N)]
N, W = [int(x) for x in input().split()]
dp = [float('inf')] * 1000 * 100*10
vs = set()
vs.add(0)
dp[0] = 0
for i in range(N):
w, v = [int(x) for x in input().split()]
tmpDP = dp.copy()
for vv in list(vs):
if dp[vv + v] > dp[vv] + w:
tmpDP[vv + v] = dp[vv] + w
vs.add(vv + v)
dp = tmpDP
ans = 0
for v in list(vs):
if dp[v] <= W:
ans = max(ans, v)
print(ans)
| import sys
from collections import Counter, deque, defaultdict
from itertools import accumulate, permutations, combinations, takewhile, compress, cycle
from functools import reduce
from math import ceil, floor, log10, log2, factorial
from pprint import pprint
sys.setrecursionlimit(1000000)
# MOD = 10 ** 9 + 7
# N = int(input())
# A = [int(x) for x in input().split()]
# V = [[0] * 100 for _ in range(100)]
# A = [int(input()) for _ in range(N)]
N, W = [int(x) for x in input().split()]
dp = defaultdict(lambda: float('inf'))
dp[0] = 0
for i in range(N):
w, v = [int(x) for x in input().split()]
add = defaultdict(lambda: float('inf'))
for vv in list(dp.keys()):
if dp[vv + v] > dp[vv] + w:
add[vv + v] = dp[vv] + w
dp.update(add)
print((max([i for i in list(dp.items()) if i[1] <= W], key=lambda x:x[0])[0]))
| p03164 |
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()])
V = 10 ** 5
inf = float("inf")
dp = [[inf] * (V + 1) for _ in range(N + 1)]
dp[0][0] = 0
ans = -1
for i in range(N):
for j in range(V + 1):
w, v = wv[i]
if j >= v:
dp[i + 1][j] = min(dp[i][j], dp[i][j - v] + w)
else:
dp[i + 1][j] = dp[i][j]
if dp[i + 1][j] <= W:
ans = max(ans, j)
print(ans) | 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 = [[float('inf')] * (10**5 + 1) for _ in range(n + 1)]
dp[0][0] = 0
for i in range(1, n + 1):
w, v = wv[i - 1]
for j in range(10**5 + 1):
if j - v >= 0:
dp[i][j] = min(dp[i - 1][j], dp[i - 1][j - v] + w)
else:
dp[i][j] = dp[i - 1][j]
ans = 0
for i in range(10**5 + 1):
if dp[-1][i] <= W:
ans = max(ans, i)
print(ans) | p03164 |
N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
#import math
INF = 10 ** 12 # math.inf
V = 10 ** 5 + 10
dp = [[INF] * V for _ in range(N + 1)]
dp[0][0] = 0
for i, (w, v) in enumerate(WV):
for n in range(V):
if v <= n:
dp[i + 1][n] = min(dp[i + 1][n], dp[i][n - v] + w)
dp[i + 1][n] = min(dp[i + 1][n], dp[i][n])
"""
for line in dp:
for cell in line:
if cell == INF:
print(" INF", end="")
else:
print("{:5d}".format(cell), end="")
print()
"""
r = 0
for i in range(V):
if dp[-1][i] <= W:
r = i
print(r) | N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
INF = 10 ** 12
V = 10 ** 3 * 100 + 10
dp = [0] + [INF] * V
for w, v in WV:
for i in range(V, v - 1, -1):
dp[i] = min(dp[i], dp[i - v] + w)
r = 0
for i in range(V):
if dp[i] <= W:
r = i
print(r)
"""
for cell in dp:
if cell == INF:
print(" INF", end="")
else:
print("{:5d}".format(cell), end="")
print()
"""
| p03164 |
N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
INF = 10 ** 12
V = 10 ** 3 * 100 + 10
dp = [0] + [INF] * V
for w, v in WV:
for i in range(V, v - 1, -1):
dp[i] = min(dp[i], dp[i - v] + w)
r = 0
for i in range(V):
if dp[i] <= W:
r = i
print(r)
"""
for cell in dp:
if cell == INF:
print(" INF", end="")
else:
print("{:5d}".format(cell), end="")
print()
"""
| N, W = list(map(int, input().split()))
WV = [list(map(int, input().split())) for _ in range(N)]
INF = 10 ** 12
MAX_V = 10 ** 5 + 10
dp = [INF] * MAX_V
dp[0] = 0
for w, v in WV:
for i in range(MAX_V - 1, v - 1, -1):
dp[i] = min(dp[i], dp[i - v] + w)
#print(dp)
max_v = 0
for v, w in enumerate(dp):
if w <= W:
max_v = max(max_v, v)
print(max_v)
| p03164 |
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()
max_v = 100001
wv = [iln() for _ in range(N)]
max_w = 10**10
dp = [[max_w for _ in range(max_v+1)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
for sum_v in range(max_v):
if sum_v - wv[i][1] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v-wv[i][1]]+wv[i][0])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
ans = 0
for sum_v in range(max_v):
if dp[N][sum_v] <= W: ans = sum_v
print(ans) | 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 ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, 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 fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
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)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
MOD = 10**9+7
N,W = imn()
wv = [iln() for _ in range(N)]
max_v = 10**3*100+1
dp = [[10**10 for _ in range(max_v)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
for sum_v in range(max_v):
if wv[i][1] <= sum_v:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v-wv[i][1]]+wv[i][0])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
ans = 0
for v in range(max_v):
if dp[N][v] <= W: ans = v
print(ans) | p03164 |
N, W = list(map(int, input().split()))
dp = [[W+1]*(100000+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(100000+1):
if j+v <= 100000:
dp[i+1][j+v] = min(dp[i+1][j+v], dp[i][j] + w)
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
i = -1
while True:
if dp[N][i] <= W:
print((100000+1+i))
break
else:
i -= 1 | INF_V = 1000*100
N, W = list(map(int, input().split()))
dp = [[W+1]*(INF_V+1) for _ in range(N+1)]
dp[0][0] = 0
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(INF_V-1000+1):
dp[i+1][j+v] = min(dp[i+1][j+v], dp[i][j] + w)
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
print(([i for (i, w) in enumerate(dp[N]) if w <= W][-1])) | p03164 |
MAX_INT = int(10e10)
N,W = list(map(int,input().split()))
w = [0]
v = [0]
for i in range(N):
a,b = list(map(int,input().split()))
w.append(a)
v.append(b)
V_MAX = max(v)
# dp[i][v] = w
dp = [[MAX_INT]*(N*V_MAX+1) for i in range(N+1)]
for i in range(1,N+1):
dp[i-1][v[i-1]] = w[i-1]
for j in range(1,N*V_MAX+1):
if j < v[i]:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-v[i]]+w[i]) # max(iの品を使わない時, iの品を使う時)
for j in range(N*V_MAX,0,-1):
for i in range(1,N+1):
if dp[i][j] <= W:
print(j)
exit()
| MAX_INT = int(10e10)
N,W = list(map(int,input().split()))
w = [0]
v = [0]
for i in range(N):
a,b = list(map(int,input().split()))
w.append(a)
v.append(b)
V_MAX = max(v)
# dp[i][v] = w
dp = [[MAX_INT]*(N*V_MAX+1) for i in range(N+1)]
for i in range(N+1):
dp[i][v[i]] = w[i]
for i in range(1,N+1):
for j in range(1,N*V_MAX+1):
if j < v[i]:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-v[i]]+w[i],dp[i][j]) # max(iの品を使わない時, iの品を使う時)
for j in range(N*V_MAX,0,-1):
for i in range(1,N+1):
if dp[i][j] <= W:
print(j)
exit()
| p03164 |
def solve():
N, W = list(map(int, input().split()))
MAX_V = 100100
MAX_N = 110
w = []
v = []
for i in range(N):
tmpw, tmpv = list(map(int, input().split()))
w.append(tmpw)
v.append(tmpv)
dp = [[float('inf') for i in range(MAX_V+1)] for j in range(MAX_N+1)]
dp[0][0] = 0
for i in range(N):
for sum_v in range(MAX_V):
if sum_v - v[i] >= 0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v - v[i]] + w[i])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
res = 0
for sum_v in range(MAX_V+1):
if dp[N][sum_v] <= W:
res = sum_v
print(res)
if __name__ == '__main__':
solve() | def solve():
n, w = list(map(int, input().split()))
l = [list(map(int, input().split())) for i in range(n)]
lim = n * 10 ** 3 + 1
dp = [[10**15 for i in range(lim)] for i in range(n+1)]
for i in range(n+1):
dp[i][0] = 0
for i in range(n):
for sum_v in range(lim):
if sum_v-l[i][1]>=0:
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v - l[i][1]] + l[i][0])
dp[i+1][sum_v] = min(dp[i+1][sum_v], dp[i][sum_v])
ans = 0
for sum_v in range(lim):
if dp[n][sum_v] <= w:
ans = sum_v
print(ans)
if __name__ == '__main__':
solve() | p03164 |
N,W = list(map(int,input().split()))
WV = [[0,0]] + [list(map(int,input().split())) for _ in range(N)]
vrng = (10**3)*N+1
dp = [[float('inf') for _ in range(vrng)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(1, N+1):
tmpw, tmpv = WV[i]
for j in range(vrng):
if j-tmpv>=0:
dp[i][j] = min(dp[i-1][j],dp[i-1][j-tmpv]+tmpw)
else:
dp[i][j] = dp[i-1][j]
ans = -float('inf')
for row in dp:
for j,w in enumerate(row):
if w<=W and ans<j:
ans = j
print(ans) | N,W = list(map(int,input().split()))
WV = [[0,0]] + [list(map(int,input().split())) for _ in range(N)]
sumV = sum([v for _,v in WV])
dp = [[float('inf') for _ in range(sumV+1)] for _ in range(N+1)]
dp[0][0] = 0
for i in range(1, N+1):
tmpw, tmpv = WV[i]
for j in range(sumV+1):
if j-tmpv>=0:
dp[i][j] = min(dp[i-1][j],dp[i-1][j-tmpv]+tmpw)
else:
dp[i][j] = dp[i-1][j]
ans = -float('inf')
for row in dp:
for j,w in enumerate(row):
if w<=W and ans<j:
ans = j
print(ans) | p03164 |
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()))
mv = n*max(v)
dp = [[float("INF")]*(mv+1) for _ in range(n+1)]
for i in range(n): dp[i][0] = 0
for i in range(1,n+1):
for s in range(1,mv+1):
if s - v[i] < 0: dp[i][s] = dp[i-1][s]
else: dp[i][s] = min(dp[i-1][s], dp[i-1][s-v[i]] + w[i])
ans = 0
for x in range(1,mv+1):
if dp[n][x] <= W: ans = x
print(ans) | 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()))
mv = n*max(v)
dp = [[float("INF")]*(mv+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for s in range(mv+1):
if s - v[i] < 0: dp[i+1][s] = dp[i][s]
else: dp[i+1][s] = min(dp[i][s], dp[i][s-v[i]] + w[i])
ans = 0
for x in range(1,mv+1):
if dp[n][x] <= W: ans = x
print(ans) | p03164 |
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()))
mv = n*max(v)
dp = [[float("INF")]*(mv+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for s in range(mv+1):
if s - v[i] < 0: dp[i+1][s] = dp[i][s]
else: dp[i+1][s] = min(dp[i][s], dp[i][s-v[i]] + w[i])
ans = 0
for x in range(1,mv+1):
if dp[n][x] <= W: ans = x
print(ans) | 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()))
mv = sum(v)
dp = [[float("INF")]*(mv+1) for _ in range(n+1)]
dp[0][0] = 0
for i in range(n):
for s in range(mv+1):
if s - v[i] < 0: dp[i+1][s] = dp[i][s]
else: dp[i+1][s] = min(dp[i][s], dp[i][s-v[i]] + w[i])
ans = 0
for x in range(1,mv+1):
if dp[n][x] <= W: ans = x
print(ans) | p03164 |
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, W = na()
wv = [na() for _ in range(n)]
dp = [0]+[float("inf")]*(10**5)
for i in range(n):
for j in range(10**5,1,-1):
dp[j] = min(dp[j],dp[j-wv[i][1]]+wv[i][0])
res = 0
for v,e in enumerate(dp):
if e <= W:
res = v
print(res)
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip() # ignore trailing spaces
n, W = na()
wv = [na() for _ in range(n)]
dp = [0]+[float("inf")]*(10**5)
for i in range(n):
for j in range(10**5,wv[i][1]-1,-1):
dp[j] = min(dp[j],dp[j-wv[i][1]]+wv[i][0])
res = 0
for v,e in enumerate(dp):
if e <= W:
res = v
print(res)
| p03164 |
import sys
# input処理を高速化する
input = sys.stdin.readline
# 入力
N, W = list(map(int, input().split()))
array = [list(map(int, input().split())) for _ in range(N)] # [重さ、価値]
# sum_vの取りうる上限値
# MAX_V = (10**3 + 1) * N
MAX_V = 0
for line in array:
MAX_V += line[1]
MAX_V += 1
# 最小値を求めるので無限大の値
f_inf = float('inf')
def chmin(a, b):
if a <= b:
return a
else:
return b
def knapsack(n, w):
# dpの初期化 dp[i][sum_v]は重さの総和の最小値
dp = [[f_inf] * MAX_V for j in range(N + 1)]
# 初期条件
dp[0][0] = 0
# forは全て関数の中で回す。
# 入力
for i in range(N):
# w, v = map(int, input().split())
for sum_v in range(MAX_V):
# i番目の品物を選ぶ場合
if sum_v - array[i][1] >= 0:
dp[i + 1][sum_v] = chmin(dp[i + 1][sum_v],
dp[i][sum_v - array[i][1]] + array[i][0])
# i番目の品物を選ばない場合
dp[i + 1][sum_v] = chmin(dp[i + 1][sum_v], dp[i][sum_v])
# dp[N][sum_v]の値が、W以下であるsum_vの値の最大値
ans = 0
for sum_v in range(MAX_V):
if dp[N][sum_v] <= W:
ans = sum_v
print(ans)
knapsack(N, W)
| # N個、重さW
N, W = list(map(int, input().split()))
# 重さ, 価値
array = [list(map(int, input().split())) for _ in range(N)]
# 価値の最大値
sum = 1
for i in range(N):
sum += array[i][1]
weights = [[float('inf')] * (sum + 1) for _ in range(N + 1)]
# 初期値
weights[0][0] = 0
# 価値ごとの重さの最小値を出す
for n in range(N):
# 価値が0..1000までのそれぞれについて、価値を超えているうちの重さの最小値を算出する
for v in range(sum + 1):
# n回目の品物を持ち帰らない場合の重量
weights[n + 1][v] = weights[n][v]
weight = weights[n][v - array[n][1]] + array[n][0]
if weight < weights[n + 1][v]:
weights[n + 1][v] = weight
ans = 0
for i in range(sum):
if weights[N][i] <= W:
ans = i
print(f"{ans}")
| p03164 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
INF = float("inf")
dp = [0] + [INF] * 10**5
for _ in range(N):
w, v = list(map(int, input().split()))
for j in range(10**5, v-1, -1):
dp[j] = min(dp[j], dp[j-v] + w)
for i, x in enumerate(dp):
if x <= W:
ans = i
print(ans) | N, W = list(map(int, input().split()))
INF = float("inf")
dp = [0] + [INF] * 10**5
for _ in range(N):
w, v = list(map(int, input().split()))
for j in range(10**5, v-1, -1):
dp[j] = min(dp[j], dp[j-v] + w)
for i, x in enumerate(dp):
if x <= W:
ans = i
print(ans) | p03164 |
def main2():
#1:初期化
N,W = list(map(int,input().split()))
wv = []
for _ in range(N):
wv.append(list(map(int,input().split())))
dp = [[W+1]*(1000*N+1) for i in range(N+1)] #valueの最大値は10**3なので全てが10**3でも入るような配列を用意．
#print(*dp,sep="\n")
#2:初期値(dp[0][0]だけだと結果が合わない)
for i in range(N+1):
dp[i][0] = 0
#3:dp実行部(貰うDP)
for i in range(1,N+1):
for j in range(1,1000*N+1):
if wv[i-1][1] <= j: #dpの横が重さだが，jが重さ以下ならそもそも入れられない．
dp[i][j] = min(dp[i-1][j], dp[i-1][j-wv[i-1][1]]+wv[i-1][0])
else:
dp[i][j] = dp[i-1][j]
#print(i,j)
#print(*dp,sep="\n")
#4:出力
#print(*dp,sep="\n")
output = 0
for i in range(1000*N+1):
if dp[N][i] <= W:
output = i
print(output)
if __name__ == '__main__':
main2() | def main():
#1:初期化
N,W = list(map(int,input().split()))
dp = [W+1]*(N*10**3+1)
#2:初期値
dp[0] = 0
#3:dp実行部(貰うDP)
for i in range(N):
w, v = list(map(int,input().split()))
for i in range(N*10**3, v-1, -1):
tmp = dp[i-v] + w
if dp[i] > tmp:
dp[i] = tmp
#print(dp,sep="\n")
#4:出力
output = 0
for i in range(N*10**3+1):
if dp[i] <= W:
output = i
print(output)
if __name__ == '__main__':
main() | p03164 |
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 = [[10**9+1]*(sum(v)+1) for i in range(N+1)]
dp[0][0] = 0
#v[i]を使うかどうか
for i in range(N):
#価値がjのときの最小の重さ総量
for j in range(sum(v)+1):
if j >= v[i]:
dp[i+1][j] = min(dp[i][j-v[i]]+w[i],dp[i][j])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for i in range(sum(v)+1):
if dp[N][i] <= W:
ans = max(ans,i)
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[i][j]:i番目の品物を詰めて価値jのときの重さの最小値
dp = [[10**9+1]*(sum(v)+1) for i in range(N+1)]
dp[0][0] = 0
#v[i-1]を使うかどうか
for i in range(1,N+1):
#価値がjのときの最小の重さ
for j in range(sum(v)+1):
if j >= v[i-1]:
dp[i][j] = min(dp[i-1][j-v[i-1]]+w[i-1],dp[i-1][j])
else:
dp[i][j] = dp[i-1][j]
# 重さがW以下のもので価値が最大となるものを探す
ans = 0
for i in range(sum(v)+1):
if dp[-1][i] <= W:
ans = max(ans,i)
print(ans) | p03164 |
N,W = list(map(int, input().split()))
v_max = (10**3)*(N+1)
inf = float('inf')
dp = [inf for _ in range(v_max+1)]
dp[0] = 0
for _ in range(N):
w,v = list(map(int, input().split()))
for j in range(v_max,-1,-1):
if j==0:
dp[j] = 0
else:
a = dp[j]
b = w + dp[j-v]
if v>j:
dp[j] = a
else:
dp[j] = min(a,b)
ans = None
for i in range(v_max,-1,-1):
z = dp[i]
if z<=W and z!=inf:
ans = i
break
print(ans) | import sys
input = sys.stdin.buffer.readline
N,W = list(map(int, input().split()))
v_max = (10**3)*N
inf = float('inf')
dp = [inf for _ in range(v_max+1)]
dp[0] = 0
for _ in range(N):
w,v = list(map(int, input().split()))
for j in range(v_max,v-1,-1):
b = w + dp[j-v]
if b<dp[j]:
dp[j] = b
ans = None
for i in range(v_max+1):
z = dp[i]
if z<=W:
ans = i
print(ans)
| p03164 |
N,W=list(map(int,input().split()))
w=[]
v=[]
for _ in range(N):
a,b=list(map(int,input().split()))
w.append(a)
v.append(b)
V=sum(v)
dp=[[V+1 for _ in range(V+1)] for _ in range(N+1)]
dp[0][0]=0
ans=0
for i in range(N): #i番目の荷物を拾うかどうか
for j in range(V+1): #価値jを超える重量の最小値
dp[i+1][j]=min(dp[i][j],dp[i][max(0,j-v[i])]+w[i])
if dp[i+1][j]<=W:
ans=max(ans,j)
print(ans) | N,W=list(map(int,input().split()))
w=[]
v=[]
for _ in range(N):
a,b=list(map(int,input().split()))
w.append(a)
v.append(b)
V=sum(v)
dp=[[10**9 for _ in range(V+1)] for _ in range(N+1)]
dp[0][0]=0
ans=0
for i in range(N): #i番目の荷物を拾うかどうか
for j in range(V+1): #価値jを超える重量の最小値
dp[i+1][j]=min(dp[i][j],dp[i][max(0,j-v[i])]+w[i])
if dp[i+1][j]<=W:
ans=max(ans,j)
print(ans) | p03164 |
#E
inf = float("inf")
N,W = list(map(int,input().split()))
WV = [list(map(int,input().split())) for _ in range(N)]
dp = [[inf for j in range(10**5+1)] for i in range(N+1)] #dp[i][v] = W
for i in range(N):
dp[i][0] = 0
for i in range(N):
w,v = WV[i]
for j in range(10**5+1):
if j+v <= 10**5:
dp[i+1][j+v] = min(dp[i][j]+w,dp[i][j+v])
dp[i+1][j] = min(dp[i][j],dp[i+1][j])
#print(dp)
ans = 0
for j in range(10**5+1):
w = dp[N][j]
if w <= W:
ans = j
print(ans)
|
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
v_max = 10 ** 5
w_max = 10 ** 18
dp = [[w_max for _ in range(v_max + 1)] for _ in range(n + 1)]
for i in range(n):
dp[i][0] = 0
for i in range(n):
w_, v_ = wv[i]
for j in range(v_max + 1):
if j + v_ <= v_max:
dp[i+1][j+v_] = min(dp[i][j] + w_, dp[i][j + v_])
dp[i+1][j] = min(dp[i][j], dp[i+1][j])
ans = 0
for i in range(v_max + 1):
w_ = dp[n][i]
if w_ <= w:
ans = i
print(ans)
| p03164 |
n,W=list(map(int,input().split()))
w=[]
v=[]
for i in range(n):
a,b=list(map(int,input().split()))
w.append(a)
v.append(b)
V=sum(v)
INF=10**18
dp=[[INF for _ in range(V+1)] for _ in range(n+1)]
dp[0][0]=0
for i in range(n):
for j in range(V+1):
if j<v[i]:dp[i+1][j]=dp[i][j]
else:dp[i+1][j]=min(dp[i][j],dp[i][j-v[i]]+w[i])
for i in range(V+1):
if dp[n][i]<=W:ans=i
print(ans) | INF=10**18
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()))
k=sum(v)
dp=[INF]*(k+1)
dp[0]=0
for i in range(n):
for j in range(k,-1,-1):
if j>=v[i] and dp[j-v[i]]!=INF:dp[j]=min(dp[j],dp[j-v[i]]+w[i])
for i,x in enumerate(dp):
if x<=m:ans=i
print(ans) | p03164 |
# /usr/bin/python
# -*- coding: utf-8 -*-
#
import sys
N,W = list(map(int, input().split()))
v = [0] * N
w = [0] * N
for i in range(N):
w[i],v[i] = list(map(int, input().split()))
dp = [float('inf')] * (10**5+1)
dp[0] = 0
MAX_V = 0
for i in range(N):
MAX_V += v[i]
for j in range(MAX_V,-1,-1):
if j >= v[i] and dp[j-v[i]]+w[i] <= W:
dp[j] = min(dp[j], dp[j-v[i]]+w[i])
ans = 0
for i in range(len(dp)):
if dp[i] < float('inf'):
ans = max(ans, i)
print(ans) | # /usr/bin/python
# -*- coding: utf-8 -*-
#
import sys
N,W = list(map(int, input().split()))
v = [0] * N
w = [0] * N
for i in range(N):
w[i],v[i] = list(map(int, input().split()))
dp = [float('inf')] * (sum(v)+1)
dp[0] = 0
MAX_V = 0
ans = 0
for i in range(N):
MAX_V += v[i]
for j in range(MAX_V,-1,-1):
if j >= v[i] and dp[j-v[i]]+w[i] <= W:
ans = max(ans,j)
dp[j] = min(dp[j], dp[j-v[i]]+w[i])
print(ans)
| p03164 |
N,W = list(map(int,input().split()))
weight = [0]
value = [0]
for i in range(N):
w,v = list(map(int,input().split()))
weight.append(w)
value.append(v)
maxValue = N*1000
dp = [[float("inf") for i in range(maxValue+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0] = 0
for i in range(1,N+1):
for v in range(1,maxValue+1):
dp[i][v] = dp[i-1][v]
if value[i] > v: continue;
dp[i][v] = min(dp[i][v],weight[i] + dp[i-1][v-value[i]])
ans = 0
for x in range(maxValue+1):
if dp[N][x] <= W:
ans = x
print(ans) |
N,W = list(map(int,input().split()))
weight = [0]
value = [0]
for i in range(N):
w,v = list(map(int,input().split()))
weight.append(w)
value.append(v)
maxValue = sum(value)
dp = [[float("inf") for i in range(maxValue+1)] for j in range(N+1)]
for i in range(N+1):
dp[i][0] = 0
for i in range(1,N+1):
for v in range(1,maxValue+1):
dp[i][v] = dp[i-1][v]
if value[i] <= v:
dp[i][v] = min(dp[i][v],weight[i] + dp[i-1][v-value[i]])
ans = 0
for x in range(maxValue+1):
if dp[N][x] <= W:
ans = x
print(ans) | p03164 |
N,W = list(map(int,input().split()))
INF = 10**9+7
NV = (10**3)*N
dp = [[0]+[INF for j in range(NV)] for i in range(N+1)]
for i in range(1,N+1):
w,v = list(map(int,input().split()))
for j in range(NV+1):
if j < v:
dp[i][j] = min(dp[i-1][j], w)
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-v]+w)
ans = 0
for j in range(NV+1):
if dp[N][j] <= W:
ans = j
print(ans)
| N,W = list(map(int,input().split()))
INF = 10**9+7
NV = (10**3)*N
dp = [[INF for j in range(NV+1)] for i in range(N+1)]
dp[0][0] = 0
for i in range(1,N+1):
w,v = list(map(int,input().split()))
for j in range(NV+1):
if j < v:
dp[i][j] = min(dp[i-1][j], w)
else:
dp[i][j] = min(dp[i-1][j], dp[i-1][j-v]+w)
ans = 0
for j in range(NV+1):
if dp[N][j] <= W:
ans = j
print(ans)
| p03164 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.