深入浅出Prim算法和Kruskal算法求最小生成树算法

深入浅出Prim算法和Kruskal算法求最小生成树：

Prim算法

​ 首先初始化距离 正无穷。

​ n 次迭代(因为要选中n个点)，找到不在集合(当前生成树)中的且距离当前块最小的点(记作)m点，，用m点去更新其他掉到集合中的点的距离，标记这个点，这里区别Dijkstra算法求单源最短路，Dijkstra算法是从未确定的点中找到距离最小的点，去更新到 初始点的距离。

传送门：
858. Prim算法求最小生成树 - AcWing题库

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=510,INF = 0x3f3f3f3f; //INF 表示正无穷
int n,m;
int dist[N];// 表示到集合中的最短距离
int g[N][N];
bool st[N];
 
 
int prim(){
	int res=0;
	memset(dist,0x3f,sizeof dist);//初始化距离
	for(int i=0;i<n;i++){ //一开始集合内没有任何点
		int t=-1;
		for(int j=1;j<=n;j++){
            // !st[j] 保证这个点在集合外
            // t==-1 表示当前没有找到任何一个点，比如一开始的时候，我们的结合中是没有任何一个点,我们默认放入第一个进去。
			if(!st[j]&&(t==-1||dist[t]>dist[j])){
				t=j;
			}
            // t 存放的是距离最小的点
		}
   
     	if (i && dist[t] == INF) return INF;
    // 第一轮的时候不加入，因为此时只有一个点
        if (i) res += dist[t];
		st[t]=true; //将t这个点放入集合中
		for(int j=1;j<=n;j++){
			  if(!st[j])
                {dist[j] = min(dist[j], g[t][j]); 
        }
		} 
			
	} 
	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] = g[b][a] = min(g[a][b], c); //保留长度最小的边，因为是最小生成树
    }
	
	 int t = prim();

    if (t == INF) puts("impossible");//不联通
    else printf("%d\n", t);
	
	return 0;
} 

Kruskal算法:

传送门：

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

算法思想：

​ 首先按照权重从小到大排序.

​ 依次处理每一对，看边的两个点是否联通，使用并查集，如果判断两个点联通，有一个共同的父亲就可以。

​ 终止条件是：加入了n-1条边。

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


using namespace std;
const int N =1e5+10,M=2e5+10,INF = 0x3f3f3f3f;
int n,m;
int p[N];
struct Node{
	int a,b,w;
	bool operator<(const Node& t){ // 重载小于运算符
		return w<t.w;
	}
	
} Nodes[M] ;//定义一个结构体数组

int find(int x){// 查找x的父亲元素
	if(p[x]!=x) p[x]=find(p[x]); // 这一步使用了路径压缩，也就是让孩子节点都指向了其祖宗元素
	return p[x]; 
} 

int  Kruskal(){
	
	sort(Nodes,Nodes+m);//排序
	
	for(int i=1;i<=n;i++) p[i]=i;
	int res=0,cnt=0;//res计算权值
	for(int i=0;i<m;i++){
		int a=Nodes[i].a,b=Nodes[i].b,w=Nodes[i].w;
		int fa=find(a),fb=find(b);
		if(fa!=fb){
			p[fa]=fb;//让a变成b的孩子
			cnt++;//边
			res+=w; 
		}
	}
	
	if(cnt<n-1) return INF;
	
	return res;
	
}

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);
        Nodes[i] = {a, b, w};//构造结构体数组
    }
	int res= Kruskal();
	if(res==INF) puts("impossible");
	else printf("%d\n",res);

   
    return 0;
}

当然了，排序的时候还可以这样写：

bool cmp(struct Node A, struct Node B)
{
	return A.w < B.w;
}
	sort(Nodes, Nodes + m,cmp);//第三个参数是一个比较规则