๐งจ ๋ฐฑ์ค 1707๋ฒ - ์ด๋ถ ๊ทธ๋ํ
๋ฌธ์ ๋์ด๋ : ๊ณจ๋4 (๋ฎ์ ์ ๋ต๋ฅ ์๋ ์ด์ ๊ฐ ์๋ค)
๋ฌธ์ ๋งํฌ : www.acmicpc.net/problem/1707
1707๋ฒ: ์ด๋ถ ๊ทธ๋ํ
์ ๋ ฅ์ ์ฌ๋ฌ ๊ฐ์ ํ ์คํธ ์ผ์ด์ค๋ก ๊ตฌ์ฑ๋์ด ์๋๋ฐ, ์ฒซ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ K(2≤K≤5)๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ์งธ ์ค์๋ ๊ทธ๋ํ์ ์ ์ ์ ๊ฐ์ V(1≤V≤20,000)์ ๊ฐ์ ์ ๊ฐ์
www.acmicpc.net
๊ทธ๋ํ์ ์ ์ ์ ์งํฉ์ ๋๋ก ๋ถํ ํ์ฌ, ๊ฐ ์งํฉ์ ์ํ ์ ์ ๋ผ๋ฆฌ๋ ์๋ก ์ธ์ ํ์ง ์๋๋ก ๋ถํ ํ ์ ์์ ๋, ๊ทธ๋ฌํ ๊ทธ๋ํ๋ฅผ ํน๋ณํ ์ด๋ถ ๊ทธ๋ํ (Bipartite Graph) ๋ผ ๋ถ๋ฅธ๋ค.
๐งจ ์๊ณ ๋ฆฌ์ฆ ์ ํ ๋ฐ C++ ์ฝ๋
๋ฉ๋ชจ๋ฆฌ์ด๊ณผ, ๋ฐํ์์๋ฌ(Segfault, OutofBounds)์ ํ๋ ธ์ต๋๋ค ์๋ฌ๊น์ง ๋ช๋ฒ์ด๋ ๋๊ณ ์์ผ ๋๋์ด ์ ๋ต์ด๋ค,, ๊ณ์ 50ํผ ๋ถ๊ทผ์์ 'ํ๋ ธ์ต๋๋ค' ๋์ค๊ธธ๋ ๋ญ๊ฐ ๋ฌธ์ ๊ฐ ์ถ์๋๋ฐ ์๊ณ ๋ณด๋ ๋งจ ์๋ ์ด๊ธฐํ ์ฝ๋์์ ๋ฒ์ ์ค์ ์ ์๋ชป ํด์คฌ๋ค. ^^
์ด ๋ฌธ์ ๋ DFS, BFS ๋ชจ๋ ์ฌ์ฉ๊ฐ๋ฅํ์ง๋ง ๋๋ ๊น์ด์ฐ์ ํ์์ผ๋ก ๊ตฌํํ๋ค. ์ผ๋จ ๋ ๊ฐ์ง ๋จ๊ณ๊ฐ ํ์ํ๋ฐ, ๋จผ์ ์ด๋ถ๊ทธ๋ํ์ธ์ง ๋ฅผ ์๋ ค๋ฉด ๋ชจ๋ ์ ์ ์ ํ์ํ๋ฉฐ ์ธ์ ํ ์ ์ ๋ผ๋ฆฌ๋ ๋ค๋ฅธ ์์ผ๋ก ์์น ์ ํด์ค์ผ ํ๋ค. RED 2, BLUE 3์ผ๋ก ์์น ํด์คฌ๋ค. ๋ชจ๋ ์์น ํ์ผ๋ฉด, ์์น ๋ ๊ทธ๋ํ๋ฅผ ํ์ํ๋ฉฐ ์ธ์ ํ ์ ์ ์ ์๊น์ด ๋ค๋ฅธ์ง ๊ฐ์์ง ๋น๊ตํด๋ด์ผํ๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ๋ค๋ฉด NO, ๋ค๋ฅด๋ค๋ฉด YES๋ฅผ ์ถ๋ ฅํ๋ฉด ๋๋ค.
๋ฏธ๋ก ๋ฌธ์ ์ฒ๋ผ 2์ฐจ์ ์ขํ๋ฅผ ์ด์ฉํ ๊ฒ์ด ์๋๋ฏ๋ก, ๊ทธ๋ํ(G)๋ ํ๋ ฌ์ฒ๋ผ ํํํ๊ณ ์ 2์ฐจ๋ฐฐ์ด์ ์ฐ๋ 1 -> 3 ์ผ๋ก ๊ฐ๋ ์์ง๋ฅผ ํํํ์๋๋ฐ, ์ด ๋ฐฉ๋ฒ์ ์ฐ๋ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ๋ฌธ์ ๊ฐ ๋ฌ๋ค. ๊ทธ๋์ vector๋ฅผ ์ฌ์ฉํด ๋ฆฌ์คํธ ํํ๋ก ํํํ๋ค. (๋ง์น ๋๋ฌด-์ ๊ทธ๋ํ์ฒ๋ผ?) ๊ฐ ๋ ธ๋์ ๋ํด ๋ค๋ฅธ ๋ ธ๋๋ก ๊ฐ๋ ์์ง๊ฐ ์๋ ๊ฒฝ์ฐ์๋ง ๊ทธ๋ํ์ ํ๋์ฉ ์ถ๊ฐํด์คฌ๋ค. ๊ทธ๋ฆฌ๊ณ ๋ ธ๋ ๋ฐฉ๋ฌธ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๋ isMarked๋ ์ด์ง๊ฐ์ ๋ด์ง ์๊ณ 0, 1, 2, 3์ผ๋ก RED, BLUE ์์ ์น ํ ์ ์๊ฒ๋ ํ๋ค. ์ค์ ๋ก ๊ทธ๋ํ์ ์น ํ์ง ์์ ์ด์ ๋ ์ฝ๋ ์ง๋ ๊ฒ ๋ฒ๊ฑฐ๋ก์์ง๊น๋ด ๊ทธ๋ฌ๋๋ฐ.. ์ ์๋ฌด๋๋ isMarked์ ์ผ๋ ฌ๋ก ๋ด๋๊ฒ ๊น๋ํ ๊ฑฐ ๊ฐ๋ค.
#include <iostream>
#include <queue>
using namespace std;
#define RED 2
#define BLUE 3
int T;
int v, e;
vector<int> G[20001];
int isMarked[20001] = { 0 };
void recursiveDFS(vector<int> G[20001], int start) {
if (!isMarked[start]) {
isMarked[start] = RED;
}
for (int i = 0; i < G[start].size(); i++) {
int next = G[start][i];
if (!isMarked[next]) {
if (isMarked[start] == RED) {
isMarked[next] = BLUE;
}
else if (isMarked[start] == BLUE) {
isMarked[next] = RED;
}
recursiveDFS(G, next);
}
}
return;
}
bool isBipartiteGraph() {
for (int i = 0; i < v; i++) { // i๋ ์ค์ ์ ์
for (int j = 0; j < G[i].size(); j++) { // j๋ i์ ์์ง๋ก ์ฐ๊ฒฐ๋ ๋ ๋ค๋ฅธ ์ ์ ๋ค์ ์ธ๋ฑ์ค
int next = G[i][j]; // i(๊ธฐ์ค; ์ค์ ์ ์ ) -> next(iํ j์ด์ ์ซ์; ๋ค์์ ์ )
if (isMarked[i] == isMarked[next]) {
//cout << "NO" << '\n';
return false;
}
}
}
//cout << "YES" << '\n';
return true;
}
int main(void) {
cin >> T;
for (int i = 0; i < T; i++) {
cin >> v >> e;
for (int j = 0; j < e; j++) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
for (int k = 0; k < v; k++) {
if (!isMarked[k]) {
recursiveDFS(G, k);
}
}
if (isBipartiteGraph()) cout << "YES\n";
else cout << "NO\n";
// ์ด๊ธฐํ
for (int i = 0; i < 20001; i++) {
G[i].clear();
isMarked[i] = 0;
}
}
return 0;
}
์ด์ฌํ ํ๊ธด ํ์ง๋ง ๋จธ๋ฆฌ์ ๋ญ๊ฐ ๋จ์๋์ง ๋ชจ๋ฅด๊ฒ ๋ค.. ํ๋ค๊ฐ ๋์ ํ ์๋ฌธ์ด ์ ํ๋ ค์ ๋ค๋ฅธ ๋ถ๋ค์ด ์ง๋ฌธํ ๊ฑธ ์ฐธ๊ณ ํ๋ค. ๋ฉ๋ชจ๋ฆฌ์ด๊ณผ๋ Segfault ๋ฐํ์์๋ฌ๋ ์ธ์ ๋ง์ฃผ์ณ๋ ์ด๋ ต๋ค. BFS, DFS๋ฅผ 1์ฐจ์ 2์ฐจ์์์ ์์ ์์ฌ๋ก ์ฌ์ฉํ๋๋ก ๋ ํ์ด๋ด์ผ๊ฒ๋ค
'Problem Solving > BOJ ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] ๋ฐฑ์ค 9370๋ฒ ๋ฏธํ์ธ ๋์ฐฉ์ง (C++ ์ฝ๋) (0) | 2021.02.06 |
---|---|
[BOJ] ๋ฐฑ์ค 10282๋ฒ ํดํน (C++ ์ฝ๋) (0) | 2021.02.06 |
[BOJ] ๋ฐฑ์ค 10026๋ฒ ์ ๋ก์์ฝ (C++ ์ฝ๋) (0) | 2021.01.23 |
[BOJ] ๋ฐฑ์ค 1012๋ฒ ์ ๊ธฐ๋ ๋ฐฐ์ถ (C++ ์ฝ๋) (0) | 2021.01.23 |
[BOJ] ๋ฐฑ์ค 2178๋ฒ ๋ฏธ๋กํ์ (C++ ์ฝ๋) (0) | 2021.01.22 |