์ฝ๋์๋ ํ๋ก๊ทธ๋๋ฐ๋์ ๊ฐ์ ์๊ฐ
Dynamic Programming
์กฐ๊ฑด
- ๋ฌธ์ ๊ฐ ๋ ์์ subproblem์ผ๋ก ์ชผ๊ฐ์ง ๋
- subproblem์ solution์ผ๋ก ๋ ํฐ problem์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๋
- ๋๋ subprolem์ด ๊ฒน์น ๋ -> ํ์ํ ๊ณ์ฐ ์๋ฅผ ์ค์ผ ์ ์๋ค.
ํผ๋ณด๋์น ์์ด
๋ํ์ ์ธ ๋์ ํ๋ก๊ทธ๋๋ฐ์ ์์

ํผ๋ณด๋์น ์์ด F(7)์ ๊ตฌํ๊ณ ์ถ๋ค๋ฉด?
F(7) = F(6) + F(5)
F(7) = F(5) + F(4) + F(4) + F(3)
F(7) = F(4) + F(3) + F(3) + F(2) + F(3) + F(2) + F(2) + F(1)
.
.
.
์๊ฐ ๋ณต์ก๋๋?
์ธต์ด ๋์ด๋ ๋๋ง๋ค 2๊ฐ ๊ณฑํด์ง๊ณ ์ด n๊ฐ์ ์ธต์ด๊ธฐ ๋๋ฌธ์ O(2n)
def fib_naive(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
fib = fib_naive(n-1) + fib_naive(n-2)
return fib
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ผ๋ก ์ ์ฉํด๋ณด์๊ตฌ
- ๊ฒฐ๊ณผ ๊ฐ์ array๋ฅผ ๋ฏธ๋ฆฌ ๋ง๋ค์ด ๋๋ค.
- ๋๋ ์ง๋ subproblem์์ ํ์ํ ๊ฐ์ array์์ ์ฐพ๋๋ค.
- ๊ฐ์ด ์์ผ๋ฉด ๊ทธ ๋ ๊ณ์ฐํด์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
fib_array = [0,1]
def fib_recur_dp(n):
if n < len(fib_array): # ๊ตฌํด์ผ ํ n๋ฒ์งธ ํผ๋ณด๋์น ์๊ฐ ๋ฐฐ์ด์ ์กด์ฌํ๋ฉด ๊ทธ ๊ฐ์ return
return fib_array[n]
else:
fib = fib_recur_dp(n-1) + fib_recur_dp(n-2)
fib_array.append(fib)
return fib
์ด๋ ๊ฒ ๊ณ์ฐํ๋ฉด ์๊ฐ ๋ณต์ก๋๋ ๋ค์๊ณผ ๊ฐ๋ค. O(n)
ํ์ง๋ง ์์ ํจ์์์ fib_recur_dp(10000)๊ณผ ๊ฐ์ด ํฐ ์ซ์๋ฅผ ๊ตฌํ๋ ค๋ฉด ์ฌ๊ท ๊น์ด ์ด๊ณผ ์๋ฌ๊ฐ ๋์จ๋ค.
๊ฐ์ฅ ์์ ์ซ์ n๋ถํฐ ์ชผ๊ฐ๋๊ฐ๋ฉด์ ํด๊ฒฐํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ top-down ๋ฐฉ์์ ๋ค์ด๋๋ฏน ์๋ฃจ์ ์ด๋ผ๊ณ ํ๋ค. ์์๊ฐ๋ stack์ ํ๊ณ๊ฐ ์๊ธฐ ๋๋ฌธ์ ์ข์ solution์ ์๋๋ค.
Bottom up ๋ค์ด๋๋ฏน ์๋ฃจ์
๊ฐ์ฅ ์์ F(0) ๋ถํฐ F(1), F(2) ... ์์๋๊ฐ๋ ๊ฒ
def fib_dp(n):
if n == 0:
return 0
elif n == 1:
return 1
fib_array = [0,1]
for i in range(2,n+1):
num = fib_array[i-1] + fib_array[i-2]
fib_array.append(num)
return fib_array(n)
์๊ฐ ๋ณต์ก๋: O(n)
๊ณต๊ฐ ๋ณต์ก๋: O(n)
'Algorithm > ๋์ ๊ณํ๋ฒ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Dynamic Programming] ๋์ ๋ฐ๊พธ๊ธฐ - ์ด๊ธ (0) | 2023.10.20 |
---|---|
[Dynamic Programming] ์ต์ ๋น์ฉ ๊ตฌํ๊ธฐ - ์ด๊ธ (0) | 2023.10.20 |
[Dynamic Programming] ๊ณ๋จ ์ค๋ฅด๊ธฐ - ์ด๊ธ (0) | 2023.10.20 |