Problem:


Score : 500 points

Problem Statement

Takahashi is at an all-you-can-eat restaurant.

The restaurant offers N kinds of dishes. It takes A_i minutes to eat the i-th dish, whose deliciousness is B_i.

The restaurant has the following rules:

You can only order one dish at a time. The dish ordered will be immediately served and ready to eat.

You cannot order the same kind of dish more than once.

Until you finish eating the dish already served, you cannot order a new dish.

After T-0.5 minutes from the first order, you can no longer place a new order, but you can continue eating the dish already served.

Let Takahashi's happiness be the sum of the deliciousness of the dishes he eats in this restaurant.

What is the maximum possible happiness achieved by making optimal choices?

Constraints

2 \leq N \leq 3000

1 \leq T \leq 3000

1 \leq A_i \leq 3000

1 \leq B_i \leq 3000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N T
A_1 B_1
:
A_N B_N

Output

Print the maximum possible happiness Takahashi can achieve.

Sample Input 1

2 60
10 10
100 100

Sample Output 1

110

By ordering the first and second dishes in this order, Takahashi's happiness will be 110.

Note that, if we manage to order a dish in time, we can spend any amount of time to eat it.

Sample Input 2

3 60
10 10
10 20
10 30

Sample Output 2

60

Takahashi can eat all the dishes within 60 minutes.

Sample Input 3

3 60
30 10
30 20
30 30

Sample Output 3

50

By ordering the second and third dishes in this order, Takahashi's happiness will be 50.

We cannot order three dishes, in whatever order we place them.

Sample Input 4

10 100
15 23
20 18
13 17
24 12
18 29
19 27
23 21
18 20
27 15
22 25

Sample Output 4

145



Sample input:
2 60
10 10
100 100


Sample output:
110

Submission status: Accepted

Solution code:
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)


# compiled by pythran
'''
#pythran export main2()
import numpy as np
i8 = np.int64
i4 = np.int32

def solve(A, B, N, T, can_add):
    ret = 0
    d = np.empty(T, i8)
    for i in range(T):
        d[i] = -1
    d[0] = 0
    for i in range(0, N - 1):
        for j in range(T - A[i] - 1, -1, -1):
            if d[j] >= 0:
                d[j + A[i]] = max(d[j + A[i]], d[j] + B[i])
        ret = max(ret, np.max(d) + can_add[i + 1])
    return ret

def main2():
    stdin = open('/dev/stdin')
    N, T = map(int, stdin.readline().split())
    A = np.empty(N, i8)
    B = np.empty(N, i8)
    for i in range(N):
        A[i], B[i] = map(int, stdin.readline().split())
    ind = np.argsort(A)
    A = A[ind]
    B = B[ind]
    can_add = np.empty(N, i8)
    can_add[N - 1] = B[N - 1]
    for i in range(N - 2, -1, -1):
        can_add[i] = max(can_add[i + 1], B[i])
    ans = solve(A, B, N, T, can_add)
    print(ans)
'''

Submission status: Accepted

Solution code:
import sys
import numpy as np

def main():
    input = sys.stdin.readline
    N, T = map(int, input().split())
    dishes = []
    for _ in range(N):
        a, b = map(int, input().split())
        dishes.append((a, b))
    
    dishes = sorted(dishes, key=lambda x: x[0])
    
    ans = 0
    dp = np.zeros(T, dtype=int)
    for a, b in dishes:
        ans = max(ans, dp.max() + b)
        np.maximum(dp[:-a] + b, dp[a:], out=dp[a:])

    return ans

if __name__ == '__main__':
    print(main())

Submission status: Accepted

Solution code:
import numpy as np
n,t = map(int, input().split())
item = [None]*n
ans = 0
dp = np.zeros(t, dtype=int)

for i in range(n):
    a,b = map(int, input().split())
    item[i]=[a,b]
item.sort(key=lambda x:x[0])

for i in range(n):
    a,b = item[i]
    ans = max(ans, dp.max()+b)
    dp[a:] = np.maximum(dp[a:], dp[:-a]+b)

