最小生成树算法——Prim算法和Kruskal算法

最新推荐文章于 2022-04-26 19:16:46 发布
转载 最新推荐文章于 2022-04-26 19:16:46 发布 · 139 阅读 · 0

本文详细解析了Prim和Kruskal两种最小生成树算法的原理与实现，包括Prim算法的“加点法”和Kruskal算法的贪心思想及并查集应用，并附带经典题目解析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Prim算法理解，可以看这篇文章https://blog.youkuaiyun.com/yeruby/article/details/38615045

其实就是每次从当前树中外选取一个离树最近且不构成环的点，同时sum记录权值，然后把这个点加入树中，直到所有节点都被访问过，最小生成树生成成功，输出最小生成树的权值和。

下面是Prim算法的板子，和最短路有点相似，也称为“加点法”。


 
  1. 
   
    
    
    
   
    
   
    
    
    
     //最小生成树Prim算法 
    
    
   
  2. 
   
    
    
    
   
    
   
    
    
    
     #include<iostream>
    
    
   
  3. 
   
    
    
    
   
    
   
    
    
    
     #define INF 0x3f3f3f3f
    
    
   
  4. 
   
    
    
    
   
    
   
    
    
    
     using 
     namespace 
     std;
    
    
   
  5. 
   
    
    
    
   
    
   
    
    
    
     const 
     int maxn = 
     110;
    
    
   
  6. 
   
    
    
    
   
    
   
    
    
    
     int n,m;
    
    
   
  7. 
   
    
    
    
   
    
   
    
    
    
     int G[maxn][maxn];
    
    
   
  8. 
   
    
    
    
   
    
   
    
    
    
     int prim()
    
    
   
  9. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  10. 
   
    
    
    
   
    
   
    
    
    	
     int mst[maxn],sum=
     0,lowcost[maxn];
    
    
   
  11. 
   
    
    
    
   
    
   
    
    
    	
     //lowcost[i]: 表示以i为终点的边的最小权值,
    
    
   
  12. 
   
    
    
    
   
    
   
    
    
    	
     //当lowcost[i]=0说明以i为终点的边的最小权值=0,
    
    
   
  13. 
   
    
    
    
   
    
   
    
    
    	
     //也就是表示i点加入了MST
    
    
   
  14. 
   
    
    
    
   
    
   
    
    
        
     //mst[i]:表示对应lowcost[i]的起点，
    
    
   
  15. 
   
    
    
    
   
    
   
    
    
    	
     //即说明边<mst[i],i>是MST的一条边，
    
    
   
  16. 
   
    
    
    
   
    
   
    
    
    	
     //当mst[i]=0表示起点i加入MST  
    
    
   
  17. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     2;i<=n;i++){
    
    
   
  18. 
   
    
    
    
   
    
   
    
    
    
     		lowcost[i]=G[
     1][i];
    
    
   
  19. 
   
    
    
    
   
    
   
    
    
    
     		mst[i]=
     1;
     //初始化lowcost数组为到起始点的距离，mst数组为1（即所有点的起点都是1） 
    
    
   
  20. 
   
    
    
    
   
    
   
    
    
    
     	}
    
    
   
  21. 
   
    
    
    
   
    
   
    
    
    
     	mst[
     1]=
     0;
     //起始点进树 
    
    
   
  22. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int  i = 
     2;i<=n;i++){
    
    
   
  23. 
   
    
    
    
   
    
   
    
    
    		
     int minn=INF,minid=
     0;
    
    
   
  24. 
   
    
    
    
   
    
   
    
    
    		
     for(
     int j = 
     2;j<=n;j++)
     //遍历lowcost数组，查询最小值 
    
    
   
  25. 
   
    
    
    
   
    
   
    
    
    			
     if(minn>lowcost[j]&&lowcost[j]!=
     0)
    
    
   
  26. 
   
    
    
    
   
    
   
    
    
    
     			   minn=lowcost[minid=j];
    
    
   
  27. 
   
    
    
    
   
    
   
    
    
    
     //		printf("%d-%d=%d\n",mst[minid],minid,minn); 
    
    
   
  28. 
   
    
    
    
   
    
   
    
    
    
     		lowcost[minid]=
     0;
     //查询到的最短的点进树 
    
    
   
  29. 
   
    
    
    
   
    
   
    
    
    
     		sum+=minn;
    
    
   
  30. 
   
    
    
    
   
    
   
    
    
    		
     for(
     int j=
     2;j<=n;j++){
     //节点进树后更新外面的点到树的最短距离并且mst记录其起点 
    
    
   
  31. 
   
    
    
    
   
    
   
    
    
    			
     if(G[minid][j]<lowcost[j]){
    
    
   
  32. 
   
    
    
    
   
    
   
    
    
    
     				 lowcost[j]=G[minid][j];
    
    
   
  33. 
   
    
    
    
   
    
   
    
    
    
     				 mst[j]=minid;
    
    
   
  34. 
   
    
    
    
   
    
   
    
    
    
     			}  
    
    
   
  35. 
   
    
    
    
   
    
   
    
    
    
     		}
    
    
   
  36. 
   
    
    
    
   
    
   
    
    
    
     	}
    
    
   
  37. 
   
    
    
    
   
    
   
    
    
    	
     return sum;
    
    
   
  38. 
   
    
    
    
   
    
   
    
    
    
     } 
    
    
   
  39. 
   
    
    
    
   
    
   
    
    
    
     int main()
    
    
   
  40. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  41. 
   
    
    
    
   
    
   
    
    
    	
     scanf(
     "%d %d",&n,&m);
    
    
   
  42. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     1;i<=n;i++)
    
    
   
  43. 
   
    
    
    
   
    
   
    
    
    	   
     for(
     int j = 
     1;j<=n;j++)
    
    
   
  44. 
   
    
    
    
   
    
   
    
    
    
     	       G[i][j]=INF;       
     //初始化 
    
    
   
  45. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     1;i<=m;i++){
    
    
   
  46. 
   
    
    
    
   
    
   
    
    
    		
     int a,b,cost;
    
    
   
  47. 
   
    
    
    
   
    
   
    
    
    		
     scanf(
     "%d %d %d",&a,&b,&cost);
    
    
   
  48. 
   
    
    
    
   
    
   
    
    
    
     		G[a][b]=G[b][a]=cost;
    
    
   
  49. 
   
    
    
    
   
    
   
    
    
    
     	}
    
    
   
  50. 
   
    
    
    
   
    
   
    
    
    	
     int cost=prim();
    
    
   
  51. 
   
    
    
    
   
    
   
    
    
    	
     printf(
     "%d\n",cost);
    
    
   
  52. 
   
    
    
    
   
    
   
    
    
    	
     return 
     0;
    
    
   
  53. 
   
    
    
    
   
    
   
    
    
    
      }

