input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
# atcoder DPまとめ
# D_Knapsack1
# def get_inputs():
# [n, w] = [int(x) for x in input().split()]
# g = []
# for _ in range(n):
# g.append([int(x) for x in input().split()])
#
# return n, w, g
if __name__ == "__main__":
n, w = list(map(int, input().split()))
#### First Try
# この方法では後半の問題でTLEになってしまう
# 二重ループの部分で時間がかかっている
# # dp[i][w]はi-1個目の品物を加えるか吟味した後、重さw以下で最大の価値
# dp = [[0] * (w + 1) for _ in range(n + 1)]
#
# for i in range(1, n + 1):
# for wgt in range(w + 1):
# if wgt >= g[i -1][0]:
# dp[i][wgt] = max(dp[i - 1][wgt - g[i - 1][0]] + g[i - 1][1], dp[i - 1][wgt])
# else:
# dp[i][wgt] = dp[i - 1][wgt]
#
# print(max(dp[n]))
### Second Try
# 動的計画法の部分で、古いiの情報は不要で一つ前の状態さえあれば解ける
# そこに着目し、かつ不要な判定や更新を減らすために、あるiの時に、
# 大きなwから最適値を求めるようにする
# dp[w]は,現在評価中のiにおいて、重さwの時の最大価値の値
### Third Try
# maxをやめてif文に変更
### Fourth Try
# 最初に荷物の情報をリストに読み込んでいたが、そこが時間がかかているようなので逐次読み込みに修正
dp = [0] * (w + 1) # 初期値は０ 範囲は0〜wまで
for i in range(n): # 品物0からn-1までを評価
wt, vl = list(map(int, input().split()))
for j in range(w, wt - 1, -1):
tmp = dp[j - wt] + vl
if tmp > dp[j]:
dp[j] = tmp
print((dp[w]))
| def calc(num,capacity):
dp = [0]*(capacity+1)
for _ in range(num):
weight, value = list(map(int, input().split()))
for w in range(capacity,weight - 1,-1):
tmp = dp[w - weight] + value
if dp[w] < tmp:
dp[w] = tmp
return dp[capacity]
num, capacity = list(map(int, input().split()))
print((calc(num,capacity))) | p03163 |
def knapsack(weight,value,N,W,i,cache):
if i == N or W <= 0:
return 0
if cache[i][W] != 0:
return cache[i][W]
op1,op2 = 0,0
if weight[i] <= W:
op1 = value[i] + knapsack(weight,value,N,W-weight[i],i+1,cache)
op2 = knapsack(weight,value,N,W,i+1,cache)
cache[i][W] = max(op1,op2)
return cache[i][W]
N,W = list(map(int,input().split()))
weight = []
value = []
for i in range(N):
w,v = list(map(int,input().split()))
weight.append(w)
value.append(v)
cache = [[0 for i in range(W+1)] for j in range(N+1)]
print((knapsack(weight,value,N,W,0,cache))) | N,W = list(map(int,input().split()))
weight = []
value = []
for i in range(N):
w,v = list(map(int,input().split()))
weight.append(w)
value.append(v)
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(1,N+1):
for j in range(1,W+1):
op1,op2 = 0,0
if weight[i-1] <= j:
op1 = value[i-1] + dp[i-1][j-weight[i-1]]
op2 = dp[i-1][j]
dp[i][j] = max(op1,op2)
print((dp[N][W])) | p03163 |
def solve():
max_weight, list_of_weight_and_value = read()
result = think(max_weight, list_of_weight_and_value)
write(result)
def read():
n, max_weight = read_int(2)
list_of_weight_and_value = []
for i in range(n):
list_of_weight_and_value.append(read_int(2))
return max_weight, list_of_weight_and_value
def read_int(n):
return list([int(x) for x in read_line().split(' ')])[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(max_weight, list_of_weight_and_value):
MAX_WEIGHT = 10 ** 5
MAX_N = 100
INVALID_VALUE = MAX_WEIGHT * MAX_N + 1
# dp[w] means max value at total weight 'w'
dp = [INVALID_VALUE for x in range(max_weight + len(list_of_weight_and_value) + 1)]
dp[0] = 0
for weight, value in list_of_weight_and_value:
for i in range(len(dp) - 1, -1, -1):
if dp[i] != INVALID_VALUE and i + weight < len(dp):
if dp[i + weight] == INVALID_VALUE:
dp[i + weight] = dp[i] + value
else:
dp[i + weight] = max(dp[i + weight], dp[i] + value)
return max([x for x in dp[:max_weight + 1] if x != INVALID_VALUE])
def write(result):
print(result)
if __name__ == '__main__':
solve() | def solve():
max_weight, list_of_weight_and_value = read()
result = think(max_weight, list_of_weight_and_value)
write(result)
def read():
n, max_weight = read_int(2)
list_of_weight_and_value = []
for i in range(n):
list_of_weight_and_value.append(read_int(2))
return max_weight, list_of_weight_and_value
def read_int(n):
return list([int(x) for x in read_line().split(' ')])[:n]
def read_line(n=0):
if n == 0:
return input().rstrip()
else:
return input().rstrip()[:n]
def think(max_weight, list_of_weight_and_value):
MAX_WEIGHT = 10 ** 5
MAX_N = 100
INVALID_VALUE = -1
# dp[w] means max value at total weight 'w'
dp = [INVALID_VALUE for x in range(max_weight + len(list_of_weight_and_value) + 1)]
dp[0] = 0
for weight, value in list_of_weight_and_value:
for i in range(len(dp) - 1, -1, -1):
if dp[i] != INVALID_VALUE and i + weight < len(dp):
if dp[i + weight] == INVALID_VALUE:
dp[i + weight] = dp[i] + value
else:
dp[i + weight] = max(dp[i + weight], dp[i] + value)
return max([x for x in dp[:max_weight + 1] if x != INVALID_VALUE])
def write(result):
print(result)
if __name__ == '__main__':
solve() | p03163 |
n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*(w+1) for _ in range(n+1)]
#dpテーブル
def rec(i,j):#再帰 i:何個目の商品を見てるか j:残りのナップサックの容量
if dp[i][j] != 0:#メモされてればそれを返す
return dp[i][j]
res = 0
if i == n:#すべての商品を調べ終えた
return res
else:
if j - l[i][0] < 0:#容量が足りない
ans = rec(i+1,j)
else:
#品物を入れるときと入れないとき両方調べる
ans = max(rec(i+1,j),rec(i+1,j-l[i][0]) + l[i][1])
dp[i][j] = ans#メモして返す
return dp[i][j]
print((rec(0,w))) | n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*(w+1) for _ in range(n+1)]
#dp:=i番目以降の商品から重さの総和がj以下となるように選んだ時の価値の総和の最大
#初期条件 dpｗｐ0で作ってるのでいらない
for j in range(w):dp[n][j] = 0
#漸化式
#dp[i][j] = dp[i+1][j] (j < w[i])
# max(dp[i+1][j] , dp[i+1][j-w[i]]+v[i]) (otherwise)
for i in reversed(list(range(n))):
for j in range(w+1):
if j < l[i][0]:
dp[i][j] = dp[i+1][j]
else:
dp[i][j] = max(dp[i+1][j] , dp[i+1][j - l[i][0]] + l[i][1] )
print((dp[0][w])) | p03163 |
N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
# dp[i][j](j=0,1,...,W)の値が求まっている状態で、dp[i+1][j]を更新することを考える
for i in range(N):
for j in range(W+1):#重さ0からWまでチェック
if j-w[i]>=0:#入れてもOKな場合,容量と価値を足す
dp[i+1][j]=max(dp[i][j],dp[i][j-w[i]]+v[i])
else:#何も入れずに先に進む
dp[i+1][j]=dp[i][j]
print((max(dp[N])))
| N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
DP = [[0] * (W + 2) for i in range(N + 2)]
"""
DP[0][W]
DP[i][j]
i:荷物の個数
j:残り容量
"""
for i in range(N):
for j in range(W+1):
if j>=w[i]:#残り容量に余裕があるとき
DP[i+1][j]=max(DP[i][j],DP[i][j-w[i]]+v[i])
else:
DP[i+1][j]=DP[i][j]
print((max(DP[N]))) | p03163 |
N,W = [int(i) for i in input().split()]
w = [] # limit weight to knapsack capacity
v = [] # maximize value
for i in range(N):
line = input().split()
w.append(int(line[0]))
v.append(int(line[1]))
mem = [[0]*(W+1) for i in range(N)]
for i in range(w[0], W+1):
mem[0][i] = v[0]
for i in range(1, N):
for j in range(1, W+1):
if w[i] > j:
mem[i][j] = mem[i-1][j]
else:
mem[i][j] = max(mem[i-1][j], v[i] + mem[i-1][j - w[i]])
#print(mem)
print(("%s" % mem[N-1][W])) | N,W = [int(i) for i in input().split()]
dp = [0 for i in range(W+1)] # dp[i] is the the max value you have achieve with weight i
for i in range(N):
w,value = [int(i) for i in input().split()]
for weight in range(W-w, -1, -1): # range of kanpsack weight in which i can push the current item
dp[weight + w] = max(dp[weight + w], dp[weight] + value)
print(("%s" % dp[W])) | p03163 |
def p_d():
N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j - w >= 0:
dp[i][j] = max(v + dp[i - 1][j - w], dp[i][j], dp[i - 1][j])
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j])
print((max(dp[N])))
if __name__ == '__main__':
p_d()
| def p_d():
N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j - w >= 0:
dp[i][j] = max(v + dp[i - 1][j - w], dp[i - 1][j])
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j])
print((max(dp[N])))
if __name__ == '__main__':
p_d()
| p03163 |
def p_d():
N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j - w >= 0:
dp[i][j] = max(v + dp[i - 1][j - w], dp[i - 1][j])
else:
dp[i][j] = max(dp[i - 1][j], dp[i][j])
print((max(dp[N])))
if __name__ == '__main__':
p_d()
| def p_e():
"""
ナップサック問題（制約厳しい版）
"""
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
NEXT = [0] * (W + 1)
for j in range(1, W + 1):
if j - w >= 0:
NEXT[j] = max(v + dp[j - w], dp[j])
else:
NEXT[j] = dp[j]
dp = NEXT
print((max(NEXT)))
if __name__ == '__main__':
p_e()
| p03163 |
import sys
input = sys.stdin.readline
N, W = list(map(int, input().split()))
#x = [tuple(map(int, input().split())) for _ in range(N)]
x = [None] * N
for i in range(N):
x[i] = tuple(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i, (w, v) in enumerate(x, 1):
dpi = dp[i]
dpim = dp[i-1]
for j in range(1, W + 1):
if w <= j:
a = dpim[j - w] + v
if a > dpim[j]:
dpi[j] = a
else:
dpi[j] = dpim[j]
else:
dpi[j] = dpim[j]
print((dp[-1][W])) | #!/usr/bin/env python3
#import
#import math
#import numpy as np
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [0] * (W + 1)
for w, v in wv:
for i in range(W, 0, -1):
if i - w < 0:
break
dp[i] = max(dp[i], dp[i - w] + v)
print((dp[W]))
| p03163 |
def main():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[0] = 0
ws = []
ps = []
for _ in range(N):
w, v = list(map(int, input().split()))
ws.append(w)
ps.append(v)
for i in range(len(ws)):
for j in range(W - ws[i], -1, -1):
dpi = dp[j]
if dpi != -1:
if dp[j + ws[i]] < dpi + ps[i]:
dp[j + ws[i]] = dpi + ps[i]
print((max(dp)))
main() | def dynamicprogramming():
N, W = list(map(int, input().split()))
dp = [-1] * (W + 1)
dp[0] = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for i in range(W - w, -1, -1):
dpi = dp[i]
if dpi != -1:
if dp[i + w] < dpi + v:
dp[i + w] = dpi + v
print((max(dp)))
dynamicprogramming() | p03163 |
# -*- coding: utf-8 -*-
"""
D - Knapsack 1
https://atcoder.jp/contests/dp/tasks/dp_d
"""
import sys
def solve(N, W, items):
ans = {0: 0}
for w, v in items:
u = dict()
for x, y in list(ans.items()):
if x+w <= W and ans.get(x+w, 0) < y+v:
u[x+w] = y+v
ans.update(u)
return max([v for v in list(ans.values())])
def main(args):
N, W = list(map(int, input().split()))
items = [[int(i) for i in input().split()] for _ in range(N)]
ans = solve(N, W, items)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:]) | # -*- coding: utf-8 -*-
"""
D - Knapsack 1
https://atcoder.jp/contests/dp/tasks/dp_d
"""
import sys
def solve(N, W, items):
dp = [0-1] * (W+1)
dp[0] = 0
for w, v in items:
for i in range(W, w-1, -1):
if dp[i-w] != -1:
dp[i] = max(dp[i], dp[i-w]+v)
return max(dp)
def main(args):
N, W = list(map(int, input().split()))
items = [[int(i) for i in input().split()] for _ in range(N)]
ans = solve(N, W, items)
print(ans)
if __name__ == '__main__':
main(sys.argv[1:]) | p03163 |
N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if j - w[i] >= 0:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - w[i]] + v[i])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
print((dp[N][W]))
# print(dp)
| N, W = list(map(int, input().split()))
w, v = [0] * N, [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if j - w[i] >= 0:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - w[i]] + v[i])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
print((dp[N][W]))
| p03163 |
n, w = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(n)]
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
if j-w_v[i][0] >= 0:
dp[i+1][j] = max(dp[i+1][j], dp[i][j-w_v[i][0]] + w_v[i][1])
print((dp[n][w]))
| n, w = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(n)]
#import numpy as np
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
dp[i+1][j] = max(dp[i][j], dp[i+1][j])
if j-w_v[i][0] >= 0:
dp[i+1][j] = max(dp[i+1][j], dp[i][j-w_v[i][0]] + w_v[i][1])
print((dp[n][w]))
| p03163 |
def main():
n, w = list(map(int, input().split()))
weight = [0 for _ in range(110)]
value = [0 for _ in range(110)]
for i in range(n):
x, y = list(map(int, input().split()))
weight[i] = x
value[i] = y
dp = [[0 for _ in range(110000)] for i in range(110)]
for i in range(n):
for sum_w in range(w+1):
if sum_w - weight[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w - weight[i]] + value[i])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[n][w]))
main()
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main():
N, W = list(map(int, readline().split()))
INF = int(1e5)+100
weight = [0 for _ in range(110)]
value = [0 for _ in range(110)]
for i in range(N):
w, v = list(map(int, readline().split()))
weight[i] = w
value[i] = v
dp = [[0 for _ in range(INF)] for _ in range(110)]
for i in range(N):
for sum_w in range(W+1):
if sum_w - weight[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w-weight[i]] + value[i])
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
print((dp[N][W]))
if __name__ == '__main__':
main()
| p03163 |
def inpl(): return list(map(int, input().split()))
N, L = inpl()
DP = [0]*(L+1)
for i in range(N):
DP2 = [0]*(L+1)
w, v = inpl()
for i in range(w):
DP2[i] = DP[i]
for j in range(L-w+1):
DP2[j+w] = max(DP[j] + v, DP2[j+w-1], DP[j+w])
DP = DP2
print((DP2[-1])) | def inpl(): return list(map(int, input().split()))
N, W = inpl()
DP = [0]*(W+1)
for _ in range(N):
DP2 = [0]*(W+1)
w, v = inpl()
for i in range(w):
DP2[i] = DP[i]
for i in range(w, W+1):
DP2[i] = max(DP[i], DP[i-w]+v)
DP = DP2
print((DP[-1]))
| p03163 |
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
#品物は0～N-1と考えるので注意！
DP = [[-1]*(W+1) for _ in range(N-1)] #0~N-2
#DP[depth:0~N-1][0~W] calc()の結果をメモる
#DP[N-1][]については、W-pwsum>=N-1の重さならN-1の重さ
##W-pwsum<N-1の重さ なら 0
##→W-(N-1)>=pwsumとW-(N-1)<pwsumで場合分け
DP.append([0]*(W+1))
tmppwsum = 0
weiofMinus1, valofNminus1 = wv[N-1]
while W-weiofMinus1>=tmppwsum:
DP[N-1][tmppwsum] = valofNminus1
tmppwsum += 1
#合計pwsumの重さを入れた状態で、
#depth以降の品物を選ぶ場合の最大価値を返す関数
def calc(depth, pwsum):
#メモ済みだったらメモした値を返す
dp = DP[depth][pwsum]
if dp != -1: return dp
nowWei, nowVal = wv[depth] #今選んでる品物のこと
if pwsum + nowWei > W:
#入れると重さ超過なので、入れずに次を考える
# if depth >= N-1:
# #今の品物が最後なら、以降得られる価値は0
# DP[depth][pwsum] = 0
# return 0
# else:
#次の品物が無い場合はDPで省かれている
#次の品物がある場合、今のを入れずに次へいく
irenai = calc(depth+1, pwsum)
DP[depth][pwsum] = irenai
return irenai
if pwsum + nowWei <= W:
#入れても大丈夫な場合
# if depth >= N-1:
# #今の品物が最後なら、今の品物しか入れられない
# DP[depth][pwsum] = nowVal
# return nowVal
#次の品物が無い場合はDPで省かれている
#次の品物がある場合、今のを入れる入れないの2択
ireru = nowVal + calc(depth+1, pwsum+nowWei)
irenai = calc(depth+1, pwsum)
ans = max(ireru, irenai)
DP[depth][pwsum] = ans
return ans
print((calc(0, 0))) | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
#品物は0～N-1と考えるので注意！
DP = [0]*(W+1) #0~W
#各iにつき、残り重さがWの時の最大価値をDPに入れる
#i=N-1までいった時のmax(DP)が答え
for i in range(0, N, 1): #0~N-1
w, v = wv[i]
#残りwei(W-DPの2個目の添字)がw未満の場合入れられない
#入れない場合は変えなければいい
for nw in range(W, w-1, -1):
iretaV = DP[nw-w] + v
if iretaV > DP[nw]:
DP[nw] = iretaV
print((max(DP))) | p03163 |
N,Wmax=list(map(int,input().split(' ')))
info=[ list(map(int,input().split(' '))) for i in range(N) ]
W = [ info[i][0] for i in range(N) ]
V = [ info[i][1] for i in range(N) ]
#dp[i][j]=i番目の品物までだけを選び重量制限をjとしたときの価値の最大値
dp = []
for i in range(N):
if i==0:
#重量制限がW[0]以上なら荷物を積むのが最善
dp.append([ V[0] if W[0]<=w else 0 for w in range(Wmax+1) ])
else:
#今回の重量制限をwとする
#今回は荷物を積む場合: dp[i][w] = dp[i-1][w-w[i]]+v[i]
#今回は荷物を積まない場合: dp[i][w] = dp[i-1][w]
#よってこの2つのうち大きいほうをdp[i][w]に採用する
l = []
for w in range(Wmax+1):
val1 = (dp[i-1][w-W[i]]+V[i]) if w-W[i]>=0 else 0
val2 = dp[i-1][w]
l.append(max(val1,val2))
dp.append(l)
print((dp[N-1][Wmax])) | N,Wmax=list(map(int,input().split(' ')))
W=[]
V=[]
for _ in range(N):
w,v = list(map(int,input().split(' ')))
W.append(w)
V.append(v)
#dp[i][j]=i番目の品物までだけを選び重量制限をjとしたときの価値の最大値
dp = []
dp.append([0]*min(W[0],Wmax+1)+ [V[0]]*max(0, Wmax+1-W[0]))
for i in range(1,N):
#今回の重量制限をwとする
#今回は荷物を積む場合: dp[i][w] = dp[i-1][w-w[i]]+v[i]
#今回は荷物を積まない場合: dp[i][w] = dp[i-1][w]
#よってこの2つのうち大きいほうをdp[i][w]に採用する
dpi = []
for j in range(Wmax+1):
if j<W[i]:
dpi.append(dp[i-1][j])
else:
dpi.append(max(dp[i-1][j], dp[i-1][j-W[i]]+V[i]))
dp.append(dpi)
print((dp[N-1][Wmax])) | p03163 |
n,k = list(map(int,input().split()))
w=[]
v=[]
dp =[[0 for i in range(k+1)] for j in range(n+1)]
for i in range(n):
a,b = list(map(int,input().split()))
w.append(a)
v.append(b)
for i in range(n):
for sum_w in range(k+1):
if sum_w - w[i] >=0:
dp[i+1][sum_w]=max(dp[i][sum_w],dp[i][sum_w - w[i]] + v[i])
else:
dp[i+1][sum_w]=dp[i][sum_w]
print((dp[-1][-1])) | N, W = list(map(int, input().split()))
a = []
for i in range(N):
x,y = list(map(int,input().split()))
a.append([x,y])
dp = [0]*(W+1)
max_weight = 0
for w, v in a:
max_w = min(max_weight, W-w)
for old_v, from_i in zip(dp[max_w::-1], list(range(max_w, -1, -1))):
if dp[from_i+w] < old_v + v:
dp[from_i+w] = old_v + v
max_weight = min(max_weight+w, W)
print((max(dp)))
| p03163 |
N,W = list(map(int,input().split()))
dp = [0]*(W+1)
L = []
for i in range(N):
tb,ta = list(map(int,input().split()))
L.append([ta,tb])
for i in range(N):
for w in range(W,-1,-1):
if w-L[i][1]>=0 :dp[w] = max(dp[w],dp[w-L[i][1]]+L[i][0])
print((dp[-1])) | N,W = list(map(int,input().split()))
dp = [0]*(W+1)
L = []
for i in range(N):
ta,tb = list(map(int,input().split()))
L.append([tb,ta])
for i in range(N):
for w in range(W,-1,-1):
if w-L[i][1]>=0 :dp[w] = max(dp[w],dp[w-L[i][1]]+L[i][0])
print((dp[-1])) | p03163 |
# N, W = 3, 8
# ARR = [
# [3, 30],
# [4, 50],
# [5, 60],
# ]
# #
# N, W, = 6, 15
# ARR = [
# [6, 5],
# [5, 6],
# [6, 4],
# [6, 6],
# [3, 5],
# [7, 2],
# ]
N,W = list(map(int,input().split()))
ARR = []
for i in range(N):
ARR.append(list(map(int,input().split())))
def calculate(n, w, arr):
srr = [[0] * (w+1) for i in range(n+1)]
for i in range(1, n + 1):
for j in range(1, w + 1):
if j - arr[i-1][0] >= 0:
s1 = srr[i - 1][j]
s2 = srr[i - 1][j - arr[i-1][0]] + arr[i-1][1]
srr[i][j] = max(s1, s2)
else:
srr[i][j] = srr[i - 1][j]
print((srr[-1][-1]))
calculate(N, W, ARR)
| # N, W = 3, 8
# ARR = [
# [3, 30],
# [4, 50],
# [5, 60],
# ]
# #
N, W, = 6, 15
ARR = [
[6, 5],
[5, 6],
[6, 4],
[6, 6],
[3, 5],
[7, 2],
]
N,W = list(map(int,input().split()))
ARR = []
for i in range(N):
ARR.append(list(map(int,input().split())))
def calculate(n, w, arr):
srr = [[0] * (w+1) for i in range(n+1)]
for i in range(1, n + 1):
for j in range(1, w + 1):
if j - arr[i - 1][0] >= 0:
s1 = srr[i - 1][j]
s2 = srr[i - 1][j - arr[i - 1][0]] + arr[i - 1][1]
srr[i][j] = max(s1, s2)
else:
srr[i][j] = srr[i-1][j]
print((srr[-1][-1]))
calculate(N, W, ARR)
| p03163 |
n, w = list(map(int, input().split()))
g = []
for i in range(n):
g.append(list(map(int, input().split())))
m = [[0 for j in range(w+1)]for i in range(n+1)]
for i in range(n+1):
for j in range(w+1):
if j-g[i-1][0] < 0:
m[i][j] = m[i-1][j]
else:
m[i][j] = max(m[i-1][j], m[i-1][j-g[i-1][0]]+g[i-1][1])
print((m[n][w])) | n, w = list(map(int, input().split()))
g = []
for i in range(n):
g.append(list(map(int, input().split())))
m = [[0 for j in range(w+1)]for i in range(n+1)]
for i in range(n):
for j in range(w+1):
if j-g[i][0] < 0:
m[i+1][j] = m[i][j]
else:
m[i+1][j] = max(m[i][j], m[i][j-g[i][0]]+g[i][1])
print((m[n][w])) | p03163 |
def f(i,w,d):
if i==n:
return 0
if (i,w) not in d:
if a[i][0]>w:
d[i,w]=f(i+1,w,d)
else:
d[i,w]=max(f(i+1,w,d),f(i+1,w-a[i][0],d)+a[i][1])
return d[i,w]
n,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
print(f(0,w,{})) | n,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
z=[[0]*(w+1)]
for i in range(n):
z.append(z[-1][:])
for j in range(w+1):
if a[i][0]<=j:
z[i+1][j]=max(z[i+1][j],z[i][j-a[i][0]]+a[i][1])
print(max(z[-1]))
| p03163 |
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(W):
w = wv[i - 1][0]
v = wv[i - 1][1]
if j + w <= W:
dp[i][j + w] = max(dp[i][j + w], dp[i - 1][j] + v)
dp[i][j] = max(dp[i][j], dp[i - 1][j])
else:
dp[i][j] = max(dp[i][j], dp[i - 1][j])
print((max(dp[-1]))) | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(W):
w = wv[i - 1][0]
v = wv[i - 1][1]
if j + w <= W:
dp[i][j + w] = max(dp[i][j + w], dp[i - 1][j] + v)
dp[i][j] = max(dp[i][j], dp[i - 1][j])
print((max(dp[-1]))) | p03163 |
N, W = list(map(int, input().split()))
wv = [tuple(map(int, input().split()))for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(1, N+1):
for j in range(1, W+1):
if 0 <= j-wv[i-1][0]:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-wv[i-1][0]]+wv[i-1][1])
dp[i][j] = max(dp[i-1][j], dp[i][j])
print((dp[-1][-1])) | n, w = list(map(int, input().split()))
weights, values = list(zip(*[tuple(map(int, input().split()))for _ in range(n)]))
dp = [0]*(w+1)
for i in range(1, n+1):
for j in reversed(list(range(1, w+1))):
if j-weights[i-1] < 0:
continue
dp[j] = max(dp[j], dp[j-weights[i-1]]+values[i-1])
print((dp[-1])) | p03163 |
N, W = list(map(int, input().split()))
A = []
V = []
for i in range(N):
a, v = list(map(int, input().split()))
A.append(a)
V.append(v)
dp = [[0] * (W+1)]
for i in range(N)[::-1]:
a = []
for w in range(W+1):
if A[i] > w:
a.append(dp[-1][w])
else:
a.append(
dp[-1][w]
if dp[-1][w] > dp[-1][w-A[i]] + V[i]
else dp[-1][w-A[i]] + V[i]
)
dp.append(a)
print((dp[-1][W])) | N, W = list(map(int, input().split()))
A = []
V = []
for i in range(N):
a, v = list(map(int, input().split()))
A.append(a)
V.append(v)
dp = [0] * (W+1)
for i in range(N)[::-1]:
a = dp[:]
for w in range(W+1):
if A[i] <= w and a[w] < dp[w-A[i]] + V[i]:
a[w] = dp[w-A[i]] + V[i]
dp = a
print((dp[W])) | p03163 |
def solve(N, W, weight_values):
dp = [0 for _ in range(W + 1)]
for i in range(N):
wi, vi = weight_values[i]
for w in range(W, wi - 1, -1):
dp[w] = max(dp[w], vi + dp[w - wi])
print((dp[W]))
def iln():
return list(map(int, input().split()))
N, W = iln()
w_v = []
for i in range(N):
w_v.append(iln())
solve(N, W, w_v) |
N,W=list(map(int,input().split()))
dp=[0]*(W+1)
L = sorted([list(map(int,input().split())) for i in range(N)])
s=0
for w, v in L:
s+=w
for j in range(min(W,s),w-1,-1):
if dp[j-w]+v > dp[j]: dp[j]=dp[j-w]+v
print((max(dp))) | p03163 |
N,W=list(map(int,input().split()))
dp=[0]*(W+1)
L = sorted([list(map(int,input().split())) for i in range(N)])
s=0
for w, v in L:
s+=w
for j in range(min(W,s),w-1,-1):
if dp[j-w]+v > dp[j]: dp[j]=dp[j-w]+v
print((max(dp))) | def solve(N, W, weightValues):
dp = [0] * (W + 1)
s = 0
for w, v in weightValues:
s += w
for j in range(min(W, s), w - 1, -1):
if dp[j - w] + v > dp[j]:
dp[j] = dp[j - w] + v
print((max(dp)))
N, W = list(map(int, input().split()))
weightValues = sorted([list(map(int, input().split())) for i in range(N)])
solve(N, W, weightValues) | p03163 |
def solve(N, W, weight_values):
dp = [0 for _ in range(W + 1)]
for i in range(N):
wi, vi = weight_values[i]
for w in range(W, wi - 1, -1): # loop from W down to wi
if dp[w - wi] + vi > dp[w]:
dp[w] = dp[w - wi] + vi
print((dp[W]))
def iln(): return list(map(int, input().split()))
N, W = iln()
w_v = []
for i in range(N):
w_v.append(iln())
solve(N, W, w_v) | def solve(N, W, weightValues):
dp = [0] * (W + 1)
s = 0
for w, v in weightValues:
s += w # why ?
for i in range(min(W, s), w - 1, -1): # why min(W, s)
if dp[i - w] + v > dp[i]:
dp[i] = dp[i - w] + v
print((max(dp)))
def iln(): return list(map(int, input().split()))
N, W = iln()
w_v = []
for i in range(N):
w_v.append(iln())
solve(N, W, w_v) | p03163 |
n,max_w = list(map(int,input().split()))
w=[]
v=[]
for i in range(n):
tmp_w,tmp_v = list(map(int,input().split()))
w.append(tmp_w)
v.append(tmp_v)
dp =[[-1]*(max_w+1) for i in range(n+1)]
#i番目以降の品物から、重さの総和がj以下となるように選ぶ
def knapsac(i,j):
if dp[i][j]>=0:
return dp[i][j]
if i == n:
#品物は残っていない
dp[i][j] = 0
elif j < w[i]:
#品物が入らない
dp[i][j] = knapsac(i+1,j)
else:
#品物が入る→品物を入れる場合と入れない場合を両方試す
dp[i][j] = max(knapsac(i+1,j),knapsac(i+1,j-w[i])+v[i])
return dp[i][j]
print((knapsac(0,max_w))) | n,w = list(map(int,input().split()))
info = [[0,0]]+[list(map(int,input().split())) for i in range(n)]
## dp[i][j]:i番目までのアイテムを重さjのナップサックに詰めるときの最大価値
dp = [[0]*(w+1) for i in range(n+1)]
for i in range(n+1):
for j in range(w+1):
if j-info[i][0]>=0:
dp[i][j] = max(dp[i-1][j],dp[i-1][j-info[i][0]]+info[i][1])
else:
dp[i][j] = dp[i-1][j]
print((dp[n][w]))
| p03163 |
# coding: utf-8
# Your code here!
N,W=list(map(int,input().split()))
l=[-1]*(W+1)
l[0]=0
dp=l[:]
for i in range(N):
w,v=list(map(int,input().split()))
for index,item in enumerate(l):
if item!=-1 and W>=index+w:
dp[index+w]=max(item+v,l[index+w])
l=dp[:]
print((max(l)))
| # coding: utf-8
# Your code here!
N,W=list(map(int,input().split()))
jwels=[]
for _ in range(N):
jwels.append(list(map(int,input().split())))
dp=[-1]*(W+1)
dp[0]=0
for w,v in jwels:
for i in range(W+1)[::-1]:
if dp[i]!=-1 and i+w<=W:
dp[i+w]=max(dp[i]+v,dp[i+w])
print((max(dp)))
| p03163 |
# coding: utf-8
# Your code here!
N,W=list(map(int,input().split()))
jwels=[]
for _ in range(N):
jwels.append(list(map(int,input().split())))
dp=[-1]*(W+1)
dp[0]=0
for w,v in jwels:
for i in range(W+1)[::-1]:
if dp[i]!=-1 and i+w<=W:
dp[i+w]=max(dp[i]+v,dp[i+w])
print((max(dp)))
| # coding: utf-8
# Your code here!
N,W=list(map(int,input().split()))
dp=[-1]*(W+1)
dp[0]=0
for _ in range(N):
w,v=list(map(int,input().split()))
for i in range(W+1)[::-1]:
if dp[i]!=-1 and i+w<=W:
dp[i+w]=max(dp[i+w],dp[i]+v)
print((max(dp))) | p03163 |
a = list(map(int, input().split()))
b = [list(map(int, input().split())) for i in range(a[0])]
result = []
max_weight = a[1]
def calc(i, queue):
if len(b) <= i:
return
current = b[i]
prev = queue[-1] if 0 < len(queue) else [0, 0]
if current[0] + prev[0] <= max_weight:
result.append(prev[1] + current[1])
next_queue = queue[:]
next_queue.append([prev[0] + current[0], prev[1] + current[1]])
calc(i + 1, next_queue)
calc(i + 1, queue)
calc(0, [])
print((max(result))) | a = list(map(int, input().split()))
b = [list(map(int, input().split())) for i in range(a[0])]
max_index = a[0]
max_weight = a[1]
dp = [ [0] * (max_weight + 1) for j in range(max_index + 1)]
def solve():
for i in range(max_index - 1, -1, -1):
for j in range(max_weight + 1):
if (j < b[i][0]):
dp[i][j] = dp[i + 1][j]
else:
dp[i][j] = max([dp[i + 1][j], dp[i + 1][j - b[i][0]] + b[i][1]])
print((dp[0][max_weight]))
solve() | p03163 |
N,W = [int(v) for v in input().split()]
items = [[int(v) for v in input().split()] for _ in range(N)]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(1,N+1):
w,v = items[i-1]
for cap in range(W+1):
if cap - w >= 0:
dp[i][cap] = max(dp[i][cap],dp[i-1][cap-w]+v)
dp[i][cap] = max(dp[i][cap],dp[i-1][cap])
print((dp[-1][-1]))
| N,W = [int(v) for v in input().split()]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(1,N+1):
w,v = [int(v) for v in input().split()]
for cap in range(W+1):
if cap - w >= 0:
dp[i][cap] = max(dp[i][cap],dp[i-1][cap-w]+v)
dp[i][cap] = max(dp[i][cap],dp[i-1][cap])
print((dp[-1][-1]))
| p03163 |
def opt(N,W):
dp=[0]*(W+1)
for _ in range(N):
w,v=list(map(int,input().split()))
for i in range(W,w-1,-1):
dp[i]=max(dp[i],dp[i-w]+v)
print((dp[W]))
N,W=list(map(int,input().split()))
opt(N,W) | def opt(N,W):
dp=[0]*(W+1)
for _ in range(N):
w,v=list(map(int,input().split()))
for i in range(W,w-1,-1):
tmp=dp[i-w]+v
if tmp>dp[i]:
dp[i]=tmp
print((dp[W]))
N,W=list(map(int,input().split()))
opt(N,W)
| p03163 |
import sys
sys.setrecursionlimit(10000)
from functools import lru_cache
def resolve():
N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)] # [N][0:weight, 1:value]
dp = [[-1] * (W+1) for _ in range(N+1)]
#print(dp)
@lru_cache(maxsize=None)
def dfs(w, i):
if dp[i][w] >= 0:
return dp[i][w]
if i >= N:
res = 0
elif w < w_v[i][0]:
res = dfs(w, i+1)
else:
res = max(dfs(w - w_v[i][0], i+1) + w_v[i][1], dfs(w, i+1))
dp[i][w] = res
return res
res = dfs(W, 0)
print(res)
if __name__ == "__main__":
resolve() | def resolve():
N, W = list(map(int, input().split()))
w_v = [list(map(int, input().split())) for _ in range(N)] # [N][0:weight, 1:value]
dp = [[0] * (W+1) for _ in range(N+1)]
for i in range(N-1,-1,-1):
for j in range(W+1):
w = w_v[i][0]
v = w_v[i][1]
if j < w_v[i][0]:
dp[i][j] = dp[i+1][j]
else:
dp[i][j] = max(dp[i+1][j], dp[i+1][j - w] + v)
print((dp[0][W]))
if __name__ == "__main__":
resolve() | p03163 |
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 16 19:31:10 2019
Knapsack1
@author: maezawa
"""
n, w = list(map(int, input().split()))
warr = [0]*(n+1)
varr = [0]*(n+1)
for i in range(n):
wi, vi = list(map(int, input().split()))
warr[i+1] = wi
varr[i+1] = vi
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(1,n+1):
for j in range(1,w+1):
jw = j-warr[i]
if jw <0:
continue
dp[i][j] = max([dp[k][jw] + varr[i] for k in range(i)])
dp[i][j] = max(dp[i][j], dp[i-1][j])
print((dp[n][w])) |
n, w = list(map(int, input().split()))
warr = [0]*(n+1)
varr = [0]*(n+1)
for i in range(n):
wi, vi = list(map(int, input().split()))
warr[i+1] = wi
varr[i+1] = vi
dp = [[0]*(w+1) for _ in range(n+1)]
for i in range(1,n+1):
for j in range(1,w+1):
jw = j-warr[i]
if jw <0:
dp[i][j] = dp[i-1][j]
continue
dp[i][j] = max(dp[i-1][jw] + varr[i], dp[i-1][j])
print((dp[n][w])) | p03163 |
import sys
sys.setrecursionlimit(1000000) # 再帰上限を増やす
def main():
input = sys.stdin.readline # 文字列に対してinputした場合は、rstripするのを忘れずに！
N, W = list(map(int, input().rstrip().split()))
item_list = []
for _ in range(N):
w, v = list(map(int, input().rstrip().split()))
item_list.append((w, v))
# dp[i][w] = i番目まで見て重さwで持ち帰れる最大の価値
dp = [[0] * (W + 1) for _ in range(N)]
for i, item in enumerate(item_list):
for w in range(W+1):
# もし品物iが入れられる
if w + item[0] <= W:
dp[i][w+item[0]] = max(dp[i][w+item[0]], dp[i-1][w]+item[1])
# 入れないパターン
dp[i][w] = max(dp[i][w], dp[i-1][w])
print((dp[N-1][W]))
if __name__ == '__main__':
main() | import sys
sys.setrecursionlimit(1000000) # 再帰上限を増やす
def main():
input = sys.stdin.readline # 文字列に対してinputした場合は、rstripするのを忘れずに！
N, W = list(map(int, input().rstrip().split()))
item_list = []
for _ in range(N):
w, v = list(map(int, input().rstrip().split()))
item_list.append((w, v))
# dp[i][w] = i番目まで見て重さwで持ち帰れる最大の価値
dp = [[0] * (W + 1) for _ in range(N+1)]
for i, item in enumerate(item_list, 1):
for w in range(W+1):
# もし品物iが入れられる
if w + item[0] <= W:
dp[i][w+item[0]] = max(dp[i][w+item[0]], dp[i-1][w]+item[1])
# 入れないパターン
dp[i][w] = max(dp[i][w], dp[i-1][w])
print((dp[N][W]))
if __name__ == '__main__':
main() | p03163 |
N,W = list(map(int,input().split()))
lis = [[[0,0]]]
for i in range(N):
w,v = list(map(int,input().split()))
new = []
for j in lis[i]:
if j[0] + w <= W:
new.append([j[0] + w , j[1] + v])
new.append([j[0] ,j[1]])
lis.append(new)
ans = 0
for i in lis[-1]:
ans = max( ans , i[1] )
print (ans)
|
N,W = list(map(int,input().split()))
lis = [ [0] * (W+1) ]
for i in range(N):
w,v = list(map(int,input().split()))
new = [0] * (W+1)
for j in range(W+1):
new[j] = max(new[j],lis[-1][j])
if j+w <= W:
new[j+w] = max(new[j+w],lis[-1][j]+v)
lis.append(new)
print((lis[-1][W]))
| p03163 |
N, W = list(map(int, input().split()))
w = [0] * N
v = [0] * N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
def chmax(a, b):
if a >= b:
return a
else:
return b
dp = [[0]*(10**5 + 10) for _ in range(110)]
#i個の品物を入れて重さがjになっているときの価値の総和の最大値
#dp[i+1][j] = dp[i][j - w[i] + v[i]] 入れるとき
#dp[i+1][j] = dp[i][j] 入れないとき
#dp[0][j] = 0 初期値設定でOK
for i in range(N+1):
for j in range(W+1):
dp[i+1][j] = chmax(dp[i+1][j], dp[i][j])
if (i < N):
if (j >= w[i]):
dp[i+1][j] = chmax(dp[i+1][j], dp[i][j - w[i]] + v[i])
print((dp[N][W])) | N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)] #1-index
def chmax(a,b):
if a >= b:
return a
else:
return b
# dp[i+1][w]: i番目までの品物を選びその重さがwを超えないときの最大価値
dp = [[0]*(W+10) for _ in range(N+10)]
for i in range(N):
for w in range(W+1):
dp[i+1][w] = dp[i][w]
if w - wv[i][0] >= 0:
dp[i+1][w] = chmax(dp[i][w - wv[i][0]] + wv[i][1], dp[i][w])
print((dp[N][W])) | p03163 |
import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
wv = [[int(i) for i in input().split()] for j in range(N)]
def ans(N, W, wv):
d = [[0] * (W+1) for i in range(N+1)]
for i in range(N):
for j in range(W+1):
if wv[i][0] > j:
d[i+1][j] = d[i][j]
else:
d[i + 1][j] = max(d[i][j], d[i][j-wv[i][0]] + wv[i][1])
return d[N][W]
print((ans(N, W, wv)))
| import sys
input = sys.stdin.readline
N, W = [int(i) for i in input().split()]
def ans(N, W):
d = [0] * (W+1)
for i in range(N):
wi, vi = [int(i) for i in input().split()]
for w in range(W, wi - 1, -1):
v_ = d[w - wi] + vi
if v_ > d[w]:
d[w] = v_
return d[W]
print((ans(N, W)))
| p03163 |
N, W = [int(_) for _ in input().split()]
WV = sorted([[int(_) for _ in input().split()] for _ in range(N)],
reverse=True)
dp = {}
dp[0] = 0
for w, v in WV:
dp_o = dp.copy()
for k in dp_o:
if k + w <= W:
dp[k + w] = max(dp_o.get(k + w, 0), dp_o[k] + v)
print((max([v for k, v in list(dp.items())])))
| N, W = [int(_) for _ in input().split()]
WV = [[int(_) for _ in input().split()] for _ in range(N)]
dp = {}
dp[0] = 0
for w, v in WV:
dp_o = dp.copy()
for k in dp_o:
if k + w <= W:
dp[k + w] = max(dp_o.get(k + w, 0), dp_o[k] + v)
print((max([v for k, v in list(dp.items())])))
| p03163 |
n, w = (int(x) for x in input().split())
wv = [[0, 0]]
for _ in range(n):
wv.append([int(x) for x in input().split()])
dp = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(w + 1):
dp[0][i] = 0
for i in range(1, n + 1):
for j in range(1, w + 1):
if j - wv[i][0] >= 0:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - wv[i][0]] + wv[i][1])
else:
dp[i][j] = dp[i - 1][j]
print((dp[n][w])) | n, w = (int(x) for x in input().split())
wv = [[0, 0]]
for _ in range(n):
wv.append([int(x) for x in input().split()])
dp = [[0] * (w + 1) for _ in range(n + 1)]
for i in range(w + 1):
dp[0][i] = 0
for i in range(1, n + 1):
for j in range(0, w + 1):
if j - wv[i][0] >= 0:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - wv[i][0]] + wv[i][1])
else:
dp[i][j] = dp[i - 1][j]
print((dp[n][w])) | p03163 |
def main():
N, W = list(map(int, input().split()))
wi, vi = list(map(int, input().split()))
dp = [0] * wi + [vi] * (W + 1 - wi)
for _ in range(1, N):
wi, vi = list(map(int, input().split()))
dp[wi:] = [max(i + vi, j) for i, j in zip(dp, dp[wi:])]
print((dp[-1]))
if __name__ == '__main__':
main()
| def main():
N, W = list(map(int, input().split()))
wi, vi = list(map(int, input().split()))
dp = [0] * wi + [vi] * (W + 1 - wi)
for _ in range(1, N):
wi, vi = list(map(int, input().split()))
for i in range(W, wi - 1, -1):
t = dp[i - wi] + vi
if t > dp[i]:
dp[i] = t
print((dp[-1]))
if __name__ == '__main__':
main()
| p03163 |
n, w = list(map(int, input().split()))
arr = [list(map(int, input().split())) for _ in range(n)]
# 最大化問題なので0で初期化
dp = [[0] * (w + 1) for _ in range(n + 1)]
# 品物iを選べる場合、前の行からsum_wから品物iの重さを引いた要素を参照する
for i in range(1, n + 1):
for j in range(1, w + 1):
if j - arr[i - 1][0] >= 0:
dp[i][j] = max(dp[i][j], dp[i - 1][j - arr[i - 1][0]] + arr[i - 1][1])
else:
dp[i][j] = dp[i - 1][j]
print((max(max(dp)))) | n, w = list(map(int, input().split()))
arr = [list(map(int, input().split())) for _ in range(n)]
# 最大化問題なので0で初期化
dp = [[0] * (w + 1) for _ in range(n + 1)]
# 品物iを選ばない場合で更新してから、選べる場合は再更新
for i in range(1, n + 1):
for j in range(w + 1):
dp[i][j] = dp[i - 1][j]
if j - arr[i - 1][0] >= 0:
dp[i][j] = max(dp[i][j], dp[i - 1][j - arr[i - 1][0]] + arr[i - 1][1])
print((dp[n][w])) | p03163 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N, W = list(map(int, input().split()))
w = [0]*N
v = [0]*N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(N):
for j in range(W+1):
if w[i]<=j:
dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]]+v[i])
else:
dp[i+1][j] = dp[i][j]
print((dp[N][W]))
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N, W = list(map(int,input().split()))
wv = [tuple(map(int,input().split())) for i in range(N)]
dp = [0]*(W+1)
for i in range(N):
for j in range(W, wv[i][0]-1, -1):
dp[j] = max(dp[j], dp[j-wv[i][0]]+wv[i][1])
print((max(dp)))
if __name__ == '__main__':
main()
| p03163 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N, W = list(map(int,input().split()))
wv = [tuple(map(int,input().split())) for i in range(N)]
dp = [0]*(W+1)
for i in range(N):
for j in range(W, wv[i][0]-1, -1):
dp[j] = max(dp[j], dp[j-wv[i][0]]+wv[i][1])
print((max(dp)))
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations
#from itertools import accumulate, product
from bisect import bisect_left,bisect_right
from math import floor, ceil
#from operator import itemgetter
#mod = 1000000007
N, W = list(map(int,input().split()))
w = [0]*N
v = [0]*N
for i in range(N):
w[i], v[i] = list(map(int, input().split()))
dp = [0]*(W+1)
for i in range(N):
for j in range(W, w[i]-1, -1):
dp[j] = max(dp[j], dp[j-w[i]]+v[i])
print((max(dp)))
if __name__ == '__main__':
main() | p03163 |
N, W = list(map(int, input().split()))
X = [0] + [-1] * W
for i in range(N):
w, v = list(map(int, input().split()))
for j in range(W - w, -1, -1):
if X[j] >= 0:
X[j+w] = max(X[j+w], X[j]+v)
print((max(X))) | def MAX(a, b):
return b + (((((a + ms - b) & ms) >> (K - 1)) * tt) & (ms + a - b))
def tolist(n):
sx = bin(n)[2:] + "_"
return [int(sx[-(i+1) * K - 1:-i * K - 1], 2) for i in range((len(sx)+K-2) // K)]
K = 52
N, W = list(map(int, input().split()))
ms = int(("1" + "0" * (K - 1)) * (W + 1), 2)
tt = (1 << K - 1) - 1
one = int(("0" * (K - 1) + "1") * (W + 1), 2)
s = 1 << K - 2 + (W * K)
for _ in range(N):
w, v = list(map(int, input().split()))
s = MAX(s, (s >> w * K) + one * v)
print((max(tolist(s)) - (1 << K - 2))) | p03163 |
n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
#重さ、価値の順
dp=[[0]*(w+1) for i in range(n+1)]
#配列のインデックスを重さに対応させる
for i in range(n):
for sum_w in range(w+1):
if sum_w-l[i][0]>=0:
dp[i+1][sum_w]=max(dp[i+1][sum_w],dp[i][sum_w-l[i][0]]+l[i][1])
#l[i]を入れるとき
dp[i+1][sum_w]=max(dp[i+1][sum_w],dp[i][sum_w])
#入れない時
print((dp[-1][-1]))
| #DP-C
n,w=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(n)]
dp=[[0]*(w+1) for i in range(n+1)]
for i in range(1,n+1):
for sum_w in range(w+1):
if sum_w-l[i-1][0]>=0:
dp[i][sum_w]=max(dp[i-1][sum_w],dp[i-1][sum_w-l[i-1][0]]+l[i-1][1])
else:
dp[i][sum_w]=dp[i-1][sum_w]
print((max(dp[-1]))) | p03163 |
N,W = list(map(int,input().split()))
dp = [0 for _ in range(W+1)]
for i in range(N):
w,v = list(map(int,input().split()))
for j in range(W+1):
if j+w <= W:
dp[j] = max(dp[j],dp[j+w]+v)
print((max(dp))) | N, capW = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
def knapsack01(items, capW):
dp = [0] * (capW+1)
for wi, vi in items:
for w in reversed(list(range(wi, capW+1))):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
return max(dp)
print((knapsack01(items, capW))) | p03163 |
import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(N)]
DP = [[0] * (W+1) for _ in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if sum_w - wv[i][0] >= 0:
DP[i+1][sum_w] = max(
DP[i][sum_w - wv[i][0]] + wv[i][1],
DP[i+1][sum_w])
DP[i+1][sum_w] = max(DP[i][sum_w], DP[i+1][sum_w])
print((DP[N][W]))
if __name__ == '__main__':
main()
| import sys
def main():
_input = sys.stdin.readline
N, W = list(map(int, _input().split()))
wv = [list(map(int, _input().split())) for _ in range(N)]
wv.sort()
DP = [-1] * (W+1)
DP[0] = 0
sum_w = 0
for w, v in wv:
sum_w += w
for j in range(min(W, sum_w), w-1, -1):
if DP[j-w] == -1:
continue
if DP[j] < DP[j-w] + v:
DP[j] = DP[j-w] + v
print((max(DP)))
if __name__ == '__main__':
main()
| p03163 |
N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
weights2check = [0]
for _ in range(N):
w, v = list(map(int, input().split()))
new_weights2check = []
for k in weights2check:
if k + w <= W:
dp[k + w] = max(dp[k + w], dp[k] + v)
new_weights2check.append(k + w)
weights2check += new_weights2check
ans = max(dp[i] for i in weights2check)
print(ans) | N, W = list(map(int, input().split()))
dp = [0] * (W + 1)
weights2check = [0]
ans = 0
for _ in range(N):
w, v = list(map(int, input().split()))
for k in range(W-w, -1, -1):
dp[k + w] = max(dp[k + w], dp[k] + v)
ans = max(ans, dp[k + w])
print(ans)
| p03163 |
N,W=list(map(int,input().split()))
wv=[list(map(int,input().split())) for i in range(N)]
dp=[[0]*(W+1) for _ in range(N+1)]
for w in range(W+1):
for n in range(N):
if wv[n][0]<=w:
dp[n+1][w]+=max(wv[n][1]+dp[n][w-wv[n][0]],dp[n][w])
else:
dp[n+1][w]=dp[n][w]
print((dp[N][W])) | N, W = list(map(int, input().split()))
wv = [[int(i) for i in input().split()] for i in range(N)]
dp=[[0]*(W+1) for i in range(N+1)]
for w in range(W+1):
for n in range(N):
if wv[n][0] <= w:
dp[n+1][w] = max(dp[n][w-wv[n][0]] + wv[n][1], dp[n][w])
else:
dp[n+1][w] = dp[n][w]
print((dp[N][W])) | p03163 |
N,W=list(map(int,input().split()))
wv=[list(map(int,input().split())) for _ in range(N)]
dp=[[0]*(W+1) for _ in range(N+1)]
for w in range(W+1):
for n in range(N):
if w>=wv[n][0]:
dp[n+1][w] += max(dp[n][w-wv[n][0]]+wv[n][1], dp[n][w])
else:
dp[n+1][w]=dp[n][w]
print((dp[-1][-1]))
| N,W=list(map(int,input().split()))
w=[0]*N
v=[0]*N
for i in range(N):
w[i],v[i]=list(map(int,input().split()))
dp=[[0]*(W+1) for i in range(N+1)]
for i in range(W+1):
for g in range(N):
if i>=w[g]:
dp[g+1][i]=max(dp[g][i],v[g]+dp[g][i-w[g]])
else:
dp[g+1][i]=dp[g][i]
print((dp[N][W]))
| p03163 |
n,W=list(map(int,input().split()))
w_list=[]
v_list=[]
dp=[]
for i in range(n):
w,v=list(map(int,input().split()))
w_list.append(w)
v_list.append(v)
for i in range(n):
dp_sub=[]
for j in range(W+1):
dp_sub.append(-1)
dp.append(dp_sub)
dp_sub=[]
for j in range(W+1):
dp_sub.append(0)
dp.append(dp_sub)
for i in range(n):
i_=n-1-i
for j in range(W+1):
if w_list[i_]<=j:
dp[i_][j]=max(dp[i_+1][j],dp[i_+1][j-w_list[i_]]+v_list[i_])
else:
dp[i_][j]=dp[i_+1][j]
print((dp[0][W]))
| n,W=list(map(int,input().split()))
w_list=[0]
v_list=[0]
for i in range(n):
w,v=list(map(int,input().split()))
w_list.append(w)
v_list.append(v)
dp=[]
for i in range(n+1):
sub_list=[]
for j in range(W+1):
sub_list.append(0)
dp.append(sub_list)
for i in range(1,n+1):
for j in range(W+1):
if j>=w_list[i]:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-w_list[i]]+v_list[i])
else:
dp[i][j]=dp[i-1][j]
print((dp[n][W]))
| p03163 |
N,W = list(map(int,input().split()))
L = [list(map(int,input().split())) for i in range(N)]
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N) :
weight_i,value_i = L[i]
for weight in range(W+1) :
if weight - weight_i >= 0 :
dp[i+1][weight] = max(dp[i][weight], dp[i][weight - weight_i] + value_i)
else :
dp[i+1][weight] = dp[i][weight]
ans = dp[N][W]
print(ans)
| n,w = list(map(int,input().split()))
dp = [[0]*(w+1) for i in range(n+1)]
for i in range(1, n+1) :
a, v = list(map(int,input().split()))
for j in range(1, w+1) :
if j < a :
dp[i][j] = max(dp[i-1][j], dp[i][j-1])
else :
dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-a]+v)
print((dp[n][w]))
| p03163 |
import sys
def 解():
input = sys.stdin.readline
N,W=[int(_) for _ in input().split()]
#dp = [[0]*(W+1) for _ in range(N+1)]
dp = [0]*(W+1)
for i in range(N):
w,v=[int(_) for _ in input().split()]
for j in range(W,w-1,-1):
dp[j] = max(dp[j] ,dp[j-w]+v)
print((dp[W]))
解()
| import sys
def 解():
input = sys.stdin.readline
N,W=[int(_) for _ in input().split()]
dp = [0]*(W+1)
for i in range(N):
w,v=[int(_) for _ in input().split()]
for j in range(W,w-1,-1):
dp[j] = max(dp[j] ,dp[j-w]+v)
print((dp[W]))
解()
| p03163 |
N, W = list(map(int, input().split(' ')))
pair = [tuple(map(int, input().split(' '))) for _ in range(N)]
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if sum_w >= pair[i][0]:
dp[i+1][sum_w] = max(dp[i][sum_w], dp[i][sum_w-pair[i][0]] + pair[i][1])
else:
dp[i+1][sum_w] = dp[i][sum_w]
print((dp[-1][-1])) | N, WW = list(map(int, input().split()))
W = [0] * N
V = [0] * N
for i in range(N):
w, v = list(map(int, input().split()))
W[i] = w
V[i] = v
dp = [[0]*(WW+1) for _ in range(N+1)]
for n in range(1, N+1):
w = W[n-1]
v = V[n-1]
for sum_w in range(WW+1):
if sum_w <= WW - w:
# n番目の商品を選ぶ
dp[n][sum_w+w] = max(dp[n-1][sum_w] + v, dp[n][sum_w+w])
dp[n][sum_w] = max(dp[n-1][sum_w], dp[n][sum_w])
print((dp[-1][-1])) | p03163 |
def LI(): return [int(x) for x in input().split()]
def II(): return int(eval(input()))
N,W=LI()
LIS=[tuple(LI()) for _ in range(N)]
DP = [[0]*(W+1) for i in range(N+1)]
for i,(w,v) in enumerate(LIS, 1):
for wb in range(0, W+1):
DP[i][wb] = DP[i-1][wb]
if wb >= w :
DP[i][wb] = max(DP[i][wb], DP[i-1][wb-w]+v)
# for lis in DP:
# print(lis)
print((DP[N][W]))
| def LI(): return [int(x) for x in input().split()]
def II(): return int(eval(input()))
N,W=LI()
LIS=[tuple(LI()) for _ in range(N)]
DP = [[0]*(W+1) for i in range(N+1)]
for i,(w,v) in enumerate(LIS, 1):
for wb in range(0, W+1):
DP[i][wb] = DP[i-1][wb]
if wb >= w :
DP[i][wb] = max(DP[i][wb], DP[i-1][wb-w]+v)
print((DP[N][W]))
| p03163 |
def MAP(): return list(map(int,input().split()))
def INT(): return int(eval(input()))
def FLOAT(): return float(eval(input()))
MOD = 10**9+7
N,W = MAP()
weight=[]
value=[]
for i in range(N):
w,v = MAP()
weight.append(w)
value.append(v)
dp = [[0]*(W+1) for _ in range(N+1)]
for i in range(N):
for sum_w in range(W+1):
if sum_w-weight[i]>=0:
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w-weight[i]]+value[i])
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w])
print((dp[N][W])) | n,W = list(map(int,input().split()))
w = []
v = []
for i in range(n):
w_,v_ = list(map(int,input().split()))
w.append(w_)
v.append(v_)
dp = [[0]*(W+1) for _ in range(n+1)]
for i in range(n):
for sum_w in range(W+1):
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w])
if sum_w-w[i]>=0:
dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w-w[i]]+v[i])
print((dp[n][W])) | p03163 |
n,w=list(map(int,input().split()))
d,f=list(map(int,input().split()))
if n==1:print((f if d<=w else 0));exit()
dp=[[0,0],[d,f]]#w,v
dp_=[]
for i in range(1,n):
d,f=list(map(int,input().split()))
if dp_==[]:
for x,c in dp:
if x+d<=w:dp_.append([x+d,c+f])
dp_+=dp
dp=[]
else:
for x,c in dp_:
if x+d<=w:dp.append([x+d,c+f])
dp+=dp_
dp_=[]
print((max(sum(dp+dp_,[])[1::2]))) | n,w=list(map(int,input().split()))
dp=[0]*(w+1)
for i in range(n):
wi,vi=list(map(int,input().split()))
for j in range(w-wi,-1,-1):
dp[j+wi]=max(dp[j+wi],dp[j]+vi)
print((dp[-1])) | p03163 |
n,W=list(map(int,input().split()))
li=[]
wr=[0]*n
vr=[0]*n
dd = [[0 for _ in range(W+1)] for k in range(n+1)]
for i in range(n):
w,v=list(map(int,input().split()))
wr[i]=w
vr[i]=v
mw=min(wr)
def maxv(i,w):
if dd[i][w]!=0:
return dd[i][w]
if i==n:
return 0
if W-w<mw:
return 0
if w+wr[i]<=W:
a=vr[i]+maxv(i+1,w+wr[i])
else:
a=0
b=maxv(i+1,w)
c=max(a,b)
dd[i][w]=c
return c
print((maxv(0,0)))
| n,W=list(map(int,input().split()))
dp=[0]*(W+1)
dd=dp.copy()
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W):
cw=j+w
cv=dp[j]+v
if cw <=W and dd[cw]<cv:
dd[cw]=cv
dp=dd.copy()
print((dp[W])) | p03163 |
n,W=list(map(int,input().split()))
dp=[0]*(W+1)
dd=dp.copy()
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W):
cw=j+w
cv=dp[j]+v
if cw <=W and dd[cw]<cv:
dd[cw]=cv
dp=dd.copy()
print((dp[W])) | n,W=list(map(int,input().split()))
dp=[0]*(W+1)
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W,-1,-1):
cw=j+w
cv=dp[j]+v
if cw <=W and dp[cw]<cv:
dp[cw]=cv
print((dp[W])) | p03163 |
n,W=list(map(int,input().split()))
dp=[0]*(W+1)
for i in range(n):
w,v=list(map(int,input().split()))
for j in range(W,-1,-1):
cw=j+w
cv=dp[j]+v
if cw <=W and dp[cw]<cv:
dp[cw]=cv
print((dp[W])) | n,W=list(map(int,input().split()))
dp=[0]*(W+1)
for _ in range(n):
w,v=list(map(int,input().split()))
for j in range(W-w,-1,-1):
dp[j+w]=max(dp[j+w],dp[j]+v)
print((dp[W])) | p03163 |
n,w=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
dp=[[0 for _ in range(w+1)] for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
weight,value=a[i]
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
if j+weight<=w:
dp[i+1][j+weight]=max(dp[i][j+weight],dp[i][j]+value)
print((dp[-1][-1])) | n,W=list(map(int,input().split()))
a=[list(map(int,input().split())) for _ in range(n)]
dp=[[0 for _ in range(W+1)] for _ in range(n+1)]
for i in range(n):
weight,value=a[i]
for j in range(W+1):
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
if j+weight<=W:
dp[i+1][j+weight]=max(dp[i][j+weight],dp[i][j]+value)
print((dp[-1][-1])) | p03163 |
N, W = list(map(int, input().split()))
item = [list(map(int, input().split())) for _ in range(N)]
dp = [[0]*100100 for _ in range(110)]
for i in range(N):
for sum_w in range(W+1):
weight, value = item[i]
if sum_w - weight >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[N][W])) | N, W = list(map(int, input().split()))
dp = [[0]*100100 for _ in range(110)]
for i in range(N):
weight, value = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w - weight >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[N][W])) | p03163 |
N, W = list(map(int, input().split()))
dp = [[0]*100100 for _ in range(110)]
for i in range(N):
weight, value = list(map(int, input().split()))
for sum_w in range(W+1):
if sum_w - weight >= 0:
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - weight] + value)
dp[i + 1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])
print((dp[N][W])) | N, W = list(map(int, input().split()))
dp = [[0] * (W + 1) for i in range(N + 1)]
for i in range(1, N + 1):
w, v = list(map(int, input().split()))
for j in range(1, W + 1):
if j >= w:
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w] + v)
else:
dp[i][j] = dp[i - 1][j]
print((dp[N][W])) | p03163 |
import os
import sys
from io import BytesIO, IOBase
def knapsack(wt,price,n,c,dp):
if n<0 or c==0:
return 0
if dp[n][c]!=-1:
return dp[n][c]
inc=exc=0
if c>=wt[n]:
inc=price[n]+knapsack(wt,price,n-1,c-wt[n],dp)
exc=0+knapsack(wt,price,n-1,c,dp)
dp[n][c]=max(inc,exc)
return max(inc,exc)
def main():
n,c=list(map(int,input().split()))
wt=[]
price=[]
for _ in range(n):
w,v=list(map(int,input().split()))
wt.append(w)
price.append(v)
dp=[[-1 for x in range(c+1)] for y in range(n+1)]
print((knapsack(wt,price,n-1,c,dp)))
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main() | def knapsackBottomUp(wt,price,c,n):
dp=[[0 for x in range(c+1)] for y in range(n+1)]
for i in range(n+1):
for w in range(c+1):
if i==0 or w==0:
dp[i][w]=0
else:
inc=exc=0
if wt[i-1]<=w:
inc=price[i-1]+dp[i-1][w-wt[i-1]]
exc=dp[i-1][w]
dp[i][w]=max(inc,exc)
return dp[n][c]
n,c=list(map(int,input().split()))
wt=[]
price=[]
for _ in range(n):
w,v=list(map(int,input().split()))
wt.append(w)
price.append(v)
print((knapsackBottomUp(wt,price,c,n))) | p03163 |
x, y = list(map(int, input().split()))
dp = [0]*(y+1)
for i in range(x):
w, v = list(map(int, input().split()))
for j in range(y, w-1, -1):
num = dp[j-w]+v
if num > dp[j]:
dp[j] = num
print((dp[-1])) | def main():
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [0] * (w + 1)
for wi, vi in wv:
for sum_w in range(w, wi - 1, -1):
v = dp[sum_w - wi] + vi
if dp[sum_w] < v:
dp[sum_w] = v
print((dp[w]))
if __name__ == '__main__':
main()
| p03163 |
import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
wv = [None] * N
for i in range(N):
wv[i] = tuple(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i, (w, v) in enumerate(wv, start=1):
dp_i = dp[i]
dp_im = dp[i - 1]
for j in range(1, W + 1):
if j < w:
dp_i[j] = dp_im[j]
elif dp_im[j - w] + v > dp_im[j]:
dp_i[j] = dp_im[j - w] + v
else:
dp_i[j] = dp_im[j]
ans = dp[-1][-1]
print(ans)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N, W = list(map(int, input().split()))
wv = [None] * N
for i in range(N):
wv[i] = tuple(map(int, input().split()))
dp = [[0] * (W + 1) for _ in range(N + 1)]
for i, (w, v) in enumerate(wv, start=1):
dp_i = dp[i]
dp_im = dp[i - 1]
for j in range(1, W + 1):
if j < w:
dp_i[j] = dp_im[j]
else:
a = dp_im[j - w] + v
b = dp_im[j]
if a > b:
dp_i[j] = a
else:
dp_i[j] = b
ans = dp[-1][-1]
print(ans)
if __name__ == "__main__":
main()
| p03163 |
def calc():
N,W=list(map(int,input().split()))
dp=[-1]*(W+1)
dp[0]=0
for i in range(N):
w,v=list(map(int,input().split()))
for j in range(W-w,-1,-1):
if dp[j]!=-1:
dp[j+w]=max(dp[j+w],dp[j]+v)
print((max(dp)))
calc() | def calc():
N,W=list(map(int,input().split()))
dp=[-1]*(W+1)
dp[0]=0
for i in range(N):
w,v=list(map(int,input().split()))
for j in range(W-w,-1,-1):
if dp[j]!=-1:
if dp[j+w]<dp[j]+v:
dp[j+w]=dp[j]+v
print((max(dp)))
calc() | p03163 |
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,W=LI()
dp=[[0 for _ in range(W+1)]for __ in range(n+1)]
w=[]
v=[]
for _ in range(n):
a,b=LI()
w.append(a)
v.append(b)
# dp[i+1][j] iまでで最大化
for i in range(n):
for j in range(W+1):
if j<w[i]:
dp[i+1][j]=dp[i][j]
else:
dp[i+1][j]=max(dp[i][j],dp[i][j-w[i]]+v[i])
return dp[n][W]
# main()
print((main()))
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
def main():
n,W=LI()
dp=[[0 for _ in range(W+1)]for __ in range(n+1)]
w=[]
v=[]
for _ in range(n):
a,b=LI()
w.append(a)
v.append(b)
# dp[i+1][j] iまでで最大化
for i in range(n):
for j in range(W+1):
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
if j+w[i]<=W:
dp[i+1][j+w[i]]=max(dp[i+1][j+w[i]],dp[i][j]+v[i])
return dp[n][W]
# main()
print((main()))
| p03163 |
import copy
n,w=list(map(int,input().split()))
wv=[list(map(int,input().split())) for _ in range(n)]
dp=([0]*wv[0][0])+[wv[0][1]]*(w+1-wv[0][0])
for i in range(n-1):
dp_copy=copy.deepcopy(dp)
for j in range(w+1):
if j>=wv[i+1][0]:
dp[j]=max(dp_copy[j],dp_copy[j-wv[i+1][0]]+wv[i+1][1])
print((dp[-1])) | n,w=list(map(int,input().split()))
wv=[list(map(int,input().split())) for _ in range(n)]
dp=[[0]*(w+1) for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
if j>=wv[i][0]:
dp[i+1][j]=max(dp[i][j],dp[i][j-wv[i][0]]+wv[i][1])
else:
dp[i+1][j]=dp[i][j]
print((dp[-1][-1])) | p03163 |
# D-Knapsack 1
N,W = list(map(int,input().split()))
Weight = [0 for _ in range(N)]
Value = [0 for _ in range(N)]
for i in range(N):
Weight[i],Value[i] = list(map(int,input().split()))
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N):
# あらゆる合計重量sum_wに対して品物iを入れるべきか計算する
for sum_w in range(W+1):
# i番目を選ぶ場合
if sum_w - Weight[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w - Weight[i]] + Value[i])
# i番目を選ばない場合
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
# for d in dp:
# print(d)
print((dp[N][W])) | # D-Knapsack 1
N,W = list(map(int,input().split()))
Weight = [0 for _ in range(N)]
Value = [0 for _ in range(N)]
for i in range(N):
Weight[i],Value[i] = list(map(int,input().split()))
# dp[i+1][w]:= i番目までの品物の中から重さがwを超えないように選んだときの、価値の総和の最大値
dp = [[0 for i in range(W+1)] for j in range(N+1)]
for i in range(N):
# あらゆる合計重量sum_wに対して品物iを入れるべきか計算する
for sum_w in range(W+1):
# i番目を選ぶ場合
if sum_w - Weight[i] >= 0:
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w - Weight[i]] + Value[i])
# i番目を選ばない場合
dp[i+1][sum_w] = max(dp[i+1][sum_w], dp[i][sum_w])
# for d in dp:
# print(d)
print((dp[N][W])) | p03163 |
def resolve():
import sys
input = sys.stdin.readline
# 整数 1 つ
# n = int(input())
# 整数複数個
n, w = list(map(int, input().split()))
# 整数 N 個 (改行区切り)
# N = [int(input()) for i in range(N)]
# 整数 N 個 (スペース区切り)
# N = list(map(int, input().split()))
# 整数 (縦 H 横 W の行列)
A = [list(map(int, input().split())) for i in range(n)]
Knap = [[0] * (w+1) for _ in range(n+1)]
for i in range(n):
for j in reversed(list(range(i+1))):
for k in range(w+1):
# if (Knap[j][k] > 0 or (j == 0 and k ==0)) and k + A[i][0] <= w:
point = k + A[i][0]
if point <= w:
Knap[j+1][k + A[i][0]] = max((Knap[j+1][point]), (Knap[j][k] + A[i][1]))
knapmax = 0
for i in range(n):
knapmax = max(knapmax, max(Knap[i+1]))
print(knapmax)
resolve() | def resolve():
import sys
input = sys.stdin.readline
# 整数 1 つ
# n = int(input())
# 整数複数個
n, w = list(map(int, input().split()))
# 整数 N 個 (改行区切り)
# N = [int(input()) for i in range(N)]
# 整数 N 個 (スペース区切り)
# N = list(map(int, input().split()))
# 整数 (縦 H 横 W の行列)
A = [list(map(int, input().split())) for i in range(n)]
Knap = [[0] * (w+1) for _ in range(n+1)]
# Knap = [[0] * (110) for _ in range(10**5+10)]
for i in range(n):
for k in range(w+1):
if k + A[i][0] <= w:
# point = k + A[i][0]
Knap[i+1][k+A[i][0]] = max(Knap[i+1][k+A[i][0]], (Knap[i][k] + A[i][1]))
Knap[i+1][k] = max(Knap[i][k], Knap[i+1][k])
# knapmax = 0
# for i in range(n):
# knapmax = max(knapmax, max(Knap[i+1]))
print((Knap[n][w]))
# print(*Knap, sep="\n")
resolve() | p03163 |
N,W = list(map(int,input().split()))
w = []
v = []
for i in range(N):
w_,v_ = list(map(int,input().split()))
w.append(w_)
v.append(v_)
dp = [[0]*(W+1) for _ in range(N+1)]
def memo(i,j):
if dp[i][j]:
return dp[i][j]
if i == N:
dp[i][j] = 0
elif w[i] > j:
dp[i][j] = memo(i+1,j)
else:
dp[i][j] = max(memo(i+1,j),memo(i+1,j-w[i])+v[i])
return dp[i][j]
print((memo(0,W))) | import sys
sys.setrecursionlimit(10**9)
N,W = list(map(int,input().split()))
w = []
v = []
for i in range(N):
w_,v_ = list(map(int,input().split()))
w.append(w_)
v.append(v_)
dp = [[0]*(W+1) for _ in range(N+1)]
def memo(i,j):
if dp[i][j]:
return dp[i][j]
if i == N:
dp[i][j] = 0
elif w[i] > j:
dp[i][j] = memo(i+1,j)
else:
dp[i][j] = max(memo(i+1,j),memo(i+1,j-w[i])+v[i])
return dp[i][j]
print((memo(0,W))) | p03163 |
# 再帰関数使用時は再帰上限を十分にとること
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
# グローバル変数定義
INF = 10 ** 13
N, W = list(map(int, input().split()))
# knopsock[n][0] = w : n = 品物の位置 , w = 重さ
# knopsock[n][1] = v : n = 品物の位置 , v = 価値
knapsack = [list(map(int, input().split())) for _ in range(N)]
# db[n][w] = v : w = 現在の重さ, n = 見てきた品物の数, v = 現在の価値
db = [[INF] * W for _ in range(N)]
def dfs(n, w):
"""
品物に対する深さ優先探索による全探索（メモ化再帰）。
Args:
n (int) : 見てきた品物の数
w (int) : ここまでの重さの総和
Returns:
v (int) : 価値の総和の最大値
"""
# 終了条件：現在の個数が全ての品物の個数を越える
if n >= N:
return 0
if w + knapsack[n][0] > W:
# １つ前までの重さ + 今回の品物の重さが重さの最大値を越えていたら今回の品物は選べない
return dfs(n + 1, w)
else:
# 今回の品物を選ぶか選ばないかで全探索
return max([dfs(n + 1, w), dfs(n + 1, w + knapsack[n][0]) + knapsack[n][1]])
def main():
out = dfs(0, 0)
print(out)
if __name__ == "__main__":
main() | import sys
readline = sys.stdin.readline
def chmax(a, b):
"""
2値の大きい値を返す
Args:
a (int) : 値１
b (int) : 値２
Return:
a (int) : aまたはbの大きい値
"""
if a < b:
a = b
return a
def main():
N, W = list(map(int, readline().split()))
# knopsock[n][0] = w : n = 品物の位置 , w = 重さ
# knopsock[n][1] = v : n = 品物の位置 , v = 価値
knapsack = [list(map(int, readline().split())) for _ in range(N)]
# db[n][w] = v : w = 現在の重さ, n = 見てきた品物の数, v = 現在の価値
dp = [[0] * (W + 1) for _ in range(N + 1)]
for n in range(1, N + 1):
for w in range(W + 1):
if w - knapsack[n - 1][0] < 0:
dp[n][w] = dp[n - 1][w]
else:
dp[n][w] = chmax(dp[n - 1][w], dp[n - 1]
[w - knapsack[n - 1][0]] + knapsack[n - 1][1])
print((dp[N][W]))
if __name__ == "__main__":
main()
| p03163 |
n, mw = list(map(int, input().split()))
w, v = [], []
for _ in range(n):
x, y = list(map(int, input().split()))
w.append(x)
v.append(y)
dp = [[0 for _ in range(mw+1)] for _ in range(n+1)]
for i in range(1, n+1):
for j in range(mw+1):
if w[i-1] <= j:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1])
else:
dp[i][j] = dp[i-1][j]
print((dp[n][mw]))
| n, mw = list(map(int, input().split()))
goods = [tuple(map(int, input().split())) for _ in range(n)]
dp = [[0 for _ in range(mw+1)] for _ in range(n+1)]
for i in range(n):
for j in range(mw+1):
w, v = goods[i]
if j >= w:
dp[i+1][j] = max(dp[i][j], dp[i][j - w] + v)
else: dp[i+1][j] = dp[i][j]
print((dp[n][mw])) | p03163 |
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)
dp=[[0]*(W+1) for i in range(N+1)]
for i in range(N):
for j in range(W+1):
if j-w[i]>=0:
dp[i+1][j]=dp[i][j-w[i]]+v[i]
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[N][W])) | N,W=list(map(int,input().split()))
w,v=[],[]
for i in range(N):
ww,vv=list(map(int,input().split()))
w.append(ww)
v.append(vv)
dp=[[0]*(W+1) for i in range(N+1)]
for i in range(N):
for j in range(W+1):
if j-w[i]>=0:
dp[i+1][j]=max(dp[i][j-w[i]]+v[i],dp[i+1][j])
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
print((dp[-1][-1]))
| p03163 |
def main():
N, W = [int(n) for n in input().split()]
baggages = [[int(n) for n in input().split()] for i in range(N)]
VALUE, WEIGHT = 1, 0
dp = [[-1] * (W+1) for n in range(N)]
# dp[baggage][weight] := baggage番目までの荷物を使ってweight以下に抑える
dp[0] = [0 if weight < baggages[0][WEIGHT] else baggages[0][VALUE] for weight in range(W+1)]
for baggage in range(N):
for max_weight in range(W+1):
if dp[baggage][max_weight] != -1:
continue
bag_w = baggages[baggage][WEIGHT]
bag_v = baggages[baggage][VALUE]
val1 = dp[baggage-1][max_weight]
val2 = dp[baggage-1][max_weight-bag_w]+bag_v if max_weight >= bag_w else 0
dp[baggage][max_weight] = max(val1, val2)
print((dp[N-1][W]))
if __name__ == "__main__":
main() | N,W = [int(_n) for _n in input().split()]
A = []
for i in range(N):
w,v = [int(_n) for _n in input().split()]
A.append((w,v))
dp = [[0]*(W+1) for _ in range(N)]
for w in range(W+1):
dp[0][w] = 0 if w < A[0][0] else A[0][1]
for i in range(N):
for w in range(W+1):
dp[i][w] = dp[i-1][w]
if w >= A[i][0]:
dp[i][w] = max(dp[i-1][w], dp[i-1][w-A[i][0]] + A[i][1])
print((dp[N-1][W])) | p03163 |
import sys
sys.setrecursionlimit(10 ** 8)
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)
dp = [[-1] *(W + 1) for i in range(N + 1)]
def dfs(i, W):
if dp[i][W] != -1:
return dp[i][W]
if i == N:
ans = 0
elif w[i] > W:
ans = dfs(i + 1, W)
else:
ans = max(dfs(i + 1, W), dfs(i + 1, W - w[i]) + v[i])
dp[i][W] = ans
return ans
print((dfs(0, W))) | 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)
dp = [[0] *(W + 1) for i in range(N + 1)]
for i in range(N):
for j in range(W + 1):
if j < w[i]:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i])
print((dp[N][W])) | p03163 |
N, W = list(map(int, input().split()))
w_list = []
v_list = []
for i in range(N):
w, v = list(map(int, input().split()))
w_list.append(w)
v_list.append(v)
dp = [[0 for i in range(W+1)] for i in range(N)]
for i in range(N):
w = w_list[i]
v = v_list[i]
for j in range(W+1):
if j-w >= 0:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w]+v)
else:
dp[i][j] = dp[i-1][j]
print((dp[N-1][W])) | N,W = list(map(int,input().split()))
w_list = []
v_list = []
for _ in range(N):
w,v = list(map(int,input().split()))
w_list.append(w)
v_list.append(v)
dp = [[0]*(W+1) for i in range(N+1)]
for i in range(1,N+1):
w = w_list[i-1]
v = v_list[i-1]
for j in range(1,W+1):
if j-w >= 0:
dp[i][j] = max(dp[i-1][j],dp[i-1][j-w]+v)
else:
dp[i][j] = dp[i-1][j]
print((dp[N][W])) | p03163 |
N,W = list(map(int,input().split()))
w_list = []
v_list = []
for _ in range(N):
w,v = list(map(int,input().split()))
w_list.append(w)
v_list.append(v)
dp = [[0]*(W+1) for i in range(N+1)]
for i in range(1,N+1):
w = w_list[i-1]
v = v_list[i-1]
for j in range(1,W+1):
if j-w >= 0:
dp[i][j] = max(dp[i-1][j],dp[i-1][j-w]+v)
else:
dp[i][j] = dp[i-1][j]
print((dp[N][W])) | n,W = list(map(int,input().split()))
dp = [[0]*(W+1) for i in range(n)]
for i in range(n):
w,v = list(map(int,input().split()))
if i == 0:
for j in range(W+1):
if w <= j:
dp[0][j] = v
else:
for j in range(W+1):
if j < w:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = max(dp[i-1][j-w]+v, dp[i-1][j])
print((dp[-1][-1])) | p03163 |
n,w=list(map(int,input().split()))
WV=[list(map(int,input().split())) for i in range(n)]
#WV[i][0]が重さ、WV[i][1]が価値
#配るDP
dp=[[0 for i in range(w+1)] for i in range(n+1)]
#dp[i][j]はi回目(0,n-1)に重さjまで入るmax value
for i in range(n):
for j in range(w+1):
if WV[i][0]+j<=w and i <=n-1:
dp[i+1][j+WV[i][0]]=max(dp[i][j+WV[i][0]], dp[i][j]+WV[i][1])
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
else:
dp[i+1][j]=max(dp[i][j],dp[i+1][j])
print((max(dp[n]))) | # 貰うDP
n, w = list(map(int, input().split()))
WV = [list(map(int, input().split())) for i in range(n)]
# dp[i][w] 重さwでの最高価値
dp = [[-1] * (w + 1) for i in range(n + 1)]
for j in range(w + 1):
dp[0][j] = 0
for i in range(n):
for j in range(w + 1):
if j - WV[i][0] >= 0 and j - WV[i][0] <= w:
dp[i + 1][j] = max(dp[i][j - WV[i][0]] + WV[i][1], dp[i][j])
else:
dp[i + 1][j] = dp[i][j]
print((dp[n][w]))
| p03163 |
n, m = list(map(int, input().split()))
WV = [tuple(map(int, input().split())) for i in range(n)]
W = [w for w, v in WV]
V = [v for w, v in WV]
DP = [[0 for j in range(m+1)] for i in range(n+1)]
for i in range(n):
for j in range(W[i]):
DP[i+1][j] = DP[i][j]
for j in range(W[i], m+1):
DP[i+1][j] = max(DP[i][j], DP[i][j-W[i]]+V[i])
print((DP[n][m]))
| n, m = list(map(int, input().split()))
WV = [tuple(map(int, input().split())) for i in range(n)]
W = [w for w, v in WV]
V = [v for w, v in WV]
DP = [[0 for j in range(m+1)] for i in range(n+1)]
for i in range(1, n+1):
for j in range(W[i-1]):
DP[i][j] = DP[i-1][j]
for j in range(W[i-1], m+1):
DP[i][j] = max(DP[i-1][j], DP[i-1][j-W[i-1]]+V[i-1])
print((DP[n][m]))
| p03163 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4
1 2 3 5
output:
30
"""
import sys
from functools import reduce
def gcd(x, y):
if x < y:
x, y = y, x
while y > 0:
r = x % y
x = y
y = r
return x
def lcm(a, b):
return a * b // gcd(a, b)
def solve(_n_list):
return reduce(lcm, _n_list)
if __name__ == '__main__':
_input = sys.stdin.readlines()
cnt = int(_input[0])
n_list = list(map(int, _input[1].split()))
print((solve(n_list))) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4
1 2 3 5
output:
30
"""
import sys
from functools import reduce
def gcd(x, y):
if x < y:
x, y = y, x
while y > 0:
r = x % y
x = y
y = r
return x
def lcm(a, b):
return a * b // gcd(a, b)
def solve(_n_list):
return reduce(lcm, _n_list)
if __name__ == '__main__':
_input = sys.stdin.readlines()
cnt = int(_input[0])
n_list = tuple(map(int, _input[1].split()))
print((solve(n_list))) | p02469 |
eval(input())
a=list(map(int,input().split()))
m=max(a)
i,f=1,0
while i:
for j in a:
if (m*i)%j:break
if j==a[-1]: f=1
if f:break
i+=1
print((m*i)) | def gcd(a,b):
while b:a,b=b,a%b
return a
def lcm(a,b):
return a//gcd(a,b)*b
eval(input())
a=list(map(int,input().split()))
b=1
for i in a:
b=lcm(b,i)
print(b) | p02469 |
import sys
n = int(sys.stdin.readline())
s = sys.stdin.readline()
def count(s, idx):
w = s.count("W", 0, idx)
e = s.count("E", idx + 1)
return w + e
m = count(s, 0)
j = 0
for i in range(1, len(s)):
m2 = count(s, i)
if m2 < m:
m = m2
j = i
print(m)
| import sys
n = int(sys.stdin.readline())
s = list(sys.stdin.readline())
it = s[0]
w = 0
e = s[1:].count('E')
m = e
j = 0
for i in range(1, len(s)):
if it == 'W':
w = w + 1
it = s[i]
if it == 'E':
e = e - 1
m2 = w + e
if m2 < m:
m = m2
j = i
print(m)
| p03341 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, S):
ans = sys.maxsize
for i in range(N):
ans = min(ans, S[:i].count('W') + S[i + 1:].count('E'))
return ans
def main():
N = read_int()
S = read_str()
print(slv(N, S))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, S):
W = 0
E = S.count('E')
ans = E + W
for s in S:
if s == 'E':
E -= 1
ans = min(E + W, ans)
if s == 'W':
W += 1
return ans
def main():
N = read_int()
S = read_str()
print(slv(N, S))
if __name__ == '__main__':
main()
| p03341 |
_, s = open(0).read().split()
left, right = [0], []
lw, re = 0, 0
for i in s:
if i == 'W':
lw += 1
left += [lw]
for i in s[::-1]:
if i == 'E':
re += 1
right += [re]
print((min(i + j for i, j in zip(left[:-1], right[-2::-1] + [0])))) | def main():
_, s = open(0).read().split()
w, res = 0, 0
for i in s:
if i == 'W':
w += 1
elif w:
w -= 1
res += 1
else:
pass
return res
if __name__ == '__main__':
print((main())) | p03341 |
N,M=list(map(int,input().split()))
n=[list(map(int,input().split())) for _ in range(N)]
m=[list(map(int,input().split())) for _ in range(M)]
result=[]
for i in range(len(n)):
result=[]
for j in range(len(m)):
result.append(abs(n[i][0]-m[j][0])+abs(n[i][1]-m[j][1]))
print((result.index(min(result))+1)) | n,m=map(int,input().split())
ab=[list(map(int,input().split())) for _ in range(n)]
cd=[list(map(int,input().split())) for _ in range(m)]
r=[]
for i in ab:
x1,y1=i[0],i[1]
temp=[]
for j in cd:
x2,y2=j[0],j[1]
temp.append(abs(x1-x2)+abs(y1-y2))
r.append(temp.index(min(temp))+1)
print(*r,sep='\n')
| p03774 |
n,m=list(map(int,input().split()))
a=[]
b=[]
c=[]
d=[]
for i in range(n):
A,B=list(map(int,input().split()))
a.append(A)
b.append(B)
for i in range(m):
C,D=list(map(int,input().split()))
c.append(C)
d.append(D)
for i in range(n):
minimum=1000000000
ans=0
for j in range(m):
if abs(a[i]-c[j])+abs(b[i]-d[j])<minimum:
minimum=abs(a[i]-c[j])+abs(b[i]-d[j])
ans=j+1
print(ans)
| n,m=list(map(int,input().split()))
a=[]
b=[]
for i in range(n):
x,y=list(map(int,input().split()))
a.append([x,y])
for i in range(m):
x,y=list(map(int,input().split()))
b.append([x,y])
for i in a:
ans=10**18
t=0
for j in range(m):
if abs(i[0]-b[j][0])+abs(i[1]-b[j][1])<ans:
t=j+1
ans=abs(i[0]-b[j][0])+abs(i[1]-b[j][1])
print(t)
| p03774 |
def manhattan_distance(s, c):
return abs(s[0]-c[0]) + abs(s[1]-c[1])
def main():
n, m = list(map(int, input().split()))
student = []
for _ in range(n):
a, b = list(map(int, input().split()))
student.append([a, b])
checkpoint = []
for _ in range(m):
c, d = list(map(int, input().split()))
checkpoint.append([c, d])
for s in student:
d = {}
for i, c in enumerate(checkpoint):
d[i] = manhattan_distance(s, c)
print((sorted(list(d.items()), key=lambda x: x[1])[0][0]+1))
if __name__ == "__main__":
main() | def man_dis(s, c):
return abs(s[0]-c[0])+abs(s[1]-c[1])
def main():
n, m = list(map(int, input().split()))
s_list = [list(map(int, input().split())) for _ in range(n)]
c_list = [list(map(int, input().split())) for _ in range(m)]
for s in s_list:
minv = 1000000000
for i, c in enumerate(c_list):
tmp = man_dis(s, c)
if tmp < minv:
minv = tmp
idx = i
print((idx+1))
if __name__ == "__main__":
main() | p03774 |
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
cd = [list(map(int, input().split())) for _ in range(m)]
for i in range(n):
s = 0
t = float('inf')
for j in range(m):
p = abs(ab[i][0] - cd[j][0]) + abs(ab[i][1] - cd[j][1])
if p < t:
s = j+1
t = p
print(s) | n,m = list(map(int, input().split()))
ab = []
for _ in range(n):
a,b = list(map(int, input().split()))
ab.append((a,b))
cd = []
for _ in range(m):
c,d = list(map(int, input().split()))
cd.append((c,d))
for i in ab:
s = float("inf")
for j in range(m):
t = abs(i[0]-cd[j][0]) + abs(i[1]-cd[j][1])
if t < s:
s = t
ans = j+1
print(ans) | p03774 |
n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
cd = [list(map(int, input().split())) for _ in range(m)]
p = [float("INF")] * n
check = [""]*n
for i in range(n):
for j in range(m):
if abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1]) < p[i]:
p[i] = abs(ab[i][0]-cd[j][0])+abs(ab[i][1]-cd[j][1])
check[i] = j+1
for s in check: print(s) | n,m = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
cd = [list(map(int, input().split())) for _ in range(m)]
for a,b in ab:
ans = []
for c,d in cd:
ans.append(abs(a-c)+abs(b-d))
print((ans.index(min(ans))+1)) | p03774 |
n, m = (int(i) for i in input().split())
ab = [[int(i) for i in input().split()] for j in range(n)]
cd = [[int(i) for i in input().split()] for j in range(m)]
for i in range(n):
d_min = 1000000000
p_num = 0
for j in range(m):
cur_d = abs(ab[i][0] - cd[j][0]) + abs(ab[i][1] - cd[j][1])
if cur_d < d_min:
d_min = cur_d
p_num = j + 1
print(p_num) | def main():
N, M = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
CD = [[int(i) for i in input().split()] for j in range(M)]
for a, b in AB:
cur = 10**12
cur_ans = -1
for i, cd in enumerate(CD):
if cur > abs(a-cd[0])+abs(b-cd[1]):
cur = abs(a-cd[0])+abs(b-cd[1])
cur_ans = i
print((cur_ans+1))
if __name__ == '__main__':
main()
| p03774 |
def main():
N, M = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
CD = [[int(i) for i in input().split()] for j in range(M)]
for a, b in AB:
cur = 10**12
cur_ans = -1
for i, cd in enumerate(CD):
if cur > abs(a-cd[0])+abs(b-cd[1]):
cur = abs(a-cd[0])+abs(b-cd[1])
cur_ans = i
print((cur_ans+1))
if __name__ == '__main__':
main()
| def main():
import sys
input = sys.stdin.buffer.readline
N, M = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
CD = [[int(i) for i in input().split()] for j in range(M)]
for a, b in AB:
mi = 10**20
ans = -1
for i, p in enumerate(CD):
d = abs(p[0] - a) + abs(p[1] - b)
if d < mi:
mi = d
ans = i+1
print(ans)
if __name__ == '__main__':
main()
| p03774 |
n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(n)]
cd = [list(map(int,input().split())) for _ in range(m)]
ans = [0]*n
for i in range(n):
count = 10**9
for j in range(m):
ch = abs(ab[i][0] - cd[j][0]) + abs(ab[i][1] - cd[j][1])
#print("i =",i,"j=",j,"ch =",ch,count)
if ch < count:
ans[i] = j+1
count = ch
print((ans[i])) | n,m = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(n)]
cd = [list(map(int,input().split())) for _ in range(m)]
ans = [0]*n
for i in range(n):
count = 10**9
for j in range(m):
ch = abs(ab[i][0] - cd[j][0]) + abs(ab[i][1] - cd[j][1])
if ch < count:
ans[i] = j+1
count = ch
print((ans[i])) | p03774 |
n, m = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(n)]
CD = [list(map(int, input().split())) for _ in range(m)]
for i in range(n):
a, b = AB[i]
res = float("inf")
for j in range(m):
c, d = CD[j]
dist = abs(a - c) + abs(b - d)
if res > dist:
res = dist
ans = j + 1
print(ans) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(n)]
CD = [list(map(int, input().split())) for _ in range(m)]
for a, b in AB:
min_dist = f_inf
res = 0
for i in range(m):
c, d = CD[i]
dist = abs(a - c) + abs(b - d)
if min_dist > dist:
min_dist = dist
res = i + 1
print(res)
if __name__ == '__main__':
resolve()
| p03774 |
N, M = list(map(int, input().split()))
ab = [[int(i) for i in input().split()] for i in range(N)]
cd = []
for i in range(M):
c, d = list(map(int, input().split()))
cd.append([c, d, i])
ans = []
for a, b in ab:
dis = float('inf')
num = 0
for c, d, i in cd:
if (abs(c-a) + abs(b-d)) < dis:
dis = (abs(c-a) + abs(b-d))
num = i + 1
ans.append(num)
for i in ans:
print(i)
| N, M = list(map(int, input().split()))
ab = [[int(i) for i in input().split()] for i in range(N)]
cd = [[int(i) for i in input().split()] for i in range(M)]
ans = []
for a, b in ab:
num = float('inf')
for i in range(M):
if num > abs(a - cd[i][0]) + abs(b - cd[i][1]):
num = abs(a - cd[i][0]) + abs(b - cd[i][1])
check = i + 1
ans.append(check)
for i in ans:
print(i) | p03774 |
n,m = list(map(int,input().split()))
x = [list(map(int,input().split())) for i in range(n)]
y = [list(map(int,input().split())) for i in range(m)]
for a,b in x:
l = [abs(a-c)+abs(b-d) for c,d in y]
print((l.index(min(l))+1)) | n,m = list(map(int,input().split()))
x = [list(map(int,input().split())) for i in [0]*(n+m)]
for a,b in x[:n]:
l = [abs(a-c)+abs(b-d) for c,d in x[n:]]
print((l.index(min(l))+1)) | p03774 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.