์๋ฐ์คํฌ๋ฆฝํธ ํ๋ก๊ทธ๋๋จธ์ค ๊ฑฐ์ค๋ฆ๋ ๋ฌธ์ ํ์ด
๐ ๋ฌธ์
โพ ํด์ค
Finn์ ํธ์์ ์์ ์ผ๊ฐ ์๋ฅด๋ฐ์ดํธ๋ฅผ ํ๊ณ ์์ต๋๋ค. ์ผ๊ฐ์ ์๋์ด ๋๋ฌด ์์ด ์ฌ์ฌํ Finn์ ์๋๋ค๊ป ๊ฑฐ์ค๋ฆ๋์ n ์์ ์ค ๋ ๋ฐฉ๋ฒ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๊ธฐ๋ก ํ์์ต๋๋ค.
์๋ฅผ ๋ค์ด์ ์๋๊ป 5์์ ๊ฑฐ์ฌ๋ฌ ์ค์ผ ํ๊ณ 1์, 2์, 5์์ด ์๋ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด 4๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก 5์์ ๊ฑฐ์ฌ๋ฌ ์ค ์ ์์ต๋๋ค.
- 1์์ 5๊ฐ ์ฌ์ฉํด์ ๊ฑฐ์ฌ๋ฌ ์ค๋ค.
- 1์์ 3๊ฐ ์ฌ์ฉํ๊ณ , 2์์ 1๊ฐ ์ฌ์ฉํด์ ๊ฑฐ์ฌ๋ฌ ์ค๋ค.
- 1์์ 1๊ฐ ์ฌ์ฉํ๊ณ , 2์์ 2๊ฐ ์ฌ์ฉํด์ ๊ฑฐ์ฌ๋ฌ ์ค๋ค.
- 5์์ 1๊ฐ ์ฌ์ฉํด์ ๊ฑฐ์ฌ๋ฌ ์ค๋ค.
๊ฑฐ์ฌ๋ฌ ์ค์ผ ํ๋ ๊ธ์ก n๊ณผ Finn์ด ํ์ฌ ๋ณด์ ํ๊ณ ์๋ ๋์ ์ข ๋ฅ money๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, Finn์ด n ์์ ๊ฑฐ์ฌ๋ฌ ์ค ๋ฐฉ๋ฒ์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
โพ ์ ํ ์ฌํญ
- n์ 100,000 ์ดํ์ ์์ฐ์์ ๋๋ค.
- ํํ ๋จ์๋ 100์ข ๋ฅ ์ดํ์ ๋๋ค.
- ๋ชจ๋ ํํ๋ ๋ฌดํํ๊ฒ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค.
- ์ ๋ต์ด ์ปค์ง ์ ์์ผ๋, 1,000,000,007๋ก ๋๋ ๋๋จธ์ง๋ฅผ return ํด์ฃผ์ธ์.
โพ ์ ์ถ๋ ฅ ์์
n | money | result |
5 | [ 1, 2, 5 ] | 4 |
๐ ๋ด ํ์ด
๊ท์น ์ฐพ๋ค๊ฐ ์๊ฐ์ ๋ค ์ผ๋ค ...
์ด๋ฒ ๋ฌธ์ ๋ ๋ ํผ๋ฐ์ค๋ฅผ ์ฐธ๊ณ ํ๋ฉฐ ์์ ๊ณต๋ถ๋ฅผ ํด๋ฒ๋ ธ๋ค ใ
๐ Dynamic Programming ๋์ ํ๋ก๊ทธ๋๋ฐ
2021.10.11 - [๊ฐ๋ฐ ๊ณต๋ถ/Algorithm] - Dynamic Programming ๋์ ํ๋ก๊ทธ๋๋ฐ
๐ ์ฝ๋ ๊ณต๋ถ
์ฒ์ ๋ฌธ์ ์ ์ ๊ทผํ ๋, fix๋๋ ๊ฐ์ ์์ด์ผ ๊ฒ ๋ค๋ ์๊ฐ์ ํ๋ค.
๊ธฐ์ค์ด ์์ด์ผ ๊ธฐ์ค์ ์ค์ฌ์ผ๋ก ๋๋จธ์ง ๊ฐ๋ค์ ์กฐํฉํด ์ํ๋ ํฉ์ ๋์ถํด๋ผ ์ ์์ผ๋๊น.
๊ทธ๋ฐ๋ฐ ์กฐํฉ์ผ๋ก ๊ฒฝ์ฐ์ ์๋ฅผ ์ฐพ๊ณ ํด๋นํ๋ ๊ฒฝ์ฐ์ ์์ ํฉ์ ๋ ๊ตฌํด์ผํ๋ค๊ณ ์๊ฐํ๋ ๋๋ฌด ๋ง๋งํ๋ค.
--> ์ฌ๊ธฐ์๋ถํฐ ์ฌ๊ณ ์ ํ๋ก๊ฐ ๊ผฌ์ธ๋ฏ
์ผ๋จ ๊ธฐ์ค์ด ๋๋ ์๊ฐ ๊ฐ์ง๊ณ ์๋ ๊ท์น(?)์ ๋ถ์ํด๋ณด๊ธฐ๋ก ํ๋ค.
n (์ํ๋ ํฉ) ์ ์ผ์ชฝ์ ์ ๋ ฌํ๊ณ , 1 2 3 --- ๊ธฐ์ค์ ๋์ดํด ๋ฐ๋ณต๋๋ ํน์ฑ์ ์ฐพ์๋ณด์๋ค.
1์ ๋ฐ๋ก ์ ์์ 1์ ๊ณ์ ๋ํด๋๊ฐ๋ ํน์ฑ์ด ์์๊ณ ,
2๋ ๋ฐ๋ก ์ ์ ์์ 2๋ฅผ ๊ณ์ ๋ํด๋๊ฐ๋ ํน์ฑ์ด ์์๊ณ ,
3์ ๋ฐ๋ก ์ ์ ์ ์์ 3์ ๊ณ์ ๋ํด๋๊ฐ๋ ํน์ฑ์ด ์์๋ค.
๊ฒฝ์ฐ์ ์ ๊ด์ ์์ ๋ณด๋ฉด ์ด๋จ๊น ?
์ฐ๋ฆฐ ํฉ 5๋ฅผ ๋ง์กฑ์ํค๋ [ 1, 2, 5 ] ๊ฐ ์กฐํฉ๋ ๋ฐฐ์ด์ ๊ฐ์๋ฅผ ์ฐพ๊ณ ์ถ๋ค. -> ์กฐํฉํ๊ณ ์ถ์ ์ซ์๊ฐ ์ ํด์ ธ์์์ ์์ง ๋ง์
2๊ฐ ๊ธฐ์ค์ผ ๋, 2 + 2 + 1 ๋๋ 2 + 1 + 1 + 1 ์ case ๋ค์ ๋์ถํด๋ผ ์ ์๋ค.
๊ทธ๋ฐ๋ฐ ... ์ด๋ ํฉ 3์ด ๊ฐ๋ ๊ฒฝ์ฐ์ ์์๋ ๋์ผํ๋ค. 2 + 1 ๋๋ 1 + 1 + 1
๋ค๋ฅธ ๊ฒฝ์ฐ๋ ๋ง์ฐฌ๊ฐ์ง๋ค. ํฉ 4๋ฅผ ๋ง์กฑ์ํค๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ฐพ์๋ณด๋ฉด,
1 + 1 + 1 + 1 ๋๋ 2 + 1 + 1 ๋๋ 2 + 2 ์ด๋ ๊ฒ ์ด 3๊ฐ์ case๋ฅผ ๋์ถํ ์ ์๊ณ
์ด ์์
โ 1์ ๊ธฐ์ค์ผ๋ก ํฉ 4๋ฅผ ๋ง์กฑ์ํค๋ 1 + 1 + 1 + 1
โ 2๋ฅผ ๊ธฐ์ค์ผ๋ก ํฉ 4๋ฅผ ๋ง์กฑ์ํค๋ 2 + 1 + 1 ๊ณผ 2 + 2 ๊ฐ ํฌํจ๋์ด์๋ค.
์ฐ๋ฆฌ๊ฐ ๊ตฌํ๊ณ ์ถ์ ๊ฑด ์กฐํฉํ ์ ์๋ ๊ฒฝ์ฐ์ ์๋๊น, cases๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ ๊ตฌํด๋ณด์.
์ฐ๋ฆฌ๋ 1์ ๊ธฐ์ค์ผ๋ก ( ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ) ๊ฐ ์๋ง๋ค 1๊ฐ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ฐ์ง ์ ์๋ค.
** ์ธ๋ฑ์ค 0์ 1์ ํ ๋นํด๋์ ์ด์ ๋, ๊ธฐ์ค์ด ๋๋ ์ซ์๊ฐ ๊ฐ์ง ์ ์๋ ๊ธฐ๋ณธ์ ์ธ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ํ๋ด๊ธฐ ์ํด์์ด๋ค.
2๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํด๋ณด์.
์์ 1์ ๊ธฐ์ค์ผ๋ก ๊ฐ ์ซ์๊ฐ ๊ฐ์ง ์ ์๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋ด์ ๋ฐฐ์ด์ ๊ทธ๋๋ก ๋ฐ์์จ๋ค.
2๋ ( 1 + 1 ) ๊ณผ ( 2 ) -> ์๊ธฐ ์์ // array[2] = array[2] + array[0]
3์ ( 1 + 1 + 1 ) ๊ณผ ( 2 + 1 ) -> ์๊ธฐ ์์ // array[3] = array[3] + array[1]
4๋ 1 + 1 + 1 + 1 ๊ณผ 2 + ( 1 + 1 ) ๊ณผ 2 + ( 2 ) -> ์๊ธฐ ์์ // array[4] = array[4] + array[2]
5๋ 1 + 1 + 1 + 1 + 1 ๊ณผ 2 + ( 1 + 1 + 1 ) ๊ณผ 2 + ( 2 + 1 ) -> ์๊ธฐ ์์ // srray[5] = array[5] + array[3]
์จ๋๊ณ ๋ณด๋๊น ์ด์ ์์ผ ๋ฐ๋ณต๋๋ ์์๊ฐ ๋ณด์ธ๋ค ...
์ด ๊ท์น์ ์ค์ค๋ก ์ฐพ์ ๋๊น์ง ๋ฌธ์ ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ํ์ด์ผ๊ฒ ๋ค ์ดํ ...!
5๋ ์๊ธฐ ์์ 1์ ํฌํจํด, ์ด 4๊ฐ์ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ฐ๋๋ค. result ๊ฐ 4๋๊น !!~!! ์ ๋ต์ด๋ค ์ ๋ต
๐ ์ฝ๋
function solution (n, money){
let arr = new Array(n+1).fill(0);
arr[0] = 1;
for(let el of money){
for(let i=el; i<n+1; i++){
arr[i] = arr[i] + arr[i - el];
}
}
return arr[n];
}
๐ ๊นจ๋ฌ์ ์
๋ฐ๋ณต์ ์ผ๋ก ๊ตฌํด์ผํ๋ ์์ ๊ฐ๋ค์ ๋ฐฐ์ด์ ์ ์ฅํด, ํฐ ๊ฐ์ ๊ตฌํ ๋ ์ง์์ ์ผ๋ก ์ฐธ์กฐํ๋ ๊ฑธ ๋ณผ ์ ์์๋ค.
๊ณต๊ฐ ๋ณต์ก๋๋ ์ ๊ณ ... ์จ์ผํ๋ ์์๋ ์ ์์ง๋ง ๊ท์น์ ์ฐพ๋ ๊ฒ ์ ๋ง ์ด๋ ค์ด ๋ฌธ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ ์กฐํฉ๊ณผ ์์ด, ์ค๋ณต ์กฐํฉ์ ์์ ์์ฌ๋ก ์ฌ์ฉํ์ง ๋ชปํด์ ๋ ์์ ๋ชป๋์ง ์์๋ ์ถ๋ค.
๋ ๋ง์ ๋ฌธ์ ๋ค์ ์ ํ๋ฉด์ ๋์ ์ต๋๋ก ๋ ธ๋ ฅํด์ผ๊ฒ ๋ค.
๊ทธ๋ฆฌ๊ณ ์ธ๋ฑ์ค๋ ์ซ์๋ก ํ์ฉํด์ ๋ณต์ก๋๋ฅผ ์ค์๋ค๊ณ ํด์ผํ๋ ...? ์ฌํผ ๋ฐ์๊ณผ ์ ๋ฆฌ !!! ์ค์ํ๋ค.