其实也可以用一个visited数组来标记是否被访问过。

Kruskal算法（基于贪心思想和并查集的实现)

关于算法的理解可以看这篇博客https://blog.youkuaiyun.com/luoshixian099/article/details/51908175

不过上面博客的代码实现比较复杂。

关于并查集的理解可以看这篇文章https://blog.youkuaiyun.com/niushuai666/article/details/6662911

其实算法很好理解，就是先把图中所有边按照权值从小到大给他们排个序（贪心)，然后每次取一条边，判断边的起点和终点是否在一个连通分量里面，如果不在就合并,(这里关键在于连通分量的查询和合并），直到构成一棵最小生成树。

一谈到贪心，我们就不能简单的去用，还要能证明，不然说不定就错了（QAQ,就像01背包一样）

具体的证明过程可以去百度，或者看紫书356页。

下面给出伪代码的实现


 
  1. 
   
    
    
    
   
    
   
    
    
    
     把所有边排序，记第i小的边为e[i]（i<=
     1<m)
    
    
   
  2. 
   
    
    
    
   
    
   
    
    
    
     初始化MST为空
    
    
   
  3. 
   
    
    
    
   
    
   
    
    
    
     初始化连通分量为空，让每个点自成一个独立的连通分量
    
    
   
  4. 
   
    
    
    
   
    
   
    
    
    
     初始化sum=
     0
    
    
   
  5. 
   
    
    
    
   
    
   
    
    
    
     for(i=
     0;i<m(边的个数);i++)
    
    
   
  6. 
   
    
    
    
   
    
   
    
    
        
     if(e[i].u(起点)和e[i].v(终点)不在同一个连通分量中){
    
    
   
  7. 
   
    
    
    
   
    
   
    
    
    
              把边e[i]加入MST中
    
    
   
  8. 
   
    
    
    
   
    
   
    
    
    
              合并e[i].u和e[i].v所在的连通分量
    
    
   
  9. 
   
    
    
    
   
    
   
    
    
    
              sum+=e[i].w;(记录权值)
    
    
   
  10. 
   
    
    
    
   
    
   
    
    
    
         }
    
    
   
  11. 
   
    
    
    
   
    
   
    
    
     
    
    
   
  12. 
   
    
    
    
   
    
   
    
    
     
    
    
   
  13.

