1. ๋ฌธ์ ์ค๋ช
2. ์ ๊ทผ ๋ฐฉ์
KEY WORD
: ์ด๋ถ ๊ทธ๋ํ
์ด๋ถ ๊ทธ๋ํ์ ๋ํด์ ์์ง ๋ชปํ๋ฉด ํ ์ ์๋ ๋ฌธ์ ์๋ค. ๋๋ ๋ชฐ๋ผ์, ๋จผ์ ์ด๋ถ ๊ทธ๋ํ๋ฅผ ๊ณต๋ถํ ๋ค์ ๋ค์ ๋ฌธ์ ๋ฅผ ์ ํ๋ค. ๋จผ์ ์ด๋ถ ๊ทธ๋ํ์ ๋ํ ์ค๋ช ๋ถํฐ ์ ์ผ๋ ค๊ณ ํ๋๋ฐ, ์ด์ ๋ํด์ ์์๋ ๋ถ๋ค์ ๋ชฉ์ฐจ์์ (3) ํ์ด ๋ฐฉ์ ๋ถํฐ ๋ณด์๊ธธ ๋ฐ๋๋ค.
(1) ์ด๋ถ ๊ทธ๋ํ๋ ๋ฌด์์ธ๊ฐ์?
๊ทธ๋ํ์ ์ ์ ๋ค์ 2๊ฐ์ ๋ถ๋ถ์งํฉ
์ผ๋ก ๋ถํ ํ์ ๋, ์ ์ ์ด
- ๊ฐ์ ๋ถ๋ถ์งํฉ ๋ด์ ์ ์ ๊ณผ๋ ๊ฐ์ ์ ๊ฐ์ง์ง ์๋๋ค.
- ๋ฌด์กฐ๊ฑด ๋ฐ๋ํธ ๋ถ๋ถ์งํฉ์ด๋๋ง ๊ฐ์ ์ ๊ฐ์ง๋ค.
๊ฐ ์ฑ๋ฆฝํ๋ฉด, ํด๋น ๊ทธ๋ํ๋ฅผ ์ด๋ถ ๊ทธ๋ํ
๋ผ๊ณ ํ๋ค. ๋ง๋ก ํ๋๊น ์ด๋ ค์ด๋ฐ, ๊ทธ๋ฆผ์ผ๋ก ๊ทธ๋ ค๋ณด๊ฒ ๋ค.
๋ค์๊ณผ ๊ฐ์ด ์๊ธด ๊ทธ๋ํ๊ฐ ์๋ค. ํด๋น ๊ทธ๋ํ๋ ์ด๋ถ ๊ทธ๋ํ์ด๋ค. ์ด๋ถ ๊ทธ๋ํ ์์ ์ฆ๋ช ํ๋ 2๊ฐ์ ๋ถ๋ถ์งํฉ์ผ๋ก ๋๋์ด ๋ณด๋ฉด, ๋ค์๊ณผ ๊ฐ๋ค.
๋ง์ฝ ๊ทธ๋ํ๊ฐ ๋ค์๊ณผ ๊ฐ์ด ๋ฐ๋๋ฉด,
์ด๋ถ ๊ทธ๋ํ์ 2๊ฐ์ ์กฐ๊ฑด์ ๋ง์ถ๊ธฐ ์ํด์๋ ๋ถ๋ถ์งํฉ์ด 3๊ฐ๊ฐ ํ์ํด์ง๋ค. ๋ฐ๋ผ์ ์ด๋ 2๊ฐ์ ๋ถ๋ถ์งํฉ์ผ๋ก ๋๋์ด์ผ ํ๋ค๋ ์ด๋ถ ๊ทธ๋ํ์ ์ฒซ ๋ฒ์งธ ์กฐ๊ฑด์ ์งํค์ง ๋ชปํด์, ๋ ์ด์ ์ด๋ถ ๊ทธ๋ํ๊ฐ ์๋๊ฒ ๋๋ค.
๋ค์๊ณผ ๊ฐ์ด ์ธ๋ด ์ฌ์ด ์๋ ๊ฒฝ์ฐ๋ผ๋ฉด ์ด๋ป๊ฒ ๋ ๊น?
๋น์ฐํ ์ด๋ถ ๊ทธ๋ํ์ด๋ค. ์ด๋๋ G,H๊ฐ ์ ๋ถ๋ถ์งํฉ ์ค ์ด๋์ ๋ค์ด๊ฐ๋ , ๊ฐ์ ๋ฐ๋ก๋ฐ๋ก ๋ค์ด๊ฐ๋ฉด ์ฑ๋ฆฝํ๋ค.
(2) ์ด๋ถ ๊ทธ๋ํ ํ๋จ์ ์ด๋ป๊ฒ ํ๋์?
๋๋ BFS
๋ฅผ ์จ์ ๊ทธ๋ํ์ ์ด๋ถ ๊ทธ๋ํ์ธ์ง ์ฌ๋ถ๋ฅผ ํ๋จํ๋ค. ํ๋จ ๋ฐฉ๋ฒ์ ๊ฐ๋จํ๋ค. ์ด๋ถ ๊ทธ๋ํ๋ 2๊ฐ์ ๋ถ๋ถ์งํฉ์ผ๋ก ์๋ฒฝํ ๋๋ ์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์, ๊ทธ๋ํ ๋ด์ ๋ชจ๋ ์ ์ ์ด ์ธ์ ํ ์ ์ ๊ณผ๋ ๋ค๋ฅธ ์
์ด๋ฉด์, ์๊น์ด 2๊ฐ๋ง ์ฐ์ธ๋ค.
๋ฅผ ๋ง์กฑํ๋ฉด ์ด๋ถ ๊ทธ๋ํ์ด๋ค.
a. ์๊น์ 2๊ฐ ์ ํด๋๊ณ , BFS๋ฅผ ํตํด, ์ธ์ ํ ์ ์ ์๋ ์์ ๊ณผ ๋ค๋ฅธ ์๊น์ ์น ํ๋ค.
b. ๋ง์ฝ ์น ํด์ ธ ์๋ ๊ฒฝ์ฐ, ์ธ์ ์ ์ ์ ์๊น์ด ํ ์ ์ ๊ณผ ๊ฐ์ผ๋ฉด ์ด๋ถ ๊ทธ๋ํ๊ฐ ์๋๋ฏ๋ก ๋ฐ๋ก bfs๋ฅผ ์ข
๋ฃํ๋ค.
c. ์ธ์ ์ ์ ๊ณผ ํ ์ ์ ์ ์๊น์ด ๋ค๋ฅด๋ฉด, ์ด๋ถ ๊ทธ๋ํ์ธ์ง ์ฌ๋ถ ํ์ธ์ ๊ณ์ํด๋๊ฐ๋ค.
(3) ํ์ด ๋ฐฉ์
๋๋์ด ํ์ด ๋ฐฉ์์ด๋ค.
a. ์ด๋ถ ๊ทธ๋ํ์ธ์ง ํ๋จํ๋ค. ๋ง์ฝ ์ด๋ถ ๊ทธ๋ํ๊ฐ ๋ง๋ค๋ฉด, ์๊น๋ณ๋ก ์ ์ ์ด ๋ช ๊ฐ ์๋์ง ๊ณ ๋ฅธ๋ค.
b. ๋ถ๋ถ์งํฉ์ A์ B๋ผ๊ณ ํ ๋, A์ ํ ๋ผ, B์ ์ฌ์ ํน์ B์ ์ฌ์, A์ ํ ๋ผ ๋ผ๋ ๊ฒฝ์ฐ๋ง ๋ง์กฑํ๋ฉด, ๊ฒ์์ ์ ๋ ๋๋ผ ์ ์๋ ๊ฒฝ์ฐ๋ค. ๋ฌด์กฐ๊ฑด ์์ง์ฌ์ผ ํ๊ธฐ์, ๊ฐ์ ์๋ก ๋ค๋ฅธ ๋ถ๋ถ์งํฉ์ผ๋ก ์์ํ ์ด๋ํ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
c. ๋ฐ๋ผ์ A ๋ถ๋ถ์งํฉ์ ์์ ๊ฐ์
x B์ ๋ถ๋ถ์งํฉ์ ์์ ๊ฐ์
X 2 (ํ ๋ผ ์ฌ์ ์์น ์ฒด์ธ์ง)
๊ฐ ๋ต์ด ๋๋ค.
3. ์ฝ๋ ๋ถ์
import java.io.*;
import java.util.*;
public class Main {
// ์ธ์ ๋ฆฌ์คํธ
static ArrayList<Integer> [] lists;
static char [] vertex_color;
static char [] color = new char[]{'B','W'};
public static void main(String[] args) throws IOException {
// ์
๋ ฅ ๋ฐ๊ธฐ
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
lists = new ArrayList[N+1];
vertex_color = new char[N+1];
for (int i = 1; i <= N; i++) {
lists[i] = new ArrayList<>();
}
for (int i = 0; i < M; i++) {
st = new StringTokenizer(br.readLine());
int start = Integer.parseInt(st.nextToken());
int end = Integer.parseInt(st.nextToken());
lists[start].add(end);
lists[end].add(start);
}
if (!bfs(1)) {
System.out.println(0);
}else {
int cnt = 0;
int Bcnt = 0;
int Wcnt = 0;
for (int i = 1; i < vertex_color.length; i++) {
if(vertex_color[i] == 'B') Bcnt++;
else Wcnt++;
}
cnt += Bcnt*Wcnt*2;
System.out.println(cnt);
}
}
// ํ ์์น์์ ์๊น ์น ํ๊ธฐ -> ํด๋น ๋ฌธ์ ๋ ๋ชจ๋ ์ ์ ์ด ์ด์ด์ ธ ์์ผ๋ฏ๋ก, BFS ๋ฑ ํ ๋ฒ ํ๋ฉด ๋๋ค.
public static boolean bfs(int start) {
int value = 0;
ArrayDeque<Integer> aq1 = new ArrayDeque<>();
aq1.add(start);
vertex_color[start] = color[toggle(value)];
while (!aq1.isEmpty()){
int Qsize = aq1.size();
value++;
for (int i = 0; i < Qsize; i++) {
int now = aq1.poll();
for (int j = 0; j < lists[now].size(); j++) {
int next = lists[now].get(j);
if(vertex_color[next] == '\u0000') {
vertex_color[next] = color[toggle(value)];
aq1.add(next);
}else if(vertex_color[next] == vertex_color[now]) return false;
}
}
}
return true;
}
// ์๊น ํ ๊ธ ํจ์
public static int toggle (int value) {
return value%2;
}
}