๋ฌธ์
์๋๋ก๋ฉ๋ค ์ ์น์ ์ต์คํ๋ ์ค๋ฐ์์๋ ๋ค์ ์ฃผ์ ์จ๋๊ณต์์ผ๋ก ์ํ์ ๊ฐ๋๋ค. ์์ ์ ์๋์ ์ํ ๋ ํ์๋ค์ ๋ ๋ช ์ฉ ์ง์ ์ง์ด ํ๋ํ๊ฒ ํ๋ ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ ์๋ก ์น๊ตฌ๊ฐ ์๋ ํ์๋ค๋ผ๋ฆฌ ์ง์ ์ง์ด ์ฃผ๋ฉด ์๋ก ์ธ์ฐ๊ฑฐ๋ ๊ฐ์ด ๋์๋ค๋์ง ์๊ธฐ ๋๋ฌธ์, ํญ์ ์๋ก ์น๊ตฌ์ธ ํ์๋ค๋ผ๋ฆฌ๋ง ์ง์ ์ง์ด ์ค์ผ ํฉ๋๋ค.
๊ฐ ํ์๋ค์ ์์ ๋ํด ์ด๋ค์ด ์๋ก ์น๊ตฌ์ธ์ง ์ฌ๋ถ๊ฐ ์ฃผ์ด์ง ๋, ํ์๋ค์ ์ง์ง์ด์ค ์ ์๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์ธ์. ์ง์ด ๋๋ ํ์๋ค์ด ์ผ๋ถ๋ง ๋ค๋ฅด๋๋ผ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ๋ด ๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์๋ก ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋๋ค.
- (ํ์ฐ,์ ์์นด) (์จ๋,ํฐํ๋) (ํจ์ฐ,์ ๋ฆฌ)
- (ํ์ฐ,์ ์์นด) (์จ๋,์ ๋ฆฌ) (ํจ์ฐ,ํฐํ๋)
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ์ C (C <= 50) ๊ฐ ์ฃผ์ด์ง๋๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ ์ค์๋ ํ์์ ์ n (2 <= n <= 10) ๊ณผ ์น๊ตฌ ์์ ์ m (0 <= m <= n*(n-1)/2) ์ด ์ฃผ์ด์ง๋๋ค. ๊ทธ ๋ค์ ์ค์ m ๊ฐ์ ์ ์ ์์ผ๋ก ์๋ก ์น๊ตฌ์ธ ๋ ํ์์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฒํธ๋ ๋ชจ๋ 0 ๋ถํฐ n-1 ์ฌ์ด์ ์ ์์ด๊ณ , ๊ฐ์ ์์ ์ ๋ ฅ์ ๋ ๋ฒ ์ฃผ์ด์ง์ง ์์ต๋๋ค. ํ์๋ค์ ์๋ ์ง์์ ๋๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค๋ง๋ค ํ ์ค์ ๋ชจ๋ ํ์์ ์น๊ตฌ๋ผ๋ฆฌ๋ง ์ง์ง์ด์ค ์ ์๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
์์ ์ ๋ ฅ
3 2 1 0 1 4 6 0 1 1 2 2 3 3 0 0 2 1 3 6 10 0 1 0 2 1 2 1 3 1 4 2 3 2 4 3 4 3 5 4 5 |
์์ ์ถ๋ ฅ
1 3 4 |
๋ฌธ์ ํ์ด
์์ ํ์์ ์ด์ฉํด ์กฐํฉ์ ๋ชจ๋ ๋ง๋ค์ด ๋ณด์.
์์ง ์ง์ ์ฐพ์ง ๋ชปํ ํ์๋ค์ ๋ช ๋จ์ด ์ฃผ์ด์ง ๋ ์น๊ตฌ๋ผ๋ฆฌ ๋์ฉ ์ง์ง๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ณ์ฐํด๋ผ.
-
์ง์ ์ง์ ํ์๋ค์ ๋ช ๋จ - taken
-
์น๊ตฌ์ธ ํ์๋ค์ ๋ช ๋จ - areFriends
/* ์น๊ตฌ์ธ ํ์๋ค ๋ผ๋ฆฌ ์ง์ ์ง์ด์ฃผ๊ธฐ */
/* 2019-07-08 ์ํ */
#include <iostream>
using namespace std;
bool areFriends[10][10]; //ํ์์ ์๊ฐ ์ต๋ 10๋ช
์ด๊ธฐ ๋๋ฌธ์
int findPair(int n, bool *taken) {
//taken - ์ง์ ๊ตฌํ๋๊ฐ ?
//n - ํ์ ์
int first = -1;
for (int i = 0; i < n; i++) {
if (!taken[i]) {
first = i; // ๊ฐ์ฅ ์ฒซ๋ฒ์งธ๋ก ์ง์ ๊ตฌํ์ง ๋ชปํ ์ฌ๋
break;
}
}
if (first == -1) return 1; // ๋ค ์ง์ ๊ตฌํ๋ค๋ฉด 1์ return ํ๋ค.
int ret = 0;
for (int i = first + 1; i < n; i++) { // ์ง์ ์ ํ ์ฌ๋ ์ฐพ๊ธฐ
if (!taken[i] && areFriends[first][i]) { //์ด ์น๊ตฌ๋ ์ง์ด ์๊ณ ์๋ก ์น๊ตฌ๋ผ๋ฉด
taken[i] = taken[first] = true; // ์ง์ ๊ตฌํจ
ret += findPair(n, taken); // ๋จ์ ์ง ๊ณ ๋ฅด๋ ์์
์ ์ฌ๊ท๋ก ๋ ๋๊ธด ๊ฒ. ๋ชจ๋ ์ง์ ๊ตฌํ๋ค๋ฉด 1์ด ์๋๋ฉด 0์ด return ๋์์ ๊ฒ์ด๋ค.
taken[i] = taken[first] = false; // ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ ์์ ์ ์์ผ๋ ๋ค์ ์ด๊ธฐํ ํด์ค๋ค
}
}
return ret;
}
int main() {
int c; // ํ
์คํธ ์ผ์ด์ค์ ์
int n, m; // ํ์์ ์, ์น๊ตฌ ์์ ์
cin >> c;
if (c > 50) return -1 ;
for (int i = 0; i < c; i++) {
int t1, t2;
bool taken[10] = { false, };
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
areFriends[i][j] = false;
}
}
cin >> n >> m;
//ํ์์ ์๋ 2~10
for (int j = 0; j < m; j++) { // ์น๊ตฌ์ ์ ์ฅํ๊ธฐ
cin >> t1 >> t2;
areFriends[t1][t2] = true;
areFriends[t2][t1] = true;
}
cout << findPair(n, taken) << endl;
}
return 0;
}
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํด๊ฒฐ ์ ๋ต 1์ ์ฝ๋๋ฅผ ์ด์ฉํด์ ํ์๋ค. ์ฒ์์ ํ์์ ์์์ 2๊ฐ๋ฅผ ๋ชจ๋ ์กฐํฉ์ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ ค๊ณ ํ์ผ๋ ๋จ์ํ ์ง์ ๊ตฌํ๋ ๊ฒ์ด ์๋๋ผ ํ์๋ค์ ์ง ์ง์ ์ ์๋ ๋ฐฉ๋ฒ์ ์๋ฅผ ๊ตฌํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์ฑ
์ ์ฐธ๊ณ ํ๋ค.
->์ฌ๊ธฐ์ ์ฌ์ฉํ ์๊ณ ๋ฆฌ์ฆ๋ ๋น์ทํ ๋ฅ์์ ๊นจ๋ฌ์๋ค.
์ฑ ์์๋ ์ค๋ณต ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๊ฐ์ฅ ๋ฒํธ๊ฐ ๋น ๋ฅธ ํ์์ ์ง์ ๊ตฌํ๋ ๋ฐฉ๋ฒ์ ์ฑํํ๊ณ , ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ findPair ํจ์์์๋ ๊ฐ์ฅ ์ฒซ ๋ฒ์งธ๋ก ์ง์ ๊ตฌํ์ง ๋ชปํ ์ฌ๋์ ์ฐพ์๋ธ๋ค. ์ด๋ ๋ชจ๋ ์ฌ๋์ด ์ง์ ๊ตฌํ๋ค๋ฉด ํ๋์ ๋ฐฉ๋ฒ์ ์ฐพ์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ 1์ return ํ๋ค. ์ด return ๋ 1์ ์ถํ ret์ ๋ํด์ง๋ค.
์ฒ์์ 0๋ถํฐ ์ง ๊ตฌํ๊ธฐ๋ฅผ ์์ํ๋ค. 0์ ์ง์ด ๋ ์ฌ๋์ ์ฐพ๋๋ฐ ์๊ธฐ ์์ ๊ณผ๋ ์น๊ตฌ๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์ 1๋ถํฐ ์ง์ด ๋ ์ ์๋์ง ํ๋ณํ๋ค. ์ง์ด ๋ ์ ์๋ค๋ฉด ์ง์ ๊ตฌํ๋ค๊ณ check ํ ํ, ๋ค์ ๋๋จธ์ง ํ์๋ค์ ์ง์ ๊ตฌํ๊ธฐ ์ํด์ ์ฌ๊ท๋ก ์๊ธฐ ์์ ์ ํธ์ถํ๋ค.
๋ง์ฝ 0๊ณผ 1์ด ์ง์ด๋ผ๊ณ ํ๋ฉด 2๋ฒ ์น๊ตฌ์ ์ง์ ์ฐพ๊ฒ ๋ ๊ฒ์ด๋ค. 2๋ฒ ํ์์ ์ง์ด ์๋ค๋ฉด ๋ชจ๋ for๋ฌธ์ ๋๊ณ ret์ ๋ฐํํ ํ ๋ฐ ์ด๋ ret์ 0์ด ๋๋ค. ์ด๋ ์ง์ง๋ ๊ฒ์ด ์คํจํ์์ ๋ปํ๋ค. ํ์ง๋ง 2๋ฒ ํ์์ด 3๋ฒ ํ์๊ณผ ์น๊ตฌ๋ผ๋ฉด ์ง์ ์ง์ ์ ์๋ค. ์ด ๊ฒฝ์ฐ์๋ if๋ฌธ์ ๋ง์กฑ์์ผ ๋ค์ ์ฌ๊ท๋ก ์๊ธฐ ์์ ์ ํธ์ถํ๋ค. ๋ค์ ํธ์ถ๋ findpair ํจ์๊ฐ ๋ ์ด์ ์ง์ ๊ตฌํ ์ฌ๋์ด ์๋ ๊ฒ์ ๋ฐ๊ฒฌํ๊ณ 1์ return ํ๋ค.
for (int i = first + 1; i < n; i++) { // ์ง์ ์ ํ ์ฌ๋ ์ฐพ๊ธฐ
if (!taken[i] && areFriends[first][i]) { //์ด ์น๊ตฌ๋ ์ง์ด ์๊ณ ์๋ก ์น๊ตฌ๋ผ๋ฉด
taken[i] = taken[first] = true; // ์ง์ ๊ตฌํจ
ret += findPair(n, taken); // ๋จ์ ์ง ๊ณ ๋ฅด๋ ์์
์ ์ฌ๊ท๋ก ๋ ๋๊ธด ๊ฒ. ๋ชจ๋ ์ง์ ๊ตฌํ๋ค๋ฉด 1์ด ์๋๋ฉด 0์ด return ๋์์ ๊ฒ์ด๋ค.
taken[i] = taken[first] = false; // ๋ค๋ฅธ ๋ฐฉ๋ฒ๋ ์์ ์ ์์ผ๋ ๋ค์ ์ด๊ธฐํ ํด์ค๋ค
}
}
์ด๋๊ฐ ๋ผ์์ผ ๋๋์ด first๊ฐ 0์ด๊ณ i๊ฐ 1์ธ ์ํฉ์์ ret += findPair(n, taken); ์ด ๋๋ ๊ฒ์ด๋ค.
0๊ณผ 1์ด ์ง์ด ๋๋ ๊ฒฝ์ฐ๋ฟ ์๋๋ผ 0์ 2,3๊ณผ๋ ์ง์ด ๋ ์ ์๋ค(0์ด 1,2,3๊ณผ ์น๊ตฌ๋ผ๋ฉด). ์ด ๊ฒฝ์ฐ๋ฅผ ๋ชจ๋ ํ์ธํ๊ธฐ ์ํด์ ๋ ๋ค ์ง์ด ์๋ค๊ณ ์ด๊ธฐํํด์ฃผ๊ณ ๋ค์ for๋ฌธ์ ๋์๊ฐ๊ฒ ๋๋ค. ์ด๋ฐ ์์ผ๋ก ์์ subproblem์ ํด๊ฒฐํ๋ ์ฌ๊ท ํจ์๊ฐ ๋ชจ๋ ๋๋๊ฒ ๋๊ณ ์ฒซ ๋ฒ์งธ๋ก ํธ์ถ๋ findPairํจ์๊ฐ ret๋ฅผ ๋ฐํํ๋ฉด์ ๋ชจ๋ ํ์์ ์น๊ตฌ๋ผ๋ฆฌ๋ง ์ง์ง์ด์ค ์ ์๋ ๋ฐฉ๋ฒ์ ๊ฐ์๊ฐ ์ถ๋ ฅ๋๋ค.