最小生成树（算法）

最小生成树（算法）
1.普利姆算法（Prim）
朴素版Prim
(1)适用范围
(2)模板
(3)算法思路
(4例题：Prim算法求最小生成树
堆优化版Prim
(1)适用范围
2.克鲁斯卡尔算法（Kruskal）
(1)适用范围
(2)模板
(3)算法思路
(4)例题：Kruskal算法求最小生成树
(5)优点

最小生成树（算法）

最小生成树问题就是解决如何用最小的“代价”，用N-1条边连接N个点的问题

1.普利姆算法（Prim）

朴素版Prim

(1)适用范围

适用于稠密图（常用）

(2)模板

时间复杂度是 O(n2+m)O(n2+m), nn 表示点数， mm 表示边数

int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 0;
    for (int i = 0; i < n; i ++ )
    {
        int t = -1;
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

(3)算法思路

（与Dijkatra算法极为相似）
①先将所有距离都初始化为正无穷 dist[i]<-+∞
②n次迭代：
for(int i=0;i<n;i++)
{
①找到集合外距离最近的点赋值给t
②用t更新其他点到集合的距离 （与Dijkatra算法的区别：Dijkatra算法为 用t更新其他点到起点的距离）
③把t加到集合当中去s[t]=ture

}

(4)例题：Prim算法求最小生成树

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N=510;

int n,m;
int g[N][N];
int dist[N];
bool st[N];

int prim()
{
	memset(dist,0x3f,sizeof dist);	

	int res=0;
	for(int i=0;i<n;i++)
	{
		int t=-1;
		for(int j=1;j<=n;j++)
		{
			if(!st[j]&&(t==-1||dist[t]>dist[j]))
			t=j;
		}
		if (i && dist[t] ==INF) return INF;

		if(i) res+=dist[t];
		for(int j=1;j<=n;j++) dist[j]=min(dist[j],g[t][j]);
		st[t]=true;
	}
	return res;
}

int main()
{
	
	scanf("%d%d",&n,&m);
	
	memset(g,0x3f,sizeof g);
	
	while(m--)
	{
		int a,b,c;
		scanf("%d%d%d",&a,&b,&c);
		g[a][b]=a[b][a]=min(g[a][b],c);
	}
	int t=prim();
	
	if(t==INF) puts("impossible");
	else printf("%d\n");	
	
	return 0;
}

堆优化版Prim

(1)适用范围

适用于稀疏图（基本不用）
（因为用不太到，所以此处省略一万字…）

2.克鲁斯卡尔算法（Kruskal）

(1)适用范围

适用于稀疏图（常用）

(2)模板

时间复杂度是 O(mlogm)O(mlogm), nn 表示点数， mm 表示边数

int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }

    if (cnt < n - 1) return INF;
    return res;
}

(3)算法思路

①将所有边按照从小到大顺序排序。（可以用快速排序，一般应用中使用sort函数因为排序导致了此算法的瓶颈，时间复杂度为O(mlogn)）
②从小到大枚举每条边a–b，权重为w（核心思想，时间复杂度为O(m)）
如果if当前a和b不连通的话 ，（实际上为并查集的简单应用）
则将a–b这条边加入集合中。
（只要这条对应的两个点不在集合当中的话，我们就把这条边加入集合当中）

(4)例题：Kruskal算法求最小生成树

#include <iostream>    
#include <algorithm>

using namespace std;

const int N=200010;         //注意范围大小 

int n,m;
int p[N];                //并查集操作中要使用这个数组 

struct Edge                //开一个结构体来存所有边 
{
	int a,b,w;             // a,b为边的两个顶点，w为边的权重 
	
	bool operator< (const Edge &W)const  //重载一下小于号,方便按照权重来排序 
	{
		return  w<W.w;
	}
}edges[N];


int find(int x)                   //并查集模板 
{
	if(p[x]!=x) p[x]=find(p[x]);      
	return p[x];
}

int main()
{
	scanf("%d%d",&n,&m);
	
	for(int i=0;i<m;i++)
	{
		int a,b,w;
		scanf("%d%d%d",&a,&b,&w);    
		edges[i]={a,b,w};        //把所有的边读入进去 
	}
	//下面为kruskal算法 
	sort(edges,edges+m);          //第一步先把所有边排序 
	
	for(int i=1;i<n;i++)           //初始化一下并查集 
	p[i]=i;
	
	int res=0,cnt=0;              
	for(int i=0;i<m;i++)           //从小到大枚举所有边 
	{
		int a=edges[i].a,b=edges[i].b,w=edges[i].w;
		
		a=find(a),b=find(b);       //find为并查集函数，让a等于a子通结点，b等于b的子通结点 
		if(a!=b)                    //如果两个子通结点不连通的话，即判断两个子通结点是否相等 
		{
			p[a]=b;                 //两条边加入进之后，再将这两条边合并 
			res+=w;                 //先把权重加进来，res存的是最小生成树中的所有树边的权重之和 
			cnt++;                   //cnt存的是当前加入了多少条边 
		}                   
	}
	                                      //判断加入进多少条边
	if(cnt<n-1) puts("impossible");        //加进的边小于n-1的话，说明这个图为不连通的 
	else printf("%d\n",res);                 //否则输出所有树边长度之和 
	
	return 0;
	
	
}

(5)优点

①稀疏图的最小生成树问题常用此方法。
②思路简单，不太用考虑边界问题。
③不需要邻接表，邻接矩阵来存图，只要把每条边存进去就可以了，所以开一个结构体来存，不需要用复杂的数据结构。

小编寄语：
因为今天是植树节，所以特此学习了最小生成树问题的算法，嘿嘿，还比较有意思吧。愿疫情过后，大家携手建起绿色地球。
（文中部分内容代码若发现错误，还请多多指教~~）