最小生成树(Prim、Kruskal)算法，秒懂！

转x33g5p2x  于2021-09-30 转载在 其他  
字(6.3k)|赞(0)|评价(0)|浏览(320)

前言

在数据结构与算法的图论中，(生成)最小生成树算法是一种常用并且和生活贴切比较近的一种算法。但是可能很多人对概念不是很清楚，什么是最小生成树?
一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。

通俗易懂的讲就是最小生成树包含原图的所有节点而只用最少的边和最小的权值距离。因为n个节点最少需要n-1个边联通，而距离就需要采取某种策略选择恰当的边。

学习最小生成树实现算法之前我们要先高清最小生成树的结构和意义所在。咱么首先根据一些图更好的祝你理解。

一个故事

在城市道路规划中，是一门很需要科学的研究(只是假设学习不必当真)。在公路时代城市联通的主要矛盾是时间慢，而造价相比运输时间是次要矛盾。所以在公路时代我们尽量使得城市能够直接联通，缩短城市联系时间，而稍微考虑建路成本！随着科技发展、高级铁路、信息传输相比公路运输快非常非常多，从而事件的主要矛盾从运输时间转变为造价成本，故有时会关注联通所有点的路程(最短)，这就用到最小生成树算法。

城市道路铺设可能经历以下几个阶段。

  • 初始，各个城市没有高速公路(铁路)。
  • 政府打算各个城市铺设公路(铁路)，每个城市都想成为交通枢纽，快速到达其他城市，但每个城市都有这种想法，如果实现下去造价太昂贵。并且造成巨大浪费。
  • 最终国家选择一些主要城市进行联通，有个别城市只能稍微绕道而行，而绕道太远的、人流量多的国家考虑新建公路(铁路)，适当提高效率。

不过上面铁路规划上由于庞大的人口可能不能够满足与"有铁路"这个需求，人们对速度、距离、直达等条件一直在追求中……

但是你可以想象这个场景：有些东西造假非常非常昂贵，使用效率非常高，我这里假设成黄金镶钻电缆 铺设，所以各个城市只要求不给自己落下，能通上就行(没人敢跳了吧)。

要从有环图中选取代价和最小的路线一方面代价最小(总距离最小最省黄金)另一方面联通所有城市。

然而根据上图我们可以得到以下最小生成树,但是最么生成这个最小生成树，就是下面要讲的了。

而类似的还有局部区域岛屿联通修桥，海底通道这些高成本的都多多少少会运用。

Kruskal算法

上面介绍了最小生成树是什么，现在需要掌握和理解最小生成树如何形成。给你一个图，用一个规则生成一个最小生成树。而在实现最小生成树方面有prim和kruskal算法，这两种算法的策略有所区别，但是时间复杂度一致。

Kruskal算法，和前面讲到的并查集关系很大，它的主要思想为：
先构造一个只含 n 个顶点、而边集为空的子图，把子图中各个顶点看成各棵树上的根结点，之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，即把两棵树合成一棵树，反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直到森林中只有一棵树，也即子图中含有 n-1 条边为止。

简而言之，Kruskal算法进行调度的单位是边,它的信仰为:所有边能小则小，算法的实现方面要用到并查集判断两点是否在同一集合。

而算法的具体步骤为：

  1. 将图中所有边对象(边长、两端点)依次加入集合(优先队列)q1中。初始所有点相互独立。
  2. 取出集合(优先队列)q1最小边，判断边的两点是否联通。
  3. 如果联通说明两个点已经有其它边将两点联通了，跳过，如果不连通，则使用union（并查集合并）将两个顶点合并，这条边被使用(可以储存或者计算数值)。
  4. 重复2，3操作直到集合（优先队列）q1为空。此时被选择的边构成最小生成树。

Prim算法

除了Kruskal算法以外，普里姆算法（Prim算法）也是常用的最小生成树算法。虽然在效率上差不多。但是贪心的方式和Kruskal完全不同。

prim算法的核心信仰是：从已知扩散寻找最小。它的实现方式和Dijkstra算法相似但稍微有所区别，Dijkstra是求单源最短路径，而每计算一个点需要对这个点重新更新距离，而prim不用更新距离。直接找已知点的邻边最小加入即可！prim和kruskal算法都是从边入手处理。

对于具体算法具体步骤，大致为：

  1. 寻找图中任意点，以它为起点，它的所有边V加入集合(优先队列)q1,设置一个boolean数组bool[]标记该位置(边有两个点，每次加入没有被标记那个点的所有边)。
  2. 从集合q1找到距离最小的那个边v1并 判断边是否存在未被标记的一点p ，如果p不存在说明已经确定过那么跳过当前边处理，如果未被标(访问)记那么标记该点p,并且与p相连的未知点(未被标记)构成的边加入集合q1， 边v1(可以进行计算距离之类，该边构成最小生成树) .
  3. 重复1，2直到q1为空，构成最小生成树 ！

