最小生成树——Prim&&Kruskal

DancingZ

墨衍会员 · AI 创作全网分发码龄9年

关注

原创最新推荐文章于 2024-08-15 16:07:03 发布 452 阅读 AI 写同款· GEO 优化 ›

大话数据结构-普里姆算法（Prim）和克鲁斯卡尔算法（Kruskal） 最小生成树的定义，普里姆算法（Prim）和克鲁斯卡尔（Kruskal），以及各种存储结构下的最小生成树的代码实现。阅读详情

这几天做的几套模拟题都要用最小生成树搞~忘得都差不多的我特地来打两个板子。

首先，二者均采用贪心策略。

算法过程：大概是不断从未知集合往已知集合加元素。

感性理解：对于一颗树中的节点(u,v)，如果二者间的边权w1小于u->v路径中的边权w2，显然断开w2连接w1更优，这时我们证明了对于max(u->v)<w(u,v)；而如果我们采用贪心策略每次选中连接未知集合和已知集合最小边，显然得到的u->v路径上的边都是最小的，即不存在更优解，那么贪心得到的解即是最优解。

#include<bits/stdc++.h>
using namespace std;
#define Inc(i,L,r) for(register int i=(L);i<=(r);++i)
const int N = 1010,Maxe=N*(N-1)/2;
struct Edge{
	int cnt,h[N],w[Maxe],to[Maxe],next[Maxe];
	inline void add(int x,int y,int z){
		next[++cnt]=h[x];to[cnt]=y;w[cnt]=z;h[x]=cnt;
	}
}e;
struct Node{
	int idx,dist;
	bool operator <(const Node&A)const {
		return A.dist<dist;
	}
};
struct MST{
	int n,m;
	bool vst[N];
	inline void init(){
		scanf("%d%d",&n,&m);
		Inc(i,1,m){
			int x,y,z;scanf("%d%d%d",&x,&y,&z);
			e.add(x,y,z),e.add(y,x,z);
		}
	}
	priority_queue<Node>Q;
	inline void Prim(){
		Q.push((Node){1,0});
		while(!Q.empty()){
			int x=Q.top().idx,dist=Q.top().dist;Q.pop();
			if(vst[x])continue;
			vst[x]=1;
			for(int p=e.h[x];p;p=e.next[p])
				if(!vst[e.to[p]])Q.push((Node){e.to[p],e.w[p]});
		}
	}
};

#include<bits/stdc++.h>
using namespace std;
#define Inc(i,L,r) for(register int i=(L);i<=(r);++i)
const int N = 510,M = 3e5+10;
struct edge{
	int u,v,w;
	bool operator <(const edge&A)const {
		return A.w>w;
	}
};
struct MST{
	int n,m,fa[N];
	edge e[M];
	inline void init(){//n个点，m条边 
		scanf("%d%d",&n,&m);
		for(int i=1;i<=m;i++){
			int x,y,z;scanf("%d%d%d",&x,&y,&z);
			e[i]=(edge){x,y,z};
		}
	}
	inline int getfa(int u){
		return u!=fa[u]?fa[u]=getfa(fa[u]):u;
	}
	inline void Kruskal(){
		sort(e+1,e+m+1);
		for(int i=1;i<=n;i++)fa[i]=i;
		for(int i=1;i<=m;i++){
			int nd1=e[i].u,nd2=e[i].v;
			int f1=getfa(nd1),f2=getfa(nd2);
			if(f1==f2)continue;
			fa[f2]=f1;
		}
	}
};

比较Prim和Kruskal算法，前者是针对点，后者是对于边。

那么，prim显然更加适合稠密图，kruskal则对于稀疏图更优。

顺带一提：我的prim写法为了和较大数据规模搞，用的优先队列+邻接表，于是时间复杂度(n+m)logm，实际上，可以用邻接矩阵存储保证严格n^2。

收录于