์ฝํ ๋ฌธ์ ๋ฅผ ํ๋ค ๋ณด๋ฉด, ์์ฃผ ๋์ค๋ ๊ฐ๋ ์ธ Dynamic Programming์ ๋ํด ์ ๋ฆฌํ๊ณ ์ ํ๋ค.
DP๋ ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ํธ๋ ๋ฐฉ์์ผ๋ก, ๋จ์ํ ์ชผ๊ฐ๋ ๊ฒ ๋ฟ ์๋๋ผ ์ด๋ฏธ ๊ณ์ฐํ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํด์ ๋ค์ ๊ณ์ฐํ๋ ์๊ณ ๋ฅผ ๋์ด์ฃผ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ฆ, ๋ฐ๋ณต๋๋ ๊ณ์ฐ์ ์ค์ด๊ธฐ ์ํด, ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅ(memoization ๋๋ tabulation) ํด๋๊ณ ์ฌํ์ฉํ๋ ๋ฐฉ์์ด๋ค.
๐ฑ DP๋ ์ธ์ ์ฌ์ฉํ ๊น?
์๋ ๋ ์กฐ๊ฑด์ ๋ง์กฑํ ๋ ์ธ ์ ์๋ค.
1. ๊ฒน์น๋ ๋ถ๋ถ ๋ฌธ์ : ๊ฐ์ ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๋ฒ ๋ค์ ๊ณ์ฐํด์ผ ํ๋ ์ํฉ
2. ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ : ํฐ ๋ฌธ์ ์ ์ต์ ํด๊ฐ ์์ ๋ฌธ์ ๋ค์ ์ต์ ํด๋ก ์ด๋ฃจ์ด์ ธ ์๋ ๊ตฌ์กฐ
๊ฐ์ฅ ๋ํ์ ์ธ ์๋ ํผ๋ณด๋์น ์์ด์ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
๐ฑ DP ์ฌ์ฉ ๋ฐฉ์์?
DP๋ ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์ฌ์ฉ๋ฒ์ ๋๋ ์ ์๋ค.
1. Top-down ๋ฐฉ์ (์ฌ๊ท + Memoization)
- ์ด๋ฆ ๊ทธ๋๋ก ์์์๋ถํฐ ๋ด๋ ค์ค๋ฉด์ ๊ณ์ฐํ๊ณ , ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ค.
- ์ฃผ๋ก ์ฌ๊ทํจ์๋ฅผ ์ฌ์ฉํด์ ๊ตฌํํ ์ ์๋ค.
- ๋ํ์ ์ธ ์๊ฐ ํผ๋ณด๋์น ์์ด!
2. Bottom-up ๋ฐฉ์ (๋ฐ๋ณต๋ฌธ + Tabulation)
- ์ด๋ฆ๋๋ก ์๋์์๋ถํฐ ์ฐจ๊ณก์ฐจ๊ณก ๊ณ์ฐํด์ ์ต์ข ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ ๋ฐฉ์์ด๋ค.
- ์ฃผ๋ก ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ตฌํํ๋ค.
๐ฑ DP๊ฐ ์ฌ์ฉ๋๋ ๋ฌธ์ ์์๋ค
- ์ต๋/์ต์๊ฐ์ ๊ตฌํ๋ ๋ฌธ์
- ํน์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์
- ๊ฒฝ๋ก์ ์, ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์
- ๋ฐฐ๋ญ ๋ฌธ์ (0/1 Knapsack), ๋์ ๊ตํ ๋ฌธ์ ๋ฑ
- ์ ์ ๋ถํ ๋ฌธ์
๐ฑ ์ ์ ๋ถํ (Partition Problem) ๋ฌธ์ ํ์ด - ์์๊ณ ๋ คX
๊ทธ ์ค, ๋ฌธ์ ๋ฅผ ํ๋ฉฐ ๊ฐ์ฅ ๋ง์ด ์ฃผ์ ํ๋ ์ ํ์ ์ ๋ฆฌํ๊ณ ์ ํ๋ค. ์ ์ ๋ถํ ๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์ด๋ค.
์์ ์ ์๋ค์ ์กฐํฉ ์ค์์, ๊ทธ ํฉ์ด ์ ์ n์ด ๋๋ ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ
์๋ฅผ ๋ค์ด, n = 4์ผ ๋, ๊ฐ๋ฅํ ์กฐํฉ(์์๋ฅผ ๋ฌด์)์:
- 1 + 1 + 1 + 1
- 1 + 1 + 2
- 2 + 2
- 1 + 3
- 4
→ ์ด 5๊ฐ์ง
์ด๋ฌํ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ DP๋ฅผ ๊ตฌํํด๋ณด์.
def count_combinations(n):
dp = [0] * (n + 1)
dp[0] = 1 # ํฉ์ด 0์ด ๋๋ ๋ฐฉ๋ฒ์ '์๋ฌด๊ฒ๋ ์ ํํ์ง ์๋ 1๊ฐ์ง'๋ฟ
# 1๋ถํฐ n๊น์ง์ ์ซ์๋ฅผ ์ฌ์ฉํด์ ์กฐํฉ์ ๋ง๋ฆ
for num in range(1, n + 1):
for i in range(num, n + 1):
dp[i] += dp[i - num]
return dp[n]
- dp[i]๋ "ํฉ์ด i๊ฐ ๋๋ ์กฐํฉ์ ์"๋ฅผ ์ ์ฅํ๋ค.
- ์ฒ์์ dp[0] = 1 → ์๋ฌด๊ฒ๋ ์ ์จ์ 0์ ๋ง๋๋ ๊ฒฝ์ฐ ํ ๊ฐ์ง.
- ๊ทธ ๋ค์, ์ซ์ 1๋ถํฐ n๊น์ง ์ฐจ๋ก๋๋ก ์ฌ์ฉํ๋ฉด์, ๊ฐ ์ซ์๋ฅผ ์ฌ์ฉํด์ ๋ง๋ค ์ ์๋ ํฉ๋ค์ ์ ๋ฐ์ดํธ ํ๋ค.
- ์ด๋๋ ์ค๋ณต ์กฐํฉ์ ํ์ฉํ์ง๋ง ์์๋ ๋ฌด์.
๐ฑ ์ ์ ๋ถํ (Partition Problem) ๋ฌธ์ ํ์ด - ์์๊ณ ๋ คO
์์๋ฅผ ๊ณ ๋ คํ๋ ๋ฐฉ๋ฒ์ Permutation(์์ด) ๋ฌธ์ ์ด๋ค.
def count_permutations(n):
dp = [0] * (n + 1)
dp[0] = 1 # base case
for i in range(1, n + 1):
for num in range(1, n + 1):
if i - num >= 0:
dp[i] += dp[i - num]
return dp[n]
'๐ ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [ํ๋ก๊ทธ๋๋จธ์ค] : ์ฐ์ ๋ถ๋ถ ์์ด ํฉ์ ๊ฐ์ (3) | 2025.07.14 |
|---|---|
| [ํ๋ก๊ทธ๋๋จธ์ค] : ๋ฉ๋ฆฌ๋ฐ๊ธฐ (0) | 2025.07.13 |
| ํ๋ก๊ทธ๋๋จธ์ค : ๊ทค ๊ณ ๋ฅด๊ธฐ (0) | 2025.06.28 |
| ๋ฐฑ์ค 17219: ๋น๋ฐ๋ฒํธ ์ฐพ๊ธฐ (0) | 2025.05.13 |
| ๋ฐฑ์ค 10989: ์ ์ ๋ ฌํ๊ธฐ 3 (0) | 2025.05.13 |