https://school.programmers.co.kr/learn/courses/30/lessons/12914
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋ฌธ์ ์ค๋ช
ํจ์ง์ด๋ ๋ฉ๋ฆฌ ๋ฐ๊ธฐ๋ฅผ ์ฐ์ตํ๊ณ ์์ต๋๋ค. ํจ์ง์ด๋ ํ๋ฒ์ 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 ์ด๋ ํ์ผ์ ๊ฐ์ ธ์ 1111 ,121, 112, 211 ์ฒ๋ผ ์์ด๊ณผ ๊ฐ์ dfs ๋ก ํ์ด์ผํ๋, ๊ณ ๋ฏผ์ ํ์ต๋๋ค. ํ์ง๋ง ์ ํ์ฌํญ์ ๋ณด๋ฉด n ์ 2000 ์ด๊ณ ์ด๋ฐ ์๋๋ ์ ๋ชป๋ ๊ฑธ ์ ์ ์์์ฃ .
์ด ๋ฌธ์ ๋ ํ์ด๋ฒ์ ์์ฃผ ์ฌ์ด ๋ฌธ์ ์ด์ง๋ง, ์ด ํ์ด๋ฒ์ ๋ ์ฌ๋ฆฌ๋ ๊ฒ ๋ ์ด๋ ค์ด ๋ฌธ์ ์ธ ๊ฒ ๊ฐ์ต๋๋ค.
๋จผ์ ๋ฌธ์ ํ์ด ์ ๊ทผ๋ฒ์ ๋ง์๋๋ฆฌ์๋ฉด, ์ด ๋ฌธ์ ๋ dp๋ก ํ์ด์ผํฉ๋๋ค.
DP๋ฅผ ์ฌ์ฉํ ์ ์๋ ๋ฌธ์ ์ ์์
1. ํผ๋ณด๋์น ์์ด: ํผ๋ณด๋์น ์์ด์ n๋ฒ์งธ ๊ฐ์ ๊ณ์ฐํ ๋ F(n) = F(n-1) + F(n-2) ํํ๋ก ์ ์๋๋ฉฐ, DP๋ก ํจ์จ์ ์ผ๋ก ๊ณ์ฐํ ์ ์์ต๋๋ค.
2. ์ต์ ๊ฒฝ๋ก ๋ฌธ์ : ์๋ฅผ ๋ค์ด, 2์ฐจ์ ๊ฒฉ์์์ ์ข์๋จ์์ ์ฐํ๋จ๊น์ง ๊ฐ๋ ๊ฒฝ๋ก์ ์ต์ ๋น์ฉ์ ๊ตฌํ๋ ๋ฌธ์ ๋ DP๋ก ํด๊ฒฐํ ์ ์์ต๋๋ค.
3. ๋์ ๊ตํ ๋ฌธ์ : ์ฃผ์ด์ง ๊ธ์ก์ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ต์ ๋์ ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ๋ DP๋ก ํด๊ฒฐํ ์ ์์ต๋๋ค.
์ด ์ค ์ด๋ฌธ์ ๋ ํผ๋ณด๋์น ์์ด์ ํ์ฉํ์ฌ ํ์ด์ผํ๋ ๋ฌธ์ ์ ๋๋ค.
ํ์ด์ ์ ํ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
dp[n] = dp[n-1] + dp[n-2]
ํจ์ง์ด๊ฐ n๋ฒ์งธ ์นธ์ ๋๋ฌํ๋ ๋ฐฉ๋ฒ์ ๋ค์ ๋ ๊ฐ์ง๋ก ๋๋ฉ๋๋ค.
1. n-1๋ฒ์งธ ์นธ์์ 1์นธ ๋ฐ์ด์ ๋์ฐฉํ ๊ฒฝ์ฐ
2. n-2๋ฒ์งธ ์นธ์์ 2์นธ ๋ฐ์ด์ ๋์ฐฉํ ๊ฒฝ์ฐ
์ด ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ํฉ์น๋ฉด, n๋ฒ์งธ ์นธ์ ๋๋ฌํ๋ ์ด ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ตฌํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ n๋ฒ์งธ ์นธ์ ๋๋ฌํ๋ ๋ฐฉ๋ฒ์ ์๋ dp[n-1] (1์นธ ๋ฐ๊ธฐ)์ dp[n-2] (2์นธ ๋ฐ๊ธฐ)์ ํฉ์
๋๋ค.
์๋ฅผ ๋ค์ด ํจ์ง์ด๊ฐ 4๋ฒ์งธ ์นธ์ ๋๋ฌํ๋ ๋ฐฉ๋ฒ์ 3๋ฒ์งธ ์นธ์์ ํ ์นธ ์์ง์ด๋ ๋ฐฉ๋ฒ๊ณผ 2๋ฒ์งธ ์นธ์์ ๋ ์นธ ์์ง์ด๋ ๋ฐฉ๋ฒ 2๊ฐ์ง๊ฐ ์๋ค๋ ๊ฒ์ ๋๋ค.
์ ๋ต ํ์ด
class Solution {
public int solution(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = (dp[i - 1] + dp[i - 2]) % 1234567;
}
return dp[n];
}
}
๋จผ์ n์ด 2000 ์ดํ ์์ฐ์์ด๋ฏ๋ก 1๊ณผ 2์ผ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด ์ค์ผํฉ๋๋ค. ์ ํ์์ n -1 ๊ณผ n - 2๋ก ์ธ์ฐ๊ธฐ ๋๋ฌธ์ ์ฒซ ์๊ฐ 3์ด๊ธฐ ๋๋ฌธ์ ๋๋ค. ๋ง์ฝ n์ด 3์ด์ 2000์ดํ์๋ค๋ฉด ์ด ๊ณผ์ ์ด ํ์๊ฐ ์์ต๋๋ค.
๋ฐ๋ณต๋ฌธ์์ ๋ชจ๋๋ฌ ์ฐ์ฐ์ด ์ฐ์ ๋๋ค. ์ด๋ค ๊ฐ์ ๋๋ ๋๋จธ์ง์ ๋ ๊ทธ ๋๋จธ์ง๋ฅผ ๋ํ๋ฉด ๋ ์๋ฅผ ๋ํ ๊ฒ๊ณผ ์ด๋ค ๊ฐ์ ๋๋ ๋๋จธ์ง๊ฐ ๊ฐ์์ง๋๋ค. ์๋ฅผ ๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
9 % 5 = 4
19 % 5 = 4
28 % 5 = 8 % 5
๋๋จธ์ง 4์ ๋๋จธ์ง 4๋ฅผ ๋ํ๊ณ ๋ค์ 5๋ก ๋๋์ด๋ 9์ 19์ ํฉ์ 5๋ก ๋๋ ๋๋จธ์ง์ ๊ฐ์์ง์ฃ .
์ ์ดํด๊ฐ ์๋์๋ ๋ถ์ ๊ตฌ๊ธ์ ๋ชจ๋๋ฌ ์ฐ์ฐ์ ๊ฒ์ํด๋ณด์๋ฉด ๋์ฑ ์์ธํ ์ค๋ช ์ ์ฐพ์ผ์ค ์ ์์ต๋๋ค.
์ ๋ต ํ์ด๋ ๋๋ฌด ๊ฐ๋จํ์ฃ ? ํ์ง๋ง ์ด ํ์ด๋ฅผ ์ ๋ ์ฒจ์ ๋ ์ฌ๋ฆฌ์ง ๋ชปํ์ฌ ๋ฆฌ๋ง์ธ๋ํ ๊ฒธ ์ด๋ ๊ฒ ๊ธ์ ๋จ๊ฒจ๋ด ๋๋ค.
์ด ๋ฌธ์ ์ ์์ ๋น์ทํ ๋ฌธ์ ๊ฐ ํ๋ ๋ ์๋๋ฐ, ๊ฐ์ด ์ฒจ๋ถํ๋๋ก ํ๊ฒ ์ต๋๋ค.
์ด ๋ฌธ์ ๋ก ๋ค์ ํ ๋ฒ ์๋ํด๋ณด์ธ์.
https://school.programmers.co.kr/learn/courses/30/lessons/12900
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
๋๊ธ