print(ans)

Submission status: Accepted

Solution code:
# dp[i][t_sum]: i番目までの品物で時間がt_sumを超えないように選んだときの、満足度の総和の最大値
N, T = map(int, input().split())
items = sorted([tuple(map(int, input().split()))
                for i in range(N)], key=lambda x: x[0])

dp1 = [[0 for t_sum in range(T+1)] for i in range(N+2)]

for i in range(N):
    for t_sum in range(T+1):
        if t_sum-items[i][0] >= 0:
            dp1[i+1][t_sum] = max(dp1[i+1][t_sum], dp1[i]
                                  [t_sum-items[i][0]]+items[i][1])
        dp1[i+1][t_sum] = max(dp1[i+1][t_sum], dp1[i][t_sum])

ans = 0
for i in range(N):
    for t in range(T):
        ans = max(ans, dp1[i][t]+items[i][1])
print(ans)

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
N,T=map(int,input().split())
L=[]
for i in range(N):
    a,b=map(int,input().split())
    L.append((a,b))
L.sort()

dp=[-1 for i in range(6001)]
dp[0]=0
for i in range(N):
    for j in range(T):
        if dp[T-1-j]!=-1:
            dp[T-1-j+L[i][0]]=max(dp[T-1-j+L[i][0]],dp[T-1-j]+L[i][1])
print(max(dp))

Submission status: Accepted

Solution code:
N,T = map(int, input().split())
L = [[int(l) for l in input().split()] for _ in range(N)]

dp1 = [[0]*T for _ in range(N+1)]
dp2 = [[0]*T for _ in range(N+1)]

for i in range(N):
    for j in range(T):
        if j < L[i][0]:
            dp1[i+1][j] = dp1[i][j]
        else:
            dp1[i+1][j] = max(dp1[i][j], dp1[i][j-L[i][0]]+L[i][1])
        k = N-i
        if j < L[k-1][0]:
            dp2[k-1][j] = dp2[k][j]
        else:
            dp2[k-1][j] = max(dp2[k][j], dp2[k][j-L[k-1][0]]+L[k-1][1])
            
ans = 0
for i in range(N):
    for j in range(T):
        ans = max(ans, dp1[i][j]+dp2[i+1][T-j-1]+L[i][1])
        
print(ans)

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
N, T = inpl()
AB = sorted([inpl() for _ in range(N)])

ans = 0
dp_intime = [0]*T
for n in range(N):
    dp_intime_prev = dp_intime
    dp_intime = [0]*T
    a, b = AB[n]
    for t in range(T):
        if t < a:
            dp_intime[t] = dp_intime_prev[t]
        else:
            dp_intime[t] = max(dp_intime_prev[t], dp_intime_prev[t-a]+b)
    ans = max(ans, dp_intime_prev[-1]+b)
print(ans)

Submission status: Accepted

Solution code:
N,T = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort()

Tmax = T+3001
dp = [[0 for _ in range(Tmax)] for _ in range(N+1)]
for i in range(N):
  for j in range(Tmax):
    a,b = AB[i]
    if j-a >= 0:
      dp[i+1][j] = max(dp[i][j],dp[i][j-a]+b)
    else:
      dp[i+1][j] = dp[i][j]

maxB = [0 for _ in range(N-1)] + [AB[N-1][1]]
for i in range(N-2,-1,-1):
  maxB[i] = max(AB[i][1],maxB[i+1])
ans = 0
for i in range(1,N):
  ans = max(dp[i][T-1]+maxB[i],ans)
print(ans)

Submission status: Accepted

Solution code:
import numpy as np

N, T = map(int, input().split())
T -= 1

AB = [list(map(int, input().split())) for _ in range(N)]
AB.sort(key = lambda x: x[1])
AB.sort(key = lambda x: x[0], reverse = True)

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

dp = np.zeros(T + 1, dtype = np.int32)