大体步骤图解为：

因为prim从开始到结束一直是一个整体在扩散，所以不需要考虑两棵树合并的问题，在这一点实现上稍微方便了一点。

当然，要注意的是最小生成树并不唯一，甚至同一种算法生成的最小生成树都可能有所不同，但是相同的是无论生成怎样的最小生成树：

  • 能够保证所有节点连通(能够满足要求和条件)
  • 能够保证所有路径之和最小(结果和目的相同)
  • 最小生成树不唯一，可能多样的

代码实现

上面分析了逻辑实现。下面我们用代码简单实现上述的算法。

prim

  1. package 图论;
  3. import java.util.ArrayList;
  4. import java.util.Arrays;
  5. import java.util.Comparator;
  6. import java.util.List;
  7. import java.util.PriorityQueue;
  8. import java.util.Queue;
  10. public class prim {
  12. 	public static void main(String[] args) {
  13. 		int minlength=0;//最小生成树的最短路径长度
  14. 		int max=66666;
  15. 		String cityname[]= {"北京","武汉","南京","上海","杭州","广州","深圳"};
  16. 		int city[][]= {
  17. 				{ max, 8, 7, max, max, max, max }, //北京和武汉南京联通
  18. 				{ 8, max,6, max,9, 8,max }, //武汉——北京、南京、杭州、广州
  19. 				{ 7, 6, max, 3,4, max,max }, //南京——北京、武汉、上海、杭州
  20. 				{ max, max,3, max,2, max,max }, //上海——南京、杭州
  21. 				{ max, 9,4, 2,max, max,10 }, //杭州——武汉、南京、上海、深圳
  22. 				{ max, 8,max, max,max, max,2 }, //广州——武汉、深圳
  23. 				{ max, max,max, max,10,2,max }//深圳——杭州、广州
  24. 		};// 地图
  26. 		boolean istrue[]=new boolean[7];
  27. 		//南京
  28. 		Queue<side>q1=new PriorityQueue<side>(new Comparator<side>() {
  29. 			public int compare(side o1, side o2) {
  30. 				// TODO Auto-generated method stub
  31. 				return o1.lenth-o2.lenth;
  32. 			}
  33. 		});
  34. 		for(int i=0;i<7;i++)
  35. 		{
  36. 			if(city[2][i]!=max)
  37. 			{
  38. 				istrue[2]=true;
  39. 				q1.add(new side(city[2][i], 2, i));
  40. 			}
  41. 		}		
  42. 		while(!q1.isEmpty())
  43. 		{
  44. 			side newside=q1.poll();//抛出
  45. 			if(istrue[newside.point1]&&istrue[newside.point2])
  46. 			{
  47. 				continue;
  48. 			}
  49. 			else {
  50. 				if(!istrue[newside.point1])
  51. 				{
  52. 					istrue[newside.point1]=true;
  53. 					minlength+=city[newside.point1][newside.point2];
  54. 					System.out.println(cityname[newside.point1]+" "+cityname[newside.point2]+" 联通");
  55. 					for(int i=0;i<7;i++)
  56. 					{
  57. 						if(!istrue[i])
  58. 						{
  59. 							q1.add(new side(city[newside.point1][i],newside.point1,i));
  60. 						}
  61. 					}
  62. 				}
  63. 				else {
  64. 					istrue[newside.point2]=true;
  65. 					minlength+=city[newside.point1][newside.point2];
  66. 					System.out.println(cityname[newside.point2]+" "+cityname[newside.point1]+" 联通");
  67. 					for(int i=0;i<7;i++)
  68. 					{
  69. 						if(!istrue[i])
  70. 						{
  71. 							q1.add(new side(city[newside.point2][i],newside.point2,i));
  72. 						}
  73. 					}
  74. 				}
  75. 			}
  76. 			
  77. 		}
  78. 		System.out.println(minlength);		
  79. 	}
  80. 	
  81. 	static class side//边
  82. 	{
  83. 		int lenth;
  84. 		int point1;
  85. 		int point2;
  86. 		public side(int lenth,int p1,int p2) {
  87. 			this.lenth=lenth;
  88. 			this.point1=p1;
  89. 			this.point2=p2;
  90. 		}
  91. 	}
  93. }

输出结果：

上海 南京 联通
杭州 上海 联通
武汉 南京 联通
北京 南京 联通
广州 武汉 联通
深圳 广州 联通
28

