๐ก๊ฐ์ฅ ๊ฐ๋จํ๊ฒ ๋งํ์๋ฉด ์ ํ์์ ๊ตฌํ์ฌ ๋ฐ๋ณต์ ์ผ๋ก ๊ณ์ฐํ๋ ๊ฒ์ด๋ค.
์ด์ ์ ์ฌ์ฉ๋ ๊ฐ์ ์ฌ์ฌ์ฉํ๋ ๊ฒ์ด๋ผ๊ณ ์ดํดํ๋ฉด ์ฝ๋ค.
ํผ๋ณด๋์น์์ด์ด ๊ฐ์ฅ ์ฝ๊ณ ๋น ๋ฅด๊ฒ ์ดํดํ ์ ์๋ ์์ ๋ผ๊ณ ์๊ฐํ๋ค.
ํผ๋ณด๋์น ์์ด์ด๋ 1,1,2,3,5,8,13,...... ์ ๊ฐ์ด ์ด์ ์ ๋ ํญ์ ๋ํ์ฌ ๋ง๋๋ ์์ด์ด๋ค.
๋ฐ๋ผ์ f(n) = f(n-1) + f(n-2) ๊ณ์ฐ์์ ์ด์ฉํ์ฌ ๊ตฌํ ์ ์๋ค.
// ์ฌ๊ทํจ์ ์ด์ฉ(recursive)
public static int fibo(int n){
if(n == 1 || n ==0 ){
return 1;
}
return fibo(n-1)+fibo(n-2);
}
์์ ๊ฐ์ ์์ ๊ฐ๋จํ ๊ณ์ฐ์ ๋ฌธ์ ์๊ฒ ์ง๋ง,
๐คฆโโ๏ธfibo(10)
ํจ์๋ฅผ ์ฌ๊ท์ ์ผ๋ก ํธ์ถํ๋ฉด์, ์ซ์๊ฐ ์ปค์ง์ ๋ฐ๋ผ Stack OverFlow๊ฐ ๋ฐ์ํ๋ค.
์ด๋ฌํ ๋ฌธ์ ์ ์ Dynamic Programing ๊ธฐ๋ฒ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค.
๐โโ๏ธ fibo()
ํจ์์ ํธ์ถ์ ์ต์ํ์์ผ, ์ด๋ฏธ ๊ณ์ฐ๋ ์ ์ด ์๋ค๋ฉด ๊ฐ์ ๋ถ๋ฌ์์ ์ฌ์ฌ์ฉํ ์ ์๋๋ก ์ฝ๋๋ฅผ ์์ ํด๋ณด์.(์ดํด๋ฅผ ๋๊ธฐ์ํด ์์ฃผ ๊ฐ๋จํ๊ฒ ๋ง์ด ์ฝ๋์ด๋ค..)
// DP๋ฅผ ์ด์ฉํ ํผ๋ณด๋์น ์์ด
public static int[] fibo = new int[10]; // dp๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด int[] ๋ฐฐ์ด์ ์ ์ธ
public static int fibo(int n){
fibo[0] = 1;
fibo[1] = 1;
for(int i=2; i<=n; i++){
// ์์ ์ด์ฉํ์ฌ, ์ด์ ์ ์ฌ์ฉํ๋ ๊ณ์ฐ์์ ์ฌํ์ฉํ๋ค.
// ์ด๊ฒ์ memoization์ด๋ผ๊ณ ํ ์ ์๋ค.
fibo[i] = fibo[i-1] + fibo[i-2];
}
return fibo[n];
}
1. ์๊ฐ๋ณต์ก๋ : DP O(n^2) < recursive O(2^n)
์๊ฐ ๋ณต์ก๋๋ฅผ ์ดํด๋ณธ๋ค๋ฉด DP๊ฐ ํจ์ฌ ๋น ๋ฅด๋ค.
2. ๊ณต๊ฐ๋ณต์ก๋ : DP > recursive
DP์ ๊ฒฝ์ฐ ๋ฉ๋ชจ๋ฆฌ๊ณต๊ฐ์ ์ฐจ์งํ๋ค.
memoization๊ธฐ๋ฒ์ ์ฌ์ฉํ๋ฏ๋ก ๊ณ์ฐ์ด ๋๊ฐ์ ์ ์ฅํด ๋๊ณ ์๋ค๊ฐ, ํ์ํ ๊ฒฝ์ฐ ์ค๋ณต๊ณ์ฐ ์์ด ํธ์ถํ๋ค. ์์ ๊ฐ๋จํ ์์ ๋ง ์ดํด๋ณด์๋ int[]
์ ๊ฐ์ด ์ด๋๊ฐ์๋ ๊ฐ์ ์ ์ฅํ๊ณ ์์ด์ผํ๊ธฐ ๋๋ฌธ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ์ด์ ์กฐ๊ธ ๋ ์์ธํ DP์ ๋ํด ์์๋ณด์.
ํ๋์ ์ ์ ์์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ์ผ๋ก์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ
๋ชจ๋ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ
๋ชจ๋ ์ ์ ์์ ๋ชจ๋ ์ ์ ์ผ๋ก์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ ๊ฒฝ์ฐ
์ข ๋ ์์ธํ ๋ด์ฉ์ โถโถโถ Floyd Warshall ์๊ณ ๋ฆฌ์ฆ
๊ณ์ ํผ๋ณด๋์น ์์ด๋ก ์ค๋ช ์ ํด๋ณธ๋ค.
DP = ๋ฉ๋ชจ์ด์ ์ด์
์ ์๋๋ค.
ํ์ง๋ง, ๋ฉ๋ชจ์ด์ ์ด์
์ ๊ฐ๋
์ผ๋ก ์ดํดํ๊ธฐ ์ฌ์ธ๊ฑฐ ๊ฐ์์ ํจ๊ป ์ค๋ช
ํ๋ค.
๊ณ์ฐ๋ ๊ฐ์ ๋ฒ๋ฆฌ์ง์๊ณ ์ ์ฅํ๋ค๋ ๋ป.
๊ณ์ฐ๋ ๊ฐ์ ์ ์ฅํด๋๊ณ ์๋ค๊ฐ ํ์ํ ๊ฒฝ์ฐ ํธ์ถํด์ ์ฌ์ฉํ๋๊ฒ์ด๋ค.
์ด๋ ๊ฒ ์ ์ฅ๋๋ ๋ฐฐ์ด์ '์บ์'๋ผ๊ณ ํ๋ฉฐ, ์ค๊ฐ์ ์ ์ฅํ๋ ๊ฒ์ '์บ์ฑํ๋ค'๋ผ๊ณ ํํํ๋ค.
์ฌ๊ทํจ์์ด๋ค.
fibo(10)์ ๊ตฌํ๋ค๋ฉด, fibo(9), ffibo(8) ํฐ ์์์ ์์ ์์ ๋ฐฉํฅ์ผ๋ก ๊ณ์ ์ฌ๊ท์ ์ผ๋ก ํธ์ถํ๋ ๋ฐฉ๋ฒ์ ๋งํ๋ค.
public int[10] fibo = {0,}; // ๋ฐฐ์ด์ 0์ผ๋ก ๋ชจ๋ ์ด๊ธฐํ
public class int fibonachi(int n){
if(n <2){ // fibo[0] , fibo[1] = 1;
return 1;
}
if( fibo[n] == 0){
fibo[n] = fibo[n-1] + fibo[n-2];
}
return fibo[n];
}
๊ธฐ๋ณธ๊ฐ์ผ๋ก ํน์ ๊ฐ์ ๊ณ์ฐํ๋ คํ๋ ๋ฐฉ๋ฒ.
fibo(1)๋ถํฐ fibo(10)๊น์ง ์์ฐจ์ ์ผ๋ก ์ฌ๋ผ์ค๋ ๊ฒ์ ๋ปํ๋ค.
DP๋ฅผ ์ด์ฉํ ํผ๋ณด๋์น ์์ด
์์ค ์ฝ๋ ์ฐธ๊ณ !!
[์ฐธ์กฐ ๋ธ๋ก๊ทธ]
[์๊ณ ๋ฆฌ์ฆ] ๋์ ๊ณํ๋ฒ(Dynamic Programming) - 1
12. ๋์ ๊ณํ๋ฒ(Dynamic Programming)
ํ๋ก๋ฆฌ๋ค์์ฌ ์๊ณ ๋ฆฌ์ฆ