Problem:
 Score : 100 points    Problem Statement There are N items, numbered 1, 2, \ldots, N .
For each i ( 1 \leq i \leq N ), Item i has a weight of w_i and a value of v_i .  Taro has decided to choose some of the N items and carry them home in a knapsack.
The capacity of the knapsack is W , which means that the sum of the weights of items taken must be at most W .  Find the maximum possible sum of the values of items that Taro takes home.      Constraints  All values in input are integers.  1 \leq N \leq 100  1 \leq W \leq 10^5  1 \leq w_i \leq W  1 \leq v_i \leq 10^9         Input Input is given from Standard Input in the following format:  N  W  w_1  v_1  w_2  v_2  :  w_N  v_N       Output Print the maximum possible sum of the values of items that Taro takes home.        Sample Input 1 3 8
3 30
4 50
5 60      Sample Output 1 90  Items 1 and 3 should be taken.
Then, the sum of the weights is 3 + 5 = 8 , and the sum of the values is 30 + 60 = 90 .       Sample Input 2 5 5
1 1000000000
1 1000000000
1 1000000000
1 1000000000
1 1000000000      Sample Output 2 5000000000  The answer may not fit into a 32-bit integer type.       Sample Input 3 6 15
6 5
5 6
6 4
6 6
3 5
7 2      Sample Output 3 17  Items 2, 4 and 5 should be taken.
Then, the sum of the weights is 5 + 6 + 3 = 14 , and the sum of the values is 6 + 6 + 5 = 17 .

