๐ Dynamic Programming
๐ซ Dynamic Programming (๋์ ํ๋ก๊ทธ๋๋ฐ, ๋์ ๊ณํ๋ฒ)
์ฌ๋ฌ ๊ฐ์ ํ์ ๋ฌธ์ ๋ฅผ ๋จผ์ ํผ ํ์ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์์์ฌ๋ ค์ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ
์ฝ๊ฒ ์ค๋ช
ํ๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ์ ํ์์ ์ฐพ์๋ธ ํ ์ ํ์์ ํญ์ ๋ฐ์์๋ถํฐ ์ฐจ๋ก๋ก ๊ตฌํด๋๊ฐ์ ๋ต์ ์์๋ด๋ ํํ์ ์๊ณ ๋ฆฌ์ฆ.
ํผ๋ณด๋์น ๋ฌธ์
ํผ๋ณด๋์น ์์ด์ N๋ฒ์งธ ํญ์ ์ง๊ธ์ฒ๋ผ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํ๋ฉด ์ค๋ณต๋ ์ฐ์ฐ์ด ๊ณ์ ๋ฐ์ํด์ O(1.618N)์ ์๊ฐ์ด ๊ฑธ๋ฆฝ๋๋ค.
๊ทธ๋ฐ๋ฐ ํผ๋ณด๋์น ๋ฌธ์ ๋ฅผ DP๋ก ํด๊ฒฐํ๋ฉด ์ด๋ ๊ฒ ๋ฏธ๋ฆฌ ๋ฐฐ์ด์ ๋ง๋ค์ด๋๊ณ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ํ๋์ฉ ์ฑ์๊ฐ๋ ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ ์ ์๊ณ N+1์นธ์ ์ฑ์ฐ๊ณ ๋๋ฉด ๋ต์ ์ ์ ์์ผ๋ O(N)์ ๋ต์ ์์๋ผ ์ ์์ต๋๋ค.
์ด๋ ๊ฒ ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํด์ ์ด์ฉํ๋์ง ๊ทธ๋ ์ง ์์์ง์ ๋ฐ๋ผ ๊ทน์ ์ธ ์๊ฐ๋ณต์ก๋์ ์ฐจ์ด๊ฐ ๋ฐ์ํฉ๋๋ค.
DP๋ฅผ ํ๊ธฐ ์ํด์๋ ๋จผ์ ํ
์ด๋ธ์ ์ ์ํด์ผ ํ๊ณ ์ ํ์์ ์ฐพ์ ํ์ ์ด๊ธฐ ๊ฐ์ ์ ํด์ผ ํฉ๋๋ค.
DP๋ ์์ ํ๊ณ ์ด๋ ต๊ฒ ํ๊ณ ์ ํ๋ค๋ฉด ํ๋ ๋๋ ์์ด ์ด๋ ค์์ง์ง๋ง, ์ฝํ
์ ๋์ฌ ์์ค์ DP ๋ฌธ์ ๋ ์ผ๋จ ์ ํ์๋ง ์ฐพ๊ณ ๋๋ฉด ๊ทธ ๋ค๋ ์ด๊ธฐ ๊ฐ์ ์ฑ์๋ฃ์ ํ์ ๋ฐ๋ณต๋ฌธ์ ๋๋ฉด์ ๋ฐฐ์ด์ ์ฑ์ฐ๋ฉด ๋์ด์ด์ ๊ตฌํ์ด ๊ต์ฅํ ์ฝ์ต๋๋ค.
ํ์ง๋ง ๋ค์ํ DP ๋ฌธ์ ๋ฅผ ํ์ด๋ดค๊ฑฐ๋ ๋ฐ์ด๋ ์ํ์ ์ง๊ด๋ ฅ์ ๊ฐ์ง๊ณ ์์ง ์์ ์ด์ ๋ฌธ์ ์์ ์ ํ์์ ์ด๋์ด๋ด๋ ๊ณผ์ ์ด ๊ทธ๋ ๊ฒ ์ฝ์ง ์๊ณ , ๋ฌด์๋ณด๋ค๋ ์ด๋ณด ๋จ๊ณ์์๋ ์ฃผ์ด์ง ๋ฌธ์ ๊ฐ DP๋ก ํธ๋ ๋ฌธ์ ๋ผ๋ ๊ฒ ์์ฒด๋ฅผ ์์์ฐจ๋ฆฌ์ง ๋ชปํ ์๋ ์์ต๋๋ค.
๋ฌธ์ ์ง ๋ฌธ์ ์กด๋ ํ์ด๋ณผ ๊ฒ
1๋ก ๋ง๋ค๊ธฐ
๋ถ๋ถ์ ๋ฅผ ๋ฏธ๋ฆฌ ํ๊ณ ์ ์ฅํด๋๊ธด ํ๋๋ฐ, ์ด๊ฒ ํด๋ต์ ๊ตฌํ ๋ ์ฐ์ผ์ง ์์ฐ์ผ์ง๋ ๋ชจ๋ฆ.
์๋ฌดํผ ์ผ๋จ ๋ฏธ๋ฆฌ ๊ตฌํด๋๊ณ ๋ณด๋๊ฒ์ด๋ค.
๊ฐ ๋ถ๋ฌธ์ ์ ํด๋ต์ ํ์ด์ ์ ์ฅํ๊ณ ๋์ค์ ๊ฐ์ ๋ถ๋ฌธ์ ์ ๋ต์ด ํ์ํ ๊ฒฝ์ฐ ์ ์ฅ๋ ํด๋ต์ ์ฐพ์์ ํด๊ฒฐ
- ๋ถ๋ฌธ์ ๋ฅผ ์ด์ฉํ ๋ค๋ฅธ ์๊ณ ๋ฆฌ๋ฌ
- ์์ฌ์์ด ๋ฐฉ๋ฒ: ๊ฐ ๋จ๊ณ์์ ํด๋ต์ ์ผ๋ถ๋ฅผ ์ ํํ ํ ๋จ์ ๋ถ๋ฌธ์ ๋ฅผ ํด๊ฒฐ
- ๋ถํ ์ ๋ณต: ๊ท๋ฉ์ ์ ์๋ฅผ ์ด์ฉํ์ฌ ๋ถ๋ฌธ์ ๋ก ๋ถํ , ์ ๋ณต, ๊ฒฐํฉ
๐ซง vs Divide-Conquer
๋ถํ ์ ๋ณต์ ๋ฌธ์ ์์ฒด๋ฅผ ๋๋๊ณ ํธ๋๊ฑฐ๋ผ, ํ์ด๋ ๊ฒ๋ค์ด ๋์ค์ ํด๋ต์ ๊ตฌํ ๋ ๋ค ์ฐ์ธ๋ค.
์ค์ฒฉ๋ ๋ถ๋ฌธ์ ์คํ์ด๋ฉด ๋์ ๊ณํ๋ฒ, ์๋๋ฉด ๋ถํ ์ ๋ณต
- ๊ณตํต์
- ์ํ์ ์ผ๋ก ์ ์๋ ๋ฌธ์ ๋ก๋ถํฐ ์ถ๋ฐ
@ 4_0000
- ์ค์ฒฉ๋ ๋ถ๋ฌธ์ (Overlapping Subproblems) ํน์ฑ
- ๋ถ๋ฌธ์ ๋ค์ด ์ฌํ๊ฒ ์ค๋ณต๋๋ ๋ฌธ์
- DC : ๊ฐ์ ํจ์๋ฅผ ๋ฐ๋ณตํด์ ์ํ ํธ์ถ (4_0000), ์ฆ ๋ถ๋ฌธ์ ๋ฅผ ๋ ๋ฆฝ์ ์ผ๋ก ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋์ผํ ๋ถ๋ฌธ์ ๋ ๋งค๋ฒ ์๋ก ํ์ด์ผ ํจ
- DP : ๋์ผํ ๋ถ๋ฌธ์ ๊ฐ ๋ช ๋ฒ ๋ฑ์ฅํ๊ฑด ๊ฐ์ ํ๋ฒ๋ง ํ๋ฉด ๋๊ธฐ ๋๋ฌธ์, ์ค๋ณต๋ ๋ถ๋ฌธ์ ์ ์๊ฐ ์ฆ๊ฐํ๋ฉด ํ ์๋ก ์ ๋ฆฌ
- ๋ถ๋ฌธ์ ๊ฐ ์ค๋ณต๋์ง ์๋ ๋ฌธ์ : DP์ ์ฅ์ ์ด ์๋ฏธ๊ฐ ์๊ณ , ์คํ๋ ค ์ต์ข ํด๋ต์ ์ฐ์ด์ง ์์ ๋ต์ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๋๋ผ ๋ง์ ์๊ฐ์ ๋ญ๋น
- DC
- ์ ํฉํ ์: ํฉ๋ณ์ ๋ ฌ, ํต์ ๋ ฌ
- ๋ถ๋ฌธ์ ๋ค์ด ์ค๋ณต๋์ง ์์: ์ค์ฒฉ๋ ๋ถ๋ฌธ์ ํน์ฑ์ด ์์
- ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ์ชผ๊ฐ ํ ๋ถ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ ์ ๋ต โ ํํฅ์
- ์ ํฉํ ์: ํฉ๋ณ์ ๋ ฌ, ํต์ ๋ ฌ
- DP
- ์ ํฉํ ์: ํผ๋ณด๋์น ์์ด ๊ณ์ฐ
- ๋ถ๋ฌธ์ ๋ค์ด ์ฌํ๊ฒ ์ค๋ณต: ์ค์ฒฉ๋ ๋ถ๋ฌธ์ ํน์ฑ์ ๊ฐ์ง
- ๋ถ๋ฌธ์ ๋ฅผ ํ๊ณ ์ด๋ฅผ ์ด์ฉํ์ฌ ๋ ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ ๋ต โ ์ํฅ์
- ์ ํฉํ ์: ํผ๋ณด๋์น ์์ด ๊ณ์ฐ
1
2
3
4
5
6
7
8
9
int IterativeFib(int n)
{
int[] fib = new int[MAX_SIZE];
fib[0] = 0;
fib[1] = 1;
for (int i = 2; i <= n; i++)
fib[i] = fib[i - 1] + fib[i - 2];
return fib[n];
}
๐ซง vs Greedy
- ๊ณตํต์ : ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ๋ฅผ ๊ฐ๋ ์ต์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐ
์ต์ ํด : ์ต๊ณ ์ข์ ํด๋ต
- ๊ทธ๋ฆฌ๋
- ์ต์ ํด๋ฅผ ๋ณด์ฅํ๋ค๋ ์ฆ๋ช ๋ง ๋๋ฉด ๊ฐ์ฅ ํจ์จ์
- ์ต์ ํด์ ์ผ๋ถ๋ฅผ ๋จผ์ ์ ํํ ํ ๋จ์ ๋ถ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ ์ ๋ต โ ํํฅ์
- ๋์ ๊ณํ๋ฒ
- ์ผ๋ฐ์ ์ธ ๋ฌธ์ + ์ต์ ํ ๋ฌธ์ : ๋ฒ์ฉ์ฑ
- ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ๋ชจ๋ ๋์๋ค์ ๋ต์ ๊ตฌํ๊ณ ๊ทธ ๊ฐ์ด๋ฐ ์ต์ ์ ํด๋ต์ ์ฐพ์ โ ์ง๋ฅ์ ์ธ ๋ฌด์์ ๊ธฐ๋ฒ, ์ํฅ์
๐ซง ๋์ ๊ณํ๋ฒ์ ์ ์ฉ
- โ ์ต์ ํ ๋ฌธ์ ์ ๊ฒฝ์ฐ ์ต์ ๋ถ๋ถ๊ตฌ์กฐ๋ฅผ ๊ฐ๋์ง ๊ฒ์ฆ
- โ ๋ฌธ์ ๋ฅผ ์ํ์ ์ผ๋ก ์ ์
- โ ์ค์ฒฉ๋ ๋ถ๋ฌธ์ ํน์ฑ์ ๊ฐ๋์ง ์กฐ์ฌ
- โ ๋ถ๋ฌธ์ ์ ํด๋ต์ ์ ์ฅํ๊ณ ์ด๋ก๋ถํฐ ์ต์ ํด๋ฅผ ๊ตฌ์ฑํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์ถ
๐ซง Memoization
๐ซ ์ ๋ฆฌ
- ์ ๋ฆฌ
- ์ต์ ๋ถ๋ถ๊ตฌ์กฐ๋ฅผ ๊ฐ๋ ์ต์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๋ฐ ์ฌ์ฉ
- ํนํ ๋ถ๋ฌธ์ ๊ฐ ์ค์ฒฉ๋๋ ์ ๋๊ฐ ๋์์๋ก ์ ์ฉ
- ํฌ๊ธฐ ๋ณ๋ก ๊ฐ๋ฅํ ๋ชจ๋ ๋ฌธ์ ๋ฅผ ๋ฏธ๋ฆฌ ํ์ด๋๊ณ ์ฌ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ์ง๋ฅํ๋ ๋ฌด์์ ๊ธฐ๋ฒ์ด๋ผ๋ ๋ณ์นญ
์ค์ฒฉ๋๊ฐ ๋์ผ๋ฉด, ๋ถ๋ฌธ์ ๊ฐ ๋๊ฐ์ ๊ฑธ ๋ง์ด ์ฐ๋ฉด, ๋ฏธ๋ฆฌ ๋ค ํ์ด๋๊ณ ์ฐ๋ ๋์ ๊ณํ๋ฒ
๋ฎ์ผ๋ฉด ๋ฏธ๋ฆฌ ํ์ด๋ ๋ถ๋ฌธ์ ๋ฅผ ์์จ์ ํจ์จ์ด ๋ฎ์ผ๋๊น, ์ฐจ๋ผ๋ฆฌ ๋ถํ ์ ๋ณต์ ๊ณ ๋ คํด๋ณผ๊ฒ
- ๊ธฐํ ์์
- ๋ฐ์ดํฐ์ ์ ์ฌ์ฑ์ ์์๋ด๋๋ฐ ์ ์ฉํ ์ต์ฅ ๊ณตํต ๋ถ๋ถ์์ (longest common subsequence) ๋ฌธ์
- 2์ฅ์์ ๋ค๋ฃฌ ์ฌํํ๋ ์ธํ์ ๋ฌธ์
- ์์ฑ ์ธ์์ด๋ ํฉ์ฑ์์ ์ฌ์ฉ๋๋ ๋นํฐ๋น(Viterbi) ์๊ณ ๋ฆฌ์ฆ
๐ซ ์ด์ฉ
0-1-KnapSack-Problem
Algorithm-Bellman-Ford
Algorithm-Floyd-Warchall