最小生成树（MST）Prim算法和Kruskal算法

最近在看数据结构的考研课程，前期跟着y总学过一部分算法基础，但是建立在不懂图论，不会离散数学和数据结构的基础之上，学得非常非常吃力还不知道为什么吃力，现在回过头来（说实话，这个觉悟来的太迟了）去看这个最小生成树的代码，明显变得简单易学了，现在再看y总的代码，也能真正感受到y总强大的代码逻辑了。所以结合y总的代码和我的理解，记录以下思路。

最小生成树(Minimun Spanning Tree)

针对带权连通无向图而言，表示权值之和最小的树，最小生成树的树形可能不唯一，但是权值之和一定唯一且最小，因为是树（无环连通无向图），所以一定有n个顶点和n-1条边。

除此之外，最小生成树能保证全局的权值最小，但不能保证任意两个点之间的路径长度最短，适用于解决例如设计最低成本的网络结构，最低成本的电路布线，最低成本的道路规划等诸如此类的问题。

最常用的两种算法是Prim算法和Kruskal算法，下面将分别介绍他们。

Prim算法

858. Prim算法求最小生成树 - AcWing题库

主要思路

从没有加入最小生成树的点中选择一个到最小生成树代价最小的点，将他加入到最小生成树当中（更新点的状态和当前权值之和），然后更新所有的点到当前生成树的最短距离（lowcost[]数组）----主要更新的是没在生成树中的，且和刚刚新加入的点邻接的点的lowcost[]的值，但是在邻接矩阵找邻接点需要遍历所有的点，所以干脆直接更新所有的点到当前生成树的最短距离，即整个lowcost[]数组。

主要步骤

1.找lowcost[]数组最小值的点 O(V)

2.将该点加入最小生成树 O(1)

3.更新整个lowcost[]数组 O(V)

具体代码

#include<bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f
#define MAX 0x3f

const int N=5020;
int g[N][N];
int lowcost[N];
bool st[N];
int m,n;
 
int Prim()
{
	int res=0;
	memset(st,false,sizeof(st));
	memset(lowcost,MAX,sizeof(lowcost));
	for(int i=0;i<m;i++) 
	{
		int k=-1;
		for(int j=1;j<=m;j++)   //第一轮循环只加入一个顶点，后面每轮加入一个顶点和一条边，所以第一轮需要特殊处理
		{
			if(!st[j]&&(k==-1||lowcost[k]>lowcost[j]))    
            //!st[j]&&k==-1:第一轮循环默认从第一个点开始，此时lowcost[k]==INF,需要特殊处理
			{
				k=j;
			}                                             //找到没有进入最小生成树的代价最小的点 
		}
		if(i&&lowcost[k]==INF) return INF;  //特殊处理 
		if(i) 
		{
            //st[k]=true; //写在此处是错的，因为第一个点的时候虽然没有权值，但是还是需要将点加入到最小生成树当中的 
			res+=lowcost[k];                             //将这个点加入最小生成树 
		}                        
		for(int j=1;j<=m;j++)
		{ 
			lowcost[j]=min(lowcost[j],g[k][j]);        //更新没有加入的点的最小代价 
		}
		st[k]=true;
	}
	return res;
}

int main()
{
	memset(g,MAX,sizeof(g));
	freopen("A.txt","r",stdin);
	cin>>m>>n;  //m个顶点,n条边 
	while(n--)
	{
		int a,b,c;
		cin>>a>>b>>c;
		g[a][b]=min(g[a][b],c);
		g[b][a]=min(g[b][a],c);
	}
	int t=Prim();
	if(t!=INF) cout<<t<<endl;
	else cout<<"不存在最小生成树"<<endl;
	return 0; 	
}

时间复杂度：O(V²)，因为和边无关，所以适用于边稠密带权连通无向图

Kruskal算法

859. Kruskal算法求最小生成树 - AcWing题库

主要思路

排序所有的边，然后从小到大遍历所有的边，如果边的两个端点不连通，就使他们连通，如果已经连通，就不要这条边，直到所有顶点都连通为止。

用到并查集，即一开始所有的顶点都不连通，如果要求两个顶点连通，就用Union(a,b)将两个顶点连通，如果要求检查两个点是否连通就用Find(x)找到两个点的祖先，然后通过比较两个祖先是否相等来判断两个点是否连通。

对顶点的存储用到的是双亲表示法，即用一个数组p[x]表示x结点的双亲，对边的存储由于涉及排序，所以用一个struct结构体来存储

1.排序 O(ElogE)

2.找祖先节点 O(logE)

具体代码

#include<bits/stdc++.h>

using namespace std;

#define INF 0x3f3f3f3f

const int N=200020;
int m,n;
int p[N];   //用来存放每个节点的父节点（下标x表示当前节点，p[x]表示x的父节点） 

struct edge
{
	int a,b,w;
	bool operator<(const edge &W)const  //重载< 
	{
		return w<W.w;
	}
}edge[N];

int find(int x)   //只有根节点的p[x]==x:是一个递归出口 
{
	if(p[x]!=x) p[x]=find(p[x]);    //p[x]一开始是父节点，到后来就变成祖先节点
	return p[x];
}

int Kruskal()
{
	int res=0; 
	int cnt=0; 
	for(int i=1;i<=n;i++) p[i]=i;  //并查集初始化 
	sort(edge+1,edge+n+1);  //排序
	for(int i=1;i<=n;i++)
	{
		int a=edge[i].a;
		int b=edge[i].b;
		a=find(a);
		b=find(b); 
		if(a!=b)
		{
		    p[a]=b;  //将这两个点连通 
		    res+=edge[i].w;
		    cnt++;
		}
	} 
	if(cnt<m-1) return INF;   //m个顶点的生成树需要m-1条边 
	return res;
}

int main()
{
	freopen("A.txt","r",stdin);
	cin>>m>>n;  //m个顶点,n条边 
	for(int i=1;i<=n;i++)
	{
		int a,b,w;
		cin>>a>>b>>w;
		edge[i].a=a;
		edge[i].b=b;
		edge[i].w=w;
	}
	int t=Kruskal();
	if(t==INF) cout<<"不存在最小生成树"<<endl; 
	else cout<<t<<endl;
	return 0;
}

时间复杂度：O(ElogE)，适用于边稀疏带权连通无向图

总结

现在总算是彻底理解这两个算法，学算法的过程怎么说呢，拖泥带水，破罐子破摔了好久好久，最后结果是该什么样还是什么样。

希望现在自己不要半途而废，好好复习，积极向上，脚踏实地。