最小生成树 - 技术栈

一个有 n n n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n n n 个结点，并且有保持图连通的最少的边。最小生成树是所有生成树中遍全总和最小的那个，它可以用 Kruskal 算法或 Prim 算法求出。

一、Prim 算法

思想：循环 n n n 次，每次选出一个没被选过的点，加入到最小生成树中，每次循环都会更新最小值。

代码：

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
int n,m,a,b,c;
int mp[1010][1010];
int inf = 1e9;
int d[1010],vis[1010];
int ret;
void prim()
{
	for (int i = 1;i <= n;i++) d[i] = inf;
	d[1] = 0;
	for (int step = 1;step <= n;step++)
	{
		int id = -1,min = inf;
		for (int i = 1;i <= n;i++) if (!vis[i] && d[i] < min) min = d[i],id = i;
		if (id == -1)
		{
			printf("-1");
			return ;
		}
		ret += min;
		vis[id] = 1;
		for (int i = 1;i <= n;i++) if (!vis[i] && mp[i][id] < d[i]) d[i] = mp[i][id];
	}
	cout << ret;
	return ;
}
int main() {
	cin >> n >> m;
	for (int i = 1;i <= n;i++) for (int j = 1;j <= n;j++) mp[i][j] = inf;
	for (int i = 1;i <= m;i++) cin >> a >> b >> c,mp[a][b] = mp[b][a] = min(mp[a][b],c);
	prim();
	return 0;
}

二、Kruskal 算法

前置知识：并查集

并查集，在一些有 N N N 个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，期间要反复查找一个元素在哪个集合中。这一类问题反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间内计算出试题需要的结果，只能用并查集来描述。

并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。常常在使用中以森林来表示，其实顾名思义就是既能合并，又能查询的集合。

题目：并查集

现在有一个并查集，你需要完成合并和查询操作。

第一行包含两个整数 N , M N,M N,M，表示共有 N N N 个元素和 M M M 个操作。

接下来 M M M 行，每行包含三个整数 Z i , X i , Y i Z_i,X_i,Y_i Zi,Xi,Yi。

当 Z i = 1 Z_i=1 Zi=1 时，将 X i X_i Xi 与 Y i Y_i Yi 所在的集合合并。

当 Z i = 2 Z_i=2 Zi=2 时，输出 X i X_i Xi 与 Y i Y_i Yi 是否在同一集合内，是的输出 y，否则输出 N。

对于每个 Z i = 2 Z_i=2 Zi=2，输出一行一个字符 Y 或 N。

思路：利用一个 fa[i] 数组记录每个结点的父节点，通过 find 函数求出每个集合的根结点。

find 函数核心代码：return x == fa[x] ? fa[x] = find(fa[x]);

并查集代码：

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
int n,m;
int fa[100010];
int find(int x)
{
	//核心代码 find 函数
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}
int main()
{
	cin >> n >> m;
	for (int i = 1;i <= n;i++) fa[i] = i;
	for (int i = 1;i <= m;i++)
	{
		int a,b,c;
		cin >> a >> b >> c;
		if (a == 1)
		{
			int fx = find(b),fy = find(c);
			if (fx != fy) fa[fx]= fy;
		}
		else
		{
			int fx = find(b),fy = find(c);
			if (fx != fy) cout << "N\n";
			else cout << "Y\n";
		}
	}
	return 0;
}

而 Kruskal 的想法与并查集类似：将每个点看做一个集合，作出并查集的操作，求出最小值。

代码：

cpp 复制代码

#include <bits/stdc++.h>
using namespace std;
int n,m;
struct node
{
	int a,b,c;
}e[100010];
bool cmp(node a,node b)
{
	return a.c < b.c;
}
int fa[100010];
int find(int x)
{
	return x == fa[x] ? x : fa[x] = find(fa[x]);
}
int kruskal()
{
	for (int i = 1;i <= n;i++) fa[i] = i;
	int ans,cnt;
	ans = cnt = 0; 
	for (int i = 1;i <= m;i++)
	{
		int fx = find(e[i].a),fy = find(e[i].b);
		if (fx != fy)
		{
			cnt++;
			ans += e[i].c;
			if (cnt == n-1) break;
		}
		fa[fy] = fx;
	}
	return ans;
}
int main()
{
	cin >> n >> m;
	for (int i = 1;i <= m;i++) cin >> e[i].a >> e[i].b >> e[i].c;
	sort(e+1,e+m+1,cmp);
	cout << kruskal();
	return 0;
}

个人认为 Kruskal 算法更好理解，你觉得呢？