๋ฐฐ๋ญ๋ฌธ์ ๋?
๋ฐฐ๋ญ ๋ฌธ์ ๋ ์ฃผ์ด์ง ์ ํ๋ ์ฉ๋์ ๋ฐฐ๋ญ์ ์ต๋ํ์ ๊ฐ์น๋ฅผ ๊ฐ์ง ์์ดํ ์ ๋ฃ๋ ๋ฐฉ๋ฒ์ ์ฐพ๋ ๋ฌธ์ ๋ฅผ ์๋ฏธํ๋ค.
n๊ฐ์ ๋ฌผ๊ฑด์ ๋ฌด๊ฒw์ ๊ฐ์น v์ ์ฃผ์ด์ง ๋, ์ฉ๋์ด k์ธ ๋ฐฐ๋ญ์ ์ฉ๋์ ์ด๊ณผํ์ง ์๊ณ ๋ด์ ์ ์๋ ์ต๋์ ๊ฐ์น๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด๋ค.
๋ฐฐ๋ญ๋ฌธ์ ์ ํด๊ฒฐ ๋ฐฉ๋ฒ
- ๋ชจ๋ ๊ฒฝ์ฐ ํ์ (brute-force)
- ๋ฌผ๊ฑด์ ๋ด๋๋ค/๋ด์ง ์๋๋ค์ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํ์ฌ 2^n์ ๋ชจ๋ ์กฐํฉ์ ํ์ํ๋ ๋ฐฉ๋ฒ์ ์๊ฐ ๋ณต์ก๋๊ฐ ๋๋ฌด ์ปค์ n๊ฐ์ด ํฐ ๊ฒฝ์ฐ์๋ ํด๊ฒฐํ ์ ์๋ค.
- ํ์์ ์๊ณ ๋ฆฌ์ฆ (Greedy)
- ๋จ์ ๋ฌด๊ฒ๋น ๋์ ๊ฐ์น๋ถํฐ ๋ด๋ ๋ฐฉ๋ฒ.
- ๋ถํ ๋ฐฐ๋ญ ๋ฌธ์ ์์๋ ํจ์จ์ ์ผ๋ก ๋์ํ๋ค.
- ๋์ ํ๋ก๊ทธ๋๋ฐ (Dynamic Programming)
- ์ฃผ์ด์ง ์์ดํ ๊ณผ ๋ฐฐ๋ฅ์ ์ฉ๋์ ์ด์ฉํด ๊ฐ๋ฅํ ๊ฐ์น์ ์กฐํฉ์ ๊ณ์ฐ
- ๋ธ๋์น ์ค ๋ฐ์ด๋ (Branch and Bound)
- ๋ฌธ์ ์ ํ์๊ณต๊ฐ์ ํจ์จ์ ์ผ๋ก ์ค์ฌ๊ฐ๋ฉฐ(๊ฐ์ง ์น๊ธฐ) ์ต์ ํด๋ฅผ ํ์
๋ฐฐ๋ญ๋ฌธ์ with Dynamic Programming
๋ฌผ๊ฑด๊ณผ ๋ฐฐ๋ญ์ ์ฉ๋์ ๋ํ๋ด๋ DP 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธํ๋ค.
dp[i][w] : ์ฒซ i๊ฐ์ ์์ดํ ์ค์์ ์ต๋ w๊น์ง์ ๋ฌด๊ฒ๋ฅผ ๊ณ ๋ คํ์ ๋ ์ป์ ์ ์๋ ์ต๋์ ๊ฐ์น
- dp[i][w] = dp[i-1][w]
- ์์ดํ i๋ฅผ ์ ํํ์ง ์์ ๊ฒฝ์ฐ, ์ด์ i-1๊ฐ์ ์์ดํ ์ผ๋ก ๊ตฌ์ฑ๋ ์ต๋ ๊ฐ์น์ ๋์ผํจ.
- dp[i][w] = max(dp[i-1][w], dp[i-1][w-weight[i]] + values[i] )
- ์์ดํ i๋ฅผ ์ ํํ๋ ๊ฒฝ์ฐ์ ์ ํํ์ง ์๋ ๊ฒฝ์ฐ์ค ๊ฐ์น๊ฐ ๋ ๋์ ๊ฒ์ ์ ํ
๋ฐฐ๋ญ๋ฌธ์ with Dynamic Programming ์ฝ๋
def knapsack_dp(values, weights, W):
n = len(values)
dp = [[0 for _ in range(W+1)] for _ in range(n+1)]
for i in range(1, n+1):
for w in range(1, W+1):
# ๋ฐฐ๋ญ์ ํด๋น ์์ดํ
์ ๋ฃ์ ์ ์๋ ๊ฒฝ์ฐ
if weights[i-1] <= w:
# ์์ดํ
์ ๋ฃ์ง ์์์ ๊ฒฝ์ฐ์, ์์ดํ
์ ๋ฃ์ด์ ๋ฐฐ๋ญ์ ์ฉ๋์ด ์ค๊ณ ๊ฐ์น๊ฐ ๋์ด๋๋ ๊ฒ ์ค ์ต๋๊ฐ ์ ํ
dp[i][w] = max(dp[i-1][w], dp[i-1][w-weight[i-1]] + values[i-1])
# ๋ฐฐ๋ญ์ ํด๋น ์์ดํ
์ ๋ฃ์ ์ ์๋ ๊ฒฝ์ฐ
else:
dp[i][w] = dp[i-1][w]
return dp[n][w]
'๐ค์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ด๋ชจ์ค๋ฒ (Imos Method) (0) | 2024.11.01 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์ (0) | 2024.10.13 |
[์๊ณ ๋ฆฌ์ฆ] ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ (Prim's Algorithm) (0) | 2024.08.30 |
[์๊ณ ๋ฆฌ์ฆ] ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ (Kruskal Algorithm) (0) | 2024.08.29 |
[์๊ณ ๋ฆฌ์ฆ] BFS (๋๋น ์ฐ์ ํ์) (0) | 2024.08.20 |