์ผ์ฑ SW ์ญ๋ ํ ์คํธ ๊ธฐ์ถ ๋ฌธ์ - 14501๋ฒ ํด์ฌ
๋ฌธ์
์๋ด์์ผ๋ก ์ผํ๊ณ ์๋ ๋ฐฑ์ค์ด๋ ํด์ฌ๋ฅผ ํ๋ ค๊ณ ํ๋ค.
์ค๋๋ถํฐ N+1์ผ์งธ ๋๋ ๋ ํด์ฌ๋ฅผ ํ๊ธฐ ์ํด์, ๋จ์ N์ผ ๋์ ์ต๋ํ ๋ง์ ์๋ด์ ํ๋ ค๊ณ ํ๋ค.
๋ฐฑ์ค์ด๋ ๋น์์๊ฒ ์ต๋ํ ๋ง์ ์๋ด์ ์ก์ผ๋ผ๊ณ ๋ถํ์ ํ๊ณ , ๋น์๋ ํ๋ฃจ์ ํ๋์ฉ ์๋ก ๋ค๋ฅธ ์ฌ๋์ ์๋ด์ ์ก์๋์๋ค.
๊ฐ๊ฐ์ ์๋ด์ ์๋ด์ ์๋ฃํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ๊ธฐ๊ฐ Ti์ ์๋ด์ ํ์ ๋ ๋ฐ์ ์ ์๋ ๊ธ์ก Pi๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
N = 7์ธ ๊ฒฝ์ฐ์ ๋ค์๊ณผ ๊ฐ์ ์๋ด ์ผ์ ํ๋ฅผ ๋ณด์.
1์ผ | 2์ผ | 3์ผ | 4์ผ | 5์ผ | 6์ผ | 7์ผ | |
Ti | 3 | 5 | 1 | 1 | 2 | 4 | 2 |
Pi | 10 | 20 | 10 | 20 | 15 | 40 | 200 |
1์ผ์ ์กํ์๋ ์๋ด์ ์ด 3์ผ์ด ๊ฑธ๋ฆฌ๋ฉฐ, ์๋ดํ์ ๋ ๋ฐ์ ์ ์๋ ๊ธ์ก์ 10์ด๋ค. 5์ผ์ ์กํ์๋ ์๋ด์ ์ด 2์ผ์ด ๊ฑธ๋ฆฌ๋ฉฐ, ๋ฐ์ ์ ์๋ ๊ธ์ก์ 15์ด๋ค.
์๋ด์ ํ๋๋ฐ ํ์ํ ๊ธฐ๊ฐ์ 1์ผ๋ณด๋ค ํด ์ ์๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ์๋ด์ ํ ์๋ ์๋ค. ์๋ฅผ ๋ค์ด์ 1์ผ์ ์๋ด์ ํ๊ฒ ๋๋ฉด, 2์ผ, 3์ผ์ ์๋ ์๋ด์ ํ ์ ์๊ฒ ๋๋ค. 2์ผ์ ์๋ ์๋ด์ ํ๊ฒ ๋๋ฉด, 3, 4, 5, 6์ผ์ ์กํ์๋ ์๋ด์ ํ ์ ์๋ค.
๋ํ, N+1์ผ์งธ์๋ ํ์ฌ์ ์๊ธฐ ๋๋ฌธ์, 6, 7์ผ์ ์๋ ์๋ด์ ํ ์ ์๋ค.
ํด์ฌ ์ ์ ํ ์ ์๋ ์๋ด์ ์ต๋ ์ด์ต์ 1์ผ, 4์ผ, 5์ผ์ ์๋ ์๋ด์ ํ๋ ๊ฒ์ด๋ฉฐ, ์ด๋์ ์ด์ต์ 10+20+15=45์ด๋ค.
์๋ด์ ์ ์ ํ ํ์ ๋, ๋ฐฑ์ค์ด๊ฐ ์ป์ ์ ์๋ ์ต๋ ์์ต์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N (1 ≤ N ≤ 15)์ด ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ Ti์ Pi๊ฐ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด์ ์ฃผ์ด์ง๋ฉฐ, 1์ผ๋ถํฐ N์ผ๊น์ง ์์๋๋ก ์ฃผ์ด์ง๋ค. (1 ≤ Ti ≤ 5, 1 ≤ Pi ≤ 1,000)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฐฑ์ค์ด๊ฐ ์ป์ ์ ์๋ ์ต๋ ์ด์ต์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
7
3 10
5 20
1 10
1 20
2 15
4 40
2 200
์์ ์ถ๋ ฅ 1
45
ํ์ด
- ๋ ์ง์ ์ด์ต ์ ๋ ฅ ๋ฐ์ ๋ ๊ฐ๊ฐ t, p ๋ฐฐ์ด์ ์ฝ์ ํด์ค๋ค
- dp ๋ฐฐ์ด์ n+1ํฌ๊ธฐ๋งํผ 0์ผ๋ก ์ด๊ธฐํ
- ๋ค์์ ๋ถํฐ for๋ฌธ ์คํ
- time์ด n๋ณด๋ค ํฌ๋ฉด dp[i] = money ํด์ฃผ๊ณ , n๋ณด๋ค ์์ผ๋ฉด dp[i] ์ max๊ฐ ๊ตฌํ์ฌ ๋ฃ์ด์ค๋ค. ๊ทธ dp[i] ๊ฐ์ money์ ๋ฃ์ด์ค
# ์ผ์ฑ SW ์ญ๋ ํ
์คํธ ๊ธฐ์ถ ๋ฌธ์
# ๋ฐฑ์ค 14501๋ฒ. ํด์ฌ
n = int(input())
t = []
p = []
for i in range(n):
a, b = map(int, input().split())
t.append(a)
p.append(b)
dp = [0] * (n + 1)
money = 0
# ๋ค์์ ๋ถํฐ ์์
for i in range(n - 1, -1, -1):
time = i + t[i]
# time์ n๋ณด๋ค ์์์ผํจ
if time <= n:
dp[i] = max(p[i] + dp[time], money)
money = dp[i]
else:
dp[i] = money
print(money)
๋ค๋ฅธ ์ฌ๋์ ํ์ด
๋์ ํ์ด์ ๋น๊ตํ์ ๋
1) t ์ p๋ฐฐ์ด์ L์ด๋ผ๋ 2์ฐจ์ ๋ฐฐ์ด๋ก ํ๋ฒ์ ์ ๋ ฅ ๋ฐ์๋ค
2) ๋ด๊ฐ ์ฒ์ ๋ฌธ์ ๋ฅผ ์ฝ๊ณ ๊ตฌ์ํ๋ ๋ฐฉ๋ฒ์ ๊ตฌํํ์๋ค. ๋๋ ํ๋ค๊ฐ ์๋์ ๋ค๋ถํฐ ์์ํ๋ ๋ฐฉ๋ฒ์ผ๋ก ํ์๋ค. ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ์ฌ dp๋ฐฐ์ด์ ์ฝ์ ํ ํ ๋ง์ง๋ง์ max(dp) ๊ฐ์ ์ถ๋ ฅ
# ๋ค๋ฅธ ์ฌ๋์ ํ์ด
N = int(input())
L = [list(map(int, input().split())) for _ in range(N)] # 2์ฐจ์ ๋ฐฐ์ด ์ฌ์ฉ
dp = [0] * (N + 1)
for i in range(N):
for j in range(i + L[i][0], N + 1): # time์ด n๋ณด๋ค ์์ ๋๊น์ง๋ง for๋ฌธ ์คํ
if dp[j] < L[i][1] + dp[i]:
dp[j] = L[i][1] + dp[i]
print(max(dp))
์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ
- ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
- ๋ธ๋ฃจํธํฌ์ค ์๊ณ ๋ฆฌ์ฆ