Kurskal算法

kurskal算法的核心思想是将边按权值排序，每次选出权值最小的边，只要不会形成回路就加入结果集，如果形成了回路就不选这条边，类似于贪心的思想。

具体做法是先将边按权值升序排序然后依次遍历，判断是否形成回路的方法是将点划分不同集合，初始状态每个点为一个集合，只有当一条边的两端分别位于两个集合时才选择这条边，否则就丢弃，这里用到了并查集来处理集合关系，可以参考这篇博文：https://www.cnblogs.com/czc1999/p/11823820.html，选择一条边之后要将两个点合并到同一集合。

模板题： https://www.luogu.com.cn/problem/P3366

代码如下，还是比较好理解的，时间复杂度为(O(MlogM))。

#include <iostream>
#include <algorithm>
using namespace std;

int n, m;
int pre[5005];
int Find(int x) { return pre[x] == x ? pre[x] : pre[x] = Find(pre[x]); }

struct line
{
	int from, to, val;
	bool operator<(line a) { return val < a.val; }
}Arr[200005];

int Kruskal()
{
	sort(Arr, Arr + m);
	int cnt = n, res = 0;
	for (int i = 0; i < m && cnt > 1; i++)
	{
		int x = Find(Arr[i].from), y = Find(Arr[i].to);
		if (x != y)//x和y不在一个集合
		{
			pre[x] = y;//合并两个集合
			cnt--;//找到了一条边
			res += Arr[i].val;
		}
	}
	return cnt == 1 ? res : -1;//如果cnt不等于1说明没找到n-1条边，无最小生成树
}

int main() {
	cin >> n >> m;
    for (int i = 0; i < n; i++)pre[i] = i;
	for (int i = 0; i < m; i++)cin >> Arr[i].from >> Arr[i].to >> Arr[i].val;
	int res = Kruskal();
	if (-1 == res)cout << "orz"; else cout << res;
	return 0;
}

prim算法

Kruskal算法是选择边的思路，而prim算法通过选择点来得到最小生成树，有点类似于Dijkstra的感觉，初始源点可以任意选择，把点划分成已选择的点和未选择的点两个集合，需要维护一个dis数组代表每个点到已选择点的最短距离，不断把dis最小的未选择点加入已选择点集合然后更新dis，当所有点都变成已选择点(dis==0)的时候就得到了最小生成树。

代码如下，真的是跟Dijkstra很像了。

#include <iostream>
#include <algorithm>
using namespace std;

#define inf 2000000000
int n, m;
int dis[5005];
int total = 0;
int head[5005], val[400005], to[400005], nextL[400005];

void AddLine(int a, int b, int c)
{
	total++;
	to[total] = b;
	val[total] = c;
	nextL[total] = head[a];
	head[a] = total;
}

int Prim()
{
	int res = 0;
	for (int i = 2; i <= n; i++)dis[i] = inf;

	for (int i = 0; i < n; i++)//循环n次找n个点
	{
		int Min = inf, u = 1;
		for (int j = 1; j <= n; j++)//找下一个最近的未选择点
		{
			if (dis[j] != 0 && dis[j] < Min)
			{
				Min = dis[j]; u = j;
			}
		}
		if (Min == inf && u != 1)return -1;//如果遍历之后未选择点dis都为inf，说明该图是非连通图
		res += dis[u];
		dis[u] = 0;
		for (int j = head[u]; j; j = nextL[j])//更新该点周围的dis
		{
			if (dis[to[j]] > val[j])dis[to[j]] = val[j];
		}
	}
	return res;
}

int main() {
	cin >> n >> m;
	int a, b, c;
	for (int i = 0; i < m; i++)
	{
		cin >> a >> b >> c;
		AddLine(a, b, c);
		AddLine(b, a, c);
	}
	int res = Prim();
	if (-1 == res)cout << "orz"; else cout << res;
	return 0;
}

堆优化

既然prim也是要每次取dis最小的点，当然也和Dijkstra一样可以用堆优化，朴素的prim时间复杂度为(O(n^2))，优化后达到(O(nlogn))，代码如下：

#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;

#define inf 2000000000
int n, m;
int dis[5005];
int total = 0;
int head[5005], val[400005], to[400005], nextL[400005];
bool mark[5005];

void AddLine(int a, int b, int c)
{
	total++;
	to[total] = b;
	val[total] = c;
	nextL[total] = head[a];
	head[a] = total;
}

typedef pair<int, int> p;
priority_queue<p, vector<p>, greater<p>> q;

int Prim()
{
	int res = 0;
	for (int i = 2; i <= n; i++)dis[i] = inf;
	q.push(p(0, 1));
	while (!q.empty())
	{
		int u=q.top().second,v=q.top().first;
		q.pop();
		if (mark[u])continue;
		mark[u] = true;
		dis[u] = 0;
		res += v;
		for (int i = head[u]; i ; i=nextL[i])
		{
			if (dis[to[i]] > val[i])
			{
				dis[to[i]] = val[i];
				q.push(p(val[i], to[i]));
			}
		}
	}
	return res;
}

int main() {
	cin >> n >> m;
	int a, b, c;
	for (int i = 0; i < m; i++)
	{
		cin >> a >> b >> c;
		AddLine(a, b, c);
		AddLine(b, a, c);
	}
	int res = Prim();
	if (-1 == res)cout << "orz"; else cout << res;
	return 0;
}

所以选择使用哪个算法就看是点多还是边多了。