|
์ฝ๋ ์์ฑํ๊ธฐ
#include<vector>
#include<queue>
#include<algorithm>
#include<utility>
using namespace std;
typedef pair<int, int>p;
vector<vector<p>>v;
priority_queue<p, vector<p>, greater<p>> pq; //์ค๋ฆ์ฐจ์ ์ฐ์ ์์ ํ ์ ์ธ
int answer;
bool check[105];
void prim(int start) { //ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ
pq.push({ 0,start }); //์์์ start๋ ๋ญ๋ ์๊ด X
while (!pq.empty()) {
p tmp = pq.top();
int now = tmp.second, cost = tmp.first;
pq.pop();
if (check[now])continue;
answer += cost;
check[now] = 1;
for (int i = 0; i < v[now].size(); i++) {
int next = v[now][i].second;
int ncost = v[now][i].first;
if (!check[next])pq.push({ ncost, next });
}
}
}
int solution(int n, vector<vector<int>> costs) {
v.resize(n);
for (int i = 0; i < costs.size(); i++) {//์ฃผ์ด์ง ๊ฐ์ ์ผ๋ก ๊ทธ๋ํ ๊ตฌ์ฑ
int from = costs[i][0], to = costs[i][1], cost = costs[i][2];
v[from].push_back({ cost,to });
v[to].push_back({ cost,from });
}
prim(0); //ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ ์์
return answer;
}
C++
๋ณต์ฌ
|
์ฝ๋ ์ค๋ช
ํ๊ธฐ
์ต์ ์คํจ๋ ํธ๋ฆฌ (Minimum Spanning Tree, MST)๋ฅผ ๋ง๋ค๊ณ MST ๋น์ฉ์ ํฉ์ ๊ตฌํ๋ MST์ ๊ธฐ๋ณธ ๋ฌธ์
MST๋ฅผ ์์ฑํ๋ ์๊ณ ๋ฆฌ์ฆ์๋ ๋ํ์ ์ผ๋ก ํ๋ฆผ, ํฌ๋ฃจ์ค์นผ ์๊ณ ๋ฆฌ์ฆ์ด ์๋ค .
ํ๋ฆผ๊ณผ ํฌ๋ฃจ์ค์นผ ๋ชจ๋ ๊ทธ๋ฆฌ๋ ๋ฐฉ์์ ์๊ณ ๋ฆฌ์ฆ์ธ๋ฐ, ํฌ๋ฃจ์ค์นผ์ Union & Find๋ฅผ ๊ตฌํํ ์ ์์ด์ผ ์ฌ์ฉํ ์ ์๋๋ฐ, Union & Find๊ฐ ๊ธฐ์ต์ด ๋์ง ์์ ํ๋ฆผ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํด๊ฒฐํ์๋ค.
์ฝ๋๋ BFS์ ๊ฑฐ์ ์ ์ฌํ๋ฐ, ๋ค๋ฅธ ์ ์ ๊ฐ์ (edge)์ ๊ฐ์ค์น(cost)๊ฐ ์๋ค๋ ์ ๊ณผ, ์ผ๋ฐ Queue๊ฐ ์๋ ๊ฐ์ ์ ๋น์ฉ์ด ์์ ๊ฒ ๋ถํฐ ์ ํํ๊ธฐ์ ์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํ๋ค๋ ์ .
์ฐ์ ์์ ํ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์๋ 2๊ฐ์ง๊ฐ ์๋๋ฐ
1.
์ค๋ฆ์ฐจ์์ผ๋ก ์ฐ์ ์์ ํ๋ฅผ ์์ฑ ๋ฐ ๋ฐ์ดํฐ ์ฝ์
2.
๋ด๋ฆผ์ฐจ์์ผ๋ก ์ฐ์ ์์ ํ์ ์์ฑ ๋ฐ ๋ฐ์ดํฐ ์ฝ์
์ cost์ -๋ฅผ ๋ถ์ฌ์ ์ฝ์
typedef pair<int, int>p;
priority_queue<p, vector<p>, greater<p>> pq1; //์ค๋ฆ์ฐจ์ ์ฐ์ ์์ ํ ์ ์ธ
priority_queue<p> pq2; // ๋ด๋ฆผ์ฐจ์ ์ฐ์ ์์ ํ ์ ์ธ
pq1.push({cost,node});
pq2.push({-cost,node});
//๋์ ๊ฐ์ ๋ฐฉ๋ฒ์ด๋ค
C++
๋ณต์ฌ
์ฝ๋์ ๋ํ ์ค๋ช
๋ณด๋จ MST์ ๋ํ์ฌ ๊ณต๋ถํ๋ฉด ํ ์ ์๋ ๋ฌธ์
BOJ์์ ์ ์ฌํ ๋ฌธ์