๐[DP] ๋์ ๊ณํ๋ฒ(Dynamic Programming)์ด๋?
๋์ ๊ณํ๋ฒ(Dynamic Programming)์ด๋?
๋์ ๊ณํ๋ฒ์ ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋์ด ํธ๋ ๋ฌธ์
๋ฅผ ๋งํ๋ค.
ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋๋ ๊ฒ์ ๋ถํ ์ ๋ณต(Divide and Conquer)
์ ๋น์ทํด๋ณด์ธ๋ค.
ํ์ง๋ง ๊ฒฐ์ ์ ์ธ ์ฐจ์ด์ ์ด ์๋๋ฐ, ๋ฐ๋ก ์์ ๋ฌธ์ ๊ฐ ์ค๋ณต์ด ์ผ์ด๋๋์ง ์ผ์ด๋์ง ์๋์ง
์ด๋ค.
๋ถํ ์ ๋ณต์ ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ด๋ ค์ ์์ ๋ฌธ์ ๋ก ๋๋์ด ํธ๋ ๋ฐฉ์์ด๋ค. ํน์ง์ ์์ ๋ฌธ์ ์์ ๋ฐ๋ณต์ด ์ผ์ด๋์ง ์๋๋ค๋ ์ ์ด๋ค.
๋์ ๊ณํ๋ฒ์ ์์ ๋ฌธ์ ๋ค์ด ๋ฐ๋ณต๋๋ ๊ฒ
์ด ํน์ง์ด๋ฉฐ, ์ด๋ฅผ ์ด์ฉํด ํ์ด๋๊ฐ๋ ๋ฐฉ์์ด๋ค.
๋์ ๊ณํ๋ฒ ๋ฐฉ๋ฒ
๋์ ๊ณํ๋ฒ์ผ๋ก ๋ฌธ์ ๋ฅผ ํธ๋ ๋ฐฉ๋ฒ์ ๋ชจ๋ ์์ ๋ฌธ์ ๋ค์ ํ ๋ฒ๋ง
ํธ๋ ๊ฒ์ด๋ค.
์ ๋ต์ ๊ตฌํ ์์ ๋ฌธ์ ๋ค์ ์ด๋๊ฐ์ ๋ฉ๋ชจ(Momoization)
ํด๋์๋ค๊ฐ, ๊ฐ์ ์ํฉ์ด ๋ฐ์ํ๋ฉด ๊ทธ ๊ฒฐ๊ณผ๊ฐ์ ์ฌ์ฉํ๋ค.
๋์ ๊ณํ๋ฒ์ ์กฐ๊ฑด?
๋์ ๊ณํ๋ฒ์ ์ฌ์ฉํ๋ ์กฐ๊ฑด์ ๋ค์๊ณผ ๊ฐ๋ค.
- ์์ ๋ฌธ์ ๊ฐ ๋ฐ๋ณต์ด ์ผ์ด๋๋ ๊ฒฝ์ฐ
- ๊ฐ์ ๋ฌธ์ ๋ ๊ตฌํ ๋๋ง๋ค ์ ๋ต์ด ๊ฐ์์ผ ํจ
์ด๋ฌํ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฒฝ์ฐ๋ง ๋์ ๊ณํ๋ฒ์ ์ฌ์ฉํ ์ ์๋ค.
๋์ ๊ณํ๋ฒ ์์ฝ - ์ฅ์
- ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํด์ ์ค๋ณต ์ฐ์ฐ์ ์ค์
- ์ค๋ณต ์ฐ์ฐ์ ์ค์ฌ์ ์ํ ์๋๋ฅผ ๊ฐ์ ํจ
์์ - ํผ๋ณด๋์น ์์ด
ํผ๋ณด๋์น ์์ด
์ F(n) = F(n-1) + F(n-2)
์ ์ ํ์์ ๊ฐ๋ ์์ด์ด๋ค. ์ด ๋ฌธ์ ๋ ์ฌ๊ท ํจ์๋ฅผ ํตํด ํด๊ฒฐํ ์ ์์ง๋ง, n์ด
์ฆ๊ฐํจ์ ๋ฐ๋ผ ํธ์ถ๋๋ ํจ์์ ์๊ฐ ๊ธฐํ๊ธ์์ ์ผ๋ก ์ฆ๊ฐํ๊ธฐ ๋๋ฌธ์ ์ผ์ ์ ์ด์์ ์์ด์ ๊ตฌํ๊ธฐ ์ด๋ ต๋ค.
์ฌ๊ทํจ์ ์ฌ์ฉ
def fub(n):
if n <= 1:
return n
else:
return fib(n-1) + fib(n-2)
์ด ๋ฌธ์ ๋ฅผ ๋์ ๊ณํ๋ฒ(DP)๋ฅผ ์ฌ์ฉํด ์ ๊ทผํด๋ณด์.
-
์์ ๋ฌธ์ ๋ค์ด ๋ฐ๋ณต๋๋ค.
์๋ฅผ ๋ค์ด F(5) = F(4) + F(3), F(4) = F(3) - F(2) ์ธ๋ฐ, ์ฌ๊ธฐ์ F(3)์ด ๋ฐ๋ณต๋๋ ๊ฒ์ ๋ณผ ์ ์๋ค. ์ฆ, ์์ ๋ฌธ์ ๊ฐ ๋ฐ๋ณต๋๊ณ ์๋ค๋ ๋ป์ด๋ค.
-
๊ฐ์ ๋ฌธ์ ๋ ๊ตฌํ ๋๋ง๋ค ์ ๋ต์ด ๊ฐ๋ค.
ํผ๋ณด๋์น ์์ด์ F(1)๊ณผ F(2)์ ๊ฐ์ ๋ชจ๋ 1๋ก ๊ณ ์ ๋์ด ์๋ค.
์ฆ, 3๋ฒ์งธ ์์ด์ ์ธ์ ๋ ๊ฒฐ๊ณผ๊ฐ์ด 2์ด๊ณ , 4๋ฒ์งธ ์์ด์ 2 + 1์ด๋ฏ๋ก ์ธ์ ๋ ๊ฒฐ๊ณผ๊ฐ์ด ๊ฐ๋ค.
ํผ๋ณด๋์น ์์ด DP
def fibo(n):
dp[0] = 1
dp[1] = 1
if n < 2:
return dp[n]
for i in range(2, n+1):
dp[i] = dp[i-2] + dp[i-1]
return dp[n]
์ฐธ๊ณ ์๋ฃ
https://galid1.tistory.com/507
https://www.youtube.com/watch?v=0bqfTzpWySY&t=423s
๋๊ธ๋จ๊ธฐ๊ธฐ