[Algorithm] ๐ ์ต์ ์ ์ฅ ํธ๋ฆฌ (MST, Minimum Spanning Tree)
๐ ์ต์ ์ ์ฅ ํธ๋ฆฌ(MST)
๐ ์ ์ฅ ํธ๋ฆฌ(Spanning Tree)
์ฐ๊ฒฐ ๊ทธ๋ํ
์์ ๊ทธ๋ํ ํ์์ ํตํด์ ์๊ธฐ๋ ํธ๋ฆฌ ์ฃ์ง๋ก ์ด๋ฃจ์ด์ง์ฌ์ดํด์ ๊ฐ์ง ์๋ ์ต์ ๋ถ๋ถ ๊ทธ๋ํ
๋ฅผ ์๋ฏธํ๋ค.- ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ์ด ์๋ก ์ฐ๊ฒฐ๋์ด ์์ผ๋ฉด์, ์ํ๊ตฌ์กฐ๊ฐ ๋ฐ๋ณต๋์ง ์๋๋ค.
- ์ต์ ๋ถ๋ถ์ด๋ - ๋ชจ๋ ์ ์ ์ ํฌํจํ๊ณ ,
๊ฐ์ ์ ๊ฐ์ : ์ ์ ์ ๊ฐ์ -1
๐ ์ต์ ์ ์ฅ ํธ๋ฆฌ(MST, Minimum Spanning Tree)
- ์ต์ ์ ์ฅ ํธ๋ฆฌ๋
Spanning Tree
์ค์์ ์ฌ์ฉ๋ ๊ฐ์ค์น์ ๊ฐ์ด ์ต์์ธ ํธ๋ฆฌ์ด๋ค.
์์ ๊ฐ์ด ๊ฐ ๊ฐ์ ๋ค์ ๊ธธ์ด์ ํฉ์ ์ต์๊ฐ ๋๋ ์ฐ๊ฒฐ ํธ๋ฆฌ๊ฐ MST์ด๋ค.
์ด๋ฅผ ๊ตฌํ๊ธฐ ์ํด์๋ 2๊ฐ์ง ์๊ณ ๋ฆฌ์ฆ์ด ์๋ค.
- Prim MST ์๊ณ ๋ฆฌ์ฆ (๋จ๊ณ์ ํ์ฅ)
- Kruskal MSt ์๊ณ ๋ฆฌ์ฆ (Greedy)
๐ Prim MST
- Tree ์ NotTree๋ฅผ ๊ตฌ๋ถํ์ฌ ์ ์ ์ ํ ๊ฐ์ฉ ์ถ๊ฐํด๊ฐ๋ฉด์ T๋ฅผ ์ฑ์๋๊ฐ๋ค.
๐ Kruskal MST
๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ผ์ข
์ผ๋ก ๋ณดํต ์ต์ ํ์ ์ด์ฉํ์ฌ ๊ตฌํ๋ค.
๋ชจ๋ ๊ทธ๋ํ ์ ์ ์ ์ต์ํ์ ๋ฃ์์ผ๋ก์จ ์์ํ๋ค.
- ์๊ฐ๋ณต์ก๋ : O(ElogE)
๐ธ 4๋ฒ์ ์ฌ์ดํด ํ๋จ - Union & Find ํ์ฉ
Union-Find
- ์๋ก์ ์งํฉ์ ํํํ ๋ ์ฌ์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ
3๊ฐ์ง ์ฐ์ฐ
- make-set(x)
- ์ด๊ธฐํ, arr[i] = i
- union(x, y)
- ํฉ์น๊ธฐ
- x, y๊ฐ ์ํ ์งํฉ์ ํฉ์น๋ ๊ณผ์ , ์ผ๋ฐ์ ์ผ๋ก parent = x, child = y
- O(N)
- find(x)
- ์ฐพ๊ธฐ, x๊ฐ ์ํ ์งํฉ์
์ต์์ ๋ ธ๋ ๋ฐํ
- O(N-1), ํธ๋ฆฌ์ ๋์ด์ ์๊ฐ ๋ณต์ก๋๊ฐ ๋์ผํ๋ค.
- ๊ฒฝ๋ก ์์ถํ ๊ฒฝ์ฐ ์์ ์๊ฐ
- ์ฐพ๊ธฐ, x๊ฐ ์ํ ์งํฉ์
union-find ์ฝ๋ ๊ตฌํ
#### make(){
for(int i=0; i < N; i++){
root[i] = i;
}
}
union(x, y)
boolean union(int from, int to){
int fromRoot = find(from);
int toRoot = find(to);
if(fromRoot == toRoot) return false;
else root[toRoot] = fromRoot;
return true;
}
find(x)
int find(int x){
if(root[x] == x) {
return x;
} else{
return find(root[x]); // ์ฌ๊ท๋ฅผ ์ด์ฉํ๋ ๋ฐฉ์
return root[x] = find(root[x]);
}
}
๐ ํฌ๋ฃจ์ค์ปฌ vs ํ๋ฆผ
ํ๋ฆผ์ ์๊ฐ๋ณต์ก๋ : O( E log(V)) ํฌ๋ฃจ์ค์นผ์ ์๊ฐ๋ณต์ก๋ : O( E log(E)) ์ฆ, ๊ทธ๋ํ ๋ด์ ๊ฐ์ ์ด ๋ง์ ๊ฒฝ์ฐ - ํ๋ฆผ์๊ณ ๋ฆฌ์ฆ ๊ฐ์ ์ด ์ ์ ๊ฒฝ์ฐ - ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ
๐ ๊ด๋ จ ์์
tag:MST
๊ฐ์ธ ๊ณต๋ถ ๊ธฐ๋ก์ฉ ๋ธ๋ก๊ทธ์
๋๋ค.
ํ๋ฆฌ๊ฑฐ๋ ์ค๋ฅ๊ฐ ์์ ๊ฒฝ์ฐ ์ ๋ณดํด์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.๐