ํจ์ง์ด๋ ๋ฉ๋ฆฌ ๋ฐ๊ธฐ๋ฅผ ์ฐ์ตํ๊ณ ์์ต๋๋ค. ํจ์ง์ด๋ ํ๋ฒ์ 1์นธ, ๋๋ 2์นธ์ ๋ธ ์ ์์ต๋๋ค. ์นธ์ด ์ด 4๊ฐ ์์ ๋, ํจ์ง์ด๋
(1์นธ, 1์นธ, 1์นธ, 1์นธ)
(1์นธ, 2์นธ, 1์นธ)
(1์นธ, 1์นธ, 2์นธ)
(2์นธ, 1์นธ, 1์นธ)
(2์นธ, 2์นธ)
์ 5๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๋งจ ๋ ์นธ์ ๋๋ฌํ ์ ์์ต๋๋ค. ๋ฉ๋ฆฌ๋ฐ๊ธฐ์ ์ฌ์ฉ๋ ์นธ์ ์ n
์ด ์ฃผ์ด์ง ๋, ํจ์ง์ด๊ฐ ๋์ ๋๋ฌํ๋ ๋ฐฉ๋ฒ์ด ๋ช ๊ฐ์ง์ธ์ง ์์๋ด, ์ฌ๊ธฐ์ 1234567๋ฅผ ๋๋ ๋๋จธ์ง๋ฅผ ๋ฆฌํดํ๋ ํจ์, solution
์ ์์ฑํ์ธ์. ์๋ฅผ ๋ค์ด 4๊ฐ ์
๋ ฅ๋๋ค๋ฉด, 5๋ฅผ returnํ๋ฉด ๋ฉ๋๋ค.
n
์ 1์ด์, 2000์ดํ์ธ ์ ์์ด๋ค.n | result |
---|---|
4 | 5 |
3 | 3 |
์์์ ์ค๋ช ํ ๋ด์ฉ๊ณผ ๊ฐ์ต๋๋ค.
(2์นธ, 1์นธ)
(1์นธ, 2์นธ)
(1์นธ, 1์นธ, 1์นธ)
์ด 3๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ๋ฉ๋ฆฌ ๋ธ ์ ์์ต๋๋ค.
๊ท์น์ ์ฐพ๊ธฐ ์ํด ์ด ์นธ์ด 1์นธ์ผ ๋๋ถํฐ 5์นธ์ผ ๋๊น์ง ๋์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ ๋ฒ ์ ์ด๋ณด์๋ค.
์ฌ๊ธฐ์ ์ฐพ์ ๊ท์น์, ์ด ์นธ์ด N์ธ ๊ฒฝ์ฐ N-1์นธ์ผ ๋ ๊ฒฝ์ฐ์ ์์ N-2์นธ์ผ ๋ ๊ฒฝ์ฐ์ ์์ ํฉ์ด๋ผ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด, ์ด 4์นธ์ผ ๋์ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
๋ 2์นธ์ผ ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ + 3์นธ์ผ ๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์
์ด๋ค.
์ด ๊ท์น์ Dynamic Programming์ ์ ์ฉ์์ผ ๊ตฌํ์ ํด ๋ณด์๋ค.
class Solution {
public long solution(int n) {
long[] dp = new long[n + 1];
dp[1] = 1;
dp[2] = 2;
if (n == 1) {
return 1;
}
else if (n == 2) {
return 2;
}
else {
for (int i = 3; i <= n; i++) {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1234567;
}
}
return dp[n];
}
์ค๋ณต๋๋ ๊ณ์ฐ์ ๋ฒ์๋ฅผ ์ค์ด๊ธฐ ์ํด ๋ฐฐ์ด์ ํ๋ ์์ฑํด์ฃผ์๊ณ ,
์ด ์นธ์ด 1์ธ ๊ฒฝ์ฐ์ 1์, 2์ธ ๊ฒฝ์ฐ์ 2๋ฅผ ๋ฏธ๋ฆฌ ์ ์ฅํด ์ฃผ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ด ์นธ์ด 3์ธ ๊ฒฝ์ฐ๋ถํฐ n
์นธ์ธ ๊ฒฝ์ฐ๊น์ง ์์์ ์ฐพ์ ๊ท์น์ ์ ์ฉํด ์ฃผ๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์..
๋ ์ค ์์๋ค.
๋ฐํ์ ์๋ฌ๋ผ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ฌธ์ ๊ฐ ์๋ ์ถ์ด,
long[] dp = new long[2000];
๋ฐฐ์ด์ ์์ฑํ ๋ ํฌ๊ธฐ๋ฅผ n+1
๋์ , 2000
์ด๋ผ๋ ์์๊ฐ์ ๋ฃ์ด์ฃผ๋
๋ฌธ์ ๊ฐ ํด๊ฒฐ๋์๋ค!
n
์ผ๋ก 1์ด ๋ค์ด์ฌ ๋
dp[2] = 2;
์ด ๋ผ์ธ์์ 2๋ฒ ์ธ๋ฑ์ค์ ์ ๊ทผํ ์ ์์๊ธฐ ๋๋ฌธ์ด์๋ค.
์์ผ๋ก ์ด๊ธฐ๊ฐ ์ค์ ํ ๋ ์ฃผ์ํ๊ธฐ..!
ํ๋ํ๋๐โโ๏ธโโก๏ธ๐โโ๏ธโโก๏ธ๐โโก๏ธ