๐ ์๋ฐ๋ก ํธ๋ ์ฌ์ดํด ๊ฒ์ ๋ฌธ์ ํ์ด
๐ ๋ฌธ์ ๊ฐ์
๋ฐฑ์ค 20040 - ์ฌ์ดํด ๊ฒ์ ๋ฌธ์ ๋
N๊ฐ์ ์ ์ ์ด ์๊ณ , M๊ฐ์ ๊ฐ์ ์ ์์ฐจ์ ์ผ๋ก ์ฐ๊ฒฐํ ๋
์ฌ์ดํด์ด ์ฒ์ ์๊ธฐ๋ ์์ ์ ์ถ๋ ฅํ๋ ๋ฌธ์ ์ ๋๋ค.
- ๊ฐ์ ์ ์ฐจ๋ก๋ก ์ฐ๊ฒฐ๋๋ฉฐ,
- ๊ฐ์ ์ ์ฐ๊ฒฐํ ๋ ์ฌ์ดํด์ด ์๊ธฐ๋ฉด ๊ทธ **์ฐจ๋ก(1-indexed)**๋ฅผ ์ถ๋ ฅ
- ๋๊น์ง ์ฌ์ดํด์ด ์์ผ๋ฉด 0์ ์ถ๋ ฅ
๐ก ์์ ์ ๋ ฅ
6 5
0 1
1 2
2 3
0 3
4 5
์์ ์ถ๋ ฅ
4
๐ง ์๊ณ ๋ฆฌ์ฆ ์ ๊ทผ ๋ฐฉ์
์ด ๋ฌธ์ ๋ ์ ํ์ ์ธ Union-Find(์๋ก์ ์งํฉ) ์๊ณ ๋ฆฌ์ฆ์ ํ์ฉํด
์ฌ์ดํด์ ํ์งํ๋ ๋ฌธ์ ์ ๋๋ค.
- ๊ฐ์ ์ ํ๋์ฉ ์ฐ๊ฒฐํ๋ฉฐ, ๋ ๋ ธ๋๊ฐ ์ด๋ฏธ ๊ฐ์ ์งํฉ์ด๋ฉด ์ฌ์ดํด ๋ฐ์
- ๊ทธ๋ ์ง ์์ผ๋ฉด ๋ ์งํฉ์ ํฉ์นจ (union)
- ์ฌ์ดํด์ด ์๊ธด ์ฒซ ๋ฒ์งธ ๊ฐ์ ์ ๋ฒํธ๋ฅผ ์ถ๋ ฅ
๐งพ ์ฝ๋ ํด์ค
// ๋ถ๋ชจ ๋ฐฐ์ด ์ด๊ธฐํ
p = new int[N + 1];
for (int i = 1; i <= N; i++) {
p[i] = i;
}
// ๊ฐ์ ๋ง๋ค ์ฌ์ดํด ์ฌ๋ถ ์ฒดํฌ
for (int i = 0; i < M; i++) {
int a = Integer.parseInt(st.nextToken());
int b = Integer.parseInt(st.nextToken());
if (find(a) == find(b)) {
sb.append(i + 1);
check = false;
break;
} else {
union(a, b);
}
}
private static int find(int a) {
if (a == p[a]) return p[a];
return p[a] = find(p[a]); // ๊ฒฝ๋ก ์์ถ
}
private static void union(int a, int b) {
int pa = find(a);
int pb = find(b);
if (pb < pa) {
int temp = pa;
pa = pb;
pb = temp;
}
p[pb] = pa;
}
- find(): ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ฐพ์ ๊ฒฝ๋ก ์์ถ
- union(): ์์ ๋ฒํธ๋ฅผ ๋ถ๋ชจ๋ก ์ผ์ ๋ณํฉ (์ ๋ ฌ์ ์ ํ)
- ์ฌ์ดํด ํ๋ณ: find(a) == find(b)์ผ ๋ ์ฌ์ดํด ๋ฐ์
โ ํต์ฌ ํฌ์ธํธ
- Union-Find๋ก ์ฐ๊ฒฐ ์ฌ๋ถ๋ฅผ ์ถ์
- ์ฌ์ดํด์ ๋ ์ ์ ์ด ์ด๋ฏธ ๊ฐ์ ์งํฉ์ ์์ ๋ ์๊ธด๋ค
- ๋ฌธ์ ์ ํต์ฌ์ ์ฌ์ดํด์ด ์ฒ์ ์๊ธฐ๋ ์์ ์ ์ฐพ๋ ๊ฒ์ด๋ค
๐ฏ ๊ฒฐ๋ก : Union-Find๋ก ์ฌ์ดํด์ ์ก์๋ด๋ค
์ด ๋ฌธ์ ๋ DFS, BFS ์์ด ์งํฉ๋ง ๊ด๋ฆฌํด๋ ์ฌ์ดํด์ ๊ฐ์งํ ์ ์๋ค๋ ์ ์์
๊ทธ๋ํ์ ํต์ฌ์ ์ธ ์ฌ๊ณ ์ธ “์ฐ๊ฒฐ๊ณผ ์งํฉ”์ ์ฐ์ตํ๊ธฐ์ ์ข์ ๋ฌธ์ ์ ๋๋ค.
์ฐ๊ฒฐ → ๊ฐ์ ์งํฉ
์ฌ์ดํด → ์ด๋ฏธ ์ฐ๊ฒฐ๋ ์งํฉ์ ๋ ์ฐ๊ฒฐํ๋ ค ํ ๋
'Algorithm & Data Structures > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
b1774. ์ฐ์ฃผ์ ๊ณผ์ ๊ต๊ฐ (0) | 2025.05.14 |
---|---|
b4386. ๋ณ์๋ฆฌ ๋ง๋ค๊ธฐ (0) | 2025.05.13 |
b9372. ์๊ทผ์ด์ ์ฌํ (0) | 2025.05.11 |
b4195. ์น๊ตฌ๋คํธ์ํฌ (0) | 2025.05.08 |
b1976. ์ฌํ๊ฐ์ (0) | 2025.05.06 |