Kruskal:
  1. package 图论;
  3. import java.util.Comparator;
  4. import java.util.PriorityQueue;
  5. import java.util.Queue;
  7. import 图论.prim.side;
  8. /* * 作者：bigsai(公众号) */
  9. public class kruskal {
  11. 	static int tree[]=new int[10];//bing查集
  12. 	public static void init() {
  13. 		for(int i=0;i<10;i++)//初始
  14. 		{
  15. 			tree[i]=-1;
  16. 		}
  17. 	}
  18. 	public static int search(int a)//返回头节点的数值
  19. 	{
  20. 		if(tree[a]>0)//说明是子节点
  21. 		{
  22. 			return tree[a]=search(tree[a]);//路径压缩
  23. 		}
  24. 		else
  25. 			return a;
  26. 	}
  27. 	public static void union(int a,int b)//表示 a，b所在的树合并小树合并大树(不重要)
  28. 	{
  29. 		int a1=search(a);//a根
  30. 		int b1=search(b);//b根
  31. 		if(a1==b1) {//System.out.println(a+"和"+b+"已经在一棵树上");
  32. 		}
  33. 		else {
  34. 		if(tree[a1]<tree[b1])//这个是负数，为了简单减少计算，不在调用value函数
  35. 		{
  36. 			tree[a1]+=tree[b1];//个数相加 注意是负数相加
  37. 			tree[b1]=a1;       //b树成为a的子树，直接指向a；
  38. 		}
  39. 		else
  40. 		{
  41. 			tree[b1]+=tree[a1];//个数相加 注意是负数相加
  42. 			tree[a1]=b1;       //b树成为a的子树，直接指向a；
  43. 		}
  44. 		}
  45. 	}
  46. 	public static void main(String[] args) {
  47. 		// TODO Auto-generated method stub
  48. 		init();
  49. 		int minlength=0;//最小生成树的最短路径长度
  50. 		int max=66666;
  51. 		String cityname[]= {"北京","武汉","南京","上海","杭州","广州","深圳"};
  52. 		boolean jud[][]=new boolean[7][7];//加入边需要防止重复 比如 ba和ab等价的
  53. 		int city[][]= {
  54. 				{ max, 8, 7, max, max, max, max }, 
  55. 				{ 8, max,6, max,9, 8,max }, 
  56. 				{ 7, 6, max, 3,4, max,max }, 
  57. 				{ max, max,3, max,2, max,max }, 
  58. 				{ max, 9,4, 2,max, max,10 }, 
  59. 				{ max, 8,max, max,max, max,2 }, 
  60. 				{ max, max,max, max,10,2,max }
  61. 		};// 地图
  62. 		boolean istrue[]=new boolean[7];
  63. 		//南京
  64. 		Queue<side>q1=new PriorityQueue<side>(new Comparator<side>() {//优先队列存边+
  65. 			public int compare(side o1, side o2) {
  66. 				// TODO Auto-generated method stub
  67. 				return o1.lenth-o2.lenth;
  68. 			}
  69. 		});
  70. 		for(int i=0;i<7;i++)
  71. 		{
  72. 			for(int j=0;j<7;j++)
  73. 			{
  74. 				if(!jud[i][j]&&city[i][j]!=max)//是否加入队列
  75. 				{
  76. 					jud[i][j]=true;jud[j][i]=true;
  77. 					q1.add(new side(city[i][j], i, j));
  78. 				}
  79. 			}
  80. 		}
  81. 		while(!q1.isEmpty())//执行算法
  82. 		{
  83. 			side newside=q1.poll();
  84. 			int p1=newside.point1;
  85. 			int p2=newside.point2;
  86. 			if(search(p1)!=search(p2))
  87. 			{
  88. 				union(p1, p2);
  89. 				System.out.println(cityname[p1]+" "+cityname[p2]+" 联通");
  90. 				minlength+=newside.lenth;
  91. 			}
  92. 		}
  93. 		System.out.println(minlength);
  94. 		
  96. 	}
  97. 	static class side//边
  98. 	{
  99. 		int lenth;
  100. 		int point1;
  101. 		int point2;
  102. 		public side(int lenth,int p1,int p2) {
  103. 			this.lenth=lenth;
  104. 			this.point1=p1;
  105. 			this.point2=p2;
  106. 		}
  107. 	}
  108. }

输出结果

上海 杭州 联通
广州 深圳 联通
南京 上海 联通
武汉 南京 联通
北京 南京 联通
武汉 广州 联通
28

总结

最小生成树算法理解起来也相对简单，实现起来也不是很难。Kruskal和Prim主要是贪心算法的两种角度。一个从整体开始找最小边，遇到关联不断合并，另一个从局部开始扩散找身边的最小不断扩散直到生成最小生成树。在学习最小生成树之前最好学习一下dijkstra算法和并查集，这样在实现起来能够快一点，清晰一点。

力扣1584就是一个最小生成树的入门题，不过哪个有点区别的就是默认所有点是联通的，所以需要你剪枝优化。这里就不带大家一起看啦，有问题下面也可交流！

最后，如果你那天真的获得一大笔资金去修建这么一条昂贵的黄金路线，可以适当采取此方法，另外剩下的大批，苟富贵，勿相忘。。

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_40693171/article/details/120552056

内容来源于网络，如有侵权，请联系作者删除！

Java数据结构算法数据结构与算法

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com