๐๋ฌธ์ ๋ณด๋ฌ๊ฐ๊ธฐ
๐ง๐ป๐ปํ์ด ๊ณผ์
ํผ๋ณด๋์น ํจ์๋ฅผ ํธ์ถํ์ ๋, \( n = 0 \) ๋๋ \( n = 1 \)์ผ ๋์ 0๊ณผ 1์ ์ถ๋ ฅ ๊ฐ์๋ฅผ ์ธ์ผ ํฉ๋๋ค.
(์ฆ, ์ ๋ฌธ์ ์์ ์ฃผ์ด์ง ์์ค ์ฝ๋์์ if(n == 0)๊ณผ if (n==1)์ ํด๋นํ ๊ฒฝ์ฐ)
1. Top-down ๋ฐฉ์์ผ๋ก DP ๋ฐฐ์ด์ ํตํด ์ค๋ณต ๊ณ์ฐ ์ต์ํ ๋ฐฉ๋ฒ ์๋ (์คํจ)
ํผ๋ณด๋์น ํจ์๋ฅผ ์ฌ๊ท๋ก ๊ตฌํํ์ ๋์ ๋ฌธ์ ์ ์ด ๋ฐ๋ก ์ค๋ณต ๊ณ์ฐ์ ๋๋ค. ์ค๋ณต ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง๊ธฐ์ ์๊ฐ์ด ํฐ๋ฌด๋์์ด ๋ง์ด ๊ฑธ๋ฆฌ๋ ๊ฒ์ด๊ณ , ์ด๊ฒ์ ๊ฐ์ ํ๊ธฐ ์ํด DP ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ์ด๋ฏธ ๊ณ์ฐ๋ N์ด๋ผ๋ฉด ๊ณ์ฐํ์ง ์๋ ๊ฒ์ด์ฃ .
ํ์ง๋ง N == 0 ๋๋ N == 1์ด ๋ ๋๊น์ง ๋ด๋ ค๊ฐ์ผ ํ๋๋ฐ, ์ด๋ฏธ ๊ณ์ฐ๋ N์ด๋ผ๊ณ ํด์ ๊ณ์ฐ์ ์ค์งํด๋ฒ๋ฆฌ๋ฉด ์ ๋๋ก ๊ฐ์๋ฅผ ์ ์๊ฐ ์์ต๋๋ค. ๊ทธ๋ ๋ค๊ณ , ๋ค ๋ด๋ ค๊ฐ ๋ฒ๋ฆฌ๋ฉด DP ๋ฐฐ์ด์ ์ฐ๋ ์ด์ ๊ฐ ์๊ตฌ์.
๋ฐ๋ผ์ Top-down ๋ฐฉ์์์๋ N == 0 ๋๋ N == 1์ด ๋ ๋๊น์ง ๋ค ๋ด๋ ค๊ฐ์ง ์๋ ์ด์, ๋ฐฉ๋ฒ์ด ์๋ค๊ณ ํ๋จํ์๊ณ , Bottom-up ๋ฐฉ์์ผ๋ก ์๊ฐ์ ๋๋ฆฌ๊ฒ ๋์์ต๋๋ค.
2. Bottom-up ๋ฐฉ์์ผ๋ก 0๊ณผ 1์ ๊ฐ์ ์ ์ฅํด ๊ฐ๊ธฐ (์ฑ๊ณต)
ํผ๋ณด๋์น ์์ด์ ์ ํ์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
// fibonacci[0] = fibonacci[1] = 1
fibonacci[i] = fibonacci[i - 1] + fibonacci[i - 2]; // if) i >= 2
์ฌ๊ท๋ก ํผ๋ณด๋์น ์์ด์ ๊ตฌํ๋ ํจ์๋ฅผ ์งฐ์ ๋, N == 0 ๋๋ N == 1 ์ผ ๋๊ฐ ์ข ๋ฃ ์กฐ๊ฑด์ด๋ฉฐ, ๊ฐ๊ฐ 0๊ณผ 1์ ๋ฆฌํดํ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ fibonacci[i]๋ ์ด๋ฌํ 0๊ณผ 1๋ค์ด ๋ค ๋ํด์ ธ์ ์์ฑ๋ ์ซ์์ ๋๋ค.
์ฆ, ์์ ํผ๋ณด๋์น ์์ด์ ์ ํ์์ 0๊ณผ 1์ ๊ฐ์์์๋ ์ ์ฉ๋๋ค๋ ์๋ฏธ์ ๋๋ค.
fibonacci[i].zero = fibonacci[i - 1].zero + fibonacci[i - 2].zero;
fibonacci[i].one = fibonacci[i - 1].one + fibonacci[i - 2].one;
๋ฐ๋ผ์, DP[i] ๋ฐฐ์ด์ i๋ฒ์งธ ํผ๋ณด๋์น ์์ 0๊ณผ 1์ ๊ฐ์๋ฅผ ์ ์ฅํ๊ณ ์์ด์ผ ํฉ๋๋ค.
๋ฌธ์ ์กฐ๊ฑด์์ ์ ๋ ฅ์ ์ต๋ ๊ฐ์๊ฐ 40๊ฐ์ด๋ฏ๋ก, N = 40๊น์ง DP ๋ฐฐ์ด์ ์ฑ์ฐ๋๋ก ํ๊ณ , ๋ฌธ์ ์์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ์ซ์์ ์ธ๋ฑ์ค๋ก ์ฐพ์๊ฐ์ ๋ต์ ์ถ์ถํด ์ค๋ฉด ๋ฉ๋๋ค.
โ๏ธ์์ค ์ฝ๋ ๋ฐ ๊ฒฐ๊ณผ
#include <iostream>
#include <vector>
using namespace std;
using Count = pair<int, int>; // (0์ ๊ฐ์, 1์ ๊ฐ์)
void SetFastIO()
{
ios::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
}
int main()
{
SetFastIO();
const int MAX_INPUT_SIZE = 41;
vector<Count> dp(MAX_INPUT_SIZE);
dp[0] = Count(1, 0), dp[1] = Count(0, 1);
for (int i = 2; i < MAX_INPUT_SIZE; i++)
{
int sumOfZeroCount = dp[i - 1].first + dp[i - 2].first;
int sumOfOneCount = dp[i - 1].second + dp[i - 2].second;
dp[i] = Count(sumOfZeroCount, sumOfOneCount);
}
int testCase;
cin >> testCase;
for (int i = 0; i < testCase; i++)
{
int N;
cin >> N;
cout << dp[N].first << " " << dp[N].second << "\n";
}
return 0;
}
'๐คAlgorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] 1309๋ฒ | ๋๋ฌผ์ (C++) (0) | 2023.08.24 |
---|---|
[BOJ] 11048๋ฒ | ์ด๋ํ๊ธฐ (C++) (0) | 2023.08.23 |
[BOJ] 11726๋ฒ | 2xn ํ์ผ๋ง (C++) (0) | 2023.08.21 |
[BOJ] 9663๋ฒ | N-Queen (C++) (0) | 2023.05.01 |
[BOJ] 1018๋ฒ | ์ฒด์คํ ๋ค์ ์น ํ๊ธฐ (C++) (0) | 2023.04.13 |