๐ ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ MST(์ต์ ์คํจ๋ ํธ๋ฆฌ) ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ๋ค ์ค ํ๋์ ๋๋ค. (๋๋จธ์ง ํ๋๋ Prim ์๊ณ ๋ฆฌ์ฆ)
๐ก MST๋?
๊ทธ๋ํ์ ์ฐ๊ฒฐ์ฑ์ ๊ทธ๋๋ก ์ ์งํ๋ ๊ฐ์ฅ '์ ๋ ดํ' ๊ทธ๋ํ๋ฅผ ์ฐพ๋ ๋ฌธ์
ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ๊ทธ๋ํ์ ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค,
์คํจ๋ ํธ๋ฆฌ์ ํ๋์ฉ ์ถ๊ฐํด ๊ฐ๋ ๋ฐฉ์์ผ๋ก ๋์ํฉ๋๋ค.
ํ์ง๋ง, ๊ฐ์ค์น๊ฐ ์๋ค๊ณ ํด์ ๋ฌด์กฐ๊ฑด ๊ฐ์ ์ ํธ๋ฆฌ์ ๋ํ๋ ๊ฒ์ด ์๋, ์ฌ์ดํด์ด ์๊ธฐ๋ ๊ฐ์ ์ ๊ณ ๋ คํด ์ ์ธ ํด์ค๋๋ค.
๐ ๋์ํ๋ ๊ณผ์
์ ๊ทธ๋ํ๋ฅผ ๋ณด๋ฉด ๊ฐ์ค์น๊ฐ 1์ธ ๊ฐ์ , 2์ธ ๊ฐ์ , 3.. ์์๋๋ก ์ ํํด ๊ฐ๊ณ ์์ต๋๋ค.
์ด๋ 4๋ฒ์งธ์์ 5๋ฒ์งธ๋ฅผ ๋ณด๋ฉด ๊ฐ์ค์น๊ฐ 3์ธ ๊ฐ์ ๋ค์ด ๋จ์ ์๋๋ฐ๋ ๋ถ๊ตฌํ๊ณ ,
4์ธ (c,d) ๊ฐ์ ์ด ์ถ๊ฐ๋ฉ๋๋ค. ๊ทธ ์ด์ ๋ 3์ธ ๊ฐ์ ๋ค์ด ์ถ๊ฐ๋๋ฉด ํธ๋ฆฌ์ ์ฌ์ดํด์ด ์๊ธฐ๊ธฐ ๋๋ฌธ์ ๋๋ค.
ํธ๋ฆฌ์ ์ฌ์ดํด์ด ์๊ธด๋ค๋ฉด, MST๋ฅผ ๋ง์กฑํ์ง ๋ชปํฉ๋๋ค.
๐ ๊ตฌํ
ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ ์ ๋ชฉ๋ก์ ์ป์ด์ ๊ฐ์ค์น ์์๋๋ก ์ ๋ ฌํ ๋ค, ์ํํ๋ฉฐ ์ด๋ค์ ์คํจ๋ ํธ๋ฆฌ์ ์ถ๊ฐํฉ๋๋ค.
์ด๋ ๊ฐ์ ์ ์ถ๊ฐํ์ ๋ ์ฌ์ดํด์ด ์ด๋ฃจ๋์ง ์ฌ๋ถ๋ฅผ ํ๋จํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
์ด๋ฅผ ์ํด ๊น์ด ์ฐ์ ํ์์ ํ๋ฉฐ ์ญ๋ฐํฅ ๊ฐ์ ์ ์ฐพ๋ ํด๊ฒฐ์ฑ ๋ ์์ง๋ง, ๋ณต์ก๋๊ฐ ๋๊ฒ ๋์ค๊ธฐ ๋๋ฌธ์,
๊ฐ์ ์ ์ ๋ ์ ์ด ๊ฐ์ ์ปดํฌ๋ํธ์ ์ํด ์๋ ๊ฒ์ ๊ณ ๋ คํด ์ํธ ๋ฐฐํ์ ์งํฉ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉ ํ ์ ์์ต๋๋ค.
๐ก ์ํธ๋ฐฐํ์ ์งํฉ ์๋ฃ ๊ตฌ์กฐ๋?
์ฐธ๊ณ : https://withseungryu.tistory.com/40?category=753127
๐ ๊ตฌํ ์ฝ๋
const int MAX_V = 100; //๋ฌธ์ ์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค.
int V; //์ ์ ์ ๊ฐ์
vector<pair<int, int>> adj[MAX_V]; // ๊ทธ๋ํ์ ์ธ์ ๋ฆฌ์คํธ (์ฐ๊ฒฐ๋ ์ ์ ๋ฒํธ, ๊ฐ์ ๊ฐ์ค์น)
struct OptimizedDisjointSet {
vector<int> parent, rank;
OptimizedDisjointSet(int n) : parent(n), rank(n, 1) {
for (int i = 0; i < n; ++i)
parent[i] = i;
}
int find(int u) {
if (u == parent[u]) return u;
return parent[u] = find(parent[u]);
}
void merge(int u, int v) {
u = find(u); v = find(v);
if (u == v) return;
if (rank[u] > rank[v]) swap(u, v);
parent[u] = v;
if (rank[u] == rank[v]) ++rank[v];
}
};
int kruskal(vector<pair<int, int>> selected) {
int ret = 0;
selected.clear();
vector<pair<int, pair<int, int>>> edges; //(๊ฐ์ค์น, (์ ์ 1, ์ ์ 2))
for(int u=0; u<V; ++u)
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i].first, cost = adj[u][i].second;
edges.push_back(make_pair(cost, make_pair(u, v)));
}
sort(edges.begin(), edges.end()); // ๊ฐ์ค์น ์์ผ๋ก ์ ๋ ฌ
OptimizedDisjointSet sets(V);
for (int i = 0; i < edges.size(); ++i) {
int cost = edges[i].first;
int u = edges[i].second.first, v = edges[i].second.second;
if (sets.find(u) == sets.find(v)) continue; //์ด๋ฏธ u์ v๊ฐ ์ฐ๊ฒฐ๋์ด์์๊ฒฝ์ฐ
sets.merge(u, v);
selected.push_back(make_pair(u, v));
ret += cost;
}
return ret;
}
๐ก ์๊ฐ๋ณต์ก๋ : O(E* logE)
๊ถ๊ธํ์ ๊ฒ์ด ์์ผ์๋ฉด ์ธ์ ๋ ์ง ๋๊ธ ๋ฌ์์ฃผ์ธ์!
'Algorithm > Theory' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ (Prim Algorithm) (0) | 2020.07.29 |
---|---|
Union-Find, Disjoint Set (์ ๋์จ-ํ์ธ๋, ์ํธ ๋ฐฐํ์ ์งํฉ) (0) | 2020.06.22 |
์ธ๊ทธ๋จผํธ ํธ๋ฆฌ (๊ตฌ๊ฐ ํธ๋ฆฌ, Segment Tree) (0) | 2020.05.25 |
๋ฒจ๋ง-ํฌ๋ ์๊ณ ๋ฆฌ์ฆ (Bellman-Ford Algorithm) (0) | 2020.05.19 |
[c++] ์ ๋ ฅ์ ์ฌ๋ฌ ๊ฐ์ ํ ์คํธ ์ผ์ด์ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. (0) | 2020.02.04 |