ans = AB[N - 1][1]
for i in range(N - 1, 0, -1):
    # for j in range(T + 1):
    #     if j < AB[i][0]:
    #         dp[i][j] = dp[i + 1][j]
    #     else:
    #         dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - AB[i][0]] + AB[i][1])
    if AB[i][0] <= T + 1:
        dp[AB[i][0]:] = np.maximum(dp[AB[i][0]:], dp[:T + 1 - AB[i][0]] + AB[i][1])
    tmp = dp[T] + AB[i - 1][1]
    ans = max(ans, tmp)
    
print (ans)
# print (AB)

# for i in dp:
#     print (dp)

Submission status: Accepted

Solution code:
import numpy as np
I = [int(_) for _ in open(0).read().split()]
N, T = I[:2]
A, B = I[2::2], I[3::2]
dp = np.array([-1] * 6001, dtype=np.int64)
dp[0] = 0
for a, b in sorted(zip(A, B)):
    dp_new = dp[:]
    dp_new[a:a + T] = np.maximum(dp[a:a + T], dp[:T] + b)
    dp = dp_new
print(max(dp))

Submission status: Accepted

Solution code:
import numpy as np
import sys
input = sys.stdin.readline


n, t = map(int, input().split())
dish = [list(map(int, input().split())) for _ in range(n)]
dish.sort()

ans = 0
dp = np.zeros(t, dtype=int)
for time, point in dish:
    ans = max(ans, dp.max()+point)
    np.maximum(dp[time:], dp[:-time]+point, out=dp[time:])
print(ans)

Submission status: Accepted

Solution code:
from numpy import*
N,T,*L=map(int,open(0).read().split())
d=zeros(6010,int)
for w,v in sorted(zip(*[iter(L)]*2)):d[w:T+w]=maximum(d[w:T+w],d[:T]+v)
print(max(d))

Submission status: Accepted

Solution code:
from numpy import*
N,T,*AB=map(int,open(0).read().split())
dp=zeros(6010,int)
for w,v in sorted(zip(*[iter(AB)]*2)):dp[w:T+w]=maximum(dp[w:T+w],dp[:T]+v)
print(max(dp))

Submission status: Accepted

Solution code:
from numpy import zeros, maximum, array

def main():
    N, T, *AB = map(int, open(0).read().split())

    dp = zeros(T + max(AB[::2]), int)
    for w, v in sorted(zip(*[iter(AB)] * 2)):
        dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

    print(dp.max())

main()

Submission status: Accepted

Solution code:
from numpy import zeros, maximum, array

def main():
    N, T, *AB = array(open(0).read().split(), int)

    dp = zeros(6010, int)
    for w, v in sorted(zip(*[iter(AB)] * 2)):
        dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

    print(dp.max())

main()

Submission status: Accepted

Solution code:
from numpy import zeros, maximum
from sys import stdin

def main():
    N, T, *AB = map(int, stdin.buffer.read().split())

    dp = zeros(6010, int)
    for w, v in sorted(zip(*[iter(AB)] * 2)):
        dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

    print(dp.max())

main()

Submission status: Accepted

Solution code:
from numpy import zeros, maximum, int32

def main():
    N, T, *AB = map(int, open(0).read().split())

    dp = zeros(6010, int32)
    for w, v in sorted(zip(*[iter(AB)] * 2)):
        dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

    print(dp.max())

main()

Submission status: Accepted

Solution code:
from numpy import zeros, maximum

N, T, *AB = map(int, open(0).read().split())

dp = zeros(6010, int)
for w, v in sorted(zip(*[iter(AB)] * 2)):
    dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

print(dp.max())

Submission status: Accepted

Solution code:
from numpy import zeros, maximum

def main():
    N, T, *AB = map(int, open(0).read().split())

    dp = zeros(6010, int)
    for w, v in sorted(zip(*[iter(AB)] * 2)):
        dp[w:T + w] = maximum(dp[w:T + w], dp[:T] + v)

    print(dp.max())

main()