๋ฌธ์
๋ ๊ฒ์์ ๋ ๋ช ์ด์ ์ฆ๊ธฐ๋ ์ฌ๋ฐ๋ ๊ฒ์์ด๋ค.
ํ์ ์์ ๋ N๊ฐ๊ฐ ์๋ค. ์๊ทผ์ด์ ์ฐฝ์์ด๋ ํด์ ๋ฒ๊ฐ์๊ฐ๋ฉด์ ๋์ ๊ฐ์ ธ๊ฐ๋ฉฐ, ๋์ 1๊ฐ, 3๊ฐ ๋๋ 4๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ค. ๋ง์ง๋ง ๋์ ๊ฐ์ ธ๊ฐ๋ ์ฌ๋์ด ๊ฒ์์ ์ด๊ธฐ๊ฒ ๋๋ค.
๋ ์ฌ๋์ด ์๋ฒฝํ๊ฒ ๊ฒ์์ ํ์ ๋, ์ด๊ธฐ๋ ์ฌ๋์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๊ฒ์์ ์๊ทผ์ด๊ฐ ๋จผ์ ์์ํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 1,000,000,000,000)
์ถ๋ ฅ
์๊ทผ์ด๊ฐ ๊ฒ์์ ์ด๊ธฐ๋ฉด SK๋ฅผ, ์ฐฝ์์ด๊ฐ ๊ฒ์์ ์ด๊ธฐ๋ฉด CY์ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1 ๋ณต์ฌ
6
์์ ์ถ๋ ฅ 1 ๋ณต์ฌ
SK
ํ์ด๊ณผ์
์ด ๋ฌธ์ ๋ํ "๋์ 1๊ฐ, 3๊ฐ ๋๋ 4๊ฐ ๊ฐ์ ธ๊ฐ ์ ์๋ค." "๊ฒ์์ ์๊ทผ์ด๊ฐ ๋จผ์ ์์ํ๋ค." ๋ผ๋ 2๊ฐ์ ์กฐ๊ฑด ์์์
๊ท์น์ฑ์ ์ฐพ์์ผํ๋ ๋ฌธ์ ์๋ค.
#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;
for(int i = 1; i <= n; i++) {
stone(i);
std::cout << i << " ";
if (dp[i] == 0) std::cout << "SK" << "\n";
else std::cout << "CY" << "\n";
}
return (0);
}
๊ทธ๋์ 9657๋ฒ - ๋ ๊ฒ์ 3์์ ์ฌ์ฉํ๋ ์ฝ๋๋ฅผ ์์ฉํ๋ ๋ฐฉ์์ผ๋ก ์ํ๋ n๊ฐ๊น์ง์ ์ถ๋ ฅ๊ฐ์ ๋ฝ์๋ด๋ ๋ฐฉ์์ผ๋ก ๊ท์น์ฑ์ ์ฐพ์ ๊ฒฐ๊ณผ๊ฐ์ ์ฐพ์์์ต๋๋ค.
์์ ๊ฐ์์ ๊ท์น์ฑ ๊ฐ์ ๊ฒฝ์ฐ์๋ SK์ ์น๋ฆฌ์ ๊ฒฝ์ฐ 1, 3, 4, 6, 7, 9 ์ด๊ธฐ๋๋ฌธ์ ๋ฑ์ฐจ์์ด ๊ท์น์ฑ(+2, +1 ...)์
๊ฐ์ง๊ณ ์๋๊ฒ์ ์๊ฒ๋์๋ค.
๊ทธ๋์ ๊ฒฐ๊ณผ๊ฐ์์ฒด์ ๊ท์น์ฑ์ ๊ฐ์ง๊ณ ์๋ค๋ ๊ฒ์ ์๊ฒ๋์๊ณ , 7๊ฐ ๋จ์๋ก ์ชผ๊ฐ์ด ๋ณด์์๋
์์ ๊ฒฐ๊ณผ๊ฐ์์์ 1~7๊ณผ 8~14๊ฐ ๋๊ฐ์ ๊ท์น์ ๊ฐ์ง๊ณ ์๋๊ฒ์ ๋ฐ๊ฒฌํ์ฌ 7๋ก ๋๋ด์ ๋ ๋๋จธ์ง๊ฐ 0 ํน์ 2๋ก๋ง ๋์จ๋ค๋ ๊ฒ์ ๋ฐ๊ฒฌํ์ฌ ์ฝ๋์ ๋์ ์ ํ์์ต๋๋ค.
code
#include <iostream>
int main(void)
{
long long n;
std::cin >> n;
if (n % 7 == 0 || n % 7 == 2) std::cout << "CY";
else std::cout << "SK";
return (0);
}
ํ๊ธฐ
๊ท์น์ฑ์ ์ฐพ๋๊ณผ์ ์ ๋ ์ด๋ ค์ด ๊ฑฐ ๊ฐ๋ค.
'Algorithm > ๋ฌธ์ ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 2628๋ฒ - ์ข ์ด์๋ฅด๊ธฐ (C++) (0) | 2023.07.14 |
---|---|
[๋ฐฑ์ค] 9661๋ฒ - ๋ ๊ฒ์ 7 (C++) (0) | 2023.07.13 |
[๋ฐฑ์ค] 9659๋ฒ - ๋ ๊ฒ์ 5 (C++) (0) | 2023.07.13 |
[๋ฐฑ์ค] 9658๋ฒ - ๋ ๊ฒ์ 4 (C++) (0) | 2023.07.13 |
[๋ฐฑ์ค] 9657๋ฒ - ๋ ๊ฒ์ 3 (C++) (0) | 2023.07.12 |