下面是代码具体实现，不过涉及到间接排序(不知道的可以百度，有点绕)，其实也可以开个结构数组排序。


 
  1. 
   
    
    
    
   
    
   
    
    
    
     #include <iostream>
    
    
   
  2. 
   
    
    
    
   
    
   
    
    
    
     #include<algorithm>
    
    
   
  3. 
   
    
    
    
   
    
   
    
    
    
     using 
     namespace 
     std;
    
    
   
  4. 
   
    
    
    
   
    
   
    
    
    
     int p[
     110],w[
     110],r[
     110],u[
     110],v[
     110];
    
    
   
  5. 
   
    
    
    
   
    
   
    
    
    
     //第i条边的两个端点序号和权值分别存储在u[i],v[i]和w[i]中
    
    
   
  6. 
   
    
    
    
   
    
   
    
    
    
     //排序后第i小的序号存储在r[i]中(间接排序，排序的是对象的代号而不是其本身) 
    
    
   
  7. 
   
    
    
    
   
    
   
    
    
    
     int n,m;
    
    
   
  8. 
   
    
    
    
   
    
   
    
    
    
     bool cmp(const int i ,const int j)//间接排序函数 
    
    
   
  9. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  10. 
   
    
    
    
   
    
   
    
    
    	
     return w[i]<w[j];
    
    
   
  11. 
   
    
    
    
   
    
   
    
    
    
     } 
    
    
   
  12. 
   
    
    
    
   
    
   
    
    
    
     int find(int x)//并查集的find 
    
    
   
  13. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  14. 
   
    
    
    
   
    
   
    
    
    	
     return p[x]==x?x:p[x]=find(p[x]);
     //路径压缩 
    
    
   
  15. 
   
    
    
    
   
    
   
    
    
    
     } 
    
    
   
  16. 
   
    
    
    
   
    
   
    
    
    
     void init()//初始化并查集和边的序号 
    
    
   
  17. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  18. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     1;i<=n;i++)
    
    
   
  19. 
   
    
    
    
   
    
   
    
    
    
     	   p[i]=i;
    
    
   
  20. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     1;i<=m;i++)
    
    
   
  21. 
   
    
    
    
   
    
   
    
    
    
     	   r[i]=i;
    
    
   
  22. 
   
    
    
    
   
    
   
    
    
    
     }
    
    
   
  23. 
   
    
    
    
   
    
   
    
    
    
     int Kruskal()
    
    
   
  24. 
   
    
    
    
   
    
   
    
    
    
     {
    
    
   
  25. 
   
    
    
    
   
    
   
    
    
    	
     int ans=
     0;
    
    
   
  26. 
   
    
    
    
   
    
   
    
    
    
     	init();
    
    
   
  27. 
   
    
    
    
   
    
   
    
    
    
     	sort(r,r+m,cmp);
     //给边排序 
    
    
   
  28. 
   
    
    
    
   
    
   
    
    
    	
     for(
     int i = 
     1;i<=m;i++){
    
    
   
  29. 
   
    
    
    
   
    
   
    
    
    		
     int e=r[i];
    
    
   
  30. 
   
    
    
    
   
    
   
    
    
    		
     int x=find(u[e]);
    
    
   
  31. 
   
    
    
    
   
    
   
    
    
    		
     int y=find(v[e]);
     //找出两个边所在集合的编号 
    
    
   
  32. 
   
    
    
    
   
    
   
    
    
    		
     if(x!=y){
    
    
   
  33. 
   
    
    
    
   
    
   
    
    
    
     			ans+=w[e];
    
    
   
  34. 
   
    
    
    
   
    
   
    
    
    
     			p[x]=y;
    
    
   
  35. 
   
    
    
    
   
    
   
    
    
    			
     //如果在不同集合，合并 
    
    
   
  36. 
   
    
    
    
   
    
   
    
    
    
     		}
    
    
   
  37. 
   
    
    
    
   
    
   
    
    
    
     	}
    
    
   
  38. 
   
    
    
    
   
    
   
    
    
    	
     return ans;
    
    
   
  39. 
   
    
    
    
   
    
   
    
    
    
     }
    
    
   
  40. 
   
    
    
    
   
    
   
    
    
    
     int main(int argc, char** argv) {
    
    
   
  41. 
   
    
    
    
   
    
   
    
    
    	
     while(
     scanf(
     "%d %d",&n,&m)!=EOF){
    
    
   
  42. 
   
    
    
    
   
    
   
    
    
    		
     for(
     int i = 
     0;i<m;i++)
    
    
   
  43. 
   
    
    
    
   
    
   
    
    
    			
     scanf(
     "%d %d %d",&u[i],&v[i],&w[i]);
    
    
   
  44. 
   
    
    
    
   
    
   
    
    
    		
     printf(
     "%d\n",Kruskal());
    
    
   
  45. 
   
    
    
    
   
    
   
    
    
    
     	}
    
    
   
  46. 
   
    
    
    
   
    
   
    
    
    	
     return 
     0;
    
    
   
  47. 
   
    
    
    
   
    
   
    
    
    
     }

