1. ๋ฌธ์ ์ค๋ช
๋ฌธ์ ์ค๋ช
๊ฐ๋ก ๊ธธ์ด๊ฐ 2์ด๊ณ ์ธ๋ก์ ๊ธธ์ด๊ฐ 1์ธ ์ง์ฌ๊ฐํ ๋ชจ์์ ํ์ผ์ด ์์ต๋๋ค. ์ด ์ง์ฌ๊ฐํ ํ์ผ์ ์ด์ฉํ์ฌ ์ธ๋ก์ ๊ธธ์ด๊ฐ 3์ด๊ณ ๊ฐ๋ก์ ๊ธธ์ด๊ฐ n์ธ ๋ฐ๋ฅ์ ๊ฐ๋ ์ฑ์ฐ๋ ค๊ณ ํฉ๋๋ค. ํ์ผ์ ์ฑ์ธ ๋๋ ๋ค์๊ณผ ๊ฐ์ด 2๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค
- ํ์ผ์ ๊ฐ๋ก๋ก ๋ฐฐ์น ํ๋ ๊ฒฝ์ฐ
- ํ์ผ์ ์ธ๋ก๋ก ๋ฐฐ์น ํ๋ ๊ฒฝ์ฐ
์๋ฅผ๋ค์ด์ n์ด 8์ธ ์ง์ฌ๊ฐํ์ ๋ค์๊ณผ ๊ฐ์ด ์ฑ์ธ ์ ์์ต๋๋ค.
์ง์ฌ๊ฐํ์ ๊ฐ๋ก์ ๊ธธ์ด n์ด ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ด ์ง์ฌ๊ฐํ์ ์ฑ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฅผ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ๊ฐ๋ก์ ๊ธธ์ด n์ 5,000์ดํ์ ์์ฐ์ ์ ๋๋ค.
- ๊ฒฝ์ฐ์ ์๊ฐ ๋ง์ ์ง ์ ์์ผ๋ฏ๋ก, ๊ฒฝ์ฐ์ ์๋ฅผ 1,000,000,007์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ returnํด์ฃผ์ธ์.
์ ์ถ๋ ฅ ์
n | result |
---|---|
4 | 11 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
๋ค์๊ณผ ๊ฐ์ด 11๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค.
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉํ ์คํธ ์ฐ์ต
2. ๋ฌธ์ ํ์ด
keyword
: stack-up ํ๋ DP, ๋ชจ๋๋ฌ ๋ถ๋ฐฐ ๋ฒ์น
์ ํ๋ ค์ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ดค๋ค. ๊ทธ ์ค์์๋ ์ดํด๊ฐ ์ ์ผ ์๊ฐ๋ ํ์ด๋ก ์ค๋ช ํ๊ฒ ๋ค.
(1) ์ฌ์ ์ง์
๋จผ์ ์ฌ์ฉ ๋๋ ํ์ผ์ด 1 x 2 ์ง๋ฆฌ ํ์ผ์ด๋ฏ๋ก, ํ์ ์นธ์ ๋ฐ๋ฅ์ ๋ฌด์กฐ๊ฑด ์ฑ์ฐ์ง ๋ชปํ๋ค.
๋ฐ๋ผ์, DP์ stackup ๋๋ ๊ท์น์ฑ์ ๊ตฌํ๊ธฐ ์ํด์๋, ์ง์ ์นธ์ผ๋ก๋ง ์๊ฐ ํด์ผํ๋ค. ๊ทธ๋ผ n= 2๋ถํฐ n = 8 ๊น์ง ๊ฐ์ด ์์๋ณด๊ณ ๊ท์น์ฑ์ ์ฐพ์๋ณด์.
โ n=2 ์ผ ๋,
n=2์ธ ๋ฐ๋ฅ์ ์ ๋ถ ์ฑ์ฐ๋ ๊ฒฝ์ฐ๋ ์์ 3๊ฐ์ง์ด๋ค.
โ n=4 ์ผ ๋,
์, ์ด์ ๋ถํฐ ์ง์คํด์ผ ํ๋ค.
n=4์ธ ๋ฐ๋ฅ์ ํ์ผ๋ก ์ฑ์ธ ๋๋ ๋ค์ 2๊ฐ์ง์ ์ ํ์ด ์กด์ฌํ๋ค.
์ฒซ ๋ฒ์งธ๋ก, ์ด์ ๊ฒ๋ค์ ์กฐํฉํด ์ฑ์ฐ๋ ๊ฒฝ์ฐ์ด๋ค.
n=2์ธ ํ์ผ์์ 2์นธ ๋ ์ถ๊ฐํด์ ์ด์ด๋๊ฐ๋ค๊ณ ๊ฐ์ ํ์. ์ด๋ ์ ์ถ๊ฐ๋ ๋ฌผ์ํ์ ๋ฌด์์ด ๋ค์ด๊ฐ๊น?
๋น์ฐํ๊ฒ๋, n=2์์ ๋์๋ 3๊ฐ์ง ๊ฒฝ์ฐ์ ์์ด๋ค. ๊ทธ๋ ๋ค๋ฉด ๊ฐ ๊ฒฝ์ฐ๋ง๋ค 3๊ฐ์ง ๋ฒ์ ์ด ๋ ์๊ธฐ๋ฏ๋ก, 3 x 3 = 9๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ๋์จ๋ค.
๋ ๋ฒ์งธ๋ก, ์ด์ ๊ฒ๋ค์ ์กฐํฉํ์ง ์๋ ์์ ํ ์๋ก์ด ๊ฒฝ์ฐ์ด๋ค.
์๋๋ ์ด์ ๊ฒฝ์ฐ์ ์์ธ n=2 ํ์ผ์ ์กฐํฉํด์ ๋ง๋ค์๋ค๋ฉด, ์ด๋ฒ์๋ ๊ทธ ๊ฐ์์ ์์ญ์ ์นจ๋ฒํ์ฌ n=4 ๋ฅผ ์ฑ์ฐ๋ ๊ฒฝ์ฐ๋ค. ์ด๊ฑด ๊ทธ๋ฅ ์๊ฐํด๋ด๋ ์ ๋ฐ์ ์๋ค. ์์ ๊ฐ์ด 2๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๊ฒจ๋๋ค.
โ n=6 ์ผ ๋,
์ด๊ฒ๋ n=4์ ๋๊ฐ์ด 2๊ฐ์ง ์ ํ์ผ๋ก ๋๋์ด์ ์๊ฐํด์ผํ๋ค.
์ฒซ ๋ฒ์งธ, ์ด์ ์ ๊ณ์ฐํ ๊ฒ๋ค ์กฐํฉ
- n=4๊ฐ ์์ ๋์ค๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด์. n=4์ธ ํ์ผ์ ๊ฐ๋ ์ฑ์ฐ๋ ๊ฒฝ์ฐ์ ์๋ง๋ค, ๋๋จธ์ง n=2์ธ ํ์ผ์ ์ฑ์ฐ๋ 3๊ฐ์ง ๋ฃจํธ๊ฐ ์กด์ฌํ๋ค. ๋ฐ๋ผ์ f(4)*f(2)๊ฐ ๋๋ค.
- n=2๊ฐ ์์ ์ค๋ ๊ฒฝ์ฐ๋ ์๊ฐํด์ผํ๋ค.
n=4๋ฅผ ์ฑ์ฐ๋ ๊ฒฝ์ฐ์ ์ ์ค์ n=2์ธ ๊ฒฝ์ฐ 2๊ฐ์ง๋ฅผ ์กฐํฉํด์ ๋ง๋ ๊ฒ์ด ํฌํจ๋์ด ์๋๋ฐ ์ ๋ ์๊ฐํด์ผํ์ฃ ?
๋ผ๊ณ ์๋ฌธ์ด ๋ค ์ ์๊ฒ ๋ค. ๊ทธ ์ด์ ๋, n=4์ 2๋ฒ์งธ ์ ํ์ธ์กฐํฉ ํ์ง ์๊ณ ํ์ผ์ ์ ์ฒด ์ฑ์ฐ๋ ๊ฒฝ์ฐ์ ์
๋๋ฌธ์ด๋ค. n=2 ํ์ผ๋ง + n=4์ (2)๋ ์๋ก์ด ๊ฒฝ์ฐ์ ์๋ผ๊ณ ํ ์ ์๊ฒ ๋ค.
โป์ฃผ์์ โป
n=4์ ๋ ๋ฒ์งธ ์ ํ๋ n=4 ํ์ผ๋ง + n=2 ํ์ผ๋ง ์กฐํฉ์ ํฌํจ๋๋ค! ๋ค๋ง n=4์ ๋ ๋ฒ์งธ ์ ํ + n=2 ํ์ผ๋ง๊ณผ n=2ํ์ผ๋ง + n=4์ ๋๋ฒ์งธ ์ ํ์ ์์๊ฐ ๋ฌ๋ผ์ ์๋ก ๋ค๋ฅธ ๊ฒฝ์ฐ์ ์๋ก ์ฒดํฌ๋๊ธฐ ๋๋ฌธ์ ๋ค์ ์ธ์ด์ค ๊ฒ์ด๋ค.
๋ ๋ฒ์งธ, ์ด์ ๊ฒ๋ค์ ์กฐํฉํ์ง ์๋ ์์ ํ ์๋ก์ด ๊ฒฝ์ฐ
์ฌ๊ธฐ์๋ 2๊ฐ๋ค.
โ n=8์ผ ๋,
์ฒซ ๋ฒ์งธ, ์ด์ ๊น์ง ๋์จ ๊ฒฝ์ฐ์ ์๋ค์ ์กฐํฉํ๋ ๊ฒฝ์ฐ
๋ ์ค๋ช
ํ์ง ์์๋ ๋ ๊ฒ ๊ฐ๋ค.
- n=6 ํ์ผ๋ง x n=2 ํ์ผ๋ง์ผ๋ก ๋ง๋๋ ์กฐํฉ (์ด์ ํ์ผ๋ง ๊ฒฝ์ฐ์ ์ x n=2์ ํ์ผ๋ง ๊ฒฝ์ฐ์ ์)
- n=4, n=6 ์์ ๋์จ ์๋ก์ด ๊ฒฝ์ฐ๋ค์ ์ด์ฉํ ์กฐํฉ -> ์ด๊ฒ์ ์ง๊ธ๊น์ง ๊ณ์ 2๊ฐ์ฉ๋ง ๋์จ ๊ฒ์ผ๋ก ๋ฏธ๋ฃจ์ด ๋ณด์, ์์ผ๋ก๋ ๊ทธ๋ด ๊ฒ์ด๋ค. (๊ฐ๋ก๊ฐ n์ธ ๋ฐ๋ฅ์ ํ์ผ๋ง x 2)
๋ ๋ฒ์งธ, ์์ ํ ์๋ก์ด ๊ฒฝ์ฐ์ ์
ํญ์ 2๊ฐ์ง
์ ํ์ ๊ณ์ฐ
์ง๊ธ๊น์ง ์์๋ณธ ๊ท์น์ฑ์ผ๋ก ๊ฐ๋ก๊ฐ n์ธ ๋ฐ๋ฅ์ ์์ ํ ๋ฉ์ฐ๋ ๊ฒฝ์ฐ์ ์๋ ๋ค์๊ณผ ๊ฐ์ ์์ผ๋ก ๊ตฌํ ์ ์๋ค.
3. ์ฝ๋ ๋ถ์
class Solution {
public long solution(int n) {
long [] dp = new long [n+1];
// ์ด๊ธฐ ๊ฐ ์ค์
dp[2] = 3;
for(int i = 4; i <= n; i+=2){
// ์ด๊ธฐ ๊ฐ ์ค์ (์ด์ ๊บผ * dp[2] ์ธ ๊ฒฝ์ฐ์ ์ + ์์ญ ๋ฒ๋ํ์ฌ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ์ ์ 2๊ฐ)
dp[i] = dp[i-2]*dp[2] + 2;
// dp ๊ฐ ์์ฑ
for(int j = 2; j <= i-4; j+=2) {
dp[i] += dp[j]*2;
}
dp[i] = dp[i]%1000000007;
}
return dp[n];
}
}
๋ชจ๋๋ฌ ๋ถ๋ฐฐ๋ฒ์น์ ์ ๋ชฐ๋ผ์ ์ฌ์ฉํ์ง ๋ชปํ๋ค. ์ด๊ฒ๋ ์ด๋ก ๊ณต๋ถ ํด์ผ๊ฒ ๋ค.