์๊ณ ๋ฆฌ์ฆ
[Java] BOJ 11725 ํธ๋ฆฌ์ ๋ถ๋ชจ ์ฐพ๊ธฐ
๐๊ทค๐
2024. 12. 21. 01:52
๋ฌธ์
๋ฌธ์ ๋งํฌ https://www.acmicpc.net/problem/11725
- ๋ฃจํธ ์๋ ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋, ํธ๋ฆฌ์ ๋ฃจํธ๋ฅผ 1์ด๋ผ๊ณ ์ ํ์ ๋, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
- ์ฒซ์งธ ์ค์ ๋ ธ๋์ ๊ฐ์ N (2 ≤ N ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N-1๊ฐ์ ์ค์ ํธ๋ฆฌ ์์์ ์ฐ๊ฒฐ๋ ๋ ์ ์ ์ด ์ฃผ์ด์ง๋ค.
- ์ฒซ์งธ ์ค๋ถํฐ N-1๊ฐ์ ์ค์ ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋ ๋ฒํธ๋ฅผ 2๋ฒ ๋ ธ๋๋ถํฐ ์์๋๋ก ์ถ๋ ฅํ๋ค.
์์ด๋์ด
- ์ธ์ ๋ฆฌ์คํธ๋ก ํธ๋ฆฌ๋ฅผ ๊ตฌํํด์ ์๋ฐฉํฅ์ผ๋ก ํธ๋ฆฌ์ ๊ฐ์ ์ ๋ณด๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ DFS๋ก ๋ ธ๋๋ง๋ค ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ฐพ์์ ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
- ์ฐ์ ๋ฃจํธ๋ฅผ 1๋ก ์ ํ์ผ๋ฏ๋ก, 1๋ถํฐ DFS๋ฅผ ๋๋ฆฌ๋ฉฐ ๋ ธ๋ 1์ ๋ฐฉ๋ฌธ์ฒ๋ฆฌํ๊ณ , 1์ ์ฐ๊ฒฐ๋ ๋ ธ๋ ์ค ๋ฐฉ๋ฌธ ๋์ง ์์ ๋ ธ๋๋ผ๋ฉด ํด๋น ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ 1๋ก ์ ์ฅํ๊ณ (๋ง์ฝ 1์ 2๋ผ๋ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ๋์ด์์๋ค๋ฉด, parent[2] = 1์ด๋ผ ์ ์ฅ) ํด๋น ๋ ธ๋๋ก DFS๋ฅผ ๋ค์ ๋๋ฆฐ๋ค.
- ๋ค์ ๋ ธ๋๋ก DFS๋ฅผ ๋๋ฆด ๋๋, ํด๋น ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ์ฒ๋ฆฌํ๊ณ ํด๋น ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค ์ค ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ ๋์ด์์ง ์์ ๋ ธ๋๋ผ๋ฉด, ๊ทธ ๋ ธ๋์ ๋ถ๋ชจ๋ฅผ ํ์ฌ DFS๋ฅผ ๋๋ฆฌ๊ณ ์๋ ๋ ธ๋๋ก ์ ์ฅํ๊ณ ๋ค์ DFS๋ฅผ ๋๋ฆฌ๋ฉฐ ๋ฐ๋ณตํ๋ค.
๊ฒช์ ์ํ์ฐฉ์ค
- X
์ฝ๋
import java.io.*;
import java.util.*;
public class BOJ11725 {
static int N;
static ArrayList<Integer> tree[];
static int parent[];
static boolean visited[];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
N = Integer.parseInt(br.readLine());
// ์ธ์ ๋ฆฌ์คํธ๋ก ํธ๋ฆฌ ๊ตฌํ
tree = new ArrayList[N + 1];
// ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ๋ฅผ ์ ์ฅํ ๋ฐฐ์ด
parent = new int[N + 1];
// ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
visited = new boolean[N + 1];
// ์ธ์ ๋ฆฌ์คํธ ์ด๊ธฐํ
for (int i = 1; i <= N; i++) {
tree[i] = new ArrayList<>();
}
// ํธ๋ฆฌ์ ๊ฐ์ ์ ๋ณด ์
๋ ฅ๋ฐ๊ธฐ
for (int i = 0; i < N - 1; i++) {
StringTokenizer st = new StringTokenizer(br.readLine());
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
// ์๋ฐฉํฅ์ผ๋ก ์ฐ๊ฒฐ
tree[a].add(b);
tree[b].add(a);
}
// DFS๋ฅผ ํตํด ๋ถ๋ชจ ์ ๋ณด ์ฐพ๊ธฐ (๋ฃจํธ ๋
ธ๋๋ฅผ 1๋ถํฐ ์์ํ๋ค ํ์ผ๋ฏ๋ก)
dfs(1);
// 2๋ฒ ๋
ธ๋๋ถํฐ N๋ฒ ๋
ธ๋๊น์ง์ ๋ถ๋ชจ ์ถ๋ ฅ
for (int i = 2; i <= N; i++) {
sb.append(parent[i]).append("\n");
}
System.out.print(sb);
}
// ๋ถ๋ชจ ๋
ธ๋ ์ฐพ๊ธฐ ์ํ DFS
public static void dfs(int node) {
// ํ์ฌ ๋
ธ๋ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
visited[node] = true;
// ํ์ฌ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ์์ ๋
ธ๋๋ค ํ์ธ
for (int child : tree[node]) {
// ๋ฐฉ๋ฌธํ์ง ์์ ๋
ธ๋๋ผ๋ฉด
if (!visited[child]) {
// ํ์ฌ ๋
ธ๋๋ฅผ ํด๋น ๋
ธ๋์ ๋ถ๋ชจ๋ก ์ ์ฅ ํ
parent[child] = node;
// ์์ ๋
ธ๋๋ก ๋ค์ DFS๋ฅผ ๋๋ฆผ
dfs(child);
}
}
}
}