然后就是各种习题的练习，下面给出一些经典的题和题解。

POJ 1251Jungle Roads —— POJ1251题解

POJ 1287 Networking —— POJ1287题解

POJ 2031 Building a Space Station——POJ2031题解

POJ 2421 Constructing Roads —— POJ2421题解

ZOJ1586QS Network —— ZOJ1586题解

POJ1789Truck History —— POJ1789题解

POJ2349Arctic Network——POJ2349题解

POJ1751Highways——POJ1751题解

邻接矩阵存储 - Prim最小生成树算法
lshsgbb2333的博客
12-04 1275
Vertex FindMinDist( MGraph Graph, WeightType dist[] ) { /* 返回未被收录顶点中dist最小者 */ Vertex MinV, V; WeightType MinDist = INFINITY; for (V=0; V<Graph->Nv; V++) { if ( dist[V]!=0 && dist[V]
最小生成树算法——Prim & Kruskal个人总结
qq_39109729的博客
09-27 1580
最小生成树算法——Prim & Kruskal总结与代码实例 Prim算法     Prim算法的思想是：对于原始图G(V,E)，建立一个集合S，从图的某个顶点开始（顶点可以是指定顶点，也可以是随机的顶点），逐步从点集V-S中选择到S中顶点距离最小的顶点加入S，并把该条最短路径加入最小生成树。 在实现的过程中，Prim算法与求解单源最短路径算法Dijkstra算法几乎一致，唯一不同之处在于最短距离数组d[MAXN]的含义与处理方式。下面给出邻接矩阵版的pri
最小生成树-Prim算法
weixin_30423977的博客
05-02 287
Prim算法 1.概览 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英...
最小生成树之Prim算法
热门推荐
Enstein_Jun
08-23 1万+
普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克发现；并在1957年由美国计算机科学家罗伯特·普里姆独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。
【数据结构】最小生成树之prim算法和kruskal算法
weixin_34162629的博客
08-30 1308
在日常生活中解决问题经常需要考虑最优的问题，而最小生成树就是其中的一种。看了很多博客，先总结如下，只需要您20分钟的时间，就能完全理解。 比如：有四个村庄要修四条路，让村子能两两联系起来，这时就有最优的问题，怎样修才是做好的，如下图：第一个是网全图，后三个图的修路方案都可以 1.树的定义：有n个顶点和n-1条边，没有回路的称为树 生成树的定义：生成树就是包含全部顶点，n-1（n为顶点数）...
基于Qt框架的最小生成树算法(Prim和Kruskal)动态可视化实现及其应用
最新发布
05-09
内容概要：本文介绍了利用Qt框架实现Prim和Kruskal两种最小生成树算法的动态可视化项目。该项目不仅展示了这两种算法的具体执行过程，还提供了详细的源代码和技术解析。Prim算法通过维护两个节点集合之间的最短边...
图论中的最小生成树算法：Prim与Kruskal算法详解
12-07
最小生成树算法的应用广泛，在诸如网络设计、电路设计、交通规划、图像处理等多个领域都有着重要的应用。例如，在城市规划中，最小生成树算法可以用来找到成本最低的方案，来铺设连接不同城市的光缆网络。在图像处理...
最小生成树算法之Prim算法
01-01
这就叫最小生成树算法，最典型的两种算法就是Kruskal算法和本文要讲的Prim算法。 2.Prim算法的步骤是什么？ 这就要涉及一些图论的知识了。 a.假定图的顶点集合为V，边集合为E. b.初始化点集合U={u}.//u为V中的任意...
最小生成树 Prim算法
hellocsz的博客
06-20 487
假设以下情景，有一块木板，板上钉上了一些钉子，这些钉子可以由一些细绳连接起来。假设每个钉子可以通过一根或者多根细绳连接起来，那么一定存在这样的情况，即用最少的细绳把所有钉子连接起来。更为实际的情景是这样的情况，在某地分布着N个村庄，现在需要在N个村庄之间修路，每个村庄之前的距离不同，问怎么修最短的路，将各个村庄连接起来。以上这些问题都可以归纳为最小生成树问题，用正式的表述方法描述为：给定一个无方向...
最小生成树：Prim算法
08-05
使用Prim算法求解图的最小生成树，其中图用邻接矩阵存储。
最小生成树算法（prim算法）
fakerzhang的博客
04-26 292
最小生成树算法（prime算法）
最小生成树prim算法
当个码农写bug
06-30 918
这里有一个无向图, 求其最小生成树 对应的图G的邻接矩阵g为 (INF 为无穷) 0 1 2 3 4 5 6 7 8 0 0 10 INF INF 11 INF INF INF INF 1 10 0 18 12 INF 12 INF INF INF 2 INF 18 0 INF INF 6 INF 8 INF 3 INF 12 INF 0 9 INF 10 INF INF 4 11 INF INF 9 0 INF INF INF 4 5 INF 12 6 INF IN
最小生成树（prim算法）
umalaka的博客
04-27 291
题目：最小生成树（prim算法）prim算法简单来说就是加点法，如下图所示：    用邻接矩阵存放整个图的信息（注意无向图的对称性），用一个整型数组on[]来存放已经加入的点，用一个结构体数组存放每个点的信息，包括与之距离最短的点another，两点的权值weigh，以及flag标记是否已被选取。    先将第一个点放入on[]数组中，每次放入的时候所有未选用的点信息都需要更新（即比较上一次最短距...
最小生成树——Prim算法
A-lex的博客
09-20 347
package MinTree; import java.awt.*; import java.util.Arrays; import java.util.Scanner; public class Prim { static int INF=100000; public static void main(String args[]){ Scanner sc=new Scanner(System.in); int n=sc.nextInt(); .
最小生成树之prim算法
闲云野鹤的专栏
11-26 1084
转载地址：http://blog.chinaunix.net/uid-25324849-id-2182922.html 边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。    最小生成树（MST）：权值最小的生成树。    生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小
hdu_oj1102Constructing Roads
_C9的博客
03-15 169
Constructing Roads Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 38214Accepted Submission(s): 14102 Problem Description There are N villages, which are numbered from 1 to N, and you should...
ACM图论算法：最小生成树实现——Prim & Kruskal
Prim算法是一种贪心算法，它从一个初始顶点开始，逐步添加边来构建最小生成树，每次添加一条与当前树连接且权重最小的边。在提供的代码中，`prim()`函数实现了Prim算法。首先，用一个二维数组`ad`存储图的邻接矩阵...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值