input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
#coding:utf-8
import bisect
import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = True
def main(given = sys.stdin.readline):
input = lambda : given().rstrip()
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
XLMIIS = lambda x : [LMIIS() for _ in range(x)]
n, t = LMIIS()
ab = XLMIIS(n)
dp1 = [[0]*t for _ in range(n)]
for i in range(1, n):
for j in range(1, t):
if j < ab[i-1][0]:
dp1[i][j] = dp1[i-1][j]
else:
dp1[i][j] = max(dp1[i-1][j], dp1[i-1][j-ab[i-1][0]] + ab[i-1][1])
dp2 = [[0]*t for _ in range(n)]
for i in range(1, n):
for j in range(1, t):
if j < ab[n - i][0]:
dp2[i][j] = dp2[i-1][j]
else:
dp2[i][j] = max(dp2[i-1][j], dp2[i-1][j-ab[n-i][0]] + ab[n-i][1])
ans = 0
for i in range(n):
for j in range(t - 1):
ans = max(ans, dp1[i][j] + dp2[n - i - 1][t - j - 1] + ab[i][1])
print(ans)
if __name__ == '__main__':
main()
| #coding:utf-8
import bisect
import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = True
def main(given = sys.stdin.readline):
input = lambda : given().rstrip()
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
XLMIIS = lambda x : [LMIIS() for _ in range(x)]
n, t = LMIIS()
ab = XLMIIS(n)
ab.sort()
dp1 = [[0]*t for _ in range(n+1)]
for i in range(1, n+1):
for j in range(1, t):
if j < ab[i-1][0]:
dp1[i][j] = dp1[i-1][j]
else:
dp1[i][j] = max(dp1[i-1][j], dp1[i-1][j-ab[i-1][0]] + ab[i-1][1])
ans = 0
for i in range(n):
ans = max(ans, dp1[i][t-1] + ab[i][1])
print(ans)
if __name__ == '__main__':
main()
| p02863 |
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
a = []
for _ in range(N):
w, v = list(map(int, input().split()))
a.append((w, v))
a.sort()
dp = [[0] * (T + 1) for _ in range(N + 1)]
for i in range(N):
w, v = a[i]
for j in range(T):
if j + w >= T:
dp[i + 1][T] = max(dp[i + 1][T], dp[i][j] + v)
else:
dp[i + 1][j + w] = max(dp[i + 1][j + w], dp[i][j] + v)
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
dp[i + 1][T] = max(dp[i + 1][T], dp[i][T])
print((max(dp[-1]))) | import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
t = [tuple(map(int, input().split())) for _ in range(N)]
t.sort()
dp = [0] * (T + 1)
for a, b in t:
for i in range(T - 1, -1, -1):
if i + a < T: dp[i + a] = max(dp[i + a], dp[i] + b)
else: dp[-1] = max(dp[-1], dp[i] + b)
print((max(dp))) | p02863 |
# A Dynamic Programming based Python Program for 0-1 Knapsack problem
# Returns the maximum value that can be put in a knapsack of capacity W
# ty geekforgeeks
def knapSack(W, wt, val, n, avoid):
K = [[0 for x in range(W+1)] for x in range(n+1)]
# Build table K[][] in bottom up manner
for i in range(n+1):
for w in range(W+1):
if avoid != None:
index = i if i <= avoid else i + 1
else:
index = i
if i==0 or w==0:
K[i][w] = 0
elif wt[index-1] <= w:
K[i][w] = max(val[index-1] + K[i-1][w-wt[index-1]], K[i-1][w])
else:
K[i][w] = K[i-1][w]
return K[n][W]
N, T = list(map(int, input().split()))
wts = [None for i in range(N)]
val = [None for i in range(N)]
for i in range(N):
a, b = list(map(int, input().split()))
wts[i] = a
val[i] = b
best = knapSack(T, wts, val, N, None)
for i in range(N):
best = max(best, knapSack(T-1, wts, val, N - 1, i) + val[i])
print(best)
| # A Dynamic Programming based Python Program for 0-1 Knapsack problem
# Returns the maximum value that can be put in a knapsack of capacity W
# ty geekforgeeks
def knapSack(W, wt, val, n):
K = [[0 for x in range(W+1)] for x in range(n+1)]
# Build table K[][] in bottom up manner
for i in range(n+1):
for w in range(W+1):
if i==0 or w==0:
K[i][w] = 0
elif wt[i-1] <= w:
K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w])
else:
K[i][w] = K[i-1][w]
res = K[n][W]
w = W
used = [False for i in range(N)]
for i in range(n, 0, -1):
if res <= 0:
break
# either the result comes from the
# top (K[i-1][w]) or from (val[i-1]
# + K[i-1] [w-wt[i-1]]) as in Knapsack
# table. If it comes from the latter
# one/ it means the item is included.
if res == K[i - 1][w]:
continue
else:
# This item is included.
used[i - 1] = True
# Since this weight is included
# its value is deducted
res = res - val[i - 1]
w = w - wt[i - 1]
return K[n][W], used
N, T = list(map(int, input().split()))
wts = [None for i in range(N)]
val = [None for i in range(N)]
for i in range(N):
a, b = list(map(int, input().split()))
wts[i] = a
val[i] = b
best, _ = knapSack(T, wts, val, N)
other, used = knapSack(T - 1, wts, val, N)
add = 0
for i, wasUsed in enumerate(used):
if not wasUsed: add = max(add, val[i])
print((max(best, other + add)))
| p02863 |
N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort(key=lambda x:x[1])
dp1 = [[0]*T for i in range(N+1)]
for n in range(N):
for w in range(T):
if w-AB[n][0]>=0:
dp1[n+1][w] = max(dp1[n][w],dp1[n][w-AB[n][0]]+AB[n][1])
else:
dp1[n+1][w] = dp1[n][w]
for n in range(N):
for w in range(T-1):
dp1[n][w+1] = max(dp1[n][w+1],dp1[n][w])
dp2 = [[0]*T for i in range(N+1)]
for n in range(N):
for w in range(T):
if w-AB[-n-1][0]>=0:
dp2[n+1][w] = max(dp2[n][w],dp2[n][w-AB[-n-1][0]]+AB[-n-1][1])
else:
dp2[n+1][w] = dp2[n][w]
for n in range(N):
for w in range(T-1):
dp2[n][w+1] = max(dp2[n][w+1],dp2[n][w])
ans = 0
for n in range(N):
for w in range(T):
ans = max(AB[n][1]+dp1[n][w]+dp2[N-n-1][T-1-w],ans)
print(ans) | N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort(key=lambda x:x[0])
dp = [[0]*T for i in range(N+1)]
ans = 0
for n in range(N):
for w in range(T):
ans = max(ans,dp[n][w]+AB[n][1])
if w-AB[n][0]>=0:
dp[n+1][w] = max(dp[n][w],dp[n][w-AB[n][0]]+AB[n][1])
else:
dp[n+1][w] = dp[n][w]
print(ans) | p02863 |
import sys
import math
MOD=10**9+7
N,T=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(N)]
l.sort(reverse=True)
dp1=[[-10**10 for i in range(T)] for i in range(N)]
dp2=[[0 for i in range(T)] for i in range(N)]
[a,b]=l[0]
dp1[0][0],dp2[0][0]=0,b
if a<T: dp1[0][a]=b
for i in range(1,N):
[a,b]=l[i]
m=min(a,T)
for j in range(m):
dp1[i][j]=dp1[i-1][j]
dp2[i][j]=max(b,dp2[i-1][j])
for j in range(m,T):
p,q=dp1[i-1][j],dp1[i-1][j-a]+b
if p<q:
dp1[i][j]=q
dp2[i][j]=dp2[i-1][j-a]
elif p>q:
dp1[i][j]=p
dp2[i][j]=max(dp2[i-1][j],b)
else:
dp1[i][j]=p
dp2[i][j]=max(dp2[i-1][j-a],dp2[i-1][j],b)
print((max( dp1[N-1][j]+dp2[N-1][j] for j in range(T) ) )) | ans=0
n,t=list(map(int,input().split()))
food=[]
for i in range(n):
f=list(map(int,input().split()))
food.append(f)
food=sorted(food)
dp=[0,0]+[-1]*(t-1)
for a,b in food:
tmp=[dp[i] for i in range(t)]
for i in range(t):
if dp[i]==-1: continue
j=i+a
if j<t: tmp[j]=max(tmp[j],dp[i]+b)
else: ans=max(ans,dp[i]+b)
dp=[tmp[i] for i in range(t)]
print((max(ans,max(dp)))) | p02863 |
import sys
from operator import itemgetter
sys.setrecursionlimit(5000)
input = sys.stdin.readline
TIME = 0
VAL = 1
N, T = [int(a) for a in input().split()]
time_value = [None] * (N + 1)
time_value[0] = (-1, -1)
for i in range(1, N + 1):
time_value[i] = tuple(int(a) for a in input().split())
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
# T by (N + 1) table for knapsack problem
# maximum possible time is T-1
dp_table = [[-1] * T for _ in range(N + 1)]
# Fill in dp_table i.e. solve knapsack problem
for t in range(0, T):
dp_table[0][t] = 0
for n in range(1, N + 1):
dp_table[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp_table[n][t] = dp_table[n - 1][t]
else:
dp_table[n][t] = max(dp_table[n - 1][t],
time_value[n][VAL] + dp_table[n - 1][t - time_value[n][TIME]])
val_acum = time_value[N][VAL]
t = T - 1
max_val = val_acum + dp_table[N - 1][t]
for n in range(N - 1, 0, -1): # food to eat at the end
val_acum += time_value[n][VAL] # value[N] + value[N-1] + ... + value[n]
t -= time_value[n + 1][TIME] # T - 1 - (time[N] + time[N-1] + ... + time[n + 1])
if t < 0: break
tmp = val_acum + dp_table[n - 1][t]
max_val = max(max_val, tmp)
print(max_val) | import sys
from operator import itemgetter
input = sys.stdin.readline
#################
# 定数
#################
TIME = 0
VAL = 1
##################
# 入力処理
##################
N, T = [int(a) for a in input().split()]
time_value = [(-1, -1)] + [None] * (N)
for i in range(1, N + 1):
time_value[i] = tuple(int(a) for a in input().split())
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
###########################
# 動的計画法（Knapsack problem）のテーブル埋め
# 時間の最大値は T - 1
##########################
dp = [[-1] * T for _ in range(N + 1)] # (N+1)行 x T列 2次元リスト
for t in range(0, T):
dp[0][t] = 0
for n in range(1, N + 1):
dp[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp[n][t] = dp[n - 1][t]
else:
dp[n][t] = max(dp[n - 1][t],
time_value[n][VAL] + dp[n - 1][t - time_value[n][TIME]])
##########################
# DPテーブルを用いて問題を解く
##########################
# t = T - 1に食べ始める料理が N, N-1, N-2, ..., 2, 1それぞれの場合で
# 美味しさの最大値を出し、更にその最大値を取る
# 最後に食べる料理がNの場合
val_acum = time_value[N][VAL]
t = T - 1 # N以外の料理を食べるのに使える時間
max_val = val_acum + dp[N - 1][t]
for n in range(N - 1, 0, -1): # 最後に食べる料理が n = N-1, N-2, ..., 2, 1の場合
val_acum += time_value[n][VAL] # 料理 N, N-1, ..., nの美味しさ合計
t -= time_value[n + 1][TIME] # その他の料理 1, 2, ..., n-1を食べるのに使える時間
if t < 0:
break
else:
max_val = max(max_val, val_acum + dp[n - 1][t])
print(max_val)
| p02863 |
n, t = list(map(int, input().split()))
dp1 = [[-float("inf") for i in range(t)] for i in range(n + 1)]
dp1[0][0] = 0
dp2 = [[-float("inf") for i in range(t)] for i in range(n + 1)]
dp2[n][0] = 0
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
for i in range(n):
a, b = ab[i]
for j in range(t - 1, -1, -1):
if j >= a:
dp1[i + 1][j] = max(dp1[i][j], dp1[i][j - a] + b)
else:
dp1[i + 1][j] = dp1[i][j]
for i in range(n - 1, -1, -1):
a, b = ab[i]
for j in range(t - 1, -1, -1):
if j >= a:
dp2[i][j] = max(dp2[i + 1][j], dp2[i + 1][j - a] + b)
else:
dp2[i][j] = dp2[i + 1][j]
ans = [max([max(dp1[i][:j + 1]) + max(dp2[i + 1][:t - j]) + ab[i][1]]) for j in range(t) for i in range(n)]
print((max(ans))) | n, t = list(map(int, input().split()))
dp1 = [[-float("inf") for i in range(t)] for i in range(n + 1)]
dp1[0][0] = 0
dp2 = [[-float("inf") for i in range(t)] for i in range(n + 1)]
dp2[n][0] = 0
ab = []
for i in range(n):
ab.append(list(map(int, input().split())))
for i in range(n):
a, b = ab[i]
for j in range(t - 1, -1, -1):
if j >= a:
dp1[i + 1][j] = max(dp1[i][j], dp1[i][j - a] + b)
else:
dp1[i + 1][j] = dp1[i][j]
for i in range(n + 1):
for j in range(t - 1):
dp1[i][j + 1] = max(dp1[i][j], dp1[i][j + 1])
for i in range(n - 1, -1, -1):
a, b = ab[i]
for j in range(t - 1, -1, -1):
if j >= a:
dp2[i][j] = max(dp2[i + 1][j], dp2[i + 1][j - a] + b)
else:
dp2[i][j] = dp2[i + 1][j]
for i in range(n + 1):
for j in range(t - 1):
dp2[i][j + 1] = max(dp2[i][j], dp2[i][j + 1])
ans = [max([dp1[i][j] + dp2[i + 1][t - 1 - j] + ab[i][1] for j in range(t)]) for i in range(n)]
print((max(ans))) | p02863 |
# dp[i][t_sum]: i番目までの品物で時間がt_sumを超えないように選んだときの、満足度の総和の最大値
N, T = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for i in range(N)]
dp1 = [[0 for t_sum in range(T+1)] for i in range(N+2)]
dp2 = [[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])
for t_sum in range(T+1):
if t_sum-items[N-1-i][0] >= 0:
dp2[N-1-i][t_sum] = max(dp2[N-1-i][t_sum], dp2[N-i]
[t_sum-items[N-1-i][0]]+items[N-1-i][1])
dp2[N-1-i][t_sum] = max(dp2[N-1-i][t_sum], dp2[N-i][t_sum])
ans = 0
for i in range(N):
for t in range(T):
ans = max(ans, dp1[i][t]+dp2[i+1][T-1-t]+items[i][1])
print(ans)
| # dp[i][t_sum]: i番目までの品物で時間がt_sumを超えないように選んだときの、満足度の総和の最大値
N, T = list(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)
| p02863 |
n,t=list(map(int,input().split()))
ab=[list(map(int,input().split()))for _ in range(n)]
ab.sort()
dp=[6007*[0]for _ in range(n)]
ans=0
for i in range(n):
a,b=ab[i]
for j in range(6007):
if i==0:
if j>=a and j<t:dp[i][j]=b
elif j>=a and j-a<t:dp[i][j]=max(dp[i-1][j-a]+b,dp[i-1][j])
else:dp[i][j]=dp[i-1][j]
ans=max(ans,dp[i][j])
print(ans) | n,t=list(map(int,input().split()))
ab=[list(map(int,input().split()))for _ in range(n)]
ab.sort()
dp=[6007*[0]for _ in range(n)]
for i in range(n):
a,b=ab[i]
for j in range(6007):
if i==0:
if j>=a and j<t:dp[i][j]=b
elif j>=a and j-a<t:dp[i][j]=max(dp[i-1][j-a]+b,dp[i-1][j])
else:dp[i][j]=dp[i-1][j]
print((max(dp[-1]))) | p02863 |
n,t=list(map(int,input().split()))
ab=[list(map(int,input().split()))for _ in range(n)]
ab.sort()
dp=[(6007)*[0]for _ in range(n+1)]
dp[0][0]=0
ans=0
for i in range(n):
for j in range(6007):
dp[i+1][j]=max(dp[i+1][j],dp[i][j])
if j<t:dp[i+1][j+ab[i][0]]=max(dp[i][j]+ab[i][1],dp[i][j+ab[i][0]])
ans=max(ans,dp[i+1][j])
print(ans)
| n,t=list(map(int,input().split()))
dp=[[0]*(t+3001)for _ in range(n+1)]
ans=0
ab=[list(map(int,input().split()))for _ in range(n)]
ab.sort()
for i in range(1,n+1):
a,b=ab[i-1]
for j in range(t):
dp[i][j]=max(dp[i-1][j],dp[i][j])
dp[i][j+a]=dp[i-1][j]+b
ans=max(dp[i][j],dp[i][j+a],ans)
print(ans) | p02863 |
n,t = list(map(int,input().split()))
ab = [[int(i) for i in input().split()] for j in range(n)]
dp = [[0 for i in range(t)] for j in range(n+1)]
ans = 0
for h in range(n):
dp = [[0 for i in range(t)] for j in range(n+1)]
for i in range(n):
if h == 0 and i == 0:
continue
if h == i:
dp[i+1] = dp[i]
continue
for j in range(t):
#print(h,i)
dp[i+1][j] = dp[i][j]
#print(j,ab[i][0])
if j < ab[i][0]:
#print(j)
continue
#if dp[i][j] < dp[i][j-ab[i][0]] + ab[i][1]:
# dp[i+1][j] = dp[i][j-ab[i][0]] + ab[i][1]
dp[i+1][j] = max(dp[i][j],dp[i][j-ab[i][0]] + ab[i][1])
#print(dp)
#print(h,dp)
ans = max(ans,dp[n][t-1]+ab[h][1])
print(ans) | n,t = list(map(int,input().split()))
ab = [[int(i) for i in input().split()] for j in range(n)]
dp = [[0 for i in range(t)] for j in range(n+1)]
ab.sort()
ans = 0
for i in range(n):
for j in range(t):
#for k in range(2):
#dp[i+1][j] = max(dp[i][j],dp[i-1][j])
dp[i+1][j] = dp[i][j]
#print(j,ab[i][0])
if j >= ab[i][0]:
#if dp[i][j] < dp[i][j-ab[i][0]] + ab[i][1]:
# dp[i+1][j] = dp[i][j-ab[i][0]] + ab[i][1]
dp[i+1][j] = max(dp[i][j],dp[i][j-ab[i][0]] + ab[i][1])
#print(dp)
#print(h,dp)
#print(ab)
#print(dp)
max_num = [0]*n
for i in reversed(list(range(n))):
#print(i)
if i == 0:
break
if max_num[i] < ab[i][1]:
max_num[i-1] = ab[i][1]
else:
max_num[i-1] = max_num[i]
#print(max_num)
#print(ab[2272:2336])
#exit()
ans = 0
for i in range(n-1):
#print(i)
if ans < dp[i+1][t-1]+max_num[i]:
ans = dp[i+1][t-1]+max_num[i]
#print(i,ans,max_num[i],max_num[i+1],max_num[i-1])
#ans = max(ans,)
#print(max(ab[i:][1]))
#print()
print(ans)
#print()) | p02863 |
n,t = list(map(int,input().split()))
food = [[0,0] for i in range(n)]
for i in range(n):
a,b = list(map(int,input().split()))
food[i][0] = a
food[i][1] = b
dp = [[-10000000 for i in range((n+1)*3000)] for j in range(n+1)]
dp[0][0] = 0
for i in range(n):
a = food[i][0]
b = food[i][1]
for j in range(t):
eat = dp[i][j]+b
next_time = j+a
# print(j,next_time)
if dp[i+1][next_time] < eat:
dp[i+1][next_time] = eat
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
# for i in range(n):
# for j in range(10,21):
# print(dp[i][j],end=" ")
# print()
print((max(dp[-1]))) | n,t = list(map(int,input().split()))
orders = []
for i in range(n):
a,b = list(map(int,input().split()))
orders.append([a,b])
orders.sort(key=lambda x:(x[0],-x[1]))
# print(orders)
dp = [[-1e10 for i in range(t+1)] for j in range(n+1)]
dp[0][0] = 0
for i,od in enumerate(orders):
for j in range(t+1):
dp[i+1][j] = dp[i][j]
for j in range(t):
nt = j+od[0]
if nt > t-1:
nt = t
if dp[i+1][nt] < dp[i][j]+od[1]:
dp[i+1][nt] = dp[i][j]+od[1]
# for l in dp:
# print(l[:11])
# print(dp[-1])
print((max(dp[-1]))) | p02863 |
n, t = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
a = []
b = []
for ai, bi in ab:
a.append(ai)
b.append(bi)
dp = [[0 for j in range(t+1)] for i in range(n+1)]
prev = [[(0, 0) for j in range(t+1)] for i in range(n+1)]
for i in range(n):
for j in range(t):
if j + a[i] <= t-1:
if dp[i+1][j + a[i]] < dp[i][j] + b[i]:
dp[i+1][j + a[i]] = dp[i][j] + b[i]
prev[i+1][j+a[i]] = (i, j)
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
prev[i+1][j] = (i, j)
happy = dp[n][t-1]
i = n
j = t-1
used = set([])
while i > 0 or j > 0:
pi, pj = prev[i][j]
if dp[pi][pj] != dp[i][j]:
used.add(pi)
i = pi
j = pj
unused = []
for i in range(n):
if i not in used:
unused.append(b[i])
if len(unused) == 0:
ans = happy
else:
ans = happy + max(unused)
print(ans)
| n, t = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
a = []
b = []
for ai, bi in ab:
a.append(ai)
b.append(bi)
dp = [[0 for j in range(t+1)] for i in range(n+1)]
for i in range(n):
for j in range(t):
if j + a[i] <= t-1:
if dp[i+1][j + a[i]] < dp[i][j] + b[i]:
dp[i+1][j + a[i]] = dp[i][j] + b[i]
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
ans = 0
for i in range(n):
ans = max(ans, dp[i][t-1] + b[i])
print(ans)
| p02863 |
N, T = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
items.sort()
ans = 0
dp = {0: 0}
for wi, vi in items:
for w, v in list(dp.items()):
if w < T:
v2 = v + vi
if v2 > ans:
ans = v2
for w, v in list(dp.items()):
w2 = w + wi
if w2 <= T:
v2 = v + vi
if w2 in dp:
if v2 > dp[w2]:
dp[w2] = v2
else:
dp[w2] = v2
v2 = max(dp.values())
ans = max(ans, v2)
print(ans)
| import sys
input = sys.stdin.readline
def solve():
N, T = list(map(int, input().split()))
items = [tuple(map(int, input().split())) for _ in range(N)]
items.sort()
capW = T-1
dp = [0] * (capW+1)
ans = 0
for wi, vi in items:
ans = max(ans, dp[-1]+vi)
for w in reversed(list(range(wi, capW+1))):
v0 = dp[w-wi] + vi
if v0 > dp[w]:
dp[w] = v0
print(ans)
solve()
| p02863 |
import heapq as hq
def resolve():
(N,T)=(int(i) for i in input().split())
dishes=[[int(i) for i in input().split()] for _ in range(N)]
dishes.sort()
dpt=[[-1 for i in range(T+1)] for _ in range(N+1)]
vflg=[[False for i in range(T+1)] for _ in range(N+1)]
dpt[0][0]=0
q=[]
hq.heappush(q,(0,0))
while q:
(ind,cost)=hq.heappop(q)
if vflg[ind][cost]:
continue
vflg[ind][cost]=True
if ind==N:
break
aft=min(cost+dishes[ind][0],T)
sc=dpt[ind][cost]
if dpt[ind+1][cost]<sc:
dpt[ind+1][cost]=sc
hq.heappush(q,(ind+1,cost))
if cost==T:
continue
if dpt[ind+1][aft]<sc+dishes[ind][1]:
dpt[ind+1][aft]=sc+dishes[ind][1]
hq.heappush(q,(ind+1,aft))
print((max(dpt[-1])))
if __name__ == "__main__":
resolve() |
def resolve():
(N,T)=(int(i) for i in input().split())
dishes=[[int(i) for i in input().split()] for _ in range(N)]
dishes.sort()
dpt=[[-1 for i in range(T+1)] for _ in range(N+1)]
dpt[0][0]=0
for i in range(N):
for j in range(T):
dpt[i+1][j]=max(dpt[i+1][j],dpt[i][j])
dpt[i+1][min(T,j+dishes[i][0])]=max(dpt[i+1][min(T,j+dishes[i][0])],dpt[i][j]+dishes[i][1])
dpt[i+1][T]=max(dpt[i+1][T],dpt[i][T])
print((max(dpt[-1])))
# for i in dpt:
# print(i)
if __name__ == "__main__":
# unittest.main()
resolve() | p02863 |
def main():
N, T = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
AB.sort()
A = [a[0] for a in AB]
B = [b[1] for b in AB]
dp1 = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(T):
dp1[i+1][j] = max(dp1[i+1][j], dp1[i][j])
t = j - A[i]
if 0 <= t:
dp1[i+1][j] = max(dp1[i+1][j], dp1[i][t] + B[i])
ans = 0
for i in range(N):
ans = max(ans, dp1[i][T-1] + B[i])
print(ans)
if __name__ == '__main__':
main()
| def main():
N, T = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
AB.sort()
A = [a[0] for a in AB]
B = [b[1] for b in AB]
ans = 0
dp1 = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(T):
t = j - A[i]
if 0 <= t:
dp1[i+1][j] = max(dp1[i][j], dp1[i][t] + B[i])
else:
dp1[i+1][j] = dp1[i][j]
ans = max(ans, dp1[i][T-1] + B[i])
print(ans)
if __name__ == '__main__':
main()
| p02863 |
def main():
N, T = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
A = [a[0] for a in AB]
B = [b[1] for b in AB]
dp1 = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(T):
t = j - A[i]
if 0 <= t:
dp1[i+1][j] = max(dp1[i][j], dp1[i][t] + B[i])
else:
dp1[i+1][j] = dp1[i][j]
dp2 = [[0]*(T+1) for _ in range(N+2)]
for i in range(1, N+1)[::-1]:
for j in range(T):
t = j - A[i-1]
if 0 <= t:
dp2[i][j] = max(dp2[i+1][j], dp2[i+1][t] + B[i-1])
else:
dp2[i][j] = dp2[i+1][j]
ans = 0
for i in range(N):
for j in range(T):
ans = max(ans, dp1[i][j] + dp2[i+2][T - 1 - j] + B[i])
print(ans)
if __name__ == '__main__':
main()
| def main():
N, T = (int(i) for i in input().split())
AB = [[int(i) for i in input().split()] for j in range(N)]
AB.sort()
ans = 0
dp1 = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(T):
t = j - AB[i][0]
if 0 <= t:
dp1[i+1][j] = max(dp1[i][j], dp1[i][t] + AB[i][1])
else:
dp1[i+1][j] = dp1[i][j]
ans = max(ans, dp1[i][T-1] + AB[i][1])
print(ans)
if __name__ == '__main__':
main()
| p02863 |
n, T = list(map(int, input().split()))
food = []
for _ in range(n):
a, b = list(map(int, input().split()))
food.append((a, b))
dp1 = [[0]*T for _ in range(1+n)]
dp2 = [[0]*T for _ in range(1+n)]
for i in range(n):
for j in range(T):
dp1[i+1][j] = dp1[i][j]
if j - food[i][0] >= 0:
dp1[i+1][j] = max(dp1[i+1][j], dp1[i][j-food[i][0]] + food[i][1])
for i in range(n-1, -1, -1):
for j in range(T):
dp2[i][j] = dp2[i+1][j]
if j - food[i][0] >= 0:
dp2[i][j] = max(dp2[i][j], dp2[i+1][j-food[i][0]] + food[i][1])
res = 0
for i in range(n):
for j in range(T):
res = max(res, food[i][1] + dp1[i][j] + dp2[i+1][T-1-j])
print(res) | n, t = list(map(int, input().split()))
l = []
for i in range(n):
a, b = list(map(int, input().split()))
l.append((a, b))
l.sort()
ans = 0
dp = [[0]*t for _ in range(n+1)]
for i in range(n):
cur = dp[i][t-1] + l[i][1]
ans = max(ans, cur)
for j in range(t):
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
nj = j+l[i][0]
if nj < t:
dp[i+1][nj] = max(dp[i+1][nj], dp[i][j]+l[i][1])
print(ans) | p02863 |
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub
sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62-1
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().strip()
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, T, AB):
AB.sort(key=lambda x: x[0])
dp = [[0] * (N+1) for _ in range(T)]
for t in range(T):
for i in range(len(AB)):
a, b = AB[i]
if t >= a:
dp[t][i] = max(dp[t-a][i-1] + b, dp[t-1][i], dp[t][i-1])
else:
dp[t][i] = max(dp[t-1][i], dp[t][i-1])
B = list(map(lambda x: x[1], AB))
B.append(0)
dp = dp[-1]
dp.pop()
ans = 0
for i, v in enumerate(dp):
ans = max(ans, v + max(B[i+1:]))
return ans
def main():
N, T = read_int_n()
AB = [read_int_n() for _ in range(N)]
print(slv(N, T, AB))
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62-1
def read_int():
return int(buff_readline())
def read_int_n():
return list(map(int, buff_readline().split()))
def read_float():
return float(buff_readline())
def read_float_n():
return list(map(float, buff_readline().split()))
def read_str():
return readline().strip()
def read_str_n():
return readline().strip().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
class Mod:
def __init__(self, m):
self.m = m
def add(self, a, b):
return (a + b) % self.m
def sub(self, a, b):
return (a - b) % self.m
def mul(self, a, b):
return ((a % self.m) * (b % self.m)) % self.m
def div(self, a, b):
return self.mul(a, pow(b, self.m-2, self.m))
def pow(self, a, b):
return pow(a, b, self.m)
class Bisect:
def __init__(self, func):
self.__func = func
def bisect_left(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if self.__func(mid) < x:
lo = mid+1
else:
hi = mid
return lo
def bisect_right(self, x, lo, hi):
while lo < hi:
mid = (lo+hi)//2
if x < self.__func(mid):
hi = mid
else:
lo = mid+1
return lo
@mt
def slv(N, T, AB):
AB.sort()
memo = [-1] * (T + max(a for a, b in AB))
memo[0] = 0
for a, b in AB:
nm = memo[:]
for t in range(T):
if memo[t] == -1:
continue
nm[t+a] = max(nm[t+a], memo[t]+b)
memo = nm
# print(memo)
return max(memo)
def main():
N, T = read_int_n()
AB = [read_int_n() for _ in range(N)]
print(slv(N, T, AB))
if __name__ == '__main__':
main()
| p02863 |
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
dp = [-1] * (T + 3000)
dp[0] = 0
c = 0
for a, b in sorted(AB):
for j in range(c, -1, -1):
if dp[j] == -1:
continue
t = dp[j] + b
if dp[j + a] < t:
dp[j + a] = t
c = min(c + a, T - 1)
print((max(dp)))
| def main():
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
dp = [-1] * (T + 3000)
dp[0] = 0
c = 0
for a, b in sorted(AB):
for j in range(c, -1, -1):
if dp[j] == -1:
continue
t = dp[j] + b
if dp[j + a] < t:
dp[j + a] = t
c = min(c + a, T - 1)
print((max(dp)))
main()
| p02863 |
import sys
input=sys.stdin.readline #input高速化 １文字の時の改行文字に注意+
d={i:0 for i in range(3001)}
db={i:0 for i in range(3001)}
n,t=list(map(int,input().split()))
x=[tuple(map(int,input().split()))for i in range(n)]
dp=[]
dp2=[]
for time,value in x:
for k,v in list(d.copy().items()):
if k+time<t:
if d[k+time]<v+value:
d[k+time]=v+value
l=[0]
for i in range(1,t+1):
if d[i]>l[-1]:
l.append(d[i])
else:
l.append(l[-1])
dp.append(l)
for time,value in x[::-1]:
for k,v in list(db.copy().items()):
if k+time<t:
if db[k+time]<v+value:
db[k+time]=v+value
l=[0]
for i in range(1,t+1):
if db[i]>l[-1]:
l.append(db[i])
else:
l.append(l[-1])
dp2.append(l)
dp=[[0]*t,[0]*t]+dp
dp2=([[0]*t,[0]*t]+dp2)[::-1]
ans=0
for i in range(len(dp)):
for j in range(t):
if i==0 or i==len(dp)-1:
tmp=dp[i][j]+dp2[i][t-j-1]
if ans<tmp:
ans=tmp
else:
tmp=dp[i][j]+dp2[i][t-j-1]+x[i-1][1]
if tmp>ans:
ans=tmp
print(ans) | import sys
input=sys.stdin.readline #input高速化 １文字の時の改行文字に注意+
d={i:0 for i in range(3001)}
db={i:0 for i in range(3001)}
n,t=list(map(int,input().split()))
x=sorted([tuple(map(int,input().split()))for i in range(n)],key=lambda xxx:xxx[0])
dp=[]
dp2=[]
for time,value in x:
for k,v in list(d.copy().items()):
if k+time<t:
if d[k+time]<v+value:
d[k+time]=v+value
else:
break
l=[0]
for i in range(1,t+1):
if d[i]>l[-1]:
l.append(d[i])
else:
l.append(l[-1])
dp.append(l)
for time,value in x[::-1]:
for k,v in list(db.copy().items()):
if k+time<t:
if db[k+time]<v+value:
db[k+time]=v+value
else:
break
l=[0]
for i in range(1,t+1):
if db[i]>l[-1]:
l.append(db[i])
else:
l.append(l[-1])
dp2.append(l)
dp=[[0]*t,[0]*t]+dp
dp2=([[0]*t,[0]*t]+dp2)[::-1]
ans=0
for i in range(len(dp)):
for j in range(t):
if i==0 or i==len(dp)-1:
tmp=dp[i][j]+dp2[i][t-j-1]
if ans<tmp:
ans=tmp
else:
tmp=dp[i][j]+dp2[i][t-j-1]+x[i-1][1]
if tmp>ans:
ans=tmp
print(ans) | p02863 |
N,T = list(map(int,input().split()))
item=[list(map(int,input().split())) for _ in range(N)]
item = sorted(item,key=lambda x:x[0])
dp=[[0]*(T+3000) for _ in range(N+1)]
for i,(a,b) in enumerate(item,1):
for t in reversed(list(range(T))):
dist=t+a
dp[i][dist] = max(dp[i-1][t]+b,dp[i][dist])
dp[i][t]=max(dp[i-1][t],dp[i-1][t])
ans=0
for l in dp:
ans=max(ans,max(l))
print(ans)
| N,T = list(map(int,input().split()))
item=[list(map(int,input().split())) for _ in range(N)]
item = sorted(item,key=lambda x:x[0])
dp=[[0]*(T+1) for _ in range(N+1)]
for i,(a,b) in enumerate(item,1):
for t in reversed(list(range(T))):
dist=min(T,t+a)
dp[i][dist] = max(dp[i-1][t]+b,dp[i][dist])
dp[i][t]=max(dp[i-1][t],dp[i-1][t])
ans=0
for l in dp:
ans=max(ans,max(l))
print(ans)
| p02863 |
#"""
import sys
input = sys.stdin.readline
#"""
N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in [0]*N]
dp = [[[0,[]] for _ in [0]*T] for _ in [0]*(N+1)]
for i in range(N):
a,b = AB[i]
for t in range(T):
dp[i+1][t][0] = dp[i][t][0]
dp[i+1][t][1] = dp[i][t][1][:]
if t-a>=0:
if dp[i+1][t][0] < dp[i][t-a][0] + b:
dp[i+1][t][0] = dp[i][t-a][0]+b
dp[i+1][t][1] = dp[i][t-a][1][:]
dp[i+1][t][1].append(i)
ans0 = dp[N][-1][0]
ans = ans0
s = set(dp[N][-1][1])
for i in range(N):
if i in s:continue
ans = max(ans,ans0+AB[i][1])
print(ans) | #"""
import sys
input = sys.stdin.readline
#"""
N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in [0]*N]
dp = [[0 for _ in [0]*T] for _ in [0]*(N+1)]
for i in range(N):
a,b = AB[i]
for t in range(T):
dp[i+1][t] = dp[i][t]
if t-a>=0:
dp[i+1][t] = max(dp[i+1][t],dp[i][t-a]+b)
s = []
t = T-1
for j in range(N-1,-1,-1):
a,b = AB[j]
while (dp[j+1][t] == dp[j+1][t-1]) and t>0:
t -= 1
if dp[j+1][t] == dp[j][t]:
pass
else:
t -= a
s.append(j)
ans0 = dp[N][-1]
ans = ans0
for i in range(N):
if s and i==s[-1] :
s.pop()
continue
ans = max(ans,ans0+AB[i][1])
print(ans) | p02863 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,T=list(map(int,input().split()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
AB.sort()
dp=[0]*T
ans=-INF
for i in range(n):
a,b=AB[i]
ndp=dp[:]
for t in range(T):
if(t+a<T):
ndp[t+a]=max(ndp[t+a],dp[t]+b)
else:
ans=max(ans,dp[t]+b)
dp=ndp
print((max(ans,max(dp))))
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,T=list(map(int,input().split()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
AB.sort()
dp=[0]*T
ans=-INF
for i in range(n):
a,b=AB[i]
ndp=dp[:]
for t in range(T):
if(t+a<T):
ndp[t+a]=max(ndp[t+a],dp[t]+b)
else:
ans=max(ans,dp[t]+b)
dp=ndp
print(ans)
resolve() | p02863 |
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n,T=list(map(int,input().split()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
AB.sort()
dp=[0]*T
ans=-INF
for i in range(n):
a,b=AB[i]
ndp=dp[:]
for t in range(T):
if(t+a<T):
ndp[t+a]=max(ndp[t+a],dp[t]+b)
else:
ans=max(ans,dp[t]+b)
dp=ndp
print(ans)
resolve() | import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
n,t=list(map(int,input().split()))
AB=[tuple(map(int,input().split())) for _ in range(n)]
AB.sort()
ans=0
dp=[0]*t
for a,b in AB:
ans=max(ans,dp[-1]+b)
ndp=dp[:]
for i in range(t):
if(i+a<t):
ndp[i+a]=max(ndp[i+a],dp[i]+b)
dp=ndp
print(ans)
resolve() | p02863 |
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
DP = [[[0] * 2 for _ in range(T)] for _ in range(N)]
a, b = AB[0]
if a < T:
DP[0][a][0] = b
DP[0][0][1] = b
for i in range(1, N):
a, b = AB[i]
if a < T:
DP[i][a][0] = b
DP[i][0][1] = b
for j in range(T):
DP[i][j][0] = max(DP[i][j][0], DP[i - 1][j][0])
DP[i][j][1] = max(DP[i][j][1], DP[i - 1][j][1])
if j + a < T:
DP[i][j + a][0] = max(DP[i][j + a][0], DP[i - 1][j][0] + b)
DP[i][j + a][1] = max(DP[i][j + a][1], DP[i - 1][j][1] + b)
DP[i][j][1] = max(DP[i][j][1], DP[i - 1][j][1])
DP[i][j][1] = max(DP[i][j][1], DP[i - 1][j][0] + b)
ans = 0
for i in range(T):
ans = max(ans, DP[-1][i][0])
ans = max(ans, DP[-1][i][1])
print(ans) | import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(N)]
DP = [[[0] * 2 for _ in range(T)] for _ in range(2)]
a, b = AB[0]
if a < T:
DP[0][a][0] = b
DP[0][0][1] = b
t = 1
for i in range(1, N):
a, b = AB[i]
if a < T:
DP[t][a][0] = b
DP[t][0][1] = b
for j in range(T):
DP[t][j][0] = max(DP[t][j][0], DP[1 - t][j][0])
DP[t][j][1] = max(DP[t][j][1], DP[1 - t][j][1])
if j + a < T:
DP[t][j + a][0] = max(DP[t][j + a][0], DP[1 - t][j][0] + b)
DP[t][j + a][1] = max(DP[t][j + a][1], DP[1 - t][j][1] + b)
DP[t][j][1] = max(DP[t][j][1], DP[1 - t][j][1])
DP[t][j][1] = max(DP[t][j][1], DP[1 - t][j][0] + b)
t = 1 - t
ans = 0
for i in range(T):
ans = max(ans, DP[1 - t][i][0])
ans = max(ans, DP[1 - t][i][1])
print(ans) | p02863 |
from collections import defaultdict
from heapq import heappush, heappop
N, T = list(map(int, input().split()))
dic = defaultdict(list)
ls = []
pre = []
log = [[1]*N]*T
dp = [0]*(T)
for i in range(N):
a, b = list(map(int, input().split()))
ls += [(a,b)]
if a<T:
for j in range(T-1,a-1,-1):
if dp[j-a]+b>dp[j]:
dp[j] = dp[j-a]+b
log[j] = log[j-a][:]
log[j][i] = 0
else:
heappush(pre, -b)
m = 0
ind = -1
his = None
for j in range(T):
if dp[j]>m:
m = dp[j]
ind = j
for c in range(N):
if log[ind][c]:
heappush(pre,-ls[c][1])
if pre:
m -= heappop(pre)
print(m) | N, T = list(map(int, input().split()))
dp = [[0]*T for i in range(N+1)]
ls = []
for i in range(N):
a, b = list(map(int, input().split()))
ls += [(a,b)]
ls.sort(key=lambda x:x[0])
for i in range(N):
a, b = ls[i]
for j in range(T-1, a-1, -1):
dp[i+1][j] = max(dp[i][j], dp[i][j-a]+b)
pre = [0]*N
pre[-1] = ls[-1][1]
for i in range(N-2, -1, -1):
pre[i] = max(pre[i+1], ls[i][1])
ans = 0
for i in range(N-1):
ans = max(ans, max(dp[i+1])+pre[i+1])
ans = max(ans, max(dp[-1]))
print(ans) | p02863 |
N, T = list(map(int, input().split()))
ls = []
for i in range(N):
a, b = list(map(int, input().split()))
ls += [(a,b)]
ls.sort(key=lambda x:x[0])
dp = [[0]*(T) for i in range(N+1)]
for i in range(N):
a,b = ls[i]
for j in range(T-1, a-1, -1):
dp[i+1][j] = max(dp[i][j], dp[i][j-a]+b)
last = [0]*N
last[-1] = ls[-1][1]
for i in range(N-2, -1, -1):
last[i] = max(last[i+1], ls[i][1])
ans = 0
for i in range(1,N+1):
ans = max(ans, max(dp[i-1])+last[i-1])
print(ans)
| N, T = list(map(int, input().split()))
ls = []
for i in range(N):
a, b = list(map(int, input().split()))
ls += [(a,b)]
ls.sort(key=lambda x:x[0])
t = [[0]*T for i in range(N+1)]
for i in range(1,N+1):
a, b = ls[i-1]
for j in range(T):
if j-a>=0:
t[i][j] = max(t[i-1][j-a]+b,t[i-1][j])
last = [0]
for i in range(N-1,-1,-1):
last += [max(last[-1], ls[i][-1])]
ans = 0
for i in range(1,N+1):
j = N-i
ans = max(ans, last[j]+t[i][-1])
print(ans) | p02863 |
N,T = list(map(int,input().split()))
A = [0]*N
B = [0]*N
for i in range(N):
A[i],B[i] = list(map(int,input().split()))
# T-1分以内に完食を目指す，特定の料理のみ使わないで計算したい．
#DP1[i][t]はi番目の料理まででt分後までに完食で得られる幸福度の最大(商品番号は1から振る)
#DP2[i][t]はiからN番目の料理でt分後までに完食で得られる幸福度の最大
dp1 =[[0]*T for _ in range(N+1)]
dp2 =[[0]*T for _ in range(N+1)]
for i in range(N):
for t in range(1,T):
dp1[i+1][t] = dp1[i][t]
if t-A[i]>=0:
dp1[i+1][t]=max(dp1[i][t],dp1[i][t-A[i]]+B[i])
for i in reversed(list(range(0,N))):
for t in range(1,T):
dp2[i][t] = dp2[i+1][t]
if t-A[i]>=0:
dp2[i][t]=max(dp2[i+1][t],dp2[i+1][t-A[i]]+B[i])
ans=0
#i番目の料理を時間ギリギリに注文
for i in range(1,N):
for j in range(0,T):
ans = max(ans,dp1[i][j]+dp2[i+1][T-1-j]+B[i])
print(ans) | #Aをソートしておく，時間ギリギリにi番目の料理を頼むことで固定．
N,T = list(map(int,input().split()))
AB = [[0,0] for _ in range(N)]
for i in range(N):
AB[i][0],AB[i][1] = list(map(int,input().split()))
AB.sort()
#ソートした時のbの情報を維持しないと
# T-1分以内にi番目以外の料理をできるだけ完食する
#DP1[i][t]はi番目の料理まででt分後までに完食で得られる幸福度の最大(商品番号は1から振る)
dp1 =[[0]*T for _ in range(N+1)]
for i in range(N):
for t in range(1,T):
dp1[i+1][t] = dp1[i][t]
if t-AB[i][0]>=0:
dp1[i+1][t]=max(dp1[i][t],dp1[i][t-AB[i][0]]+AB[i][1])
ans=0
for i in range(N):
ans=max(ans,dp1[i][-1]+AB[i][1])
print(ans) | p02863 |
N,T = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N)]
AB.sort()
# dp[i][j]: 満足度の最大値
# i: i品目まで
# j: 制限時間(< T)
dp = [[0] * 3100 for _ in range(3100)]
dp[0][0] = 0
# 貰うDP
ans = 0
for i in range(1, N + 1):
for j in range(T):
dp[i][j] = dp[i - 1][j]
# ラストオーダーはAB[i - 1]
ans = max(ans, dp[i][j] + AB[i - 1][1])
if j - AB[i - 1][0] >= 0:
dp[i][j] = max(dp[i][j], dp[i - 1][j - AB[i - 1][0]] + AB[i - 1][1])
print(ans) | def main():
N,T = list(map(int, input().split()))
AB = [[int(i) for i in input().split()] for _ in range(N)]
AB.sort()
# dp[i][j]: 満足度の最大値
# i: i品目まで
# j: 制限時間(< T)
dp = [[0] * 3100 for _ in range(3100)]
dp[0][0] = 0
# 貰うDP
ans = 0
for i in range(1, N + 1):
for j in range(T):
dp[i][j] = dp[i - 1][j]
# ラストオーダーはAB[i - 1]
ans = max(ans, dp[i][j] + AB[i - 1][1])
if j - AB[i - 1][0] >= 0:
dp[i][j] = max(dp[i][j], dp[i - 1][j - AB[i - 1][0]] + AB[i - 1][1])
print(ans)
if __name__ == "__main__":
main() | p02863 |
def solve():
from collections import namedtuple
import sys
input = sys.stdin.readline
Dish = namedtuple('Dish', 'idx cost pt')
n, t = list(map(int, input().split()))
dishes = []
for idx in range(1, n + 1):
cost, pt = list(map(int, input().split()))
dishes.append(Dish(idx=idx, cost=cost, pt=pt))
dp_ht = [[0] * t for _ in range(n + 2)] # head->tail
dp_th = [[0] * t for _ in range(n + 2)] # tail->head
# dp[注文可能な範囲の端][完食にかかる総時間]:= 美味しさの最大値
for dish in dishes:
for cost_ in range(t):
if cost_ >= dish.cost:
dp_ht[dish.idx][cost_] = max(dp_ht[dish.idx - 1][cost_],
dp_ht[dish.idx - 1][cost_ - dish.cost] + dish.pt)
else:
dp_ht[dish.idx][cost_] = dp_ht[dish.idx - 1][cost_]
for dish in reversed(dishes):
for cost_ in range(t):
if cost_ >= dish.cost:
dp_th[dish.idx][cost_] = max(dp_th[dish.idx + 1][cost_],
dp_th[dish.idx + 1][cost_ - dish.cost] + dish.pt)
else:
dp_th[dish.idx][cost_] = dp_th[dish.idx + 1][cost_]
ret = 0
for last_dish in dishes:
for cost_ in range(t):
ret = max(ret, dp_ht[last_dish.idx - 1][cost_] + dp_th[last_dish.idx + 1][t - 1 - cost_] + last_dish.pt)
return ret
print((solve()))
| def solve():
from collections import namedtuple
import sys
input = sys.stdin.readline
Dish = namedtuple('Dish', 'idx cost pt')
n, t = list(map(int, input().split()))
dishes = []
for idx in range(1, n + 1):
cost, pt = list(map(int, input().split()))
dishes.append(Dish(idx=idx, cost=cost, pt=pt))
dp = [[0] * 2 for _ in range(t)]
# dp[完食にかかる総時間][最後の皿を選んだか]:= 美味しさの最大値
for dish in dishes:
for cost_ in range(t - 1, -1, -1):
dp[cost_][True] = max(dp[cost_][True], dp[cost_][False] + dish.pt)
if cost_ >= dish.cost:
dp[cost_][False] = max(dp[cost_][False], dp[cost_ - dish.cost][False] + dish.pt)
dp[cost_][True] = max(dp[cost_][True], dp[cost_ - dish.cost][True] + dish.pt)
return max(dp[cost_][True] for cost_ in range(t))
print((solve()))
# 最後の皿を選んだかフラグを設ける
# https://sen-comp.hatenablog.com/entry/2019/11/17/003150
| p02863 |
def solve():
from collections import namedtuple
import sys
input = sys.stdin.readline
Dish = namedtuple('Dish', 'idx cost pt')
n, t = list(map(int, input().split()))
dishes = []
for idx in range(1, n + 1):
cost, pt = list(map(int, input().split()))
dishes.append(Dish(idx=idx, cost=cost, pt=pt))
dp = [[0] * 2 for _ in range(t)]
# dp[完食にかかる総時間][最後の皿を選んだか]:= 美味しさの最大値
for dish in dishes:
for cost_ in range(t - 1, -1, -1):
dp[cost_][True] = max(dp[cost_][True], dp[cost_][False] + dish.pt)
if cost_ >= dish.cost:
dp[cost_][False] = max(dp[cost_][False], dp[cost_ - dish.cost][False] + dish.pt)
dp[cost_][True] = max(dp[cost_][True], dp[cost_ - dish.cost][True] + dish.pt)
return max(dp[cost_][True] for cost_ in range(t))
print((solve()))
# 最後の皿を選んだかフラグを設ける
# https://sen-comp.hatenablog.com/entry/2019/11/17/003150
| def solve():
from collections import namedtuple
from operator import attrgetter
import sys
input = sys.stdin.readline
Dish = namedtuple('Dish', 'idx cost pt')
n, t = list(map(int, input().split()))
dishes = []
for idx in range(1, n + 1):
cost, pt = list(map(int, input().split()))
dishes.append(Dish(idx=idx, cost=cost, pt=pt))
dishes.sort(key=attrgetter('cost'))
dp = [0] * t
# dp[完食にかかる総時間]:= 美味しさの最大値
ret = 0
for dish in dishes:
for cost_ in range(t - 1, -1, -1):
ret = max(ret, dp[cost_] + dish.pt)
if cost_ >= dish.cost:
dp[cost_] = max(dp[cost_], dp[cost_ - dish.cost] + dish.pt)
return ret
print((solve()))
# コスト昇順ソートした皿で、DPする
# 各皿は最後の皿（コスト0で、ポイントだけ加算し、以降は皿を取れない）にすることができる
# 最後の皿を選んだ時点でのポイントのmax
# https://sen-comp.hatenablog.com/entry/2019/11/17/003150
| p02863 |
N, T, *AB = list(map(int, open(0).read().split()))
dp = [0] * (T + max(AB[::2]))
for w, v in sorted(zip(*[iter(AB)] * 2)):
for i in reversed(list(range(T))):
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
| def main():
N, T, *AB = list(map(int, open(0).read().split()))
dp = [0] * (T + max(AB[::2]))
for w, v in sorted(zip(*[iter(AB)] * 2)):
for i in reversed(list(range(T))):
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
main() | p02863 |
def main():
N, T, *AB = list(map(int, open(0).read().split()))
dp = [0] * (T + max(AB[::2]))
for w, v in sorted(zip(*[iter(AB)] * 2)):
for i in reversed(list(range(T))):
dp[i + w] = max(dp[i + w], dp[i] + v)
print((max(dp)))
main() | def main():
N, T, *AB = list(map(int, open(0).read().split()))
dp = [0] * (T + max(AB[::2]))
for w, v in sorted(zip(*[iter(AB)] * 2)):
for i in reversed(list(range(T))):
if dp[i + w] < dp[i] + v:
dp[i + w] = dp[i] + v
print((max(dp)))
main()
| p02863 |
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
n, t = li()
ab = [tuple(li()) for _ in range(n)]
ans = 0
for i in range(n):
dic = defaultdict(int)
dic[0] = 0
for ai, bi in ab[:i] + ab[i+1:]:
newdic = defaultdict(int)
keys = list(dic.keys())
for time, value in list(dic.items()):
if time + ai < t and time + ai in keys:
newdic[time + ai] = max(dic[time + ai], value + bi)
elif time + ai < t:
newdic[time + ai] = value + bi
newdic[time] = max(newdic[time], value)
dic = newdic
ans = max(ans, max(dic.values()) + ab[i][1])
print(ans)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import defaultdict
n, t = li()
ab = [tuple(li()) for _ in range(n)]
ans = 0
# dp
dp = [[0]*t for _ in range(n+1)]
for i, (ai, bi) in enumerate(ab):
for ti in range(t):
if ti + ai < t:
dp[i+1][ti + ai] = max(dp[i][ti + ai], dp[i][ti] + bi)
dp[i+1][ti] = max(dp[i+1][ti], dp[i][ti])
# 経路復元
chose = set()
maxtime = dp[n].index(max(dp[n]))
for idx in range(n, 0, -1):
if dp[idx][maxtime] != dp[idx-1][maxtime]:
chose.add(idx-1)
maxtime -= ab[idx-1][0]
allitem = set(range(n))
notchose = allitem - chose
notchosemax = 0
if notchose:
for i in notchose:
notchosemax = max(notchosemax, ab[i][1])
print((max(dp[n]) + notchosemax))
| p02863 |
import sys
from operator import itemgetter
from heapq import heapify, heappop, heappush
MAX_INT = int(10e15)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
N, T = IL()
ab = [IL() for i in range(N)]
ab.sort(key=itemgetter(0))
#print(ab)
dp = [[0]*(T+1+3000+1) for _ in range(N+1)]
ans = 0
for i in range(N):
for j in range(T+1+3000+1):
time, deli = ab[i]
if 0 <= j-time < T:
dp[i + 1][j] = max(dp[i][j], dp[i][j - time] + deli)
else:
dp[i + 1][j] = dp[i][j]
ans = max(ans, dp[i + 1][j])
print(ans)
#print(dp)
| import sys
from collections import deque
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return eval(input())
N,T = IL()
ab = [IL() for i in range(N)]
ab.sort()
ans = 0
dp = [[0]*T for i in range(N+1)]
for i in range(1,N+1):
a,b = ab[i-1]
for j in range(T):
if 0 <= j-a < T:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-a] + b)
else:
dp[i][j] = dp[i-1][j]
else:
ans = max(ans, dp[i-1][-1] + b)
print(ans) | p02863 |
N, T = list(map(int, input().split()))
table = [[0] * (N + 1) for _ in range(T + 1)]
dish = sorted((tuple(map(int, input().split())) for _ in range(N)), key=lambda t: t[0])
for t in range(T + 1):
for n in range(N):
minutes_to_take, deliciousness = dish[n]
now = table[t][n]
if t < T:
table[min(T, t + minutes_to_take)][n + 1] = max(table[min(T, t + minutes_to_take)][n + 1], now + deliciousness)
if n < N:
table[t][n + 1] = max(table[t][n + 1], now)
print((max(table[t][N] for t in range(T + 1)))) | N, T = list(map(int, input().split()))
table = [[0] * (N + 1) for _ in range(T + 1)]
dish = sorted((tuple(map(int, input().split())) for _ in range(N)), key=lambda t: t[0])
for t in range(T + 1):
for n in range(N):
minutes_to_take, deliciousness = dish[n]
now = table[t][n]
if t < T:
table[min(T, t + minutes_to_take)][n + 1] = max(table[min(T, t + minutes_to_take)][n + 1], now + deliciousness)
if n < N:
table[t][n + 1] = max(table[t][n + 1], now)
print((table[T][N])) | p02863 |
def examE():
N, T = LI()
A, B = [0] * N, [0] * N
for i in range(N):
A[i], B[i] = LI()
dp = [[[0,0] for _ in range(T+ 1)] for _ in range(N + 1)]
for i in range(N):
for j in range(A[i],T+1):
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j - A[i]][0] + B[i])
dp[i + 1][j][1] = max(dp[i + 1][j][1], dp[i][j - A[i]][1] + B[i])
for j in range(1,T+1):
dp[i+1][j][1] = max(dp[i+1][j][1], dp[i][j-1][0] + B[i])
dp[i + 1][j][0] = max(dp[i + 1][j][0], dp[i][j][0])
dp[i + 1][j][1] = max(dp[i + 1][j][1], dp[i][j][1])
# print(dp[N][T])
ans = max(dp[N][T])
print(ans)
import sys,copy,bisect,itertools
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examE()
| def examE():
N, T = LI()
A, B = [0] * N, [0] * N
for i in range(N):
A[i], B[i] = LI()
dp = [[0 for _ in range(T+ 1)] for _ in range(N + 1)]
dp2 = [[0 for _ in range(T+ 1)] for _ in range(N + 1)]
for i in range(N):
for j in range(A[i],T+1):
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - A[i]] + B[i])
dp2[i + 1][j] = max(dp2[i + 1][j], dp2[i][j - A[i]] + B[i])
for j in range(1,T+1):
dp2[i+1][j] = max(dp2[i+1][j], dp[i][j-1] + B[i], dp2[i][j])
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# print(dp[N][T])
ans = dp2[N][T]
print(ans)
import sys,copy,bisect,itertools
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')
examE()
| p02863 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,t = inpl()
wv = [inpl() for _ in range(n)]
wv.sort(key = lambda x:x[1],reverse = True)
res = 0
for i in range(min(n,10)):
dp = [[0] * (t+5) for _ in range(n+5)]
for j in range(n):
w,v = wv[j]
for k in range(t):
if k < w or i == j:
dp[j+1][k] = dp[j][k]
else:
dp[j+1][k] = max(dp[j][k], dp[j][k-w] + v)
# print(dp[n][t-1])
res = max(dp[n][t-1] + wv[i][1], res)
print(res) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,t = inpl()
wv = [inpl() for _ in range(n)]
wv.sort(key = lambda x:x[1],reverse = True)
res = 0
for i in range(min(n,3)):
dp = [[0] * (t+5) for _ in range(n+5)]
for j in range(n):
w,v = wv[j]
for k in range(t):
if k < w or i == j:
dp[j+1][k] = dp[j][k]
else:
dp[j+1][k] = max(dp[j][k], dp[j][k-w] + v)
# print(dp[n][t-1])
res = max(dp[n][t-1] + wv[i][1], res)
print(res) | p02863 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,t = inpl()
wv = [None] * n
for i in range(n):
a,b = inpl()
wv[i] = (a,b)
rwv = wv[::-1]
udp = [[0] * t for _ in range(n)]
ddp = [[0] * t for _ in range(n)]
for i in range(n-1):
w,v = wv[i]
for j in range(t):
if j < w:
udp[i+1][j] = udp[i][j]
else:
udp[i+1][j] = max(udp[i][j], udp[i][j-w] + v)
res = udp[n-1][t-1] + wv[n-1][1]
for i in range(n-1):
w,v = rwv[i]
for j in range(t):
if j < w:
ddp[i+1][j] = ddp[i][j]
else:
ddp[i+1][j] = max(ddp[i][j], ddp[i][j-w] + v)
res = max(res,ddp[n-1][t-1] + wv[0][1])
# print(res)
for i in range(1,n-1):
u = i; d = n-i-1
mx = 0
for j in range(t):
tmp = udp[u][j] + ddp[d][t-1-j]
mx = max(mx, tmp)
res = max(res, mx + wv[i][1])
print(res) | from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,t = inpl()
wv = sorted([inpl() for _ in range(n)])
dp = [[0]*t for _ in range(n+1)]
for i in range(n-1):
w,v = wv[i]
for j in range(t):
if j < w:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = max(dp[i][j] , dp[i][j-w] + v)
res = 0
for i in range(n):
tmp = dp[i][t-1] + wv[i][1]
res = max(res, tmp)
print(res) | p02863 |
n, t = list(map(int, input().split()))
a = [0]
b = [0]
for i in range(n):
a_, b_ = list(map(int, input().split()))
a.append(a_)
b.append(b_)
dp1 = [[0] * t for _ in range(n+2)]
dp2 = [[0] * t for _ in range(n+2)]
for i in range(n):
for j in range(t):
if a[i+1] > j:
dp1[i+1][j] = dp1[i][j]
else:
dp1[i+1][j] = max(dp1[i][j], dp1[i][j-a[i+1]] + b[i+1])
for i in range(n+1, 1, -1):
for j in range(t):
if a[i-1] > j:
dp2[i-1][j] = dp2[i][j]
else:
dp2[i-1][j] = max(dp2[i][j], dp2[i][j-a[i-1]] + b[i-1])
ans = 0
for i in range(1, n+1):
for j in range(t):
total = b[i] +dp1[i-1][j] + dp2[i+1][t-1-j]
ans = max(ans, total)
print(ans) | N, T = list(map(int, input().split()))
AB = sorted([list(map(int, input().split())) for _ in range(N)])
dp = [[0] * N for _ in range(T)]
for i in range(1, T):
for j in range(N-1):
if AB[j][0] <= i:
dp[i][j] = max(dp[i][j-1], dp[i-AB[j][0]][j-1] + AB[j][1])
else:
dp[i][j] = dp[i][j-1]
ans = 0
for j in range(1, N):
ans = max(ans, dp[-1][j-1] + AB[j][1])
print(ans) | p02863 |
n,t = list(map(int,input().split()))
time = [-1 for i in range(6030)]
time[0] = 0
now = 0
lis = [list(map(int,input().split())) for i in range(n)]
lis.sort(key = lambda x:x[0])
for i in range(n):
for j in range(t-1,-1,-1):
if time[j] != -1:
time[j+lis[i][0]] = max(time[j+lis[i][0]],time[j]+lis[i][1])
print((max(time))) | n,t = list(map(int,input().split()))
time = [0 for i in range(3000)]
now = 0
ans = 0
lis = [list(map(int,input().split())) for i in range(n)]
lis.sort(key=lambda x:x[0])
for i in range(n):
for j in range(t-1,-1,-1):
if lis[i][0] + j >= t:
ans = max(ans,time[j]+lis[i][1])
else:
time[j+lis[i][0]] = max(time[j+lis[i][0]],time[j]+lis[i][1])
print((max(ans,max(time)))) | p02863 |
def main():
_, t, *L = list(map(int, open(0).read().split()))
d = [0] * (t + max(L[::2]))
for w, v in sorted((x, y) for x, y in zip(*[iter(L)] * 2)):
for i in range(t + w - 1, w - 1, -1):
if d[i - w] + v > d[i]:
d[i] = d[i - w] + v
print((max(d)))
if __name__=="__main__":
main()
#vs after contest | def main():
_, t, *L = list(map(int, open(0).read().split()))
d = [0] * t
cand = 0
for w, v in sorted((x, y) for x, y in zip(*[iter(L)] * 2)):
if cand < d[-1] + v:
cand = d[-1] + v
for i in range(t - 1, w - 1, -1):
if d[i - w] + v > d[i]:
d[i] = d[i - w] + v
print((max(cand, max(d))))
if __name__=="__main__":
main()
| p02863 |
def main():
n, t = list(map(int, input().split()))
f = [list(map(int, input().split())) for _ in range(n)]
dp = [[0 for i in range(t)] for j in range(n + 1)]
ls = [[[] for i in range(t)] for j in range(n + 1)]
for i in range(n):
for j in range(t):
if j - f[i][0] >= 0 and dp[i][j - f[i][0]] + f[i][1] > dp[i][j]:
dp[i + 1][j] = dp[i][j - f[i][0]] + f[i][1]
ls[i + 1][j] = ls[i][j - f[i][0]] + [i]
else:
dp[i + 1][j] = dp[i][j]
ls[i + 1][j] = ls[i][j][:]
res = dp[n][t - 1]
ff = [f[i][1] for i in range(n) if not i in ls[n][t - 1]]
if ff:
return res + max(ff)
else:
return res
print((main()))
| def main():
n, t = list(map(int, input().split()))
f = [list(map(int, input().split())) for _ in range(n)]
dp = [0 for i in range(t)]
ls = [[] for i in range(t)]
for i in range(n):
for j in range(t - 1, -1, -1):
if j - f[i][0] >= 0 and dp[j - f[i][0]] + f[i][1] > dp[j]:
dp[j] = dp[j - f[i][0]] + f[i][1]
ls[j] = ls[j - f[i][0]] + [i]
res = dp[t - 1]
ff = [f[i][1] for i in range(n) if not i in ls[t - 1]]
if ff:
return res + max(ff)
else:
return res
print((main()))
| p02863 |
import copy
def main():
n, t = list(map(int, input().split()))
f = [list(map(int, input().split())) for _ in range(n)]
dp = [0 for i in range(t)]
ls = [[] for i in range(t)]
for i in range(n):
for j in range(t - 1, -1, -1):
if j - f[i][0] >= 0 and dp[j - f[i][0]] + f[i][1] > dp[j]:
dp[j] = dp[j - f[i][0]] + f[i][1]
ls[j] = copy.copy(ls[j - f[i][0]]) + [i]
res = dp[t - 1]
ll = ls[t - 1]
fff = [0 for _ in range(n)]
for sll in ll:
fff[sll] = 1
ff = [f[i][1] for i in range(n) if fff[i] == 0]
if ff:
return res + max(ff)
else:
return res
print((main()))
|
def main():
n, t = list(map(int, input().split()))
f = [list(map(int, input().split())) for _ in range(n)]
dp1 = [[0 for i in range(t)]for j in range(n+1)]
dp2 = [[0 for i in range(t)]for j in range(n+1)]
for i in range(n):
for j in range(t - 1, -1, -1):
if j - f[i][0] >= 0:
dp1[i+1][j] = max(dp1[i][j - f[i][0]] + f[i][1],dp1[i][j])
else:
dp1[i+1][j] = dp1[i][j]
for i in range(n):
for j in range(t - 1, -1, -1):
if j - f[n-1-i][0] >= 0:
dp2[i+1][j] = max(dp2[i][j - f[n-1-i][0]] + f[n-1-i][1],dp2[i][j])
else:
dp2[i+1][j] = dp2[i][j]
res = 0
for i in range(n):
for j in range(t):
res = max(res,dp1[i][j]+f[i][1]+dp2[n-1-i][t-1-j])
return res
print((main()))
| p02863 |
def solve():
ans = 0
N, T = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
dp = [[0]*(T+A[-1][0]) for _ in range(N+1)]
for i in range(1,N+1):
for t in range(1,T+A[-1][0]):
if t<A[i-1][0] or t>=T+A[i-1][0]:
dp[i][t] = max(dp[i-1][t],dp[i][t-1])
else:
dp[i][t] = max([dp[i-1][t],dp[i][t-1],dp[i-1][t-A[i-1][0]]+A[i-1][1]])
ans = max(dp[-1])
return ans
print((solve())) | def solve():
N, T = list(map(int, input().split()))
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
dp = [[0]*(T+1) for _ in range(N+1)]
for i in range(N):
for j in range(0,T+1):
dp[i+1][j] = max(dp[i+1][j],dp[i][j])
if j<T:
t = min(T,j+A[i][0])
dp[i+1][t] = max(dp[i+1][t],dp[i][j]+A[i][1])
ans = dp[-1][-1]
return ans
print((solve())) | p02863 |
import sys
input = sys.stdin.readline
N,T=list(map(int,input().split()))
D=[tuple(map(int,input().split())) for i in range(N)]
D.sort(key=lambda x:x[1],reverse=True)
DP=[[0,0] for i in range(T+1)]
for ind,(x,y) in enumerate(D):
for time in range(T,x-1,-1):
if DP[time][0]<DP[time-x][0]+y:
if DP[time-x][1]==ind:
DP[time]=[DP[time-x][0]+y,ind+1]
else:
DP[time]=[DP[time-x][0]+y,DP[time-x][1]]
elif DP[time][0]==DP[time-x][0]+y:
if DP[time-x][1]==ind:
DP[time][1]=min(ind+1,DP[time][1])
else:
DP[time][1]=min(DP[time-x][1],DP[time][1])
#print(DP)
D.append((0,0))
ANS=DP[-1][0]
for x,y in DP[:-1]:
#if x==0:
# continue
ANS=max(ANS,x+D[y][1])
print(ANS)
| import sys
input = sys.stdin.readline
N,T=list(map(int,input().split()))
D=[tuple(map(int,input().split())) for i in range(N)]
D.sort()
DP=[0]*(T+1)
ANS=0
for i in range(N):
a,b=D[i]
for j in range(T,a-1,-1):
DP[j]=max(DP[j-a]+b,DP[j])
for j in range(i+1,N):
ANS=max(ANS,DP[T-1]+D[j][1])
print(ANS) | p02863 |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N, T = list(map(int, input().split()))
cv = [tuple(map(int, input().split())) for _ in range(N)]
cv = sorted(cv, key=lambda x : x[0])
dp = [[0]*(T+1) for _ in range(N+1)]
dp_ext = [[0]*(T+1) for _ in range(N+1)]
values = [v for c, v in cv]
max_values = [max(values[i:]) for i in range(N)]
# 貰うdp
for i in range(N):
cost, value = cv[i]
for now in range(cost, T+1):
old = now - cost
dp[i+1][now] = max(dp[i][now], dp[i][old] + value)
for j in range(1, T+1):
dp[i+1][j] = max(dp[i+1][j], dp[i+1][j-1])
for j in range(1, T+1):
dp_ext[i+1][j] = max(dp[i+1][j], dp[i][j-1] + max_values[i], dp_ext[i][j])
print((dp_ext[N][T]))
if __name__ == "__main__":
main() | import sys
def input(): return sys.stdin.readline().strip()
def main():
N, T = list(map(int, input().split()))
cv = [tuple(map(int, input().split())) for _ in range(N)]
cv = sorted(cv, key=lambda x : x[0])
dp = [[0]*(T+1) for _ in range(N+1)]
# 貰うdp
ans = 0
for i in range(N):
cost, value = cv[i]
for now in range(min(T+1, cost)):
dp[i+1][now] = dp[i][now]
for now in range(cost, T+1):
old = now - cost
dp[i+1][now] = max(dp[i][now], dp[i][old] + value)
ans = max(ans, dp[i][T-1] + value)
print(ans)
if __name__ == "__main__":
main() | p02863 |
def knapsack(n, w, info):
dp = [[0]*(w + 1) for i in range(n + 1)]
for i in range(n):
for j in range(w + 1):
weight, value = info[i]
if j < weight:
dp[i + 1][j] = dp[i][j]
else:
dp[i + 1][j] = max(dp[i][j], dp[i][j - weight] + value)
return dp
N,T = list(map(int,input().split()))
food = []
for _ in range(N):
food.append(list(map(int,input().split())))
food.sort(key= lambda x: x[0])
dp = knapsack(N,T,food)
C = [0]*(N+1)
for i in range(N)[::-1]:
C[i] = max(C[i+1], food[i][1])
ans = 0
for i in range(N+1):
ans = max(dp[i][-2] + C[i], ans)
print(ans)
| N,T = list(map(int,input().split()))
foods = []
for _ in range(N):
a,b = list(map(int,input().split()))
foods.append([a,b])
foods.sort(key=lambda x: x[0])
# dp[i][j] = 1～i 番目の料理で j 分以内に完食できる美味しさの合計の最大値
dp = [ [0]*(T+1) for _ in range(N+1) ]
for i in range(N):
a,b = foods[i]
for j in range(T+1):
if j >= a:
dp[i+1][j] = max(dp[i][j], dp[i][j-a]+b)
else:
dp[i+1][j] = dp[i][j]
# for d in dp:
# print(d)
ans = 0
for i in range(1, N+1):
b = foods[i-1][1]
ans = max(ans, dp[i][-1], dp[i-1][-2]+b)
print((max(ans, dp[-1][-1]))) | p02863 |
import sys
N, T = list(map(int, input().split()))
S = sys.stdin.readlines()
A = []
B = []
for s in S:
a, b = list(map(int, s.split()))
A.append(a)
B.append(b)
dp1 = [[0] * T for _ in range(N + 1)]
for i in range(N):
for j in range(T):
here = dp1[i][j]
if j < A[i]:
dp1[i + 1][j] = here
else:
dp1[i + 1][j] = max(here, dp1[i][j - A[i]] + B[i])
dp2 = [[0] * T for _ in range(N + 2)]
for i in range(N, 0, -1):
for j in range(T):
here = dp2[i + 1][j]
if j < A[i - 1]:
dp2[i][j] = here
else:
dp2[i][j] = max(here, dp2[i + 1][j - A[i - 1]] + B[i - 1])
ans = 0
for i in range(1, N + 1):
t = 0
for j in range(T):
t2 = dp1[i - 1][j] + dp2[i + 1][T - 1 - j]
t = max(t, t2)
ans = max(ans, t + B[i - 1])
print(ans)
| N, T = list(map(int, input().split()))
D = [tuple(map(int, input().split())) for _ in range(N)]
D.sort()
dp = [[0] * T for _ in range(N + 1)]
for i in range(N):
A, B = D[i]
for j in range(T):
here = dp[i][j]
if j < A:
dp[i + 1][j] = here
else:
dp[i + 1][j] = max(here, dp[i][j - A] + B)
maxB = [0] * (N + 1)
t = 0
for i in range(N - 1, -1, -1):
t = max(t, D[i][1])
maxB[i] = t
ans = 0
for i in range(N):
ans = max(ans, dp[i + 1][T - 1] + maxB[i + 1])
print(ans)
| p02863 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n, t = list(map(int, input().rstrip('\n').split()))
ab = [list(map(int, input().rstrip('\n').split())) for _ in range(n)]
ab.sort()
dp = [0] * t
mt = 0
for a, b in ab:
mt = max(mt, dp[-1] + b)
for i in range(t - a - 1, -1, -1):
dp[i+a] = max(dp[i+a], dp[i] + b)
print(mt)
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
n, t = list(map(int, readline().split()))
ab = [list(map(int, readline().split())) for _ in range(n)]
ab.sort()
dp = [0] * t
mt = 0
for a, b in ab:
mt = max(mt, dp[-1] + b)
for i in range(t - a - 1, -1, -1):
dp[i+a] = max(dp[i+a], dp[i] + b)
print(mt)
if __name__ == '__main__':
solve()
| p02863 |
N,T = list(map(int,input().split()))
AB = [tuple(map(int,input().split())) for i in range(N)]
dp0 = [{0:0} for i in range(N+1)]
dp1 = [{0:0} for i in range(N+1)]
for i,(a,b) in enumerate(AB):
for k0,v0 in list(dp0[i].items()):
if k0 in dp0[i+1]:
dp0[i+1][k0] = max(dp0[i+1][k0], v0)
else:
dp0[i+1][k0] = v0
if k0+a < T:
if k0+a in dp0[i+1]:
dp0[i+1][k0+a] = max(dp0[i+1][k0+a], v0+b)
else:
dp0[i+1][k0+a] = v0+b
if k0 in dp1[i+1]:
dp1[i+1][k0] = max(dp1[i+1][k0], v0+b)
else:
dp1[i+1][k0] = v0+b
for k1,v1 in list(dp1[i].items()):
if k1 in dp1[i+1]:
dp1[i+1][k1] = max(dp1[i+1][k1], v1)
else:
dp1[i+1][k1] = v1
if k1+a < T:
if k1+a in dp1[i+1]:
dp1[i+1][k1+a] = max(dp1[i+1][k1+a], v1+b)
else:
dp1[i+1][k1+a] = v1+b
print((max(dp1[-1].values()))) | N,T = list(map(int,input().split()))
AB = [tuple(map(int,input().split())) for i in range(N)]
dp0 = {0:0}
dp1 = {0:0}
for i,(a,b) in enumerate(AB):
_dp0 = {0:0}
_dp1 = {0:0}
for k0,v0 in list(dp0.items()):
if k0 in _dp0:
_dp0[k0] = max(_dp0[k0], v0)
else:
_dp0[k0] = v0
if k0+a < T:
if k0+a in _dp0:
_dp0[k0+a] = max(_dp0[k0+a], v0+b)
else:
_dp0[k0+a] = v0+b
if k0 in _dp1:
_dp1[k0] = max(_dp1[k0], v0+b)
else:
_dp1[k0] = v0+b
for k1,v1 in list(dp1.items()):
if k1 in _dp1:
_dp1[k1] = max(_dp1[k1], v1)
else:
_dp1[k1] = v1
if k1+a < T:
if k1+a in _dp1:
_dp1[k1+a] = max(_dp1[k1+a], v1+b)
else:
_dp1[k1+a] = v1+b
dp0 = _dp0
dp1 = _dp1
print((max(dp1.values()))) | p02863 |
n, t = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
a = []
b = []
for ai, bi in ab:
a.append(ai)
b.append(bi)
dp = [[0 for _ in range(t)] for _ in range(n+1)]
for i in range(n):
for j in range(t):
if j + a[i] <= t-1:
if dp[i+1][j + a[i]] < dp[i][j] + b[i]:
dp[i+1][j + a[i]] = dp[i][j] + b[i]
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
ans = 0
for i in range(n):
ans = max(ans,dp[i][t-1]+b[i])
print(ans)
| #ABC145 E
n,t = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(n)]
ab.sort()
a = []
b = []
for ai, bi in ab:
a.append(ai)
b.append(bi)
dp = [[0 for j in range(t)] for _ in range(n+1)]
# i番目より前まで注文してT分以内(max T-1)で完食する
for i in range(n):
for j in range(t):
if j+ a[i] <= t-1:
if dp[i+1][j + a[i]] < dp[i][j] + b[i]:
dp[i+1][j + a[i]] = dp[i][j] + b[i]
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
#一番遅いものをラスト(T-1分)に注文
#i番目をラストに注文 = dp[i][t-1] + b[i]
ans = 0
for i in range(n):
ans = max(ans,dp[i][t-1]+b[i])
print(ans)
| p02863 |
#ABC145 E
n,t = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(n)]
ab.sort()
a = []
b = []
for ai, bi in ab:
a.append(ai)
b.append(bi)
dp = [[0 for j in range(t)] for _ in range(n+1)]
# i番目より前まで注文してT分以内(max T-1)で完食する
for i in range(n):
for j in range(t):
if j+ a[i] <= t-1:
if dp[i+1][j + a[i]] < dp[i][j] + b[i]:
dp[i+1][j + a[i]] = dp[i][j] + b[i]
if dp[i+1][j] < dp[i][j]:
dp[i+1][j] = dp[i][j]
#一番遅いものをラスト(T-1分)に注文
#i番目をラストに注文 = dp[i][t-1] + b[i]
ans = 0
for i in range(n):
ans = max(ans,dp[i][t-1]+b[i])
print(ans)
| #ABC145 E
N,T = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(N)]
ab.sort()
dp = [[0]*T for _ in range(N+1)]
# i番目より前まで注文してT分以内(max T-1)で完食する
def chmax(a,b):
if a < b:
return b
else:
return a
for i in range(N):
for t in range(T): #T-1分がmax
if t+ab[i][0] <= T-1:
dp[i+1][t+ab[i][0]] =chmax(dp[i+1][t+ab[i][0]],dp[i][t]+ab[i][1])
dp[i+1][t] = chmax(dp[i+1][t],dp[i][t])
#一番遅いものをラスト(T-1分)に注文
#i番目をラストに注文 = dp[i][t-1] + b[i]
ans = 0
for i in range(N):
ans = chmax(ans,dp[i][T-1]+ab[i][1])
print(ans) | p02863 |
N,T = list(map(int,input().split()))
A =[list(map(int,input().split())) for i in range(N)]
A.sort(key = lambda x:x[0])
INF = float("inf")
DP = [[-INF]*(T+3001) for i in range(N+1)]
DP[0][0] = 0
for i in range(N):
for j in range(T):
DP[i+1][j] = max(DP[i+1][j],DP[i][j])
DP[i+1][j+A[i][0]] = max(DP[i+1][j+A[i][0]],DP[i][j+A[i][0]],DP[i][j]+A[i][1])
score = 0
for i in range(N):
for j in range(T+A[i][0]):
score = max(DP[i+1][j],score)
print(score) | N,T = list(map(int,input().split()))
A =[list(map(int,input().split())) for i in range(N)]
A.sort(key = lambda x:x[0])
INF = float("inf")
DP = [[-INF]*(T+3001) for i in range(N+1)]
DP[0][0] = 0
for i in range(N):
for j in range(T):
DP[i+1][j] = max(DP[i+1][j],DP[i][j])
DP[i+1][j+A[i][0]] = max(DP[i+1][j+A[i][0]],DP[i][j+A[i][0]],DP[i][j]+A[i][1])
score = 0
for i in range(N):
for j in range(T+A[i][0]):
score = DP[i+1][j] if DP[i+1][j]>score else score
print(score) | p02863 |
n, W = list(map(int, input().split()))
ab = [tuple(map(int, input().split()))for _ in range(n)]
ab.sort(reverse=True)
dp = [0]*W
for w, v in ab:
for j in reversed(list(range(W))):
if j-w < 0:
break
if dp[j] < dp[j-w]+v:
dp[j] = dp[j-w]+v
if dp[0] < v:
dp[0] = v
print((max(dp)))
| n, W = list(map(int, input().split()))
ab = [tuple(map(int, input().split()))for _ in range(n)]
ab.sort()
dp = [[0]*W for _ in range(n+1)]
for i in range(1, n+1):
w, v = ab[i-1]
for j in range(W):
if dp[i][j] < dp[i-1][j]:
dp[i][j] = dp[i-1][j]
if 0 <= j-w and dp[i][j] < dp[i-1][j-w]+v:
dp[i][j] = dp[i-1][j-w]+v
ans = 0
for i in range(n):
a, b = ab[i]
if ans < dp[i][W-1]+b:
ans = dp[i][W-1]+b
print(ans)
| p02863 |
n, t = list(map(int, input().split()))
dish = [list(map(int, input().split())) for _ in range(n)]
dish.sort(key=lambda x: x[0])
dp = [[0 for _ in range(3000)] for _ in range(3000)]
ans = 0
for i in range(n):
for j in range(t):
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
nj = j + dish[i][0]
if nj < t:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + dish[i][1])
now = dp[i][t- 1] + dish[i][1]
ans = max(ans, now)
print(ans) | n, t = list(map(int, input().split()))
dish = [list(map(int, input().split())) for _ in range(n)]
dish.sort(key=lambda x: x[0])
dp = [[0 for _ in range(3005)] for _ in range(3005)]
ans = 0
for i in range(n):
for j in range(t):
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
nj = j + dish[i][0]
if nj < t:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + dish[i][1])
now = dp[i][t- 1] + dish[i][1]
ans = max(ans, now)
print(ans) | p02863 |
def main():
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(N)]
ab.sort(key=lambda x: (x[0], x[1]))
dp = [-1 for i in range(T*2 + 1)]
dp[0] = 0
for a, b in ab:
for i in range(T*2, 0, -1):
if i >= a:
if dp[i-a] >= 0 and i - a < T:
dp[i] = max(dp[i], dp[i-a] + b)
for i in range(1, T*2+1):
dp[i] = max(dp[i], dp[i-1])
ans = dp[-1]
ab.sort(key=lambda x: x[1])
tmp = ab.pop()
dp = [-1 for i in range(T)]
dp[0] = 0
for a, b in ab:
for i in range(T-1, 0, -1):
if i >= a:
if dp[i-a] >= 0:
dp[i] = max(dp[i], dp[i-a] + b)
for i in range(1, T):
dp[i] = max(dp[i], dp[i-1])
ans = max(ans, tmp[1] + dp[-1])
# print(dp)
print(ans)
main()
| def main():
import sys
input = sys.stdin.readline
N, T = list(map(int, input().split()))
ab = [list(map(int, input().split())) for i in range(N)]
ab.sort(key=lambda x: x[0])
t = ab[-1][0]
dp = [-1 for i in range(T+t + 1)]
dp[0] = 0
for a, b in ab:
for i in range(T+t, 0, -1):
if i >= a:
if dp[i-a] >= 0 and i - a < T:
dp[i] = max(dp[i], dp[i-a] + b)
for i in range(1, T+t+1):
dp[i] = max(dp[i], dp[i-1])
ans = dp[-1]
# print(dp)
print(ans)
main()
| p02863 |
from sys import stdin
def input():
return stdin.readline()[:-1]
def intput():
return int(eval(input()))
def sinput():
return input().split()
def intsput():
return list(map(int, sinput()))
dishes = []
n, t = intsput()
for _ in range(n):
dishes.append(list(intsput()))
dishes[-1].append(dishes[-1][1] / dishes[-1][0])
maxweight = max([x[0] for x in dishes])
dp = [[[0, []]] * (t + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(t):
if dishes[i - 1][0] > j:
dp[i][j] = dp[i - 1][j][:]
else:
val = max(dp[i - 1][j][0], dp[i - 1][j - dishes[i - 1][0]][0] + dishes[i - 1][1])
dp[i][j] = [val]
if val == dp[i - 1][j][0]:
dp[i][j].append(dp[i - 1][j][1])
else:
dp[i][j].append(dp[i - 1][j - dishes[i - 1][0]][1] + [i])
rslt = dp[n][t - 1]
op = []
for i in range(1, n + 1):
if i not in rslt[1]:
op.append(i)
if op:
vv = max([dishes[i - 1][1] for i in op])
else:
vv = 0
print((rslt[0] + vv))
| from sys import stdin
def input():
return stdin.readline()[:-1]
def intput():
return int(eval(input()))
def sinput():
return input().split()
def intsput():
return list(map(int, sinput()))
dishes = []
n, t = intsput()
for _ in range(n):
dishes.append(list(intsput()))
dishes[-1].append(dishes[-1][1] / dishes[-1][0])
maxweight = max([x[0] for x in dishes])
dishes.sort(key=lambda x: x[1], reverse=True)
dp = [[[0, 1]] * (t + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for j in range(t):
if dishes[i - 1][0] > j:
dp[i][j] = dp[i - 1][j][:]
else:
val = max(dp[i - 1][j][0], dp[i - 1][j - dishes[i - 1][0]][0] + dishes[i - 1][1])
dp[i][j] = [val]
if val == dp[i - 1][j][0]:
dp[i][j].append(dp[i - 1][j][1])
else:
if i == dp[i - 1][j - dishes[i - 1][0]][1]:
dp[i][j].append(i + 1)
else:
dp[i][j].append(dp[i - 1][j - dishes[i - 1][0]][1])
rslt = dp[n][t - 1]
if rslt[1] <= n:
vv = dishes[rslt[1] - 1][1]
else:
vv = 0
print((rslt[0] + vv))
| p02863 |
I = [int(_) for _ in open(0).read().split()]
N, T = I[:2]
A, B = I[2::2], I[3::2]
dp = [-1] * 6001
dp[0] = 0
for a, b in sorted(zip(A, B)):
dp_new = dp[:]
for k in range(T):
if dp[k] == -1:
continue
dp_new[k + a] = max(dp[k + a], dp[k] + b)
dp = dp_new
print((max(dp)))
| I = [int(_) for _ in open(0).read().split()]
N, T = I[:2]
A, B = I[2::2], I[3::2]
dp = [-1] * 6001
dp[0] = 0
for a, b in sorted(zip(A, B)):
for k in range(T - 1, -1, -1):
if dp[k] == -1:
continue
dp[k + a] = max(dp[k + a], dp[k] + b)
print((max(dp)))
| p02863 |
from operator import itemgetter
N, T = [int(i) for i in input().split()]
data = []
for i in range(N):
data.append([int(i) for i in input().split()])
data.sort(key=itemgetter(0))
dp = [dict() for _ in range(N)]
for i in range(T):
dp[0][i] = 0
dp[0][T] = data[0][1]
for i in range(1, N):
time = data[i-1][0]
value = data[i-1][1]
add_value = data[i][1]
for j in range(T):
if j >= time:
dp[i][j] = max(dp[i-1][j], dp[i-1][j-time] + value)
else:
dp[i][j] = dp[i-1][j]
dp[i][T] = max(dp[i][T-1] + add_value, dp[i-1][T])
print((dp[-1][T]))
| from operator import itemgetter
N, T = [int(i) for i in input().split()]
data = []
for i in range(N):
data.append([int(i) for i in input().split()])
data.sort(key=itemgetter(0))
dp = [[0]*(T) for i in range(N)]
ans = data[0][1]
for i in range(1, N):
for j in range(T):
if j >= data[i-1][0]:
value1 = dp[i-1][j]
value2 = dp[i-1][j-data[i-1][0]] + data[i-1][1]
dp[i][j] = max(value1, value2)
else:
dp[i][j] = dp[i-1][j]
value3 = dp[i][T-1] + data[i][1]
ans = max(value3, ans)
print(ans)
| p02863 |
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
#mod = 10**9 + 7
n,t = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort(key=lambda x: x[1])
ab.sort(key=lambda x: x[0])
dp = [-1]*(t+1)
dp[0] = 0
for a, b in ab:
for j in range(t-1, -1, -1):
if dp[j] >= 0:
if j+a<=t:
dp[j+a] = max(dp[j+a], dp[j]+b)
else:
dp[-1] = max(dp[-1], dp[j]+b)
print((max(dp)))
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#inf = 10**17
#mod = 10**9 + 7
n,t = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(n)]
#ab.sort(key=lambda x: x[1])
ab.sort(key=lambda x: x[0])
dp = [-1]*(t+1)
dp[0] = 0
for a, b in ab:
for j in range(t-1, -1, -1):
if dp[j] >= 0:
if j+a<=t:
dp[j+a] = max(dp[j+a], dp[j]+b)
else:
dp[-1] = max(dp[-1], dp[j]+b)
print((max(dp)))
if __name__ == '__main__':
main() | p02863 |
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
n, t = ril()
ls = rils(n)
dp = [[0] * t for _ in range(n + 1)]
for i in range(n + 1):
for t0 in range(t):
a, b = ls[i - 1]
if i == 0 or t0 == 0:
continue
elif a <= t0:
dp[i][t0] = max(dp[i - 1][t0], dp[i - 1][t0 - a] + b)
else:
dp[i][t0] = dp[i - 1][t0]
res = set()
val = dp[n][t - 1]
t0 = t - 1
for i in reversed(list(range(n))):
a, b = ls[i]
if val <= 0:
break
if val == dp[i][t0]:
continue
else:
res.add(i)
val -= b
t0 -= a
remaining = [v for i, (_, v) in enumerate(ls) if i not in res]
if len(remaining) > 0:
print((dp[n][t - 1] + max(remaining)))
else:
print((dp[n][t - 1])) | # Python3 TLE, PyPy3 AC
import sys
input = sys.stdin.readline
ri = lambda: int(eval(input()))
rs = lambda: input().rstrip()
ril = lambda: list(map(int, input().split()))
rsl = lambda: input().rstrip().split()
ris = lambda n: [ri() for _ in range(n)]
rss = lambda n: [rs() for _ in range(n)]
rils = lambda n: [ril() for _ in range(n)]
rsls = lambda n: [rsl() for _ in range(n)]
n, t = ril()
ls = rils(n)
dp = [[0] * t for _ in range(n + 1)]
for i in range(n + 1):
for t0 in range(t):
a, b = ls[i - 1]
if i == 0 or t0 == 0:
continue
elif a <= t0:
dp[i][t0] = max(dp[i - 1][t0], dp[i - 1][t0 - a] + b)
else:
dp[i][t0] = dp[i - 1][t0]
res = set()
val = dp[n][t - 1]
t0 = t - 1
for i in reversed(list(range(n))):
a, b = ls[i]
if val <= 0:
break
if val == dp[i][t0]:
continue
else:
res.add(i)
val -= b
t0 -= a
m = 0
for i, (_, v) in enumerate(ls):
if i not in res:
m = max(m, v)
print((dp[n][t - 1] + m)) | p02863 |
import sys
sys.setrecursionlimit(10**9)
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
N, T = inpl()
A = [None]*N
B = [None]*N
for i in range(N):
A[i], B[i] = inpl()
dp_intime = [[0]*T for _ in range(N+1)]
dp_total = [[0]*T for _ in range(N+1)]
for n in range(1,N+1):
for t in range(T):
if A[n-1] > t:
dp_intime[n][t] = dp_intime[n-1][t]
dp_total[n][t] = max(B[n-1]+dp_intime[n-1][t], dp_total[n-1][t])
else:
dp_intime[n][t] = max(dp_intime[n-1][t], B[n-1]+dp_intime[n-1][t-A[n-1]])
dp_total[n][t] = max(B[n-1]+dp_intime[n-1][t],
B[n-1]+dp_total[n-1][t-A[n-1]],
dp_total[n-1][t])
print((dp_total[-1][-1])) | import sys
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
N, T = inpl()
A = [None]*N
B = [None]*N
for i in range(N):
A[i], B[i] = inpl()
dp_intime = [0]*T
dp_total = [0]*T
for n in range(N):
dp_intime_prev, dp_intime = dp_intime, [0]*T
dp_total_prev, dp_total = dp_total, [0]*T
for t in range(T):
if A[n] > t:
dp_intime[t] = dp_intime_prev[t]
dp_total[t] = max(B[n]+dp_intime_prev[t], dp_total_prev[t])
else:
dp_intime[t] = max(dp_intime_prev[t], B[n]+dp_intime_prev[t-A[n]])
dp_total[t] = max(B[n]+dp_intime_prev[t],
B[n]+dp_total_prev[t-A[n]],
dp_total_prev[t])
print((dp_total[-1])) | p02863 |
import sys
input = lambda: sys.stdin.readline().rstrip()
inpl = lambda: list(map(int,input().split()))
N, T = inpl()
A = [None]*N
B = [None]*N
for i in range(N):
A[i], B[i] = inpl()
dp_intime = [0]*T
dp_total = [0]*T
for n in range(N):
dp_intime_prev, dp_intime = dp_intime, [0]*T
dp_total_prev, dp_total = dp_total, [0]*T
for t in range(T):
if A[n] > t:
dp_intime[t] = dp_intime_prev[t]
dp_total[t] = max(B[n]+dp_intime_prev[t], dp_total_prev[t])
else:
dp_intime[t] = max(dp_intime_prev[t], B[n]+dp_intime_prev[t-A[n]])
dp_total[t] = max(B[n]+dp_intime_prev[t],
B[n]+dp_total_prev[t-A[n]],
dp_total_prev[t])
print((dp_total[-1])) | 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) | p02863 |
N,T = list(map(int,input().split()))
data = [list(map(int,input().split())) for _ in range(N)]
dp1 = [[0 for n in range(N+1)] for t in range(T+1)] #dp1[t][n] := (data[:n]の中からtまでに食べ切る範囲で美味しく）
dp2 = [[0 for n in range(N+1)] for t in range(T+1)] #dp1[t][n] := (data[:n]の中からt-1までに注文する範囲で美味しく)
for t in range(1,T+1):
for n in range(1,N+1):
if t-data[n-1][0] >= 0:
dp1[t][n] = max(dp1[t][n-1],dp1[t-data[n-1][0]][n-1]+data[n-1][1])
dp2[t][n] = max(dp2[t][n-1],dp2[t-data[n-1][0]][n-1]+data[n-1][1],dp1[t-1][n-1]+data[n-1][1])
else:
dp1[t][n] = dp1[t][n-1]
dp2[t][n] = max(dp2[t][n-1],dp1[t-1][n-1]+data[n-1][1])
print((dp2[T][N])) | import sys
input = sys.stdin.readline
N,T = list(map(int,input().split()))
data = [list(map(int,input().split())) for _ in range(N)]
dp1 = [[0]*(N+1) for t in range(T+1)] #dp1[t][n] := (data[:n]の中からtまでに食べ切る範囲で美味しく）
dp2 = [[0]*(N+1) for t in range(T+1)] #dp1[t][n] := (data[:n]の中からt-1までに注文する範囲で美味しく)
for t in range(1,T+1):
for n in range(1,N+1):
if t-data[n-1][0] >= 0:
dp1[t][n] = max(dp1[t][n-1],dp1[t-data[n-1][0]][n-1]+data[n-1][1])
dp2[t][n] = max(dp2[t][n-1],dp2[t-data[n-1][0]][n-1]+data[n-1][1],dp1[t-1][n-1]+data[n-1][1])
else:
dp1[t][n] = dp1[t][n-1]
dp2[t][n] = max(dp2[t][n-1],dp1[t-1][n-1]+data[n-1][1])
print((dp2[T][N])) | p02863 |
import sys
input = sys.stdin.readline
n,t = list(map(int,input().split()))
data = [list(map(int,input().split())) for _ in range(n)]
dp1 = [[0 for i in range(n+1)] for j in range(t+1)]
dp2 = [[0 for i in range(n+1)] for j in range(t+1)]
q = 0
for i in range(1,n+1):
q = max(q,data[i-1][0])
dp2[1][i] = q
for i in range(1,t+1):
for j in range(1,n+1):
if i-data[j-1][0] >= 0:
dp1[i][j] = max(dp1[i][j-1],dp1[i-data[j-1][0]][j-1]+data[j-1][1])
dp2[i][j] = max(dp2[i][j-1],dp2[i-data[j-1][0]][j-1]+data[j-1][1],dp1[i-1][j-1]+data[j-1][1])
else:
dp1[i][j] = dp1[i][j-1]
dp2[i][j] = max(dp2[i][j-1],dp1[i-1][j-1]+data[j-1][1])
print((dp2[t][n])) | N,T = list(map(int, input().split()))
data = [list(map(int, input().split())) for i in range(N)]
dp1 = [[0]*(N+1) for _ in range(T+1)]
dp2 = [[0]*(N+1) for _ in range(T+1)]
for t in range(T):
for n in range(N):
if t+1-data[n][0]>=0:
dp1[t+1][n+1] = max(dp1[t+1][n],dp1[t+1-data[n][0]][n]+data[n][1])
dp2[t+1][n+1] = max(dp2[t+1][n],dp2[t+1-data[n][0]][n]+data[n][1],
dp1[t][n]+data[n][1])
else:
dp1[t+1][n+1] = dp1[t+1][n]
dp2[t+1][n+1] = max(dp2[t+1][n],dp1[t][n]+data[n][1])
print((dp2[T][N]))
| p02863 |
N,T=list(map(int,input().split()))
A,B=[],[]
for i in range(N):
a,b=list(map(int,input().split()))
A.append(a);B.append(b)
dp=[[[0,0] for i in range(T)] for i in range(N+1)]
for i in range(N):
for j in range(T):
if j-A[i]>=0:
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j-A[i]][0]+B[i])
dp[i+1][j][1]=max(dp[i+1][j][1],dp[i][j-A[i]][1]+B[i])
dp[i+1][j][0]=max(dp[i+1][j][0],dp[i][j][0])
dp[i+1][j][1]=max([dp[i+1][j][1],dp[i][j][0]+B[i],dp[i][j][1]])
ans=max(dp[N][T-1][0],dp[N][T-1][1])
print(ans) | N,T=list(map(int,input().split()))
A,B=[],[]
for i in range(N):
a,b=list(map(int,input().split()))
A.append(a);B.append(b)
dp=[[0,0] for i in range(T)]
for i in range(N):
for j in reversed(list(range(T))):
dp[j][1]=max(dp[j][1],dp[j][0]+B[i])
if j-A[i]>=0:
dp[j][0]=max(dp[j-A[i]][0]+B[i],dp[j][0])
dp[j][1]=max(dp[j-A[i]][1]+B[i],dp[j][1])
ans=max(dp[T-1][0],dp[T-1][1])
print(ans) | p02863 |
"""
食べるのにかかる時間順にソートしてナップサックするのがよい。
dp[i][j]
"""
N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort(key=lambda x: x[0])
dp = [[0]*(T) for _ in range(N+1)]
for i in range(1,N+1):
a,b = AB[i-1]
for j in range(1,T):
if j-a >= 0:
dp[i][j] = max(dp[i-1][j-a]+b,dp[i-1][j])
else:
dp[i][j] = dp[i-1][j]
ans = 0
for i in range(1,N):
a,b = AB[i]
ans = max(ans,dp[i][-1]+b)
print(ans) | N,T = list(map(int,input().split()))
AB = [list(map(int,input().split())) for _ in range(N)]
AB.sort()
dp = [0]*(T)
ans = 0
for i in range(N):
a,b = AB[i]
ans = max(ans,dp[-1]+b)
for j in range(T-1,-1,-1):
if j - a >= 0:
dp[j] = max(dp[j],dp[j-a]+b)
print(ans) | p02863 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, T, *AB = list(map(int, read().split()))
A = AB[::2]
B = AB[1::2]
dp1 = [[0] * T for _ in range(N + 1)]
for i in range(N):
for t in range(T):
if 0 <= t - A[i]:
dp1[i + 1][t] = dp1[i][t - A[i]] + B[i]
if dp1[i + 1][t] < dp1[i][t]:
dp1[i + 1][t] = dp1[i][t]
dp2 = [[0] * T for _ in range(N + 1)]
for i in range(N - 1, -1, -1):
for t in range(T):
if 0 <= t - A[i]:
dp2[i][t] = dp2[i + 1][t - A[i]] + B[i]
if dp2[i][t] < dp2[i + 1][t]:
dp2[i][t] = dp2[i + 1][t]
ans = 0
for i in range(N):
tmp = max(dp1[i][t] + dp2[i + 1][T - t - 1] for t in range(T)) + B[i]
if ans < tmp:
ans = tmp
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, T, *AB = list(map(int, read().split()))
D = [(a, b) for a, b in zip(*[iter(AB)] * 2)]
D.sort()
A, B = list(zip(*D))
dp = [[0] * T for _ in range(N + 1)]
for i in range(N):
for t in range(T):
if 0 <= t - A[i]:
dp[i + 1][t] = dp[i][t - A[i]] + B[i]
if dp[i + 1][t] < dp[i][t]:
dp[i + 1][t] = dp[i][t]
ans = 0
for i in range(N):
tmp = dp[i+1][T - 1] + max(B[i + 1 :], default=0)
if ans < tmp:
ans = tmp
print(ans)
return
if __name__ == '__main__':
main()
| p02863 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, T, *AB = list(map(int, read().split()))
D = [(a, b) for a, b in zip(*[iter(AB)] * 2)]
D.sort()
A, B = list(zip(*D))
dp = [[0] * T for _ in range(N + 1)]
for i in range(N):
for t in range(T):
if 0 <= t - A[i]:
dp[i + 1][t] = dp[i][t - A[i]] + B[i]
if dp[i + 1][t] < dp[i][t]:
dp[i + 1][t] = dp[i][t]
ans = 0
for i in range(N):
tmp = dp[i+1][T - 1] + max(B[i + 1 :], default=0)
if ans < tmp:
ans = tmp
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, T, *AB = list(map(int, read().split()))
D = [(a, b) for a, b in zip(*[iter(AB)] * 2)]
D.sort()
A, B = list(zip(*D))
dp = [[0] * T for _ in range(N + 1)]
for i, (a, b) in enumerate(D):
for t in range(T):
if 0 <= t - a:
dp[i + 1][t] = dp[i][t - a] + b
if dp[i + 1][t] < dp[i][t]:
dp[i + 1][t] = dp[i][t]
ans = 0
for i in range(N):
tmp = dp[i + 1][T - 1] + max(B[i + 1 :], default=0)
if ans < tmp:
ans = tmp
print(ans)
return
if __name__ == '__main__':
main()
| p02863 |
import sys
read = sys.stdin.buffer.read
def main():
N, T, *AB = list(map(int, read().split()))
D = [(a, b) for a, b in zip(*[iter(AB)] * 2)]
D.sort()
dp = [0] * T
max_sum = [0] * N
for i, (a, b) in enumerate(D):
for t in range(T - 1, -1, -1):
if t >= a and dp[t] < dp[t - a] + b:
dp[t] = dp[t - a] + b
max_sum[i] = dp[T - 1]
ans = max(max_sum[i] + D[i + 1][1] for i in range(N - 1))
print(ans)
return
if __name__ == '__main__':
main()
| import sys
read = sys.stdin.buffer.read
def main():
N, T, *AB = list(map(int, read().split()))
D = [(a, b) for a, b in zip(*[iter(AB)] * 2)]
D.sort()
dp = [0] * T
ans = 0
for i, (a, b) in enumerate(D[:-1]):
for t in range(T - 1, -1, -1):
if t >= a and dp[t] < dp[t - a] + b:
dp[t] = dp[t - a] + b
if ans < dp[T - 1] + D[i + 1][1]:
ans = dp[T - 1] + D[i + 1][1]
print(ans)
return
if __name__ == '__main__':
main()
| p02863 |
n,t=list(map(int,input().split()))
F=[list(map(int,input().split())) for i in range(n)]
dp1=[[0]*(t+1) for i in range(n)]
for i in range(1,n):
for j in range(1,t+1):
if j-F[i-1][0]>=0:
dp1[i][j]=max(dp1[i-1][j],dp1[i][j-1],dp1[i-1][j-F[i-1][0]]+F[i-1][1])
else:
dp1[i][j]=max(dp1[i-1][j],dp1[i][j-1])
dp2=[[0]*(t+1) for i in range(n)]
for i in range(1,n):
for j in range(1,t+1):
if j-F[n-i][0]>=0:
dp2[i][j]=max(dp2[i-1][j],dp2[i][j-1],dp2[i-1][j-F[n-i][0]]+F[n-i][1])
else:
dp2[i][j]=max(dp2[i-1][j],dp2[i][j-1])
ans=0
for i in range(n):
for j in range(1,t):
a=dp1[i][j]+dp2[n-i-1][t-j-1]+F[i][1]
if a>ans:
ans=a
print(ans) | n,t=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(n)]
l.sort()
dp=[0]*(t+max(l)[0])
for a,b in l:
for i in range(0,t+a)[::-1]:
if i-a>=0:
dp[i]=max(dp[i],dp[i-a]+b)
print((max(dp[t:]))) | p02863 |
import sys
input=sys.stdin.readline
n,t=list(map(int,input().split()))
AB=[]
for i in range(n):
a,b=list(map(int,input().split()))
AB.append((a,b))
def f(m):
dp=[[0]*(t) for _ in range(n+1)]
for i in range(n):
if i==m:
a,b=AB[i]
add=b
for j in range(t):
dp[i+1][j]=dp[i][j]
else:
a,b=AB[i]
for j in range(t):
if j>=a:
dp[i+1][j]=max(dp[i][j-a]+b,dp[i][j],dp[i+1][j-1])
else:
dp[i+1][j]=max(dp[i][j],dp[i+1][j-1])
return dp[n][t-1]+add
ans=0
for i in range(n):
ans=max(ans,f(i))
print(ans)
| import sys
input=sys.stdin.readline
n,t=list(map(int,input().split()))
AB=[]
for i in range(n):
a,b=list(map(int,input().split()))
AB.append((a,b))
AB.sort(key=lambda x:x[0])
ans=0
dp=[[0]*(t) for _ in range(n+1)]
for i in range(n-1):
a,b=AB[i]
for j in range(t):
if j>=a:
dp[i+1][j]=max(dp[i][j-a]+b,dp[i][j],dp[i+1][j-1])
else:
dp[i+1][j]=max(dp[i][j],dp[i+1][j-1])
ans=max(ans,dp[i+1][t-1]+AB[i+1][1])
print(ans)
| p02863 |
from copy import deepcopy
# 多次元配列を作成する
def make_multi_list(initial, degree):
ans = [initial for _ in range(degree[-1])]
for d in reversed(degree[:-1]):
ans = [deepcopy(ans) for _ in range(d)]
return ans
N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = make_multi_list(0, [3000, 3000])
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i+1][j] = max(dp[i+1][j], dp[i][j])
# iを使うパターン
nj = j+a
if nj < T:
dp[i+1][nj] = max(dp[i + 1][nj], dp[i][j]+b)
now = dp[i][T-1]+AB[i][1]
ans = max(ans, now)
print(ans) | from copy import deepcopy
# 多次元配列を作成する
def make_multi_list(initial, degree):
ans = [initial for _ in range(degree[-1])]
for d in reversed(degree[:-1]):
ans = [deepcopy(ans) for _ in range(d)]
return ans
N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = make_multi_list(0, [3005, 3005])
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# iを使うパターン
nj = j + a
if nj < T:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + b)
now = dp[i][T - 1] + b
ans = max(ans, now)
print(ans)
| p02863 |
from copy import deepcopy
# 多次元配列を作成する
def make_multi_list(initial, degree):
ans = [initial for _ in range(degree[-1])]
for d in reversed(degree[:-1]):
ans = [deepcopy(ans) for _ in range(d)]
return ans
N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = make_multi_list(0, [3005, 3005])
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# iを使うパターン
nj = j + a
if nj < T:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + b)
now = dp[i][T - 1] + b
ans = max(ans, now)
print(ans)
| N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = dp = [[0 for _ in range(3005)] for _ in range(3005)]
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# iを使うパターン
nj = j + a
if nj < T:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + b)
now = dp[i][T - 1] + b
ans = max(ans, now)
print(ans)
| p02863 |
N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = dp = [[0 for _ in range(3005)] for _ in range(3005)]
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# iを使うパターン
nj = j + a
if nj < T:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + b)
now = dp[i][T - 1] + b
ans = max(ans, now)
print(ans)
| N, T = list(map(int, input().split()))
AB = []
for i in range(N):
a, b = list(map(int, input().split()))
AB.append((a, b))
AB.sort()
ans = 0
dp = [[0 for _ in range(3005)] for _ in range(3005)]
for i in range(N):
a, b = AB[i]
for j in range(T):
# iを使わないパターン
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j])
# iを使うパターン
nj = j + a
if nj < T:
dp[i + 1][nj] = max(dp[i + 1][nj], dp[i][j] + b)
now = dp[i][T - 1] + b
ans = max(ans, now)
print(ans)
| p02863 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def penalty(day, last, c):
val = 0
for i in range(26):
val += c[i] * (day - last[i])
return val
def calcScore(t, s, c):
val = 0
for i in range(26):
last = 0
for j in range(len(t)):
if t[j] == i:
val += s[j][i]
val -= c[i]*(j-last)*(j-last-1)//2
last = j
val -= c[i]*(len(t)-last)*(len(t)-last-1)//2
return val
D = int(eval(input()))
c = list(map(int, input().split()))
s = [[0]*26 for _ in range(D+1)]
for i in range(1, D+1):
s[i] = list(map(int, input().split()))
t = [-1]*(D+1)
for i in range(1, D+1):
t[i] = int(eval(input())) - 1
M = int(eval(input()))
score = calcScore(t, s, c)
ans = [None]*M
for i in range(M):
d, q = list(map(int, input().split()))
t[d] = q-1
ans[i] = calcScore(t, s, c)
for v in ans:
print(v) | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
def calcScore(t, s, c):
scores = [0]*26
lasts = [0]*26
for i in range(1, len(t)):
scores[t[i]] += s[i][t[i]]
dif = i - lasts[t[i]]
scores[t[i]] -= c[t[i]] * dif * (dif-1) // 2
lasts[t[i]] = i
for i in range(26):
dif = len(t) - lasts[i]
scores[i] -= c[i] * dif * (dif-1) // 2
return scores
D = int(eval(input()))
c = list(map(int, input().split()))
s = [[0]*26 for _ in range(D+1)]
for i in range(1, D+1):
s[i] = list(map(int, input().split()))
t = [-1]*(D+1)
for i in range(1, D+1):
t[i] = int(eval(input())) - 1
M = int(eval(input()))
scores = calcScore(t, s, c)
ans = [None]*M
for i in range(M):
d, q = list(map(int, input().split()))
t[d] = q-1
ans[i] = sum(calcScore(t, s, c))
for v in ans:
print(v) | p02620 |
from random import randint
import sys
input = sys.stdin.readline
def calc_score(D, C, S, T):
"""
開催日程Tを受け取ってそこまでのスコアを返す
"""
contest_last_opened = [0]*26 # コンテストiを前回開催した日
score = 0
for d, t in enumerate(T, start=1):
get_score = S[d-1][t-1]
score += get_score
contest_last_opened[t-1] = d
loss_score = 0
for i in range(26):
ld = contest_last_opened[i]
loss_score += C[i]*(d-ld)
score -= loss_score
return score
def local_search():
pass
def main(D, C, S):
T = []
for d in range(1, D+1):
# d日目に一番満足度が高いコンテストを開催する 1-indexed
# S[d-1]で最大のコンテストiを選ぶ → 0点！w
# d日目にコンテストiを選んだ時に一番スコアが高くなるiを選ぶ
today_score = calc_score(D, C, S, T + [1])
today_contest = 1
for i in range(2, 26 + 1):
tmp_score = calc_score(D, C, S, T + [i])
if today_score < tmp_score:
today_score = tmp_score
today_contest = i
T.append(today_contest)
return T
if __name__ == '__main__':
D = int(eval(input()))
C = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(D)]
T = [int(eval(input())) for i in range(D)]
M = int(eval(input()))
DQ = [[int(i) for i in input().split()] for j in range(M)]
for d, q in DQ:
T[d-1] = q
print((calc_score(D, C, S, T)))
| from random import randint
import sys
input = sys.stdin.readline
def calc_score(D, C, S, T):
"""
開催日程Tを受け取ってそこまでのスコアを返す
"""
contest_last_opened = [0]*26 # コンテストiを前回開催した日
score = 0
for d, t in enumerate(T, start=1):
get_score = S[d-1][t-1]
score += get_score
contest_last_opened[t-1] = d
loss_score = 0
for i in range(26):
ld = contest_last_opened[i]
loss_score += C[i]*(d-ld)
score -= loss_score
return score
def update_score(D, C, S, T, score, ct, ci):
"""
ct日目のコンテストをコンテストciに変更する
スコアを差分更新する
ct: change t 変更日
ci: change i 変更コンテスト
"""
contest_last_opened = [0]*26 # コンテストiを前回開催した日
for d in range(1, ct):
contest_last_opened[T[d-1]-1] = d
prei = T[ct-1] # 変更前に開催する予定だったコンテストi
prei_ld = contest_last_opened[prei-1] # preiが前回開催した日
preci_ld = contest_last_opened[ci-1] # ciが前回開催した日
score -= S[ct-1][prei-1]
score += S[ct-1][ci-1]
for d in range(ct, D+1):
if d != ct and T[d-1] == prei:
break
score += C[prei-1]*(d - ct)
score -= C[prei-1]*(d - prei_ld)
for d in range(ct, D+1):
if d != ct and T[d-1] == ci:
break
score += C[ci-1]*(d - preci_ld)
score -= C[ci-1]*(d - ct)
T[ct-1] = ci
return score, T
def local_search():
pass
def main(D, C, S):
T = []
for d in range(1, D+1):
# d日目に一番満足度が高いコンテストを開催する 1-indexed
# S[d-1]で最大のコンテストiを選ぶ → 0点！w
# d日目にコンテストiを選んだ時に一番スコアが高くなるiを選ぶ
today_score = calc_score(D, C, S, T + [1])
today_contest = 1
for i in range(2, 26 + 1):
tmp_score = calc_score(D, C, S, T + [i])
if today_score < tmp_score:
today_score = tmp_score
today_contest = i
T.append(today_contest)
return T
if __name__ == '__main__':
D = int(eval(input()))
C = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(D)]
T = [int(eval(input())) for i in range(D)]
M = int(eval(input()))
DQ = [[int(i) for i in input().split()] for j in range(M)]
score = calc_score(D, C, S, T)
for d, q in DQ:
score, T = update_score(D, C, S, T, score, d, q)
print(score)
| p02620 |
import sys
sys.setrecursionlimit(300000)
from collections import defaultdict
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def MI0(): return [int(s) - 1 for s in sys.stdin.readline().split()]
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list([int(s) - 1 for s in sys.stdin.readline().split()])
MOD = 10 ** 9 + 7
INF = float('inf')
D = I()
C = LMI()
S = [LMI() for _ in range(D)]
T = [I() - 1 for _ in range(D)]
M = I()
def eval(T):
last = defaultdict(int)
ans = 0
for d in range(D):
ans += S[d][T[d]]
last[T[d]] = d + 1
for i in range(26):
ans -= C[i] * (d + 1 - last[i])
return ans
for d, q in [tuple(MI0()) for _ in range(M)]:
T[d] = q
print((eval(T)))
| import sys
sys.setrecursionlimit(300000)
from collections import defaultdict
def I(): return int(sys.stdin.readline())
def MI(): return list(map(int, sys.stdin.readline().split()))
def MI0(): return [int(s) - 1 for s in sys.stdin.readline().split()]
def LMI(): return list(map(int, sys.stdin.readline().split()))
def LMI0(): return list([int(s) - 1 for s in sys.stdin.readline().split()])
MOD = 10 ** 9 + 7
INF = float('inf')
D = I()
C = LMI()
S = [LMI() for _ in range(D)]
T = [I() - 1 for _ in range(D)]
M = I()
last = [[i + 1] * 26 for i in range(D)]
for d in range(D):
i = T[d]
j = 0
for dd in range(d, D):
last[dd][i] = j
j += 1
def eval(d, q):
i = T[d]
val = S[d][q] - S[d][i]
contrib = 0
if d == 0:
j = 1
else:
j = last[d - 1][i] + 1
for dd in range(d, D):
if dd > d and last[dd][i] == 0:
break
contrib += j - last[dd][i]
last[dd][i] = j
j += 1
val -= contrib * C[i]
contrib = 0
j = 0
for dd in range(d, D):
if last[dd][q] == 0:
break
contrib += last[dd][q] - j
last[dd][q] = j
j += 1
val += contrib * C[q]
T[d] = q
return val
def score0(T):
last = defaultdict(int)
ans = 0
for d in range(D):
ans += S[d][T[d]]
last[T[d]] = d + 1
for i in range(26):
ans -= C[i] * (d + 1 - last[i])
return ans
score = score0(T)
for d, q in [tuple(MI0()) for _ in range(M)]:
val = eval(d, q)
score += val
print(score) | p02620 |
def scoring():
score = 0
last = [0] * 26
for d in range(len(out)):
last[out[d]] = d + 1
score += S[d][out[d]]
score -= sum((d + 1 - l) * c for l, c in zip(last, C))
return score
def local_search(d, q, score):
# old = out[d]
out[d] = q
tmp = scoring()
# if tmp > score:
# score = tmp
# else:
# out[d] = old
return tmp
D = int(eval(input()))
C = list(map(int, input().split()))
S = []
for _ in range(D):
s = list(map(int, input().split()))
S.append(s)
out = [int(eval(input())) - 1 for _ in range(D)]
res = scoring()
M = int(eval(input()))
for _ in range(M):
d, q = list(map(int, input().split()))
res = local_search(d-1, q-1, res)
print(res)
| import sys
input = sys.stdin.readline
def scoring(sc):
last = [0] * 26
res = 0
penalty = 0
for i in range(D):
t = out[i]
res += S[i][t]
penalty += sc - (i + 1 - last[t]) * C[t]
res -= penalty
last[t] = i + 1
return res
D = int(eval(input()))
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
out = [int(eval(input())) - 1 for _ in range(D)]
sc = sum(C)
M = int(eval(input()))
for _ in range(M):
d, q = list(map(int, input().split()))
out[d-1] = q - 1
print((scoring(sc)))
| p02620 |
from _collections import deque
def main():
D = int(eval(input()))
C = list(map(int,input().split()))
S = deque([])
for _ in range(D):
S.append(list(map(int,input().split())))
SELECT = deque([])
for i in range(D):
SELECT.append(int(eval(input()))-1)
def score(selects):
score = 0
L = [0 for _ in range(26)]
def calc(ans, select, n):
for i, l in enumerate(L):
if i != select:
ans -= C[i] * (n - L[i])
else:
L[i] = n
return ans
for i,select in enumerate(selects):
score += S[i][select]
for j, l in enumerate(L):
if j != select:
score -= C[j] * (i+1 - L[j])
else:
L[j] = i+1
return score
M = int(eval(input()))
for _ in range(M):
i, s = list(map(int,input().split()))
SELECT[i-1]=s-1
print((score(SELECT)))
if __name__=="__main__":
main() | D = int(eval(input()))
C = list(map(int,input().split()))
S = [list(map(int,input().split()))for _ in range(D)]
SELECT = []
for i in range(D):
SELECT.append(int(eval(input()))-1)
M = int(eval(input()))
d = []
q = []
for _ in range(M):
td, tq = list(map(int,input().split()))
d.append(td-1)
q.append(tq-1)
L_ALL = [[0]*26 for _ in range(D)]
L = [0]*26
ans = 0
for i in range(D):
ans += S[i][SELECT[i]]
L[SELECT[i]]=i+1
if i != 0:
L_ALL[i] = L_ALL[i-1][:]
L_ALL[i][SELECT[i]] = i+1
for j in range(26):
ans -= C[j]*(i+1-L[j])
for i in range(M):
day = d[i]
before = SELECT[day]
after = q[i]
ans -= S[day][before]
ans += S[day][after]
SELECT[day] = q[i]
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][before]
j = day
while 0<=j<D and L_ALL[j][before]==day+1:
L_ALL[j][before] = tmp
ans -= C[before]*(day+1-tmp)
j += 1
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][after]
j = day
while 0<=j<D and L_ALL[j][after]==tmp:
L_ALL[j][after]=day+1
ans += C[after] * (day+1-tmp)
j += 1
print(ans) | p02620 |
D = int(eval(input()))
C = list(map(int,input().split()))
S = [list(map(int,input().split()))for _ in range(D)]
SELECT = []
for i in range(D):
SELECT.append(int(eval(input()))-1)
M = int(eval(input()))
d = []
q = []
for _ in range(M):
td, tq = list(map(int,input().split()))
d.append(td-1)
q.append(tq-1)
L_ALL = [[0]*26 for _ in range(D)]
L = [0]*26
ans = 0
for i in range(D):
ans += S[i][SELECT[i]]
L[SELECT[i]]=i+1
if i != 0:
L_ALL[i] = L_ALL[i-1][:]
L_ALL[i][SELECT[i]] = i+1
for j in range(26):
ans -= C[j]*(i+1-L[j])
for i in range(M):
day = d[i]
before = SELECT[day]
after = q[i]
ans -= S[day][before]
ans += S[day][after]
SELECT[day] = q[i]
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][before]
j = day
while 0<=j<D and L_ALL[j][before]==day+1:
L_ALL[j][before] = tmp
ans -= C[before]*(day+1-tmp)
j += 1
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][after]
j = day
while 0<=j<D and L_ALL[j][after]==tmp:
L_ALL[j][after]=day+1
ans += C[after] * (day+1-tmp)
j += 1
print(ans) | def main():
D = int(eval(input()))
C = list(map(int,input().split()))
S = [list(map(int,input().split()))for _ in range(D)]
SELECT = []
for i in range(D):
SELECT.append(int(eval(input()))-1)
M = int(eval(input()))
d = []
q = []
for _ in range(M):
td, tq = list(map(int,input().split()))
d.append(td-1)
q.append(tq-1)
L_ALL = [[0]*26 for _ in range(D)]
L = [0]*26
ans = 0
for i in range(D):
ans += S[i][SELECT[i]]
L[SELECT[i]]=i+1
if i != 0:
L_ALL[i] = L_ALL[i-1][:]
L_ALL[i][SELECT[i]] = i+1
for j in range(26):
ans -= C[j]*(i+1-L[j])
for i in range(M):
day = d[i]
before = SELECT[day]
after = q[i]
ans -= S[day][before]
ans += S[day][after]
SELECT[day] = q[i]
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][before]
j = day
while 0<=j<D and L_ALL[j][before]==day+1:
L_ALL[j][before] = tmp
ans -= C[before]*(day+1-tmp)
j += 1
if day == 0:
tmp = 0
else:
tmp = L_ALL[day-1][after]
j = day
while 0<=j<D and L_ALL[j][after]==tmp:
L_ALL[j][after]=day+1
ans += C[after] * (day+1-tmp)
j += 1
print(ans)
if __name__=="__main__":
main() | p02620 |
D=int(eval(input()))
c = list(map(int,input().split()))
s=[None]*D
for i in range(D):
s[i] = list(map(int,input().split()))
t=[0]*D
for i in range(D):
t[i]=int(eval(input()))
m=int(eval(input()))
d=[None]*m
q=[None]*m
for i in range(m):
d[i],q[i] = list(map(int,input().split()))
def calc_score(t):
last=[0]*26
satis=0
pena=0
for j in range(D):
ss=s[j]
tt=t[j]
satis += ss[tt-1]
last[tt-1]=j+1
pena += sum(c[i]*(j+1-last[i]) for i in range(26))
return satis-pena
# calc_score(t)-10**6
for i in range(m):
t[d[i]-1] = q[i]
print((calc_score(t))) | D=int(eval(input()))
c = list(map(int,input().split()))
s=[None]*D
for i in range(D):
s[i] = list(map(int,input().split()))
t=[0]*D
for i in range(D):
t[i]=int(eval(input()))
m=int(eval(input()))
d=[None]*m
q=[None]*m
for i in range(m):
d[i],q[i] = list(map(int,input().split()))
sumc=sum(c)
def calc_score(t):
last=[0]*26
satis=0
pena=0
delta_pena=0
for j in range(D):
ss=s[j]
tt=t[j]
satis += ss[tt-1]
delta_pena += sumc - c[tt-1]*(j+1-last[tt-1])
last[tt-1]=j+1
pena += delta_pena
return satis-pena
for i in range(m):
t[d[i]-1] = q[i]
print((calc_score(t))) | p02620 |
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
D = INT()
C = LIST()
S = [[]] * D
for i in range(D):
S[i] = LIST()
T = [t-1 for t in LIST(D)]
M = 26
last = list2d(M, D+2, 0)
def check(T):
score = 0
for i, t in enumerate(T):
score += S[i][t]
for j in range(M):
last[j][i+1] = last[j][i] + 1
last[t][i+1] = 0
for j in range(M):
score -= C[j] * last[j][i+1]
return score
def change(day, a, b):
nxtday = last[a].index(0, day+2)
w = nxtday - day - 1
h = last[a][day] + 1
a_change = C[a] * h * w
for d in range(day, nxtday-1):
last[a][d+1] = last[a][d] + 1
nxtday = last[b].index(0, day+2)
w = nxtday - day - 1
h = last[b][day] + 1
b_change = C[b] * h * w
last[b][day+1] = 0
for d in range(day+1, nxtday-1):
last[b][d+1] = last[b][d] + 1
res = -a_change + b_change - S[day][a] + S[day][b]
return res
score = check(T)
Q = INT()
for i in range(Q):
d, q = MAP()
d -= 1; q -= 1
prev = T[d]
nxt = q
score += change(d, prev, nxt)
print(score)
T[d] = q
| import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 19
MOD = 10 ** 9 + 7
EPS = 10 ** -10
D = INT()
C = LIST()
S = [[]] * (D+1)
for i in range(1, D+1):
S[i] = LIST()
T = [0] + [t-1 for t in LIST(D)]
M = 26
last = list2d(M, D+2, 0)
def check(T):
score = 0
for i, t in enumerate(T[1:], 1):
score += S[i][t]
for j in range(M):
last[j][i] = last[j][i-1] + 1
last[t][i] = 0
for j in range(M):
score -= C[j] * last[j][i]
return score
def change(day, a, b):
nxtday = last[a].index(0, day+1)
w = nxtday - day
h = last[a][day-1] + 1
a_change = C[a] * h * w
for d in range(day, nxtday):
last[a][d] = last[a][d-1] + 1
nxtday = last[b].index(0, day+1)
w = nxtday - day
h = last[b][day-1] + 1
b_change = C[b] * h * w
last[b][day] = 0
for d in range(day+1, nxtday):
last[b][d] = last[b][d-1] + 1
res = -a_change + b_change - S[day][a] + S[day][b]
return res
score = check(T)
Q = INT()
for i in range(Q):
d, q = MAP()
q -= 1
prev = T[d]
nxt = q
score += change(d, prev, nxt)
print(score)
T[d] = q
| p02620 |
from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
from functools import lru_cache
import itertools
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
INF = 10 ** 17
def main():
D = int(eval(input()))
c = [int(a) for a in input().split()]
s = [
[int(a) for a in input().split()]
for _ in range(D)
]
t = [
int(eval(input()))
for _ in range(D)
]
M = int(eval(input()))
dq = [
[int(a) for a in input().split()]
for _ in range(M)
]
def calc_score(t):
score = 0
last = [0] * len(c)
res = []
for d, ti in enumerate(t):
sdi = s[d][ti - 1]
score += sdi
last[ti - 1] = d + 1
for i, ci in enumerate(c):
score -= ci * ((d + 1) - last[i])
res.append(score)
return res
for di, qi in dq:
t[di - 1] = qi
scores = calc_score(t)
print((scores[-1]))
if __name__ == "__main__":
main()
| from collections import deque, Counter, defaultdict
from itertools import chain, combinations
import json
# import numpy as np
import bisect
import sys
import math
import bisect
from functools import lru_cache
import itertools
sys.setrecursionlimit(10 ** 8)
M = 10 ** 9 + 7
INF = 10 ** 17
def main():
D = int(eval(input()))
c = [int(a) for a in input().split()]
s = [
[int(a) for a in input().split()]
for _ in range(D)
]
t = [
int(eval(input()))
for _ in range(D)
]
M = int(eval(input()))
dq = [
[int(a) for a in input().split()]
for _ in range(M)
]
def calc_score(t):
score = 0
last = [0] * len(c)
res = []
for d, ti in enumerate(t):
sdi = s[d][ti - 1]
score += sdi
last[ti - 1] = d + 1
for i, ci in enumerate(c):
score -= ci * ((d + 1) - last[i])
res.append(score)
return res
def calc_score_diff(t, di, qi):
old_q = t[di - 1]
last_old_q_date = 0
for i in range(di - 2, -1, -1):
if t[i] == old_q:
last_old_q_date = i + 1
break
next_old_q_date = D + 1
for i in range(di, D):
if t[i] == old_q:
next_old_q_date = i + 1
break
old_d_last = di - last_old_q_date
old_d_next = next_old_q_date - di
old_diff = old_d_next * old_d_last * c[old_q - 1]
new_q = qi
last_new_q_date = 0
for i in range(di - 2, -1, -1):
if t[i] == new_q:
last_new_q_date = i + 1
break
next_new_q_date = D + 1
for i in range(di, D):
if t[i] == new_q:
next_new_q_date = i + 1
break
new_d_last = di - last_new_q_date
new_d_next = next_new_q_date - di
new_diff = new_d_next * new_d_last * c[new_q - 1]
old_score = s[di - 1][old_q - 1]
new_score = s[di - 1][new_q - 1]
return new_diff - old_diff + new_score - old_score
score = calc_score(t)[-1]
for di, qi in dq:
diff = calc_score_diff(t, di, qi)
score += diff
print(score)
t[di - 1] = qi
if __name__ == "__main__":
main()
| p02620 |
D = int(eval(input()))
c = [int(i) for i in input().split()]
s = [[int(i) for i in input().split()] for _ in range(D)]
t = [int(eval(input()))-1 for _ in range(D)]
llst = [0]*26
def scoreing():
res = 0
for i in range(26): llst[i] = 0
for day,i in enumerate(list(range(D)),1):
llst[t[i]] = day
res += s[i][t[i]]
for j in range(26): res -= c[j]*(day-llst[j])
return res
M = int(eval(input()))
ans = [0]*M
for i in range(M):
d,q = list(map(int,input().split()))
d -= 1
q -= 1
t[d] = q
ans[i] = scoreing()
for i in range(M): print((ans[i])) | D = int(eval(input()))
c = [int(i) for i in input().split()]
s = [[int(i) for i in input().split()] for _ in range(D)]
t = [int(eval(input()))-1 for _ in range(D)]
def scoreing(x):
res = 0
last = 0
for day,i in enumerate(list(range(D)),1):
if t[i] == x:
last = day
res += s[i][x]
res -= c[x]*(day-last)
return res
score = [0]*26
for i in range(26): score[i] = scoreing(i)
M = int(eval(input()))
ans = [0]*M
for i in range(M):
d,q = list(map(int,input().split()))
d -= 1
q -= 1
old = t[d]
t[d] = q
score[old] = scoreing(old)
score[q] = scoreing(q)
ans[i] = sum(score)
for i in range(M): print((ans[i])) | p02620 |
import sys
from bisect import bisect_right, bisect_left
def checkScore(p):
global D, last, S
rst = 0
_last = last[p]
for d in range(1, D + 1):
down = C[p] * (d - _last[d])
up = S[d][p] if _last[d] == d else 0
rst += up - down
return rst
Z = 26
D = int(eval(input()))
C = list(map(int, input().split()))
S = [tuple([0] * Z)] + [tuple(map(int, input().split())) for _ in range(D)]
T = [None] + [int(eval(input())) - 1 for _ in range(D)]
M = int(eval(input()))
Q = [tuple([int(x) - 1 for x in s.split()]) for s in sys.stdin.readlines()]
last = [[0] * (D + 1) for _ in range(Z)]
V = [0] * Z
for d in range(1, D + 1):
t = T[d]
for p in range(Z):
last[p][d] = last[p][d - 1]
last[t][d] = d
for p in range(Z):
V[p] = checkScore(p)
score = sum(V)
for d, q in Q:
d += 1
p = T[d]
s = bisect_left(last[p], d)
e = bisect_right(last[p], d)
for j in range(s, e):
last[p][j] = last[p][j - 1]
old = last[q][d]
e = bisect_right(last[q], old)
for j in range(d, e):
last[q][j] = d
score -= V[p] + V[q]
V[p] = checkScore(p)
V[q] = checkScore(q)
score += V[p] + V[q]
print(score)
T[d] = q
| import sys
from bisect import bisect_right, bisect_left
def calculate_score(c):
global D, last, S
rst = 0
_last = last[c]
for d in range(1, D + 1):
down = C[c] * (d - _last[d])
up = S[d][c] if _last[d] == d else 0
rst += up - down
return rst
Z = 26
D = int(eval(input()))
C = list(map(int, input().split()))
S = [tuple([0] * Z)] + [tuple(map(int, input().split())) for _ in range(D)]
T = [None] + [int(eval(input())) - 1 for _ in range(D)] #
M = int(eval(input()))
Q = [tuple([int(x) - 1 for x in s.split()]) for s in sys.stdin.readlines()]
last = [[0] * (D + 1) for _ in range(Z)] # last[i][d]
V = [0] * Z # 各コンテストiごとの得点を保管しておく
# 初期状態でのlastを求める
for d in range(1, D + 1):
t = T[d]
for p in range(Z):
last[p][d] = last[p][d - 1]
last[t][d] = d
# 各コンテストpごとに得点を求める
for p in range(Z):
V[p] = calculate_score(p)
# 初期状態での得点
score = sum(V)
for d, q in Q:
d += 1 # Qだけ0-indexなので補正
p = T[d]
# d日目の開催が p -> q に変わる
# まず, last[p]を更新する. 更新箇所はd日目 ~ 次の開催日直前
e = bisect_right(last[p], d)
for j in range(d, e):
last[p][j] = last[p][j - 1]
# 次に, last[q]を更新する. 更新箇所はd日目 ~ 次の開催日直前
old = last[q][d]
e = bisect_right(last[q], old)
for j in range(d, e):
last[q][j] = d
score -= V[p] + V[q]
V[p] = calculate_score(p)
V[q] = calculate_score(q)
score += V[p] + V[q]
print(score)
T[d] = q | p02620 |
def P(s):
R,P,*L=[0]*28
for i in range(D):t=I[i+D][0]-1;P+=s-(i+1-L[t])*C[t];R+=I[i][t]-P;L[t]=i+1
return R
(D,),C,*I=[[*list(map(int,t.split()))]for t in open(0)]
for d,q in I[D-~D:]:I[d-1+D][0]=q;print((P(sum(C)))) | def P(s):
i,R,P,*L=[0]*29
while i<D:t=I[i+D][0]-1;P+=s-(i+1-L[t])*C[t];R+=I[i][t]-P;i+=1;L[t]=i
return R
(D,),C,*I=[[*list(map(int,t.split()))]for t in open(0)]
for d,q in I[D-~D:]:I[d-1+D][0]=q;print((P(sum(C)))) | p02620 |
def P(s):
i,R,P,*L=[0]*29
while i<D:t=I[i+D][0]-1;P+=s-(i+1-L[t])*C[t];R+=I[i][t]-P;i+=1;L[t]=i
return R
(D,),C,*I=[[*list(map(int,t.split()))]for t in open(0)]
for d,q in I[D-~D:]:I[d-1+D][0]=q;print((P(sum(C)))) | def P(s):
i,R,P,*L=[0]*29
while i<D:t=I[i+D][0]-1;P+=s+(~i+L[t])*C[t];R+=I[i][t]-P;i+=1;L[t]=i
return R
(D,),C,*I=[[*list(map(int,t.split()))]for t in open(0)]
for d,q in I[D-~D:]:I[d-1+D][0]=q;print((P(sum(C)))) | p02620 |
def f(a,d,T):
try:
return T[d:].index(a)+d
except ValueError:
return len(T)
from random import randint
A=26
D=int(eval(input()))
C=[0]+list(map(int,input().split())) #減る満足度のベース
S=[0]*(D+1) #S[d][i] :(d+1)日目にコンテストiを開催した時の満足度
for i in range(1,D+1):
S[i]=[0]+list(map(int,input().split()))
T=[0]
for i in range(D):
T.append(int(eval(input())))
L=[[0]*(A+1) for _ in range(D+1)]
for x in range(1,D+1):
t=T[x]
for j in range(1,A+1):
if t!=j:
L[x][j]=L[x-1][j]+1
else:
L[x][j]=0
X=0
for d in range(1,D+1):
X+=S[d][T[d]]
for j in range(1,A+1):
X-=C[j]*L[d][j]
M=int(eval(input()))
for _ in range(M):
d,q=list(map(int,input().split()))
p=T[d]
a=f(p,d+1,T)
b=f(q,d+1,T)
Y=0
h=L[d-1][p]
for i in range(d,a):
h+=1
Y+=h-L[i][p]
L[i][p]=h
m=0
Z=0
for j in range(d,b):
Z-=m-L[j][q]
L[j][q]=m
m+=1
T[d]=q
X+=(S[d][q]-S[d][p])+Z*C[q]-Y*C[p]
print(X)
| def f(a,d,T):
try:
return T[d:].index(a)+d
except ValueError:
return len(T)
from random import randint
A=26
D=int(eval(input()))
C=[0]+list(map(int,input().split())) #減る満足度のベース
S=[0]*(D+1) #S[d][i] :(d+1)日目にコンテストiを開催した時の満足度
for i in range(1,D+1):
S[i]=[0]+list(map(int,input().split()))
T=[0]
for i in range(D):
T.append(int(eval(input())))
L=[[0]*(A+1) for _ in range(D+1)]
for x in range(1,D+1):
t=T[x]
for j in range(1,A+1):
if t!=j:
L[x][j]=L[x-1][j]+1
else:
L[x][j]=0
X=0
for d in range(1,D+1):
X+=S[d][T[d]]
for j in range(1,A+1):
X-=C[j]*L[d][j]
M=int(eval(input()))
for _ in range(M):
d,q=list(map(int,input().split()))
p=T[d]
a=f(p,d+1,T)
b=f(q,d+1,T)
Y=0
h=L[d-1][p]
for i in range(d,a):
h+=1
Y+=h-L[i][p]
L[i][p]=h
m=0
Z=0
for j in range(d,b):
Z-=m-L[j][q]
L[j][q]=m
m+=1
X+=(S[d][q]-S[d][p])+Z*C[q]-Y*C[p]
print(X)
T[d]=q
| p02620 |
def f(a,d,T):
try:
return T[d:].index(a)+d
except ValueError:
return len(T)
from random import randint
A=26
D=int(eval(input()))
C=[0]+list(map(int,input().split())) #減る満足度のベース
S=[0]*(D+1) #S[d][i] :(d+1)日目にコンテストiを開催した時の満足度
for i in range(1,D+1):
S[i]=[0]+list(map(int,input().split()))
T=[0]
for i in range(D):
T.append(int(eval(input())))
L=[[0]*(A+1) for _ in range(D+1)]
for x in range(1,D+1):
t=T[x]
for j in range(1,A+1):
if t!=j:
L[x][j]=L[x-1][j]+1
else:
L[x][j]=0
X=0
for d in range(1,D+1):
X+=S[d][T[d]]
for j in range(1,A+1):
X-=C[j]*L[d][j]
M=int(eval(input()))
for _ in range(M):
d,q=list(map(int,input().split()))
p=T[d]
a=f(p,d+1,T)
b=f(q,d+1,T)
Y=0
h=L[d-1][p]
for i in range(d,a):
h+=1
Y+=h-L[i][p]
L[i][p]=h
m=0
Z=0
for j in range(d,b):
Z-=m-L[j][q]
L[j][q]=m
m+=1
X+=(S[d][q]-S[d][p])+Z*C[q]-Y*C[p]
print(X)
T[d]=q
| def f(a,d,T):
try:
return T[d+1:].index(a)+(d+1)
except ValueError:
return len(T)
def g(a,d,T):
try:
return T[:d].index(a)
except ValueError:
return 0
A=26
D=int(eval(input()))
C=[0]+list(map(int,input().split())) #減る満足度のベース
S=[0]*(D+1) #S[d][i] :(d+1)日目にコンテストiを開催した時の満足度
for i in range(1,D+1):
S[i]=[0]+list(map(int,input().split()))
T=[0]
for i in range(D):
T.append(int(eval(input())))
X=0
L=[0]*(A+1)
R=[[0]*(A+1) for _ in range(D+1)]
for d in range(1,D+1):
X+=S[d][T[d]]
for j in range(1,A+1):
if j!=T[d]:
L[j]+=1
R[d][j]=R[d-1][j]+1
X-=C[j]*L[j]
else:
L[j]=0
M=int(eval(input()))
for _ in range(M):
d,q=list(map(int,input().split()))
p=T[d]
Y=0
h=R[d-1][p]
for i in range(d,f(p,d,T)):
h+=1
Y+=h-R[i][p]
R[i][p]=h
Z=0
m=0
for j in range(d,f(q,d,T)):
Z+=R[j][q]-m
R[j][q]=m
m+=1
T[d]=q
X+=(S[d][q]-S[d][p])+Z*C[q]-Y*C[p]
print(X)
| p02620 |
D=int(eval(input()))
C=list(map(int,input().split()))
S=[list(map(int,input().split())) for i in range(D)]
T=[int(eval(input()))-1 for i in range(D)]
X=[0]*26
Y=[0]*26
M=int(eval(input()))
d,q=0,0
P=0
for i in range(D):
P+=S[i][T[i]]
for j in range(26):
X[j]+=C[j]
X[T[i]]=0
for j in range(26):
Y[j]+=X[j]
for i in range(M):
d,q=list(map(int,input().split()))
d,q=d-1,q-1
P-=S[d][T[d]]
P+=S[d][q]
for j in range(26):
X[j]=0
Y[T[d]],Y[q]=0,0
for j in range(D):
if j==d:
Z=q
else:
Z=T[j]
for j in range(26):
X[j]+=C[j]
X[Z]=0
Y[T[d]]+=X[T[d]]
Y[q]+=X[q]
T[d]=q
print((P-sum(Y))) | D=int(eval(input()))
C=list(map(int,input().split()))
S=[list(map(int,input().split())) for i in range(D)]
T=[int(eval(input()))-1 for i in range(D)]
X=[0]*26
Y=[0]*26
M=int(eval(input()))
d,q=0,0
P=0
for i in range(D):
P+=S[i][T[i]]
for j in range(26):
X[j]+=C[j]
X[T[i]]=0
for j in range(26):
Y[j]+=X[j]
for i in range(M):
d,q=list(map(int,input().split()))
d,q=d-1,q-1
P-=S[d][T[d]]
P+=S[d][q]
for j in range(26):
X[j]=0
Y[T[d]],Y[q]=0,0
for j in range(D):
if j==d:
Z=q
else:
Z=T[j]
X[T[d]]+=C[T[d]]
X[q]+=C[q]
X[Z]=0
Y[T[d]]+=X[T[d]]
Y[q]+=X[q]
T[d]=q
print((P-sum(Y))) | p02620 |
import sys
input = sys.stdin.readline
d = int(eval(input()))
*C, = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(d)]
T = [int(eval(input())) - 1 for i in range(d)]
L = [[-1]]
def score(T):
L = [-1 for j in range(26)]
tmp = 0
for i in range(d):
tmp += S[i][T[i]]
L[T[i]] = i
tmp -= sum([C[j] * (i - L[j]) for j in range(26)])
return tmp
m = int(eval(input()))
for k in range(m):
p, q = list(map(int, input().split()))
T[p - 1] = q - 1
print((score(T)))
| d = int(eval(input()))
dd = d * (d + 1) // 2
*C, = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(d)]
T = [int(eval(input())) - 1 for i in range(d)]
m = int(eval(input()))
PQ = [tuple(map(int, input().split())) for k in range(m)]
PQ = [(p - 1, q - 1) for p, q in PQ]
for p, q in PQ:
T[p] = q
L = [-1 for j in range(26)]
X = [0 for j in range(26)]
score = 0
for i in range(d):
score += S[i][T[i]]
X[T[i]] += (d - i) * (i - L[T[i]])
L[T[i]] = i
for j in range(26):
score -= C[j] * (dd - X[j])
print(score)
| p02620 |
d = int(eval(input()))
dd = d * (d + 1) // 2
*C, = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(d)]
T = [int(eval(input())) - 1 for i in range(d)]
m = int(eval(input()))
PQ = [tuple(map(int, input().split())) for k in range(m)]
PQ = [(p - 1, q - 1) for p, q in PQ]
for p, q in PQ:
T[p] = q
L = [-1 for j in range(26)]
X = [0 for j in range(26)]
score = 0
for i in range(d):
score += S[i][T[i]]
X[T[i]] += (d - i) * (i - L[T[i]])
L[T[i]] = i
for j in range(26):
score -= C[j] * (dd - X[j])
print(score)
| d = int(eval(input()))
dd = d * (d + 1) // 2
*C, = list(map(int, input().split()))
S = [list(map(int, input().split())) for i in range(d)]
def calc_score(T):
L = [-1 for j in range(26)]
X = [0 for j in range(26)]
score = 0
for i in range(d):
score += S[i][T[i]]
X[T[i]] += (d - i) * (i - L[T[i]])
L[T[i]] = i
for j in range(26):
score -= C[j] * (dd - X[j])
return score
T = [int(eval(input())) - 1 for i in range(d)]
m = int(eval(input()))
PQ = [tuple(map(int, input().split())) for k in range(m)]
PQ = [(p - 1, q - 1) for p, q in PQ]
for p, q in PQ:
T[p] = q
print((calc_score(T)))
| p02620 |
def solve():
from bisect import bisect_left
N, W = list(map(int, input().split()))
n1 = N//2
n2 = N-n1
a = [[tuple(map(int, input().split())) for _ in [0]*n1], [tuple(map(int, input().split())) for _ in [0]*n2]]
dp = [[(0, 0) for _ in [0]*(2**n1)], [(0, 0) for _ in [0]*(2**n2)]]
for i in range(2):
n = len(a[i])
cdp = dp[i]
ca = a[i]
append = cdp.append
for bit in range(1, 2**n):
v, w = 0, 0
for j in range(n):
if 2**j & bit:
v += ca[j][0]
w += ca[j][1]
if w <= W:
cdp[bit] = (w, v)
cdp = sorted(cdp)
dp[i] = [pair for w in [[-1]] for sa in [w.__setitem__] for pair in cdp if pair[1] > w[0] and not sa(0, pair[1])]
result = 0
inf = float("inf")
l = len(dp[1])
for w, v in dp[0]:
i = bisect_left(dp[1], (W-w, inf))
newv = v + dp[1][i-1][1] if i > 0 else 0
#print(w, v, i, newv)
if newv > result:
result = newv
print(result)
if __name__ == "__main__":
solve() | def solve():
from bisect import bisect_left
N, W = list(map(int, input().split()))
n1 = N//2
n2 = N-n1
a = [[tuple(map(int, input().split())) for _ in [0]*n1], [tuple(map(int, input().split())) for _ in [0]*n2]]
dp = [[(0, 0) for _ in [0]*(2**n1)], [(0, 0) for _ in [0]*(2**n2)]]
for i in range(2):
n = len(a[i])
cdp = dp[i]
ca = a[i]
for j in range(n):
if ca[j][1] > W:
continue
for bitset in range(2**j, 2**(j+1)):
#print(bin(bitset))
v, w = ca[j]
for k in range(j):
if 2**k & bitset:
v += ca[k][0]
w += ca[k][1]
if w <= W:
cdp[bitset] = (w, v)
cdp = sorted(cdp)
dp[i] = [pair for w in [[-1]] for sa in [w.__setitem__] for pair in cdp if pair[1] > w[0] and not sa(0, pair[1])]
#print(dp)
result = 0
inf = float("inf")
l = len(dp[1])
for w, v in dp[0]:
i = bisect_left(dp[1], (W-w, inf))
newv = v + dp[1][i-1][1] if i > 0 else 0
#print(w, v, i, newv)
if newv > result:
result = newv
print(result)
if __name__ == "__main__":
solve() | p02321 |
def solve():
from bisect import bisect_left
N, W = list(map(int, input().split()))
n1 = N//2
n2 = N-n1
a = [[tuple(map(int, input().split())) for _ in [0]*n1], [tuple(map(int, input().split())) for _ in [0]*n2]]
dp = [[(0, 0) for _ in [0]*(2**n1)], [(0, 0) for _ in [0]*(2**n2)]]
for i in range(2):
n = len(a[i])
cdp = dp[i]
ca = a[i]
for j in range(n):
if ca[j][1] > W:
continue
for bitset in range(2**j, 2**(j+1)):
#print(bin(bitset))
v, w = ca[j]
for k in range(j):
if 2**k & bitset:
v += ca[k][0]
w += ca[k][1]
if w <= W:
cdp[bitset] = (w, v)
cdp = sorted(cdp)
dp[i] = [pair for w in [[-1]] for sa in [w.__setitem__] for pair in cdp if pair[1] > w[0] and not sa(0, pair[1])]
#print(dp)
result = 0
inf = float("inf")
l = len(dp[1])
for w, v in dp[0]:
i = bisect_left(dp[1], (W-w, inf))
newv = v + dp[1][i-1][1] if i > 0 else 0
#print(w, v, i, newv)
if newv > result:
result = newv
print(result)
if __name__ == "__main__":
solve() | def solve():
from bisect import bisect_right
N, W = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0]*N]
def bitdp(items):
n = len(items)
dp = [(0, 0) for _ in [0]*(2**n)]
for bitset in range(1, 2**n):
for item_num, (item_v, item_w) in enumerate(items):
if bitset & 2**item_num:
w, v = dp[bitset-2**item_num]
if w+item_w <= W:
dp[bitset] = (w+item_w, v+item_v)
break
dp.sort()
l, maxv, inf = [(0, 0)], 0, float("inf")
append = l.append
for item, (w, v), (nextw, _) in zip(dp, dp, dp[1:]+[(inf, inf)]):
if w < nextw and maxv < v:
append(item)
maxv = v
return l
dp1 = bitdp(a[:N//2])
dp2 = bitdp(a[N//2:])
inf = float("inf")
result = 0
for w, v in dp1:
total = v + dp2[bisect_right(dp2, (W-w, inf))-1][1]
if result < total:
result = total
print(result)
if __name__ == "__main__":
solve() | p02321 |
def solve():
from bisect import bisect_right
N, W = list(map(int, input().split()))
a = [tuple(map(int, input().split())) for _ in [0]*N]
def bitdp(items):
n = len(items)
dp = [(0, 0) for _ in [0]*(2**n)]
for bitset in range(1, 2**n):
for item_num, (item_v, item_w) in enumerate(items):
if bitset & 2**item_num:
w, v = dp[bitset-2**item_num]
if w+item_w <= W:
dp[bitset] = (w+item_w, v+item_v)
break
dp.sort()
l, maxv, inf = [(0, 0)], 0, float("inf")
append = l.append
for item, (w, v), (nextw, _) in zip(dp, dp, dp[1:]+[(inf, inf)]):
if w < nextw and maxv < v:
append(item)
maxv = v
return l
dp1 = bitdp(a[:N//2])
dp2 = bitdp(a[N//2:])
inf = float("inf")
result = 0
for w, v in dp1:
total = v + dp2[bisect_right(dp2, (W-w, inf))-1][1]
if result < total:
result = total
print(result)
if __name__ == "__main__":
solve() | import sys
from bisect import bisect_right
def meet_in_the_middle(a: list, limit: int) -> tuple:
first_v, first_w, second_v, second_w = [], [], [], []
for items, v_append, w_append in (
(a[:len(a)//2], first_v.append, first_w.append),
(a[len(a)//2:], second_v.append, second_w.append)
):
enumerated = [(0, 0)]
for v, w in items:
enumerated += [(w+_w, v+_v) for _w, _v in enumerated]
enumerated.sort()
enumerated = enumerated[:bisect_right(enumerated, (limit, float("inf")))] + [(limit+1, 0)]
max_v = -1
for (cw, cv), (nw, nv) in zip(enumerated, enumerated[1:]):
if cw < nw and max_v < cv:
v_append(cv)
w_append(cw)
max_v = cv
return (first_v, first_w), (second_v, second_w)
N, W = list(map(int, input().split()))
a = [list(map(int, l.split())) for l in sys.stdin]
(first_v, first_w), (second_v, second_w) = meet_in_the_middle(a, W)
ans = 0
for v, w in zip(first_v, first_w):
i = bisect_right(second_w, W-w)-1
new_v = v + second_v[i]
if ans < new_v:
ans = new_v
print(ans)
| p02321 |
a=int(eval(input()))
b=int(eval(input()))
h=int(eval(input()))
print((int((a+b)*h/2))) | a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
| p03997 |
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print((int((a + b) * h / 2))) | a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2)) | p03997 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.