๋ฌธ์
https://www.acmicpc.net/problem/12865
12865๋ฒ: ํ๋ฒํ ๋ฐฐ๋ญ
์ฒซ ์ค์ ๋ฌผํ์ ์ N(1 ≤ N ≤ 100)๊ณผ ์ค์๊ฐ ๋ฒํธ ์ ์๋ ๋ฌด๊ฒ K(1 ≤ K ≤ 100,000)๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฒ์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฑฐ์ณ ๊ฐ ๋ฌผ๊ฑด์ ๋ฌด๊ฒ W(1 ≤ W ≤ 100,000)์ ํด๋น ๋ฌผ๊ฑด์ ๊ฐ์น V(0 ≤ V ≤ 1,000)
www.acmicpc.net
๋ด ๋ฌธ์ ํ์ด
n, k = map(int, input().split())
memory = [[0]*(k+1) for _ in range(n+1)] # [n+1][k+1] ํฌ๊ธฐ์ 0์ผ๋ก ์ฑ์์ง ๋ฐฐ์ด
for i in range(1, n+1):
w, v = map(int, input().split()) # ํ์ฌ ์
๋ ฅ๋ ๋ฌผ๊ฑด์ ๋ฌด๊ฒ, ๊ฐ์น
for j in range(1, k+1):
if w <= j: memory[i][j] = max(memory[i-1][j], memory[i-1][j-w]+v)
else: memory[i][j] = memory[i-1][j]
print(memory[n][k])
๐ dp - ๋ ์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ก, ๋ฌด๊ฒ๋ณ, ๋ฌผ๊ฑด๋ณ ๋ฐฐ๋ญ์ด ๋ด์ ์ ์๋ ์ต๋ ๊ฐ์น๋ฅผ ๋์ ํ๋๊ฒ ํฌ์ธํธ!
- 1. 0์ผ๋ก ์ฑ์์ง nํ k์ด์ memory ๋ฆฌ์คํธ๋ฅผ ์์ฑํด์ฃผ์๋ค.
1-1) ๋ฌธ์ ์์ ์ฃผ์ด์ง ์ ๋ ฅ๊ณผ ๊ฐ์ด n์ ๋ฌผ๊ฑด์ ๊ฐ์, k๋ ์ต๋ ๋ฌด๊ฒ๋ฅผ ์๋ฏธํ๋ ๋งํผ
memory์ ํ์ ์์๋๋ก ์ ๋ ฅ๋๋ ๋ฌผ๊ฑด๋ค์ ๋ปํ๊ณ , ์ด์ 1~k ๋ฌด๊ฒ๋ฅผ ๋ปํจ!
1-2) ๋ฌด๊ฒ๋ฅผ 1๋ถํฐ k๊น์ง ๋ชจ๋ ์์ฑํด์ ๋ณด๋ ์ด์ ๋, ๋ด์ ์ ์๋ ์ต๋ ๋ฌด๊ฒ์ ๋ฐ๋ฅธ ์ต๋ ๊ฐ์น๋ฅผ
์์๋๋ก ์ฐ์ฐํ๋ฉฐ ๊ฒฐ๊ตญ ๋ง์ง๋ง์๋ [n][k]์ ๋์ ๋ ๊ฐ์ผ๋ก ์ต๋ ๊ฐ์น๋ฅผ ๊ตฌํ๊ธฐ ์ํจ์ด๋ค.
1-3) ๋ฐ๋ผ์, ์๋์ ๊ฐ์ด ์๊ฐํ๋ฉด ๋๋ค.
ํ == ํ์ฌ ๋ฌผ๊ฑด
์ด == ๋ฐฐ๋ญ์ ๋ด์ ์ ์๋ ์ต๋ ๋ฌด๊ฒ
[ํ][์ด] == ํ์ฌ ํ๊น์ง์ ๋ฌผ๊ฑด๋ค ์ค, ํ์ฌ ์ด์ ๋ฌด๊ฒ๊ฐ ์ต๋์ผ ๊ฒฝ์ฐ ๊ฐ๋ฅํ ์ต๋ ๊ฐ์น
๋ฐ๋ผ์, [n][k] = n๊ฐ์ ๋ฌผ๊ฑด์ด ์๊ณ , ๋ฐฐ๋ญ์ ์ต๋ ๋ฌด๊ฒ๊ฐ k์ผ ๊ฒฝ์ฐ, ๊ฐ๋ฅํ ์ต๋ ๊ฐ์น! - 2. memory ๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ์ฐจ๋ก๋๋ก ๋๋ 2์ค for๋ฌธ์ ์์ฑํ๋ค.
2-1) j๊ฐ ํ์ฌ w๋ณด๋ค ์์ ๊ฒฝ์ฐ, ํ์ฌ ๋ฌผ๊ฑด์ ๋ฐฐ๋ญ์ ๋ฃ์ ์ ์์ผ๋ฏ๋ก
์ด์ ๋ฌผ๊ฑด์ j์ด์ ํด๋นํ๋ [i-1][j]์ ๊ฐ์ ๊ทธ๋๋ก [i][j]์ ์ ์ฅํ๋ค.
2-2) j๊ฐ ํ์ฌ w๋ณด๋ค ๊ฐ๊ฑฐ๋ ํด ๊ฒฝ์ฐ, ํ์ฌ ๋ฌผ๊ฑด์ ๋ฐฐ๋ญ์ ๋ฃ์ ์ ์์ผ๋ฏ๋ก
ํ์ฌ ๋ฌผ๊ฑด์ ๋ฐฐ๋ญ์ ๋ฃ๋๊ฒ ์ด๋์ธ์ง, ๋ฃ์ง ์๋๊ฒ ์ด๋์ธ์ง ๋ฐ์ ธ๋ด์ผ ํ๋ค.
2-3) [i-1][j]์ [i-1][j-w]+v ์ค์์ ๋ ํฐ ์๊ฐ ์ด๋ค๊ฑด์ง ๋ณด๋ฉด ๋๋ค.
์ฌ๊ธฐ์ ์ ๊น,,! [i-1][j-w]+v ๋ผ๋ ์์ด ์ด๋ป๊ฒ ๋์๋๋ฉด,,
ํ์ฌ ๋ฌผ๊ฑด์ ๋ฐฐ๋ญ์ ๋ฃ๋๋ค๋ฉด, ๋ฐฐ๋ญ์ ๋จ๋ ๋ฌด๊ฒ๋ j-w๋งํผ!!
๋ฐ๋ผ์ ์ด์ ํ์ j-w์ ํด๋นํ๋ ์ต๋ ๊ฐ์น์, ํ์ฌ ๋ฌผ๊ฑด์ ๊ฐ์น๋ฅผ ๋ํด์ค ๊ฐ์ด
๋ฐ๋ก ํ์ฌ ๋ฌผ๊ฑด์ ๋ฐฐ๋ญ์ ๋ฃ์์ ๋์ ๊ฐ์น๊ฐ ๋๋ค.!
๋ฐ๋ผ์ ์์ ๋ ๊ฐ์ ๋น๊ตํ์ฌ ๋ ํฐ ๊ฐ์ [i][j]์ ์ ์ฅํด์ฃผ๋ฉด ๋๋ค. - ์์ 1, 2๋ฒ ๊ณผ์ ์ ์ํํ๋ฉด memory[n][k]์ ๋์ ๋ ์ต๋ ๊ฐ์น๊ฐ ์ ์ฅ๋๋ฏ๋ก,
ํด๋น ๊ฐ์ ์ถ๋ ฅํด์ฃผ๋ฉด ๋!
=> ์์ ํ์ด ๊ณผ์ ์ ๊ทธ๋ฆผ์ผ๋ก ๋ํ๋ด๋ดค๋ค.
memory ๋ฆฌ์คํธ์ ๋ชจ๋ ๊ฐ์ด ์ ์ฅ๋ ๋ชจ์ต์ ๊ทธ๋ ธ๊ณ ,
๋ํ๋ก ๋ณผ ๋งํ [4][7] ์๋ฆฌ์ ์์๊ฐ์ด ๋ค์ด๊ฐ ๊ณผ์ ์ ์์ธํ ์์ฑํ๋ค.
๐ก ํผ๋๋ฐฑ
- ๋ฐฐ๋ญ ๋ฌธ์ ๋ฅผ ์ฒ์ ํ์ด๋ด์ ํ์ด๋ฅผ ์ดํดํ๋๋ฐ์ ๊ต์ฅํ ์ค๋๊ฑธ๋ ธ๋๋ฐ,,! ์ดํดํ๋ ๊ต์ฅํ ์ฝ๋๋ ์งง๊ณ ,, ๋จ์ํ? ์๊ณ ๋ฆฌ์ฆ์ด์๋ค.
- ์ด๋ฐ ์ ํ์ ๋ฌธ์ ๋ฅผ ๋ง์ด ํ์ด๋ด์ผํ ๊ฒ ๊ฐ๋ค.
'4๏ธโฃ Python > Problem Solving' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python Algorithm] ์ ์ ์ผ๊ฐํ BOJ #1932 (0) | 2021.12.17 |
---|---|
[Python Algorithm] RGB๊ฑฐ๋ฆฌ BOJ #1149 (0) | 2021.12.16 |
[Python Algorithm] ์ซ์์ ํํ Programmers(Lv.2) (0) | 2021.11.22 |
[Python Algorithm] ํ๋๋ฐ ์์ด BOJ #9461 (0) | 2021.11.16 |
[Python Algorithm] 01ํ์ผ BOJ #1904 (0) | 2021.11.16 |
๋๊ธ