最小生成树算法（附模板）

最小生成树算法

带权值无向图的权值之和最小的生成树，称为最小生成树(MST, Minimum Spanning Tree)。

一、kruskal算法

1.1 注意事项

1-适用于边少的稀疏图
2-需要借助并查集实现（https://blog.csdn.net/weixin_44816732/article/details/112489321）
3-以边为中心, 每次找权最小的边添加到树上

1.2算法思路

输入： 图G
输出： 图G的最小生成树
具体流程：

1)将边按边权升序排序。

2)然后从最小的边开始选取加入生成树中（如果加入这条边后出现了环，那么这时就破坏了生成树的性质， 则不选择这条边）

3)这种选择一直进行到图中出现了一个生成树为止。

1.3模板

//Kruskal 算法
//made by singL

#include<bits/stdc++.h>
using namespace std;
#define maxn 1003
struct edge{
	int x,y,w;
}a[maxn];
bool cmp(edge a,edge b){
	return a.w<b.w;
}
//并查集定义开始
int f[maxn];//存储首领
int find(int a) {//查找首领
    if(f[a]==a)return a;
	else return f[a]=find(f[a]);
}
int join(int i, int j) {//合并团队
    f[find(i)] = find(j);
}
//并查集定义结束
int kruskal(int n, int m){//n：边数，m：点数
    int cnt = 0, res = 0;
    sort(a+1,a+n+1,cmp); //将边按照权值从小到大排序
    for(int i = 1; i <= n && cnt != m - 1; i++)
        //判断当前这条边的两个端点是否属于同一棵树
        if(find(a[i].x) != find(a[i].y)){
            join(a[i].x, a[i].y);
            res += a[i].w;
            cnt++;
        }
    //如果加入边的数量小于m - 1,则表明该无向图不连通,等价于不存在最小生成树
    if(cnt< m-1) res = -1;
    return res;
}
int main(){
	 int n, m, ans;//n：边数，m：点数
	 cin>>n>>m;
     for(int i=1;i<=m;i++)f[i]=i;	//初始化并查集
     for(int i = 1; i <= n; i++)scanf("%d%d%d", &a[i].x, &a[i].y, &a[i].w);
	ans=kruskal(n,m);
	cout<<"最小生成树权值为："<<ans<<endl;
	return 0;
}

二、prim算法

2.1 注意事项

1-以点为中心的, 每次找离树最近的点添加到树上
2-适用于边多的稠密图, 尤其是完全图. 因为在Kurscal算法中, 必须事先求出所有边的长度才能对之排序. 但是一个有5000节点的完全图, 这样做的空间开销是巨大的. Prim算法只在更新点到树的距离时需要用到边长, 因此对于给点坐标的完全图, 可以现用现算

2.2算法思路

2.3模板

2.3.1 邻接表形式

#include<bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n,m,vis[100],re = 0,d[100];
//vis为访问标记数组，re为最小生成树的边权之和，d为节点到生成树节点集合的距离。 
struct node{
	int v,dis;
};
//邻接表读入 
vector<node>e[100];
int prim(int start){
	//一. 初始化，将起始点与生成树的距离设为0 
	d[start] = 0;
	//二. 循环n（节点个数）次 
	for(int i = 0;i<n;i++){
		//三. 循环寻找节点，找到距离生成树最近且未访问的点 
		int min = INF ,u = -1;
		for(int j = 0;j<n;j++){
			if(vis[j] == 0 && d[j] < min){
				min = d[j];
				u = j;
			}
		} 
		//四. 将节点设为已经访问，且re加上距离 
		vis[u] = 1;
		re += d[u];
		//五. 循环之前找到的距离最小的节点u可以达到的节点 
		for(int k = 0;k<e[u].size();k++){
			//六. 如果可以改变周围节点到生成树的距离，就优化 
			int v = e[u][k].v;
			if(vis[v] == 0 && e[u][k].dis < d[v]){
				d[v] = e[u][k].dis; 
			}
		}
	}
	return re;
}
int main(){
	//freopen("a.txt","r",stdin);
	//初始节点都未访问 
	memset(vis,0,sizeof vis);  
	//与生成树的距离初始化为无穷大 
	memset(d,INF,sizeof d);
	cin>>n>>m;
	int u,v,k;
	for(int i = 0;i<m;i++){
		cin>>u>>v>>k;
		node a,b;
		a.v = v;
		a.dis = k;
		b.v = u;
		b.dis = k;
		e[u].push_back(a);
		e[v].push_back(b);
		//若图为无向图记得反向设置。 
	}
	cout<<prim(0);
	return 0;
} 

2.3.2 邻接矩阵形式

#include<iostream>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxx=1100;
int e[maxx][maxx];//邻接矩阵
int dis[maxx];//最小距离
bool vis[maxx];
int n,m;
int prim(int e[][maxx],int n)
{
    int ans=0;
    //初始化
    memset(book,0,sizeof(book));
    vis[0]=1;
    for(int i=1; i<n; i++)
        dis[i]=e[0][i];
     //搜寻到树距离最小的节点
    for(int i=1; i<n; i++)
    {
        int minn=inf,u=-1;
        for(int j=0; j<n; j++)
            if(!vis[j]&&dis[j]<minn)
            {
                minn=dis[j];
                u=j;
            }
         //添加新节点到树上
        ans+=minn;
        vis[u]=1;
        //更新各个点到新生成树的最小距离
        for(int v=0; v<n; v++)
            if(!book[v])
                dis[v]=min(dis[v],e[u][v]);
    }
    return ans;
}
int main()
{
		cin>>m>>n;
		for(int i=0; i<n; i++)
        	for(int j=0; j<n; j++)
           	 if(i==j)e[i][j]=0;
             else e[i][j]=inf;
    
        for(int i=0; i<n; i++)
        {
            int a,b,c;
            cin>>a>>b>>c;
            e[a-1][b-1]=e[b-1][a-1]=c;
         }
        
        cout<<prim(e,m)<<endl;

    return 0;
}

2.3.3 堆优化