最小生成树

概述

在无向图中，若任意两个顶点Vi与Vj都有路径相连。则称该无向图为连通图；
在连通图中，若图的边具有一定的意义，每一条边都对应着一个数，称为权；权代表着连接两个顶点的代价，将这种连通图叫做连通网；
在一个有n个点，m条边的连通图中，取n个点和n-1条边组成的树叫做生成树。生成树中不存在环，若边数>=n，生成树中将会出现环；
树上权值总和最小的生成树叫做最小生成树。

算法描述

求最小生成树的一般算法可描述为：针对图G，从空树T开始，往集合T逐条选择并加入n-1条安全边(u,v),最终生成一颗含n-1条边的MST。
当一条边(u,v)加入T时，必须保证T U {(u,v)}仍是MST的子集，我们将这样的边称为T的安全边。

Kruskal算法简述
假设 WN =(V,{E})是一个含有n个顶点的连通网，则按照Kruskal算法构造最小生成树的过程为：先构造一个只含n个顶点，而边集为空的子图，若将该子图中各个顶点看作是各棵树上的根节点，则它是一个含有n棵树的一个森林。之后，从网的边集E中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一颗树；反之，若该条边的两个顶点已落在同一颗树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林里只有一颗树，也即子图中含有n-1条边为止。

Prim算法简述
1）输入：一个加权连通图，其顶点集合为V，边集合为E；
2）初始化：Vnew = {x}, 其中x为集合V中任一节点（起始点），Enew = {},为空；
3）重复下列操作1，直至Vnew=V:
        a.在集合E中选取权值最小的边<u,v>,其中u为集合Vnew中的元素，而V不在Vnew集合当中，并且v∈V（如果存在多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；
        b,将v加入集合Vnew中，将<u,v>边加入集合Enew中；
4）输出：使用集合Vnew和Enew来描述所得到的最小生成树。

实现

1.Kruskal实现

#include<iostream>
#include<string>
#include<algorithm>

using namespace std;

const int N = 1e5;
struct node {
	int l;  //节点1
	int r;  //节点2
	int w;  //权重
}e[N];

int gen[N];

bool cmp(const node& x,const node& y)
{
	return x.w < y.w;
}

//建议去看一下并查集
int find(int x)
{
	if (gen[x] != x)
		find(gen[x]);
	return gen[x];
}

int main(int argv, char **agrv)
{
	int sum =0, k = 0;
	int n, m;//点的个数以及边的个数
	cin >> n >> m;

	//初始化
	for (int i = 1; i <= n; i++)
	{
		gen[i] = i;
	}

	for (int i = 1; i <= m; i++)
	{
		cin >> e[i].l >> e[i].r >> e[i].w;
	}
	sort(e + 1, e + 1 + m, cmp);
	for (int i = 1; i <= m; i++)
	{
		int e1 = e[i].l;
		int e2 = e[i].r;
		int w = e[i].w;
		e1 = find(e1);
		e2 = find(e2);
		if (e1 != e2)
		{
			sum += w;
			//合并根节点
			gen[e2] = e1;
			k++;
		}

		if (k == n - 1)
		{
			cout << sum << endl;
			break;
		}
	}

	return 0;
}

2.prim实现

#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>

#define INF 0x3f3f3f3f

using namespace std;

const int maxn = 505;

int a[maxn][maxn];

int vis[maxn], dist[maxn];

int n, m;

int u, v, w;

long long sum = 0;

int prim(int pos) {
	dist[pos] = 0;
	// 一共有 n 个点,就需要 遍历 n 次,每次寻找一个权值最小的点,记录其下标
	for (int i = 1; i <= n; i++) {
		int cur = -1;
		for (int j = 1; j <= n; j++) {
			if (!vis[j] && (cur == -1 || dist[j] < dist[cur])) {
				cur = j;
			}
		}
		// 这里需要提前终止
		if (dist[cur] >= INF) return INF;
		sum += dist[cur];
		vis[cur] = 1;
		for (int k = 1; k <= n; k++) {
			// 只更新还没有找到的最小权值
			if (!vis[k]) dist[k] = min(dist[k], a[cur][k]);
		}
	}
	return sum;
}

int main(void) {
	scanf("%d%d", &n, &m);
	memset(a, 0x3f, sizeof(a));
	memset(dist, 0x3f, sizeof(dist));
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d", &u, &v, &w);
		a[u][v] = min(a[u][v], w);
		a[v][u] = min(a[v][u], w);
	}
	int value = prim(1);
	if (value >= INF) puts("impossible");
	else printf("%lld\n", sum);
	return 0;
}

总结

稀疏图一般选择 prim,采用 邻接矩阵 进行存储边之间的关系。
稠密图一般选择 Kruskal ,采用邻接表进行存储边之间的关系(更多采用结构体的方式)。