์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- SwiftUI
- HAVIT
- APPJAM
- ๊ธฐ์ด๋ฌธ๋ฒ
- concurrency
- binarySearch
- dfs
- SwiftUI Tutorials
- GroupBy
- ๊ณ ๋์ kit
- DynamicProgramming
- discardableResult
- URLSession
- Swift
- algoritm
- ๋์ ๊ณํ๋ฒ
- 0์ด๋์ด์๋๊ธธ
- IOS
- ์ด์งํ์
- SQL
- Til
- BFS
- SOPT
- ํ๋ก๊ทธ๋๋จธ์ค
- ์ฐ์ํ์ค๋ถ๋ถ์์ด์ํฉ
- algorithm
- GCD
- SwiftUI ํํ ๋ฆฌ์ผ
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- duno
- Today
- Total
suvera-dev ๐ฅฆ
Algorithm) Dynamic programming ๋ณธ๋ฌธ
Dynamic programming(๋์ ๊ณํ๋ฒ)์ด๋ ?
๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ ํ ์ฌ์ฉํ์ฌ ์ํ์๊ฐ ํจ์จ์ฑ์ ๋น์ฝ์ ์ผ๋ก ํฅ์์ํค๋ ๋ฐฉ๋ฒ
-> ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ต๋ํ์ผ๋ก ํ์ฉํ ์ ์๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ ์์ฑ !
๋ํ์ ์ธ ์์ : ํผ๋ณด๋์น ์์ด
- n ๋ฒ์งธ ํผ๋ณด๋์น ์ = (n-1)๋ฒ์งธ ํผ๋ณด๋์น ์ + (n-2)๋ฒ์งธ ํผ๋ณด๋์น ์
- ๋จ, 1๋ฒ์งธ ํผ๋ณด๋์น ์ = 1,2 ๋ฒ์งธ ํผ๋ณด๋์น ์ = 1
# ํผ๋ณด๋์น ํจ์ ์์ค์ฝ๋
def fibo(x):
if x == 1 or x == 2:
return 1
return fibo(x-1) + fibo(x-2)
print(fibo(4))
-> But, ํผ๋ณด๋์น ์์ด์ ์์ค์ฝ๋๋ฅผ ์ด๋ ๊ฒ ์์ฑํ๋ฉด ์ฌ๊ฐํ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๋ค.
๋ฐ๋ก f(n) ํจ์์์ n์ด ์ปค์ง๋ฉด ์ปค์ง์๋ก ์ํ ์๊ฐ์ด ๊ธฐํ๊ธ์์ ์ผ๋ก ๋์ด๋๊ธฐ ๋๋ฌธ !
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ฌ์ฉํด์ ํจ์จ์ ์ผ๋ก ํด๊ฒฐํด๋ณด์ !
1. ํฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์๋ค.
2. ์์ ๋ฌธ์ ์์ ๊ตฌํ ์ ๋ต์ ๊ทธ๊ฒ์ ํฌํจํ๋ ํฐ ๋ฌธ์ ์์๋ ๋์ผํ๋ค.
โจ ๋ฉ๋ชจ์ด์ ์ด์ ๊ธฐ๋ฒ
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ ์ค ํ ์ข ๋ฅ๋ก, ํ๋ฒ ๊ตฌํ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์
๋ฉ๋ชจํด๋๊ณ ๊ฐ์ ์์ ๋ค์ ํธ์ถํ๋ฉด ๋ฉ๋ชจํ ๊ฒฐ๊ณผ๋ฅผ ๊ทธ๋๋ก ๊ฐ์ ธ์ค๋ ๊ธฐ๋ฒ
( ๋ฉ๋ชจ์ด์ ์ด์ ์ ๊ฐ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ด๋ฏ๋ก ์บ์ฑ์ด๋ผ๊ณ ๋ ํ๋ค.)
์ด๋ป๊ฒ ๊ตฌํ๋ ์ ์์๊น? ํ ๋ฒ ๊ตฌํ ์ ๋ณด๋ฅผ ๋ฆฌ์คํธ์ ์ ์ฅํ๋ ๊ฒ
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ฌ๊ท์ ์ผ๋ก ์ํํ๋ค๊ฐ ๊ฐ์ ์ ๋ณด๊ฐ ํ์ํ ๋๋
์ด๋ฏธ ๊ตฌํ ์ ๋ต์ ๊ทธ๋๋ก ๋ฆฌ์คํธ์์ ๊ฐ์ ธ์ค๋ฉด ๋๋ค !
# ํ ๋ฒ ๊ณ์ฐ๋ ๋ฉ๋ชจ์ด์ ์ด์
ํ๊ธฐ ์ํ ๋ฆฌ์คํธ ์ด๊ธฐํ
d = [0] * 100
# ํผ๋ณด๋์น ํจ์๋ฅผ ์ฌ๊ทํจ์๋ก ๊ตฌํ - ํ๋ค์ด ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
def fibo(x):
# ์ข
๋ฃ ์กฐ๊ฑด (1 ํน์ 2 ์ผ๋ 1์ ๋ฐํ)
if x == 1 or x == 2:
return 1
# ์ด๋ฏธ ๊ณ์ฐํ ์ ์๋ ๋ฌธ์ ๋ผ๋ฉด ๊ทธ๋๋ก ๋ฐํ
if d[x] != 0:
return d[x]
# ์์ง ๊ณ์ฐํ์ง ์์ ๋ฌธ์ ๋ผ๋ฉด ์ ํ์์ ๋ฐ๋ผ์ ํผ๋ณด๋์น ๊ฒฐ๊ณผ ๋ฐํ
d[x] = fibo(x-1) + fibo(x-2)
return d[x]
print(fibo(99))
# ์์ ๊ณ์ฐ๋ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ DP ํ
์ด๋ธ ์ด๊ธฐํ
d = [0] * 100
# ์ฒซ ๋ฒ์จฐ ํผ๋ณด๋์น ์์ ๋ ๋ฒ์จฐ ํผ๋ณด๋์น ์๋ 1
d[1] = 1
d[2] = 1
n = 99
# ํผ๋ณด๋์น ํจ์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๊ตฌํ - ๋ณดํ
์
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ
for i in range(3, n+1):
d[i] = d[i-1] + d[i-2]
print(d[n])
์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ์์ค ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ์
ํฐ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์์ ๋ฌธ์ ๋ฅผ ํธ์ถํ๋ค๊ณ ํ์ฌ
ํ๋ค์ด ๋ฐฉ์์ด๋ผ๊ณ ๋งํ๋ค.
๋ฐ๋ฉด์ ๋จ์ํ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ์ฌ ์์ค์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒฝ์ฐ ์์ ๋ฌธ์ ๋ถํฐ
์ฐจ๊ทผ์ฐจ๊ทผ ๋ต์ ๋์ถํ๋ค๊ณ ํ์ฌ ๋ณดํ ์ ๋ฐฉ์์ด๋ผ๊ณ ํ๋ค.
๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์ ์ ํ์ ์ธ ํํ๋ ๋ณดํ ์ ๋ฐฉ์ !
๋ณดํ ์ ๋ฐฉ์์์ ์ฌ์ฉ๋๋ ๊ฒฐ๊ณผ ์ ์ฅ์ฉ ๋ฆฌ์คํธ๋ DP ํ ์ด๋ธ์ด๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ,
๋ฉ๋ชจ์ด์ ์ด์ ์ ํ๋ค์ด ๋ฐฉ์์ ๊ตญํ๋์ด ์ฌ์ฉ๋๋ ํํ !
์ฝ๋ฉํ ์คํธ์์ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ ๋ ๋์ฒด๋ก ๊ฐ๋จํ ํํ๋ก ์ถ์ ๋๋ค.
๋ฌธ์ ๋ฅผ ํธ๋ ์ฒซ ๋จ๊ณ๋ ๋น์ฐ ๋ฌธ์ ๊ฐ ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ์์ ํ์ ํ๊ธฐ!
์์ ํ์์ผ๋ก ์ค๋ ๊ฑธ๋ฆด๋, ๋ถ๋ถ ๋ฌธ์ ๋ค์ ์ค๋ณต ์ฌ๋ถ๋ฅผ ํ์ ํด๋ณด์
์์ ๋ค๋ฃจ์๋ ์์ด ์์ ์ฒ๋ผ ์ฌ๊ท ํจ์๋ฅผ ์์ฑํ ๋ค์ ๋์ค์ ๋ฉ๋ชจ์ด์ ์ด์ ๊ธฐ๋ฒ์
์ ์ฉํด์ ์์ ํ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ !
๊ฐ๋ฅํ๋ค๋ฉด, ๋ณดํ ์ ๋ฐฉ์์ผ๋ก ํด๋ณด์ !
์์คํ ์ ์ฌ๊ทํจ์์ ์คํ ํฌ๊ธฐ๊ฐ ํ์ ๋์ด ์์ ์ ์๊ธฐ ๋๋ฌธ
=> ๋ง์ฝ ์์ค์ฝ๋์์ recursion depth ๊ด๋ จ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค๋ฉด,
sys ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ setrecursionlimit() ํจ์๋ฅผ ํธ์ถํ์ฌ
์ฌ๊ท์ ํ์ ์ํํ ์ ์๋ค๋ ์ ์ ๋๋ง ๊ธฐ์ตํ์ !!
'Algorithm > CodingTest - Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Algorithm) Dynamic Programming ๋ฌธ์ (1) | 2022.05.03 |
---|---|
Algorithm ) Binary Search ๋ฌธ์ (0) | 2022.04.07 |
Algorithm) Binary Search (0) | 2022.04.07 |
Algorithm) Sorting ๊ธฐ๋ณธ๋ฌธ์ (0) | 2022.04.07 |
Algorithm) Sorting (0) | 2022.04.03 |