最小生成树：Prim和Kruskal算法原理及实现

目录

概念：最小生成树

性质 

Prim算法

基本思想

实现

Kruskal

基本思想

实现 

---

概念：最小生成树

最小生成树（Minimum Spanning Tree，MST）是在一个给定的无向图G(V,E)中求一个树T，使得这棵树拥有图G中所有顶点，且所有边都来自于G中的边E。

性质 

• 最小生成树是树，因此其边数等于顶点数-1，且树内一定不会有环
• 对给定的图G（V,E），其最小生成树可以不唯一，但其边权之和一定是唯一的
• 由于最小生成树实在无向图上生成的，因此其根节点可以是这棵树上的任意一个节点。

Prim算法

基本思想

对图G（V,E）设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与S的最短距离的一个顶点（记为u），访问并加入集合S。

之后令u为中介点，优化所有从u能到达的顶点v与集合S之间的最短距离。

执行n次（n为顶点数），直到集合S已包含所有顶点。

可以发现，prim算法与Dijkstra算法思想几乎完全相同，只是在涉及到最短距离时使用了集合S来代替Dijkstra中的起点S。

 

 

 

实现

• 集合S的实现方法和Dijkstra中相同，使用一个bool型数组vis[]表示顶点是否已经被访问，其中vis[i]==true表示顶点Vi已被访问，vis[i]==false则表示顶点Vi未被访问
• 不妨令int数组d[]来存放顶点Vi与集合S的最短距离。初始时除了起点s的d[s]为0，其余都为INF，表示不可达

prim算法与Dijkstra使用思想几乎完全相同，只有在数组d[]的含义上有所区别。

其中Dijkstra算法的数组d[]含义为起点s到Vi的最短距离，而prim算法则是集合S到Vi的最短距离。

const int INF=100000000;
const int MAXV=1000;
 
int n,G[MAXV][MAXV];
int d[MAXV];
bool vis[MAXV]={false};
 
int prim(){//ĬÈÏ0ºÅΪÆðʼµã£¬º¯Êý·µ»Ø×îСÉú³ÉÊ÷±ßȨ֮ºÍ 
	fill(d,d+n,INF);
	d[0]=0;
	int ans=0;
	for(int i=0;i
		int u=-1,MIN=INF;
		for(int j=0;j
			if(vis[j]==false && d[j]
				u=j;
				MIN=d[j];
			}
		}
		if(u==-1)return -1;
		vis[u]=true;
		ans+=d[u];
		for(int v=0;v
			if(vis[v]==false && G[u][v]!=INF && G[u][v]
				d[v]=G[u][v];
			}
		}
	}	
	return ans;
} 

与Dijkstra区别只在这一句代码：

Prim：

		for(int v=0;v
			if(vis[v]==false && G[u][v]!=INF && G[u][v]
				d[v]=G[u][v];
			}
		}

Dijkstra：

 
		for (int v = 0; v < n; v++) {
			//如果v未访问 && u能到达v && 以u为中介可以使d[v]更优
			if (vis[v] == false && G[u][v] != INF && d[u] + G[u][v] < d[v]) {
				d[v] = d[u] + G[u][v];
			}
		}

Kruskal

基本思想

边贪心，思想及其简洁，理解难度比prim算法低很多

kruskal算法的基本思想为：在初始状态时隐去图中所有边，这样图中的每个顶点都自成一个连通块，之后执行以下步骤：

1. 对所有边按边权从小到大进行排序
2. 按边权从小到大测试所有边，如果当前测试边所连接的两个顶点不再同一个连通块中，则把这条测试边加入当前的最小生成树中；否则，舍弃该边
3. 执行步骤2，直到最小生成树中的边数等于总顶点数-1，或者，测试完了所有边的时候结束。而当结束时如果最小生成树的边数小于总顶点数-1，说明该图不连通

实现 

有两个问题需要解决：

• 如何判断边的两个端点是否在不同的连通块中
  • 通过并查集，查询两个节点所在集合的根节点是否相同来判断他们是否在同一个集合
• 如何将测试边加入到最小生成树中
  • 并查集合并的功能，即把测试边的两个端点所在集合合并，就达到了将边加入最小生成树的效果

#include 
#include 
#include 
 
using namespace std;
 
const int MAXV=110;
const int MAXE=10010;
 
struct edge{
	int u,v;
	int cost;
}E[MAXE];
 
bool cmp(const edge&a,const edge& b){
	return a.cost
}
 
int father[MAXV];
int find(int x){
	int a=x;
	while(x!=father[x]){
		x=father[x];
	}
	while(a!=father[a]){
		int z=a;
		a=father[a];
		father[z]=x;
	}
	return x;
}
 
int Kruskal(int n,int m){
	int ans=0;
	int num_edge=0;
	for(int i=1;i<=n;i++){
		father[i]=i;
	}
	sort(E,E+m,cmp);
	for(int i=0;i
		int fatherU=find(E[i].u);
		int fatherV=find(E[i].v);
		if(fatherU!=fatherV){
			father[fatherU]=fatherV;
			ans+=E[i].cost;
			num_edge++;
			if(num_edge==n-1)break;
		}		
	}
	if(num_edge!=n-1)return -1;
	else return ans;
}
 
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=0;i
		cin>>E[i].u>>E[i].v>>E[i].cost;
	}
	int ans=Kruskal(n,m);
	cout<
	return 0;
}