[๋ฐฑ์ค] 9657๋ฒ - ๋ ๊ฒ์ 3 (C++)

๋ฌธ์
๋ ๊ฒ์์ ๋ ๋ช ์ด์ ์ฆ๊ธฐ๋ ์ฌ๋ฐ๋ ๊ฒ์์ด๋ค.
ํ์ ์์ ๋ N๊ฐ๊ฐ ์๋ค. ์๊ทผ์ด์ ์ฐฝ์์ด๋ ํด์ ๋ฒ๊ฐ์๊ฐ๋ฉด์ ๋์ ๊ฐ์ ธ๊ฐ๋ฉฐ, ๋์ 1๊ฐ, 3๊ฐ ๋๋ 4๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ค. ๋ง์ง๋ง ๋์ ๊ฐ์ ธ๊ฐ๋ ์ฌ๋์ด ๊ฒ์์ ์ด๊ธฐ๊ฒ ๋๋ค.
๋ ์ฌ๋์ด ์๋ฒฝํ๊ฒ ๊ฒ์์ ํ์ ๋, ์ด๊ธฐ๋ ์ฌ๋์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๊ฒ์์ ์๊ทผ์ด๊ฐ ๋จผ์ ์์ํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. (1 โค N โค 1000)
์ถ๋ ฅ
์๊ทผ์ด๊ฐ ๊ฒ์์ ์ด๊ธฐ๋ฉด SK๋ฅผ, ์ฐฝ์์ด๊ฐ ๊ฒ์์ ์ด๊ธฐ๋ฉด CY์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1 ๋ณต์ฌ
6
์์ ์ถ๋ ฅ 1 ๋ณต์ฌ
SK
ํ์ด๊ณผ์
๋๊ฒ์, ๋๊ฒ์ 2 ๋์๋ ์ ํ์๋ง ์๊ฐํด์ ๊ฐ๋จํ๊ฒ ํ์ด๊ฐ ๊ฐ๋ฅํ์๋๋ฐ
๋๊ฒ์ 3๋ถํฐ๋ "๋์ 1๊ฐ, 3๊ฐ ๋๋ 4๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ค." ๋ผ๋ ์กฐ๊ฑด์ด ์ถ๊ฐ๊ฐ ๋์ด์ ์ ํ์์ ์ธ์ฐ๋ ค๊ณ ํ๋ฉด ์ด๋ป๊ฒ๋
์ธ์ธ ์ ์์๊ฑฐ๊ฐ์๋ฐ. ์๊ณ ๋ฆฌ์ฆ ๋ถ๋ฅ๊ฐ dp์ธ ๋งํผ dp๋ก ์ ๊ทผํด์ ํ์ด๋ณด์์ต๋๋ค.
๋ | 1๊ฐ | 2๊ฐ | 3๊ฐ | 4๊ฐ |
์น์ | SK | CY | SK | SK |
์ด์ ์ ํ์๋ ํด์ฌ๋ฌธ์ ์ฒ๋ผ dp๋ผ๋ ๊ฒ ์์ฒด๊ฐ ์ด์ ์ ๋ง๋ค์ด์ง ๊ฐ๋ค์ ์ฐธ์กฐํด์ ํ์ฌ์ ๊ฐ์ ๊ตฌํด๋ด๋ ๋ฐฉ์์ด๋ฏ๋ก
์กฐ๊ฑด์ ๋๊ฐ์ด ์๊ฐํด์ ์ด์ ์ ๊ฐ์ ์ฐธ์กฐํ๋ ๋ฐฉ์์ผ๋ก ์์ ์ธ์ ์ต๋๋ค.
๋ | 1๊ฐ | 2๊ฐ | 3๊ฐ | 4๊ฐ | 5๊ฐ |
์น์ | SK | CY | SK | SK | ? |
์กฐ๊ฑด์์ 5๊ฐ์ ๋์ ๊ฐ์ง๊ณ ์๋ ์ํฉ์ด ์๋ค๊ณ ๊ฐ์ ์ ํด๋ณด์.
์ง๊ธ ๊ตฌํด์ผํ๋๊ตฌํด์ผ ํ๋ ๊ฒ์ ๋์ด 5๊ฐ์ผ ๋์ ์น์๋ฅผ ๊ตฌํด์ผ ํ๋๋ฐ 5๊ฐ์ผ ๋์ ์น์๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์ด์ ์ ๊ฐ๋ค์ ์ฐธ์กฐํด์ ์์ธก์ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
"๋์ 1๊ฐ, 3๊ฐ ๋๋ 4๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ค." ๋ผ๊ณ ๋ฌธ์ ์์ ๋ช ์๊ฐ ๋์ด์๊ธฐ ๋๋ฌธ์
์ฆ 5๊ฐ - 1๊ฐ, 5๊ฐ - 3๊ฐ, 5๊ฐ - 4๊ฐ์ ์น์๋ฅผ ๋ฏธ๋ฆฌ ์๊ณ ์๋ค๋ฉด ๋๊ฐ ์ด๊ธธ์ง ์์ธก์ ํ ์ ์๋ ์์ด๋ค.
์๋ฅผ ๋ค์ด ๊ฒ์์ ์์์ ์๊ทผ์ด๊ฐ ํ๋ค๊ณ ๋ฌธ์ ์์ ๋ช ์๊ฐ ๋์ด์์ด ์๊ทผ์ด๊ฐ 5๊ฐ์์ ๋์ 3๊ฐ๋ฅผ ๊ฐ์ ธ๊ฐ๋ค๋ฉด ๋จ์ ๋์ ๊ฐ์๋ 2๊ฐ์ด๊ณ
๋์ ๊ฐ์๊ฐ 2๊ฐ์ ๊ฒฝ์ฐ ๋จผ์ ์ ๊ณต์๊ฐ SK์ด ์ผ ๋ ์น์๊ฐ CY๊ฐ ๋๋ค๋ ๊ฒ์ ์ด๋ฏธ ์๊ณ ์์ผ๋ฏ๋ก ๋๊น์ง ๊ณ์ฐ์ ํด๋ณด์ง ์์๋ ์์ธก์ด ๊ฐ๋ฅํ๋ค.
์ด๋ฌํ ๋ฐฉ์์ผ๋ก dp์์ ์ธ์ธ ์ ์๊ณ , ์ ๊ณต์๊ฐ SK์ด๋ค ๋ณด๋ SK๋ n - 1, n - 3, n - 4 ์ค์ ๋ณธ์ธ์ด ์น๋ฆฌํ ์ ์๋ ๊ฒฝ์ฐ์ ์๊ฐ 1๊ฐ๋ผ๋ ์๋ ๊ฒฝ์ฐ SK๋ ์ด๊ธฐ๊ฒ ๋๋ค.
์ด๋ฌํ ํ์์ผ๋ก ์๊ฐ์ ํ๊ณ ์ฝ๋๋ก ์ฎ๊ฒจ์ ๋ฌธ์ ํด๊ฒฐ์ ์งํํ์๋ค.
code
#include <iostream>
int dp[1001] = {0};
// SK = 0, CY = 1
void stone(int n)
{
dp[1] = 0;
dp[2] = 1;
dp[3] = 0;
dp[4] = 0;
for(int i = 5; i <= n; i++) {
if (dp[i - 1] == 1 || dp[i - 3] == 1 || dp[i - 4] == 1)
dp[i] = 0;
else
dp[i] = 1;
}
}
int main(void)
{
int n;
std::cin >> n;
stone(n);
if (dp[n] == 0) std::cout << "SK";
else std::cout << "CY";
return (0);
}


ํ๊ธฐ
์ฒ์์ stone์์ ์๋ ์กฐ๊ฑด์์์ ์กฐ๊ฑด์ ๋ฐ๋๋ก ์๊ฐํด์ ์๊พธ ํ๋ ธ์๋ค.
๋ก์ง์ ์กฐ๊ธ ๋ ์ ์คํ๊ฒ ์๊ฐํ๋ ๋ ธ๋ ฅ์ ํด์ผํ ๊ฑฐ ๊ฐ๋ค.