https://www.acmicpc.net/problem/24480
๐ ์๋ฐ(Java)๋ก ํธ๋ ๊น์ด ์ฐ์ ํ์(DFS) - ๋ฐฑ์ค 24480 ๋ฌธ์ ํ์ด ๐
๐ ๋ฌธ์ ๊ฐ์
์ด ๋ฌธ์ ๋ ๋ฐฑ์ค 24480๋ฒ - ๊น์ด ์ฐ์ ํ์ 2 ๋ฌธ์ ์
๋๋ค.
์ฃผ์ด์ง ๊ทธ๋ํ๋ฅผ ๊น์ด ์ฐ์ ํ์(DFS)ํ๋ฉฐ ๋ฐฉ๋ฌธ ์์๋ฅผ ๊ธฐ๋กํด์ผ ํฉ๋๋ค.
๋จ, ๋ด๋ฆผ์ฐจ์(ํฐ ์ซ์๋ถํฐ) ์ผ๋ก ๋ฐฉ๋ฌธํด์ผ ํ๋ค๋ ์ ์ด ํน์ง์
๋๋ค.
๐ก ์์ ์ ๋ ฅ
5 5 1
1 4
1 2
2 3
2 4
3 4
๐ก ์์ ์ถ๋ ฅ
1
4
3
2
0
โก 1๋ฒ ์ ์ ๋ถํฐ ๋ด๋ฆผ์ฐจ์์ผ๋ก DFS ํ์ํ๋ฉฐ ๋ฐฉ๋ฌธ ์์๋ฅผ ์ถ๋ ฅํด์ผ ํฉ๋๋ค.
๐ ์๊ณ ๋ฆฌ์ฆ ์ ๊ทผ ๋ฐฉ์
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด DFS(๊น์ด ์ฐ์ ํ์) + ์ ๋ ฌ์ ํ์ฉํฉ๋๋ค.
โ๏ธ ์ฃผ์ ๊ณ ๋ ค ์ฌํญ
โ DFS๋ฅผ ์ฌ์ฉํ์ฌ ๊ทธ๋ํ๋ฅผ ํ์
โ ๊ฐ์ ์ ๋ณด๋ฅผ ์ ์ฅํ ๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ
โ ์ ์ ๋ฐฉ๋ฌธ ์์๋ฅผ isVisited[] ๋ฐฐ์ด์ ๊ธฐ๋ก
๐น Java ์ฝ๋ ํด์ค
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;
public class b24480 {
static int N, M, R, count = 1; // ์ ์ ์, ๊ฐ์ ์, ์์ ์ ์ , ๋ฐฉ๋ฌธ ์์ ์นด์ดํธ
static ArrayList<Integer>[] list; // ์ธ์ ๋ฆฌ์คํธ
static int[] isVisited; // ๋ฐฉ๋ฌธ ์์ ์ ์ฅ ๋ฐฐ์ด
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
// ์
๋ ฅ ์ฒ๋ฆฌ
N = sToInt(st.nextToken()); // ์ ์ ๊ฐ์
M = sToInt(st.nextToken()); // ๊ฐ์ ๊ฐ์
R = sToInt(st.nextToken()); // ์์ ์ ์
isVisited = new int[N + 1]; // ๋ฐฉ๋ฌธ ์์ ์ ์ฅ ๋ฐฐ์ด
list = new ArrayList[N + 1];
// ์ธ์ ๋ฆฌ์คํธ ์ด๊ธฐํ
for (int i = 0; i <= N; i++) {
list[i] = new ArrayList<>();
}
// ๊ฐ์ ์ ๋ณด ์
๋ ฅ
for (int i = 0; i < M; i++) {
st = new StringTokenizer(br.readLine());
int a = sToInt(st.nextToken());
int b = sToInt(st.nextToken());
list[a].add(b);
list[b].add(a);
}
// ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ (ํฐ ์ซ์๋ถํฐ ํ์)
for (int i = 1; i <= N; i++) {
list[i].sort(Collections.reverseOrder());
}
// DFS ์คํ
DFS(R);
// ๊ฒฐ๊ณผ ์ถ๋ ฅ
StringBuilder sb = new StringBuilder();
for (int i = 1; i <= N; i++) {
sb.append(isVisited[i]).append("\n");
}
System.out.println(sb);
}
// ๋ฌธ์์ด -> ์ ์ ๋ณํ ํจ์
static int sToInt(String s) {
return Integer.parseInt(s);
}
// ๊น์ด ์ฐ์ ํ์ (DFS)
static void DFS(int start) {
isVisited[start] = count++; // ๋ฐฉ๋ฌธ ์์ ๊ธฐ๋ก
for (int next : list[start]) { // ์ฐ๊ฒฐ๋ ์ ์ ์ํ
if (isVisited[next] == 0) { // ๋ฐฉ๋ฌธํ์ง ์์ ๊ฒฝ์ฐ
DFS(next);
}
}
}
}
๐ ์ฝ๋ ์ค๋ช
๐ 1. ์ ๋ ฅ ์ฒ๋ฆฌ ๋ฐ ๊ทธ๋ํ ์ด๊ธฐํ
N = sToInt(st.nextToken()); // ์ ์ ๊ฐ์
M = sToInt(st.nextToken()); // ๊ฐ์ ๊ฐ์
R = sToInt(st.nextToken()); // ์์ ์ ์
isVisited = new int[N + 1]; // ๋ฐฉ๋ฌธ ์์ ์ ์ฅ ๋ฐฐ์ด
list = new ArrayList[N + 1];
// ์ธ์ ๋ฆฌ์คํธ ์ด๊ธฐํ
for (int i = 0; i <= N; i++) {
list[i] = new ArrayList<>();
}
- ์ ์ ๊ฐ์(N), ๊ฐ์ ๊ฐ์(M), ์์ ์ ์ (R) ์ ์ ๋ ฅ๋ฐ์
- isVisited[] ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ๋ฐฉ๋ฌธ ์์๋ฅผ ๊ธฐ๋ก
- list[] ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ ์ฅ
๐ 2. ๊ฐ์ ์ ๋ณด ์ ๋ ฅ ๋ฐ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
// ๊ฐ์ ์ ๋ณด ์
๋ ฅ
for (int i = 0; i < M; i++) {
st = new StringTokenizer(br.readLine());
int a = sToInt(st.nextToken());
int b = sToInt(st.nextToken());
list[a].add(b);
list[b].add(a);
}
// ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ (ํฐ ์ซ์๋ถํฐ ํ์)
for (int i = 1; i <= N; i++) {
list[i].sort(Collections.reverseOrder());
}
- ArrayList[]๋ฅผ ์ฌ์ฉํ์ฌ ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ์์ผ๋ก ๊ฐ์ ์ ๋ณด๋ฅผ ์ ์ฅ
- ์ ์ ๋ฒํธ๊ฐ ํฐ ์์๋๋ก ๋ฐฉ๋ฌธํ๊ธฐ ์ํด Collections.reverseOrder()๋ก ์ ๋ ฌ
๐ 3. DFS ํ์
// DFS ์คํ
DFS(R);
- ์์ ์ ์ (R)๋ถํฐ DFS ํ์์ ์์
๐ 4. DFS ํ์ ๊ตฌํ
static void DFS(int start) {
isVisited[start] = count++; // ๋ฐฉ๋ฌธ ์์ ๊ธฐ๋ก
for (int next : list[start]) { // ์ฐ๊ฒฐ๋ ์ ์ ์ํ
if (isVisited[next] == 0) { // ๋ฐฉ๋ฌธํ์ง ์์ ๊ฒฝ์ฐ
DFS(next);
}
}
}
- DFS๋ฅผ ์คํํ๋ฉด์ ๋ฐฉ๋ฌธ ์์๋ฅผ ๊ธฐ๋ก
- ์ฐ๊ฒฐ๋ ์ ์ ์ค ๋ฐฉ๋ฌธํ์ง ์์ ์ ์ ๋ค์ ์์๋๋ก ๋ฐฉ๋ฌธ
- ์ด๋ฏธ ๋ฐฉ๋ฌธํ ์ ์ ์ ๋ค์ ๋ฐฉ๋ฌธํ์ง ์์
๐ฅ ์๊ฐ ๋ณต์ก๋ ๋ถ์
์ฐ์ฐ | ์ต์ ์ ๊ฒฝ์ฐ ์ํ ํ์ ์๊ฐ ๋ณต์ก๋ | ์๊ฐ ๋ณต์ก๋ |
๊ฐ์ ์ ๋ ฅ ๋ฐ ์ ๋ ฌ | M log M | O(M log M) |
DFS ํ์ | N + M | O(N + M) |
์ดํฉ | O(N + M log M) |
โ ๋น ๋ฅธ DFS ํ์์ด ๊ฐ๋ฅํ๋ฉฐ, ๊ทธ๋ํ์ ํฌ๊ธฐ๊ฐ ํฌ๋๋ผ๋ ํจ์จ์
๐ ์ ๋ฆฌ
โ ํต์ฌ ํฌ์ธํธ
โ DFS๋ฅผ ์ฌ์ฉํ์ฌ ๊ทธ๋ํ๋ฅผ ํ์ํ๋ฉฐ ๋ฐฉ๋ฌธ ์์๋ฅผ ๊ธฐ๋ก
โ ์ ์ ์ด ํฐ ์ซ์๋ถํฐ ๋ฐฉ๋ฌธํด์ผ ํ๋ฏ๋ก ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
โ ๋ฐฉ๋ฌธ ์์๋ isVisited[] ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ์ ์ฅ
๐ฏ ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ฅ์
โ
DFS๋ฅผ ํ์ฉํ์ฌ ๋น ๋ฅด๊ฒ ํ์ ๊ฐ๋ฅ
โ
์ธ์ ๋ฆฌ์คํธ + ์ ๋ ฌ์ ํตํด ์ ์ ๋ฐฉ๋ฌธ ์์ ์ ์ด ๊ฐ๋ฅ
โ
O(N + M log M) ์๊ฐ ๋ณต์ก๋๋ก ํจ์จ์ ์ธ ํ์ ๊ฐ๋ฅ
์ด ๊ธ์ด ๋์์ด ๋์
จ๋ค๋ฉด ์ข์์์ ๊ณต์ ๋ถํ๋๋ฆฝ๋๋ค!
๊ถ๊ธํ ์ ์ ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์! ๐
'Algorithm & Data Structures > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
b24445. ์๊ณ ๋ฆฌ์ฆ ์์ - ๋๋น ์ฐ์ ํ์ 2 (1) | 2025.03.06 |
---|---|
b24444. ์๊ณ ๋ฆฌ์ฆ ์์ - ๋๋น ์ฐ์ ํ์ 1 (0) | 2025.03.04 |
b3015. ์ค์์์ค ์ฌ๊ฒฐํฉ (0) | 2025.02.25 |
b.1725 ํ์คํ ๊ทธ๋จ (0) | 2025.02.06 |
b.17299 ์ค๋ฑํฐ์ (1) | 2025.02.04 |