๋ฌธ์
https://www.acmicpc.net/problem/14501
๋ฐฑ์ค ๋ฌธ์ ์ง - 0x10๊ฐ - ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
์๊ณ ๋ฆฌ์ฆ: ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ, ๋ธ๋ฃจํธํฌ์ค
ํ์ด
์๋ด์์ผ๋ก ์ผํ๊ณ ์๋ ๋ฐฑ์ค์ด๋ ํด์ฌ๋ฅผ ํ๋ ค๊ณ ํ๋ค.
์ค๋๋ถํฐ N+1์ผ์งธ ๋๋ ๋ ํด์ฌ๋ฅผ ํ๊ธฐ ์ํด์, ๋จ์ N์ผ ๋์ ์ต๋ํ ๋ง์ ์๋ด์ ํ๋ ค๊ณ ํ๋ค.
๋ฐฑ์ค์ด๋ ๋น์์๊ฒ ์ต๋ํ ๋ง์ ์๋ด์ ์ก์ผ๋ผ๊ณ ๋ถํ์ ํ๊ณ , ๋น์๋ ํ๋ฃจ์ ํ๋์ฉ ์๋ก ๋ค๋ฅธ ์ฌ๋์ ์๋ด์ ์ก์๋์๋ค.
๊ฐ๊ฐ์ ์๋ด์ ์๋ด์ ์๋ฃํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ๊ธฐ๊ฐ Ti์ ์๋ด์ ํ์ ๋ ๋ฐ์ ์ ์๋ ๊ธ์ก Pi๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
์๋ด์ ์ ์ ํ ํ์ ๋, ๋ฐฑ์ค์ด๊ฐ ์ป์ ์ ์๋ ์ต๋ ์์ต์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
11055: ๊ฐ์ฅ ํฐ ์ฆ๊ฐํ๋ ๋ถ๋ถ์์ด ๋ฌธ์ ์ ๋น์ทํ๊ฒ ํ๋ฉด ๋๋ค.
๋จ, ์ด์ ์๋ด์ด ๋๋์ผ๋ง ๋ค์ ์๋ด์ ์งํํ ์ ์๊ณ ์๋ด๊ธฐ๊ฐ์ด N(๋ง์ง๋ง ๊ทผ๋ฌด์ผ)์ ๋์ด๊ฐ๋ฉด ์๋๋ค.
๋จผ์ N๋งํผ์ dp๋ฅผ ์์ฑํ ํ ์ฒซ์งธ๋ ์ ์๋ด ์ผ์ ์ ํ์ธํ๋ค.
์ฒซ์งธ๋ ์๋ด์ ์์๊ธฐ๊ฐ์ด N ์ดํ๋ผ๋ฉด dp[0] = ์ฒซ์งธ๋ ์๋ด ๋ณด์
๋ก ํ ๋นํ๊ณ , ๋์ด๊ฐ๋ค๋ฉด ํจ์คํ๋ค.
๊ทธ ํ 1์ผ๋ถํฐ N-1์ผ๊น์ง ์ํ๋ฅผ ์งํํ๋ฉฐ dp๋ฅผ ์
๋ฐ์ดํธํ๋ค.
ํ์ฌ ๋ ์ง์ ์๋ด i๋ฅผ ๊ธฐ์ค์ผ๋ก 0 ~ i-1 ์ผ๊น์ง์ ์๋ด j๋ฅผ ๋น๊ตํ๋ฉฐ ๋ ์ง๊ฐ ๊ฒน์น์ง ์๋ ๊ฒฝ์ฐ์๋ง ์
๋ฐ์ดํธํ๋ค.
์ฆ ์๋ด์ ์์ฝํ ์ ์๋ ์กฐ๊ฑด์ ๋ ๊ฐ์ง๋ค. 1) ํ์ฌ ๋ ์ง i + ์๋ด๊ธฐ๊ฐ Ti ๊ฐ N ์ดํ์ผ๊ฒ, 2) (ํ์ฌ ๋ ์ง i - ์ด์ ์๋ด ๋ ์ง j) < Tj ๋ฅผ ๋ง์กฑํ ๊ฒ.
์์ ์์ ๋ฐ์ดํฐ๋ก ์ดํด๋ณด์.
6์ผ(์ธ๋ฑ์ค์ 5)์ ์๋ด์ ๊ธฐ์ค์ผ๋ก 2์ผ์ ์๋ด์ ๋น๊ตํ์๋, (i - j) = (5 - 1) = 4
, Tj = 5
์ด๋ฏ๋ก 2์ผ๋ ์ ์๋ด์ ์์ฝํด๋์ ์ํ์์ 6์ผ๋ ์ ์๋ด์ ์งํํ ์ ์๋ค.
์ด๋ฐ์์ผ๋ก ๋ ์กฐ๊ฑด์ ๋น๊ตํด๊ฐ๋ฉฐ ๋ง์กฑํ๋๊ฒฝ์ฐ์ (ํ์ฌ ์๋ด์ ์ ํํ ๊ฒฝ์ฐ์ ์ต๋๊ฐ dp[i], j์ผ๊น์ง์ ์ต๋๊ฐ dp[j] + ํ์ฌ ์๋ด์ ๋ณด์ Pi) ์ค ๋ ํฐ ๊ฐ์ผ๋ก ์
๋ฐ์ดํธํ๋ค.
๋ง์ฝ 2๋ฒ ์กฐ๊ฑด์ ๋ง์กฑํ์ง ๋ชปํ๋ค๋ฉด (ํ์ฌ ์๋ด์ ์ ํํ ๊ฒฝ์ฐ์ ์ต๋๊ฐ dp[i], ํ์ฌ ์๋ด์ ๋ณด์ Pi) ์ค ํฐ ๊ฐ์ ์ ํํ๋ค.
์ ์ฒด ์ฝ๋
# ๋ฉ๋ชจ๋ฆฌ: 31120KB / ์๊ฐ: 40ms
from sys import stdin
input = stdin.readline
N = int(input())
lst = [list(map(int, input().split())) for _ in range(N)]
# dp[i] = i๋ฒ์งธ ์์๋ฅผ ํฌํจํ๋ ๊ฐ ์ค ์ต๋๊ฐ
dp = [0] * N
# ์ฒซ์งธ๋ ์๋ด์ ์์๊ธฐ๊ฐ์ด N์ผ ์ดํ์ผ๋๋ง ์์ฝ ๊ฐ๋ฅ.
if lst[0][0] <= N:
dp[0] = lst[0][1]
for i in range(1, N):
# (ํ์ฌ ๋ ์ง i + i์ผ ์๋ด์ ์์๊ธฐ๊ฐ > ๋ง์ง๋ง ๊ทผ๋ฌด๋ N) ์ด๋ฉด ์ฐ๋ฃจ.
if i + lst[i][0] > N:
continue
for j in range(i):
# (ํ์ฌ ๋ ์ง - j์ผ < j์ผ ์๋ด์ ์์๊ธฐ๊ฐ)์ด๋ผ๋ฉด dp[i]์ ํ์ฌ ๋ ์ง์ ์๋ด ๋ณด์ ์ค ๋ ํฐ๊ฒ์ ํํจ.
if (i - j) < lst[j][0]:
dp[i] = max(dp[i], lst[i][1])
else:
dp[i] = max(dp[i], dp[j] + lst[i][1])
print(max(dp))