图论学习笔记 - 最小生成树

前言

给定一张边带权的无向图 G=(V,E) 由 V 中全部 n 个顶点和 E 中 n-1 条边构成的无向联通子图被称为 G 的一颗生成树。边的权值之和最小的生成树被称为无向图 G 的最小生成树。

所以任意一颗最小生成树一定包含无向图中权值最小的边。

Kruskal 算法

Kruskal 算法总是维护无向图的最小生成森林。最初生成森林由零条边构成，每个节点各自构成一颗仅包含一个点的树。在任意时刻，Kruskal 算法从剩余的边中选出一条权值最小的，并且这条边的两个端点属于生成森林中两棵不同的树（不连通），把该边加入生成森林。图中节点的连通情况可以用并查集维护

并查集yyds！！！

具体流程：

1. 建立并查集，每个点各自构成一个集合
2. 把所有边按照权值从大到小排序，依次遍历（x,y,z）
3. 若 x,y 属于同一个集合（连通），则忽略这条边，继续扫描下一条边
4. 否则，合并 x,y 所在的集合，并把 z 累加到答案中
5. 所有边扫描完成后，第4布中处理过的边就构成最小生成树

时间复杂度 O（mlogm）

题目：洛谷P3366 【模板】最小生成树

代码示例：

（请注意本代码并不能AC此题）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

const int maxn=1010000;
int n,m,ans;
int fa[maxn];

struct Edge{
	int x;
	int y;
	int z;
}e[maxn];

bool cmp(const Edge &a,const Edge &b){return a.z<b.z;}

int get(int x){
	if(fa[x]==x) return x;
	return fa[x]=get(fa[x]);
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) fa[i]=i;
	for(int i=1;i<=m;i++) cin>>e[i].x>>e[i].y>>e[i].z;
	sort(e+1,e+1+m,cmp);
	for(int i=1;i<=m;i++){
		int x=get(e[i].x);
		int y=get(e[i].y);
		if(x==y) continue;
		fa[x]=y;
		ans+=e[i].z;
	}
	cout<<ans<<endl;
	return 0;
}

其实想全部通过测试，只要加上“orz”的判断就可以了，对于 Kruskal 算法来说就是要判断所有点是不是有同一个根父节点，对于 fa 数组，存储的只是 i 节点的父节点，所以我们要判断是不是所有点都在同一个根父节点下，可以借助判断有几个节点 i 是自己，进而来判断有几个根父节点，如果超过 1 个那肯定就是没连通，就出现问题了。

代码示例（AC版）：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

const int maxn=1010000;
int n,m,ans;
int fa[maxn];

struct Edge{
	int x;
	int y;
	int z;
}e[maxn];

bool cmp(const Edge &a,const Edge &b){return a.z<b.z;}

int get(int x){
	if(fa[x]==x) return x;
	return fa[x]=get(fa[x]);
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++) fa[i]=i;
	for(int i=1;i<=m;i++) cin>>e[i].x>>e[i].y>>e[i].z;
	sort(e+1,e+1+m,cmp);
	for(int i=1;i<=m;i++){
		int x=get(e[i].x);
		int y=get(e[i].y);
		if(x==y) continue;
		fa[x]=y;
		ans+=e[i].z;
	}
	int sum=0;
	for(int i=1;i<=n;i++){
		if(fa[i]==i&&sum==1){
			cout<<"orz"<<endl;
			return 0;
		}
		else if(fa[i]==i&&sum==0) sum++;
	}
	cout<<ans<<endl;
	return 0;
}

Prim 算法

Prim 算法总是维护最小生成树的一部分。最初，Prim 算法仅确定 1 号节点属于最小生成树。

在任意时刻，设已经确定属于最小生成树的节点集合为 T，剩余节点集合为 S。Prim 算法找到两个端点分别属于集合 S,T 的权值最小的边，然后把点 x 从集合 S 中删除，加入到集合 T，并把 z 累加到答案中。

具体来说，可以维护数组 d：若 x ∈ S，则 d[x] 表示节点 x 与集合 T 中的节点之间权值最小的边的权值。若 x∈T，则 d[x] 就等于 x 被加入 T 时选出的最小边的权值。

可以类比 Dijkstra 算法，用一个数组标记节点是否属于 T。每次从未标记的节点中选出 d 值最小的，把它标记（新加入 T），同时扫描所有出边，更新另一个端点的 d 值。最后，最小生成树的权值总和就是 d[x] 的全部和（x 属于 [1,N]）

Prim 算法的时间复杂度为 O()，同理可以用二叉堆优化到 O(mlogn)。这就不如 Kruskal 算法更简便了。因此，Prim 主要用于稠密图，尤其是完全图的最小生成树的求解。

代码示例：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;

const int maxn=1001000;
const int maxx=5010;
int n,m,ans;
int d[maxn];
int a[maxx][maxx];
bool vis[maxn];

void prim(){
	memset(d,0x3f,sizeof(d));
	memset(vis,0,sizeof(vis));
	d[1]=0;
	for(int i=1;i<n;i++){
		int x=0;
		for(int j=1;j<=n;j++){
			if(!vis[j]&&(x==0||d[j]<d[x])) x=j;
		}
		vis[x]=1;
		for(int y=1;y<=n;y++){
			if(!vis[y]) d[y]=min(d[y],a[x][y]);
		}
	}
}

int main(){
	cin>>n>>m;
	memset(a,0x3f,sizeof(a));
	for(int i=1;i<=n;i++) a[i][i]=0;
	for(int i=1;i<=m;i++){
		int x,y,z;
		cin>>x>>y>>z;
		a[y][x]=a[x][y]=min(a[x][y],z);
	}
	prim();
	for(int i=2;i<=n;i++) ans+=d[i];
	cout<<ans<<endl;
}