Solution (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''
                                        
import numpy as np
i8 = np.int64
i4 = np.int32


def solve(w, v, W):
    dp = np.zeros((w.shape[0], W + 1), i8)
    dp[0, w[0]] = v[0]
    for n in range(1, w.shape[0]):
        dp[n, :w[n]] = dp[n - 1, :w[n]]
        dp[n, w[n]] = max(v[n], dp[n - 1, w[n]])
        for j in range(w[n] + 1, W + 1):
            if dp[n - 1, j - w[n]] > 0:
                dp[n, j] = max(dp[n - 1, j - w[n]] + v[n], dp[n - 1, j])
            else:
                dp[n, j] = dp[n - 1, j]
    return dp[w.shape[0] - 1].max()


def main2():
    stdin = open('/dev/stdin')
    N, W = map(int, stdin.readline().split())
    w = np.empty(N, i8)
    v = np.empty(N, i8)
    for n in range(N):
        w[n], v[n] = map(int, stdin.readline().split())
    ans = solve(w, v, W)
    print(ans)
'''

Solution (Python):
n, w = map(int, input().split())
e = tuple(map(int, input().split()) for _ in range(n))
wt, vt = zip(*e)

dp = tuple([0] * (w + 1) for _ in range(n + 1))

for i in range(n):
    dp[i + 1][:wt[i]] = dp[i][:wt[i]]
    for j in range(wt[i], w + 1):
        dp[i + 1][j] = max(dp[i][j], dp[i][j - wt[i]] + vt[i])
print(dp[n][w])

Solution (Python):
N, W = map(int, input().split())
dp = [0]*(W+1)
for i in range(N):
  w, v = map(int, input().split())
  for j in range(W, w-1, -1):
    dp[j] = max(dp[j], dp[j-w]+v)
print(dp[W])

Solution (Python):
N, W = map(int, input().split())

dp = [0] * (W+1)
for i in range(N):
    w, v = map(int, input().split())
    for j in range(W, w-1, -1):
        a = dp[j-w]+v
        if dp[j] < a:
            dp[j] = a

print(dp[W])

Solution (Python):
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()
dp = [[0] * (W+1) for i in range(N+1)]  
for i in range(1, N+1):
    wi, vi = na()
    for w in range(1, W+1):
        if w - wi >= 0:
            dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - wi] + vi)
        else:
            dp[i][w] = dp[i - 1][w]
print(dp[N][w])

Solution (Python):
import sys
input = sys.stdin.readline


n,w = map(int,input().split())
W = [0 for i in range(n)];V = [0 for i in range(n)]
for i in range(n):
    W[i],V[i] = map(int,input().split())
dp = [[0 for i in range(w+1)] for j in range(n+1)]

for i in range(n):
    for j in range(w+1):
        if j >= W[i]:
            dp[i+1][j] = max(dp[i][j],dp[i][j-W[i]]+V[i])
        else:
            dp[i + 1][j] = dp[i][j]
print(dp[n][w])

Solution (Python):
import sys
input = sys.stdin.readline


n,w = map(int,input().split())
WV = [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):
    for j in range(w+1):
        if j >= WV[i][0]:
            dp[i+1][j] = max(dp[i][j],dp[i][j-WV[i][0]]+WV[i][1])
        else:
            dp[i + 1][j] = dp[i][j]
print(dp[n][w])

Solution (Python):
n,w = map(int,input().split())
WV = [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):
    for j in range(w+1):
        if j >= WV[i][0]:
            dp[i+1][j] = max(dp[i][j],dp[i][j-WV[i][0]]+WV[i][1])
        else:
            dp[i + 1][j] = dp[i][j]
print(dp[n][w])

Solution (Python):
n,w  = map(int, (input().split()))
goods = [list(map(int, input().split())) for _ in range(n)]

dp = [[0 for _ in range(w+1)] for _ in range(n+1)]

for i in range(1, n+1):
    for j in range(1, w+1):
        
        if j - goods[i-1][0] >= 0:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-goods[i-1][0]] + goods[i-1][1])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[n][w])

Solution (Python):
n,w_max = map(int,input().split())
w = [0]
v = [0]
for _ in range(n):
    W,V = map(int,input().split())
    w.append(W)
    v.append(V)

dp = [[0]*(w_max+1) for i in range(n+1)]
for i in range(1,n+1):
    for u in range(w_max+1):
        if u>=w[i]:
            dp[i][u] = max(dp[i-1][u-w[i]]+v[i],dp[i-1][u])
        else:
            dp[i][u] = dp[i-1][u]


print(dp[n][w_max])

Solution (Python):


n,w= map(int, input().split())

wlist = []
vlist = []
for i in range(n):
    wk,vk=map(int,input().split())
    wlist.append(wk)
    vlist.append(vk)

dp=[]
for i in range(n+1):
    dp.append([0]*(w+1))


for i in range(1,n+1):
    
    for j in range(w+1):
        
        if j-wlist[i-1] >=0:
            
            dp[i][j] = max(dp[i-1][j],dp[i-1][j-wlist[i-1]]+vlist[i-1])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[n][w])

Solution (Python):
n, w = 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):
    wi, vi = wv[i - 1]
    for j in range(w + 1):
        if j < wi:
            dp[i][j] = dp[i - 1][j]
        else:
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - wi] + vi)
print(dp[n][w])

Solution (Python):
import numpy as np

N,W = map(int,input().split())

item = [list(map(int,input().split())) for _ in range(N)]

val = np.zeros(W+1,dtype = int)

for i in range(N):
  item_weight = item[i][0]
  val[item_weight :] = np.maximum(val[item_weight :], val[:-item_weight] + item[i][1])
  
print(max(val))

Solution (Python):
n, w = [int(x) for x in input().split()]
W = []
V = []
for i in range(n):
  wi, vi = [int(x) for x in input().split()]
  W.append(wi)
  V.append(vi)

dp = []
for i in range(n+1):
  dp.append([0]*(w+1))

for i in range(n):
  for sum_w in range(w + 1):
    
    if sum_w - W[i] >= 0:
      dp[i+1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w - W[i]] + V[i])

    
    dp[i+1][sum_w] = max(dp[i + 1][sum_w], dp[i][sum_w])

print(dp[n][w])

Solution (Python):
N, W = map(int, input().split())

weights = [None for i in range(N)]
values = [None for i in range(N)]



dp = [[0 for i in range(N+1)] for j in range(W+1)]

for i in range(N):
    w, v = map(int, input().split())
    weights[i] = w
    values[i] = v
    
for weight in range(W+1):
    for item in range(1,N+1):

        
        dp[weight][item] = max(dp[weight][item],
                               dp[weight][item-1])

        
        dp[weight][item] = max(dp[weight][item],
                               dp[weight-1][item])
        
        if weights[item-1] > weight: continue
 
        
        dp[weight][item] = max(dp[weight][item],
                               values[item-1] + dp[weight - weights[item-1]][item - 1])
    
print(max(dp[-1]))

Solution (Python):
import numpy as np

n, W = map(int, input().split())
wv = np.array([list(map(int, input().split())) for i in range(n)])

dp = np.zeros((n + 1, W + 1), dtype=np.int)


def chmax(a, b):
    if a > b:
        return a
    else:
        return b









for i in range(0, n):
    w, v = wv[i, :]
    dp[i + 1, w:] = np.maximum(dp[i, w:], dp[i, :-w] + v)
    dp[i + 1, :] = np.maximum(dp[i + 1, :], dp[i, :])

print(int(dp[n , W]))

Solution (Python):
N,W=map(int,input().split())
w,v=[],[]
for i in range(N):
    weight, value = map(int,input().split())
    w.append(weight)
    v.append(value)
dp = [[0 for _ in range(100100)] for _ in range(N+2)]
for i in range(N):
    for sum_w in range(W+1):
        if sum_w -w[i] >=0:
            dp[i+1][sum_w] = max(dp[i+1][sum_w],dp[i][sum_w-w[i]] + v[i])
        dp[i+1][sum_w]=max(dp[i+1][sum_w],dp[i][sum_w])
print(dp[N][W])

Solution (Python):


N, W=[int(i) for i in input().split()]
wv=[[int(i) for i in input().split()] for _ in range(N)]


dp=[[0]*(W+1) for _ in range(N)]

for i in range(N):
    for w in range(W+1):
        if i==0:
            if wv[i][0]<=w:
                dp[i][w]=wv[i][1]
        else:
            if w>=wv[i][0]:
                dp[i][w]=max(dp[i-1][w-wv[i][0]]+wv[i][1],dp[i-1][w])
            else:
                dp[i][w]=dp[i-1][w]

print(max(dp[-1]))

Solution (Python):
N, W = map(int, input().split())
dp = [-1] * (W+1)
dp[0] = 0

for i in range(N):
    w, v = map(int, input().split())
    for j in range(W-w, -1, -1):
        if dp[j] == -1:
            continue
        else:
            dp[j+w] = max(dp[j+w], dp[j] + v)

print(max(dp))

Solution (Python):
n,w=map(int,input().split())
weight,value=[0]*110,[0]*110
dp = [[0 for _ in range(100100)] for _ in range(110)]
for i in range(n):
    weight[i],value[i] = map(int,input().split())
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])

Solution (Python):
def ks(n, W, arr):
    dp = [[0 for i in range(W+1)] for j in range(n+1)]
    for i in range(1,n+1):
        for j in range(1,W+1):
            if arr[i-1][0] > j:
                dp[i][j] = dp[i-1][j]
            else:
                dp[i][j] = max(dp[i-1][j], dp[i-1][j-arr[i-1][0]]+arr[i-1][1])
    return dp[n][W]

if __name__ == "__main__":
    n, W = map(int, input().split())
    arr = []
    for i in range(n):
        w,v = map(int, input().split())
        arr.append([w,v])
    arr.sort(key = lambda x:x[0])
    ans = ks(n,W,arr)
    print(ans)

Solution (Python):
n,w=map(int,input().split())
weight,value=[0]*110,[0]*110
dp = [[0 for _ in range(100100)] for _ in range(110)]
for i in range(n):
    weight[i],value[i] = map(int,input().split())
for i in range(n):
    sum_w =0
    while sum_w <= w:
        
        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])
        sum_w +=1
print(dp[n][w])

Solution (Python):
import sys
import numpy as np
input = sys.stdin.readline

def main():
    N, W = map(int, input().split())
    wv = [list(map(int, input().split())) for i in range(N)]

    dp = np.zeros((N+1, W+1), dtype=int)

    for i in range(N):
        w, v = wv[i]
        dp[i+1] = dp[i]
        dp[i+1, w:] = np.maximum(dp[i+1, w:], dp[i+1, :-w] + v)
    
    print(dp[-1][-1])


if __name__ == "__main__":
    main()

Solution (Python):
N, W = map(int, input().split())
mX = [tuple(map(int, input().split()))
      for _ in range(N)]


dp = [[0,] * (W+1),]

for w,v in mX:
    nDp = [max(dp[-1][t], dp[-1][t-w]+v)
           if t-w >= 0 else dp[-1][t]
           for t in range(W+1)]
    dp.append(nDp)

print(dp[-1][-1])

Solution (Python):
N, W = map(int, input().split())
wv = [list(map(int, input().split())) for _ in range(N)]
dp = [[0 for _ in range(W+1)] for _ in range(N+1)]
for i in range(N):
  for j in range(W+1):
    if j - wv[i][0] >= 0:
      dp[i+1][j] = max(dp[i][j], dp[i][j-wv[i][0]]+wv[i][1])
    else:
      dp[i+1][j] = dp[i][j]

print(max(dp[N]))