1. ์ ์ฅํธ๋ฆฌ๋?
- ๊ทธ๋ํ์์ 1) ๋ชจ๋ ๋
ธ๋๋ฅผ ํฌํจํ๋ฉด์ 2) ์ฌ์ดํด์ด ์กด์ฌํ์ง ์๋ ๋ถ๋ถ ๊ทธ๋ํ๋ฅผ ์๋ฏธ
- ์ด๋ ํธ๋ฆฌ์ ์กฐ๊ฑด์ด๊ธฐ๋ ํจ
2 . ์ต์์ ์ฅํธ๋ฆฌ
- ์ต์์ ๋น์ฉ์ผ๋ก ๊ตฌ์ฑ๋๋ ์ ์ฅ ํธ๋ฆฌ๋ฅผ ์ฐพ์์ผ ํ ๋
- N๊ฐ์ ๋์๊ฐ ์กด์ฌํ๋ ์ํฉ์์ ๋ ๋์ ์ฌ์ด์ ๋๋ก๋ฅผ ๋์ ์ ์ฒด ๋์๊ฐ ์๋ก ์ฐ๊ฒฐ ๋ ์ ์๊ฒ ๋๋ก๋ฅผ ์ค์นํ๋ ๊ฒฝ์ฐ
3. ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ
- ๊ฐ์ฅ ๋ํ์ ์ธ ์ต์ ์ ์ฅ ํธ๋ฆฌ ์๊ณ ๋ฆฌ์ฆ
- ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๋ถ๋ฅ
- ๋์ ๊ณผ์
- ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋น์ฉ์ ๋ฐ๋ผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
- ๊ฐ์ ์ ํ๋์ฉ ํ์ธํ๋ฉฐ ํ์ฌ์ ๊ฐ์ ์ด ์ฌ์ดํด์ ๋ฐ์์ํค๋์ง ํ์ธ
์ฌ์ดํด์ด ๋ฐ์ํ์ง ์๋ ๊ฒฝ์ฐ → ์ต์ ์ ์ฅ ํธ๋ฆฌ์ ํฌํจ
์ฌ์ดํด์ด ๋ฐ์ํ๋ ๊ฒฝ์ฐ → ์ต์ ์ ์ฅ ํธ๋ฆฌ์ ํฌํจ X
- ๋ชจ๋ ๊ฐ์ ์ ๋ํ์ฌ 2๋ฒ์ ๊ณผ์ ์ ๋ฐ๋ณต
- ๊ฒฐ๋ก ์ต์ ์ ์ฅ ํธ๋ฆฌ์ ํฌํจ๋์ด ์๋ ๊ฐ์ ์ ๋น์ฉ๋ง ๋ชจ๋ ๋ํ๋ฉด, ๊ทธ ๊ฐ์ด ์ต์ข
๋น์ฉ์ ํด๋น
#ํน์ ์์๊ฐ ์ํ ์งํฉ์ ์ฐพ๊ธฐ
def find_parent(parent, x):
#๋ฃจํธ ๋
ธ๋๋ฅผ ์ฐพ์ ๋๊น์ง ์ฌ๊ท ํธ์ถ
if parent[x] != x:
parent[x] = find_parent(parent, parent[x])
return parent[x]
#๋ ์์๊ฐ ์ํ ์งํฉ์ ํฉ์น๊ธฐ
def union_parent(parent, a, b):
a = find_parent(parent, a)
b = find_parent(parent, b)
if a < b:
parent[b] = a
else:
parent[a] = b
#๋
ธ๋์ ๊ฐ์์ ๊ฐ์ (Union ์ฐ์ฐ)์ ๊ฐ์ ์
๋ ฅ ๋ฐ๊ธฐ
v, e = map(int, input().split())
parent = [0] * (v+1) # ๋ถ๋ชจ ํ
์ด๋ธ ์ด๊ธฐํํ๊ธฐ
#๋ชจ๋ ๊ฐ์ ์ ๋ด์ ๋ฆฌ์คํธ์, ์ต์ข
๋น์ฉ์ ๋ด์ ๋ณ์
edges = []
result = 0
#๋ถ๋ชจ ํ
์ด๋ธ์์์, ๋ถ๋ชจ๋ฅผ ์๊ธฐ ์์ ์ผ๋ก ์ด๊ธฐํ
for i in range(1, v+1):
parent[i] = i
#๋ชจ๋ ๊ฐ์ ์ ๋ํ ์ ๋ณด๋ฅผ ์
๋ ฅ ๋ฐ๊ธฐ
for _ in range(e):
a, b, cost = map(int, input().split())
#๋น์ฉ์์ผ๋ก ์ ๋ ฌํ๊ธฐ ์ํด์ ํํ์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๋น์ฉ์ผ๋ก ์ค์
#ํํ์์๋ ์ฒซ๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํจ
edges.append((cost,a,b))
#๊ฐ์ ์ ๋น์ฉ์์ผ๋ก ์ ๋ ฌ
edges.sort()
#๊ฐ์ ์ ํ๋์ฉ ํ์ธํ์ฌ
for edge in edges:
cost, a, b = edge
#์ฌ์ดํด์ด ๋ฐ์ํ์ง ์๋ ๊ฒฝ์ฐ์๋ง ์งํฉ์ ํฌํจ
if find_parent(parent, a) != find_parent(parent, b):
union_parent(parent, a, b)
result +=cost
print(result)
4. ์ฑ๋ฅ๋ถ์
- ๊ฐ์ ์ ๊ฐ์๊ฐ N๊ฐ์ผ ๋, O(NlogN)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง
- ๊ฐ์ฅ ๋ง์ ์๊ฐ ๊ฑธ๋ฆฌ๋ ๊ณณ: ๊ฐ์ ์ ๋ ฌ์ํ ๋ถ๋ถ
- sort()๋ฅผ ์ด์ฉํด N๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๊ธฐ ์ํ ์๊ฐ ๋ณต์ก๋๋ O(NlogN)
5. ์ฐธ๊ณ ์๋ฃ
https://www.youtube.com/watch?v=Gj7s-Nrt1xE