[BOJ] ํ๋ ธ์ด ํ ์ด๋ ์์(11729)
[๋ฐฑ์ค(BOJ)] 11729_ํ๋ ธ์ด ํ ์ด๋ ์์ C++
๋ฌธ์ : BOJ_11729๋ฒ ํ๋ ธ์ด ํ ์ด๋ ์์
๋ฌธ์ ์ค๋ช
์ฌ๊ท
์ฌ๊ท ๋ฌธ์ ๋ก ์ ๋ช
ํ ํ๋
ธ์ด ํ ๋ฌธ์ ์
๋๋ค.
n์ ์
๋ ฅ๋ฐ์ผ๋ฉด ์ธ ๊ฐ์ ์ฅ๋ ์ค ์ฒซ ๋ฒ์งธ ์ฅ๋์ n ๊ฐ์ ํ์ด ์์ด๋ ๊ฒ์ผ๋ก ์์ํฉ๋๋ค.
n ๊ฐ์ ํ์ ๊ฐ์ฅ ์์ ์๋ ์ํ์ด ๊ฐ์ฅ ๊ฐ๋ณ๊ณ ์๋๋ก ๊ฐ์๋ก ๋ฌด๊ฑฐ์ด ์ํ์ด๋ฉฐ, ๊ฐ๋ฒผ์ด ์ํ ์์ ๋ฌด๊ฑฐ์ด ์ํ์ด ์ฌ๋ผ๊ฐ ์ ์์ต๋๋ค.
๊ฐ ์ฅ๋ ์ค ๊ฐ์ฅ ์์ ์๋ ์ํ์ ํ๋ ์ฎ๊ธฐ๋ ๊ฒ์ 1ํ๋ก ํ ๋, ์ต์ด์ ์ฒซ ๋ฒ์งธ ์ฅ๋์ ์์๋ ์ํ์ ๋ชจ๋ ์ธ ๋ฒ์งธ ์ํ์ผ๋ก ์ฎ๊ธฐ๋ ์ต์ ์ด๋ ํ์๋ฅผ ๊ตฌํ๋ ๊ฒ์ด ๋ฌธ์ ์
๋๋ค.
Solution
ํ์ฌ ์ฅ๋์ ์์น๋ฅผ st
, ์ด๋ํด์ผ ํ๋ ์ฅ๋์ ์์น๋ฅผ ed
, ๋๋จธ์ง ์ฅ๋๋ฅผ mid
๋ผ๊ณ ํฉ์๋ค.
์ฒ์์ n์ 3์ด๋ผ๊ณ ์
๋ ฅํ๋ฉด ์ฒซ ๋ฒ์งธ ์ฅ๋์ 3๊ฐ์ ์ํ์ด ๋์ฌ ์๋ ์ํฉ์ด ๋๊ณ , ์ด ์ํ์ ๋ชจ๋ 3๋ฒ์งธ ์ํ์ ์ฎ๊ฒจ์ผ ํฉ๋๋ค.
๊ฐ์ฅ ๋ฌด๊ฑฐ์ด 3๋ฒ์งธ ์ํ์ 3๋ฒ์งธ ์ฅ๋์ ์ฎ๊ธฐ๋ ค๋ฉด 3๋ฒ์งธ ์ํ์ ์๋ ๋ชจ๋ ์ํ์ ๋ค๋ฅธ ์ฅ๋๋ก ์ด๋์์ผ์ผ ํ๊ณ , 3๋ฒ์งธ ์ฅ๋๋ ๋น์ด์์ด์ผ ํฉ๋๋ค.
์ฆ, 3๋ฒ์งธ ์ํ ์์๋ ์๋ฌด๊ฒ๋ ์๋ ์ํ + ๋๋จธ์ง ์ํ์ ๋ชจ๋ 2๋ฒ์ผ๋ก ์ฎ๊ฒจ์ง ์ํ
๋ฅผ ์ถฉ์กฑํ๋ฉด 3๋ฒ์งธ ์ํ์ 3๋ฒ ์ฅ๋๋ก ์ฎ๊ธธ ์ ์๊ณ , 3๋ฒ์งธ ์ํ์ 3๋ฒ ์ฅ๋๋ก ์ฎ๊ธด ๋ค 2๋ฒ ์ฅ๋์ ์๋ ๋ชจ๋ ์ํ์ ๋ค์ 3๋ฒ ์ฅ๋๋ก ์ฎ๊ฒจ์ผ ํฉ๋๋ค.
์ด๋ฅผ ์ฌ๊ท์ ์ธ ์ํฉ์ผ๋ก ๋ค์ ์ ๋ฆฌํ๋ฉด,
- ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ์ํ์ ์ ์ธํ n-1๊ฐ์ ์ํ์
mid
๋ก ์ฎ๊น - ๊ฐ์ฅ ๋ฌด๊ฑฐ์ด ์ํ์
ed
๋ก ์ฎ๊น - ์ฒซ ๋ฒ์งธ ๊ณผ์ ์์ ์ฎ๊ฒผ๋ n-1๊ฐ์ ์ํ์ ed๋ก ์ฎ๊น
์ด๋ฅผ ์ฌ๊ท๋ก ์ฝ๋๋ฅผ ์ง๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ต๋๋ค.
Description
- ์ ์ฒด ์ฎ๊ธด ํ์๋ฅผ ์ถ๋ ฅํ๊ณ ์ฎ๊ฒจ์ง ์ํ์ ๋ด์ฉ์ ์ถ๋ ฅํด์ผ ํ๋ฏ๋ก, ๊ฐ ์ํ์ ์ด๋๊ฒฝ๋ก๋ฅผ
queue<pair<int, int>> q
์ ๋ด๊ณ , q.size()๋ฅผ ์ถ๋ ฅํ ๋ค q์ ๋ด์ฉ์ ์ถ๋ ฅํ์ต๋๋ค. - ์ฒซ ๋ฒ์งธ ์ฅ๋์ ์์น๋ฅผ 1, ๋ ๋ฒ์งธ๋ 2, 3๋ฒ์งธ๋ 3์ผ๋ก ์ก์ผ๋ฉด
mid = 6 - st - ed
๊ฐ ๋ฉ๋๋ค. - ์ฌ๊ท์ ๊ธฐ์ ์กฐ๊ฑด์ ํ์ฌ ์ํ ๋ฒํธ๊ฐ 1์ผ ๋ ๊ฐ์ฅ ๊ฐ๋ฒผ์ด ์ํ์ด๋ฏ๋ก ์ด ์ํฉ์์ ๋ฐ๋ก ed๋ก ์ด๋ํด ์ฃผ๊ณ ์ด๋ฅผ ํ์ ๋ด๊ณ ์ฌ๊ท๋ฅผ ์ข ๋ฃํฉ๋๋ค.
#include <iostream>
#include <queue>
using namespace std;
queue <pair<int,int>> q;
void recursion(int idx, int st, int ed);
int main() {
int n;
cin >> n;
recursion(n, 1, 3);
cout << q.size() << '\n';
while (!q.empty()) {
cout << q.front().first << ' ' << q.front().second << '\n';
q.pop();
}
return 0;
}
void recursion(int idx, int st, int ed){
if(idx==1){
q.push({st,ed});
return;
}
int mid = 6-st-ed;
recursion(idx-1,st,mid);
q.push({st,ed});
recursion(idx-1,mid,ed);
}