๐
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ ๊ธฐ๋กํด๋ฌ์ผ ํ ๊ฒ ๊ฐ์์
์ค๋๋ง์ ๊ธ ๋์ ๋์ ๐
๋์ ๊ณํ๋ฒ(DP; Dynamic Programming)์ด๋ ?
ํฐ ๋ฌธ์ ๋ฅผ ์์ ํ์ ๋ฌธ์ ๋ก ๋๋์ด ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ ์ค๊ณ ๊ธฐ๋ฒ์ผ๋ก, ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ์ฌ๋ฌ ๊ฐ์ ํ์ ๋ฌธ์ ๋ก ๋ถํ ํ๊ณ ๊ฐ ํ์ ๋ฌธ์ ์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ์ฌ ์ ์ฅํ ๊ฐ์ ์ด์ฉํด ์์ ๋ฌธ์ ๋ฅผ ์ ์ง์ ์ผ๋ก ํด๊ฒฐํ๋ ๋ฐฉ์์ ์ฌ์ฉํ๋ค.
DP๋ ์ค๋ณต๋๋ ํ์ ๋ฌธ์ ๋ค์ด ์กด์ฌํ ๋ ํจ๊ณผ์ ์ผ๋ก ์ฌ์ฉ๋๋ค. ๋์ผํ ํ์ ๋ฌธ์ ๊ฐ ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณตํด์ ๊ณ์ฐ๋๋ ๊ฒฝ์ฐ, DP๋ ์ด์ ์ ๊ณ์ฐํ ๊ฐ์ ์ ์ฅํด ๋์๋ค๊ฐ ์ฌ์ฌ์ฉํจ์ผ๋ก์จ ์ค๋ณต ๊ณ์ฐ์ ํผํ ์ ์๋ค. ์ด๋ฅผ "Memoization"์ด๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
๐ก ๋ฉ๋ชจ์ด์ ์ด์ (Memoization)์ ์ด์ ์ ๊ณ์ฐํ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๋ ๋ฐฉ์์ผ๋ก ์ค๋ณต ์ํ์ ์ ๊ฑฐํ์ฌ ํ๋ก๊ทธ๋จ ์คํ ์๋๋ฅผ ๋น ๋ฅด๊ฒ ํ๋ ์ต์ ํ ๊ธฐ๋ฒ์ด๋ค.
์ ๋ฆฌํ๋ฉด, DP๋ Dynamic Table์ด๋ Memoization์ ํตํด ์ค๋ณต ๊ณ์ฐ์ ํผํ๊ณ , ํ์ ๋ฌธ์ ์ ์ต์ ํด๋ฅผ ๊ตฌํ์ฌ ์ ์ฒด ๋ฌธ์ ์ ์ต์ ํด๋ฅผ ๋์ถํ๋ ๋ฐฉ์์ผ๋ก ์ฌ์ฉ๋๋ค. ๋ํ์ ์ธ ์๋ก๋ ํผ๋ณด๋์น ์์ด, ์ต์ฅ ๊ณตํต ๋ถ๋ถ ์์ด(LCS), ์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ๋ฑ์ด ์๋ค.
๋์ ๊ณํ๋ฒ์ ํน์ฑ
โ๐ป ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ (Optimal Substructure) : ํฐ ๋ฌธ์ ์ ์ต์ ํด๊ฐ ์์ ๋ฌธ์ ์ ์ต์ ํด๋ก๋ถํฐ ๊ตฌํด์ง ์ ์๋ ์ฑ์ง
โ๐ป ์ค๋ณต๋๋ ํ์ ๋ฌธ์ (Overlapping Subproblems) : ์์ ๋ฌธ์ ๋ค์ด ๋ฐ๋ณต์ ์ผ๋ก ๋ฐ์ํ๋ ํํ๋ฅผ ๊ฐ์ง๋ ๊ฒ
๋์ ๊ณํ๋ฒ์ ๊ตฌํ ๋ฐฉ์
โ๐ป ์ํฅ์ ๋์ ๊ณํ๋ฒ (Bottom-up ๋์ ๊ณํ๋ฒ)
โ๐ป ํํฅ์ ๋์ ๊ณํ๋ฒ (Top-down ๋์ ๊ณํ๋ฒ)
๐ค ์ ๊ฐ๋ ์ผ๋ก๋ง ๋ดค์ ๋ ์์ ํ์ ๋ฌธ์ ๋ค์ ํตํด ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค๊ณ ํด์ ์ํฅ์ ๊ธฐ๋ฒ์ด๊ตฌ๋,, ๋ผ๊ณ ์๊ฐํ๋ค. ๊ทธ๋ฐ๋ฐ ๊ธฐ๋ณธ ๊ฐ๋ ์ด ํ์ ๋ฌธ์ ๋ก๋ถํฐ ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ด๋ฏ๋ก, ์ํฅ์ ๋ฟ๋ง ์๋๋ผ ํํฅ์ ๊ธฐ๋ฒ์๋ ์ ์ฉ๋ ์ ์์๋ค. ์๋ชป ์๊ฐํจ ใ ใ ใ
์ํฅ์ ๋์ ๊ณํ๋ฒ (Bottom-up ๋์ ๊ณํ๋ฒ)
์์ ํ์ ๋ฌธ์ ๋ถํฐ ์์ํ์ฌ ํ์ํ ๊ฐ์ ๊ณ์ฐํ๊ณ ์ ์ฅํ๋ ๋ฐฉ์.
์์ ๋ฌธ์ ๋ถํฐ ํฐ ๋ฌธ์ ๋ก ์งํํ๋ฉฐ, ์ด์ ์ ๊ณ์ฐํ ๊ฐ๋ค์ ํ์ฉํ์ฌ ์ ์ง์ ์ผ๋ก ์ต์ ํด๋ฅผ ๊ตฌํ๋ค. ์ฌ๊ท์ ์ธ ํธ์ถ ์์ด ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ์ฌ ๊ณ์ฐํ๊ธฐ ๋๋ฌธ์ ํจ์จ์ ์ธ ๋ฐฉ์์ !! ๋ฐ๋ณต๋ฌธ์ ํตํด ์์ ์ฐ์ฐ ๋จ์๋ฅผ ์คํํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ Dynamic Table์ ์ ์ฅํ์ฌ ์ฌ์ฉํ๋ค. ๋ณดํต ๋ฐฐ์ด์ด๋ ํ ์ด๋ธ์ ์ฌ์ฉํ์ฌ ๊ณ์ฐ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๋ฉฐ, ์ต์ข ์ ์ผ๋ก ์ํ๋ ๋ฌธ์ ์ ํด๋ฅผ ๊ตฌํ ์ ์๋ค.
๐ก Dynamic Table์ ๋ถ๋ถํด์ ๊ฒฐ๊ณผ๋ฅผ ์์์ ์ผ๋ก ์ ์ฅํ๋ ๋ฐฐ์ด์ ๋งํ๋ค.
ํํฅ์ ๋์ ๊ณํ๋ฒ (Top-down ๋์ ๊ณํ๋ฒ)
ํฐ ๋ฌธ์ ๋ฅผ ์์ ํ์ ๋ฌธ์ ๋ก ๋ถํ ํ๊ณ , ์ฌ๊ท์ ์ผ๋ก ํ์ ๋ฌธ์ ๋ฅผ ํธ์ถํ์ฌ ํด๊ฒฐํ๋ ๋ฐฉ์.
์ด ๋, Memoization์ ์ฌ์ฉํ์ฌ ์ด์ ์ ๊ณ์ฐํ ๊ฐ์ ์ ์ฅํ๊ณ ์ฌ์ฌ์ฉํจ์ผ๋ก์จ ์ค๋ณต ๊ณ์ฐ์ ํผํ๋ค โผ๏ธ ์ฌ๊ท ํธ์ถ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๊ตฌํ์ด ๊ฐ๋จํ๊ณ ์ง๊ด์ ์ด์ง๋ง, ์ฌ๊ท ํธ์ถ์ ๋ฐ๋ฅธ ์ค๋ฒํค๋๊ฐ ์์ ์ ์๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ฌ๊ท ํธ์ถ์ ์ต์ ํํ๊ธฐ ์ํด Memoization์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ผ๋ฐ์ .
๐ก ๊ฒฐ๋ก ์ ์ผ๋ก, ๋์ ๊ณํ๋ฒ์ ํํฅ์๊ณผ ์ํฅ์ ๋ชจ๋ ํด๋น๋ ์ ์๊ณ , ๋ ๋ฐฉ์์ ๋์ ๊ณํ๋ฒ์ ํต์ฌ ์์ด๋์ด๋ฅผ ํ์ฉํด์ ์ค๋ณต ๊ณ์ฐ์ ํผํ๊ณ ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ๋ฅผ ํ์ฉํ๋ ๊ฒ์ ์ฐจ์ด๊ฐ ์์ ๋ฟ์ !!! ๊ทธ์น๋ง,, ์ฒ๋ฆฌํ ๋ฐ์ดํฐ์ ์์ด ๋ง์์ง๋ฉด Stack์ ๋ฒ์๋ฅผ ์ด๊ณผํ ์ฌ๊ท ํธ์ถ๋ก ์ธํด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ํด๊ฒฐ ๊ฐ๋ฅํ ๋ฐฉ๋ฒ์ ์กด์ฌํ๋ ๋๋๋ก ์ํฅ์ DP๋ฅผ ํตํด ์์ฑํ๋ ๊ฒ์ด ์ข๋ค๊ณ ํจ ~ ใ
๊ฐ๋ ์ ์ตํ์ผ๋ ๊ทธ๋ผ ์ด๋ป๊ฒ ์ฝ๋๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ง๋์ง ๋ณด์๊ตฌ์ !!!
์๋ ์์ ์ฝ๋๋ n๋ฒ์งธ ํผ๋ณด๋์น ์์ด์ ์ซ์๋ฅผ ์ถ๋ ฅํ๋ ํจ์๋ค์ ๋๋ค๋์ฅ ๐ฟ๏ธ ( ์ฃผ์ : 0๋ฒ์งธ๊ฐ ์กด์ฌํจ !! )
์ํฅ์ ๋์ ๊ณํ๋ฒ์ผ๋ก ํผ๋ณด๋์น ์์ด ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ
func fibonacciBottomUp(_ n: Int) -> Int {
var fibo = Array(repeating: 0, count: n + 1)
fibo[0] = 0; fibo[1] = 1
if n <= 1 { return fibo[n] }
for i in 2...n { fibo[i] = fibo[i - 1] + fibo[i - 2] }
return fibo[n]
}
print(fibonacciBottomUp(10))
// ์ถ๋ ฅ : 55
// fibo : [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
ํํฅ์ ๋์ ๊ณํ๋ฒ์ผ๋ก ํผ๋ณด๋์น ์์ด ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ
var fiboMemo = [Int: Int]()
func fibonacciTopDown(_ n: Int) -> Int {
if n <= 1 {
fiboMemo[n] = n
return n
}
if let memo = fiboMemo[n] { return memo } // ์ด๋ฏธ ๊ณ์ฐํ์ฌ ์ ์ฅํด๋์๋ค๋ฉด ๊ทธ ๊ฐ์ ๋ฐํ - ๋ฉ๋ชจ์ด์ ์ด์
fiboMemo[n] = fibonacciTopDown(n - 1) + fibonacciTopDown(n - 2)
return fiboMemo[n] ?? 0
}
print(fibonacciTopDown(10))
// ์ถ๋ ฅ : 55
// fiboMemo : [6: 8, 7: 13, 3: 2, 8: 21, 9: 34, 10: 55, 1: 1, 0: 0, 5: 5, 4: 3, 2: 1]
๋ฉ๋ชจ์ด์ ์ด์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ ํด๋๊ธฐ ์ซ์ด์ ๋์ ๋๋ฆฌ๋ก ๊ตฌ์ฑํ์์ ใ ใ ใ
์ดํญ๊ณ์ ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ DP๋ฅผ ์ ์ฉํ๊ณ ์,, ๊ณต๋ถํ๊ฒ ๋๋ฉด์ ๊ธฐ๋ก์ ํ๋ค ๐
DP๋ฅผ ์ ์ฉํ๊ธฐ ์ํด์ ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ ์ฑ๋ฆฝ ํ์ธ ํ์ ์ ํ์ ๋์ถ์ด ์ค์ํ ๊ฒ ๊ฐ๋ค..
DP... ๋ ์ด ์์ ๋ ๋ชป ์๊ฒ ํ๋ค๋ !!! ํํ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm/Swift] ๊น์ด ์ฐ์ ํ์ (DFS) (0) | 2023.06.03 |
---|---|
[Algorithm] ๋ฐฑํธ๋ํน(Backtracking)๊ณผ ๋ธ๋ฃจํธํฌ์ค(Brute Force) (0) | 2023.05.19 |