最小生成树（Prim算法和Kruskal算法）

最新推荐文章于 2022-05-09 22:58:13 发布
最新推荐文章于 2022-05-09 22:58:13 发布
阅读量620 收藏
点赞数
分类专栏： 数据结构 图论 生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Opheelia/article/details/49588817
版权

最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。


概述：

在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得 w(T) 最小，则此 T 为 G 的最小生成树。最小生成树其实是最小权重生成树的简称。[1] 


Prim算法：（稠密图使用效率比较高）

const int maxn = 105;
int T, n, m;
int map[maxn][maxn];
bool vis[maxn];//标记数组
int low[maxn];//i点到邻近点（未标记）的最小距离

int Prim(){
	int ans=0,pos,min;
	MEM1(vis);
	//从某点开始，分别标记和记录该点
	vis[1]=1;pos=1;
	//第一次给low[]赋值
	for2(i,1,n){
		if(i!=pos)
			low[i]=map[pos][i];
	}

	for1(i,1,n){//找最小值并记录位置
		min=INT_MAX;
		for2(j,1,n){
			if(!vis[j]&&min>low[j]){
				min=low[j];
				pos=j;
			}
		}
		ans+=min;
		vis[pos]=1;

		for2(j,1,n){
			if(!vis[j]&&low[j]>map[pos][j])
				low[j]=map[pos][j];
		}
	}

	return ans;
}


Kruskal算法：

1.将图各边按照权值进行排序

2.将图遍历一次，找出权值最小的边，（条件：此次找出的边不能和已加入最小生成树集合的边构成环），若符合条件，则加入最小生成树的集合中。不符合条件则继续遍历图，寻找下一个最小权值的边。

3.递归重复步骤1，直到找出n-1条边为止（设图有n个结点，则最小生成树的边数应为n-1条），算法结束。得到的就是此图的最小生成树。


const int maxn=100010;
int T,n,m;
int father[maxn],r[maxn];

struct kruskal{
	int a;//边的起点
	int b;//边的终点
	int value;//边的权值
}Edge[maxn];

bool cmp(kruskal a,kruskal b){
	return a.value<b.value;//按权值排序
}

//并查集
void Make_Set(int x){
	father[x]=x;
	r[x]=1;
}

int Findfather(int x){
	return x==father[x]?x:Findfather(father[x]);
}

bool Union(int a,int b){
	a=Findfather(a);
	b=Findfather(b);
	if(a==b)
		return false;
	else{
		if(r[a]>r[b]){
			father[b]=a;
			r[a]+=r[b];
		}
		else{
			father[a]=b;
			r[b]+=r[a];
		}
	}
	return true;
}



int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
	while(~sf(n)){
		if(!n)
			break;
		for2(i,0,n){
			Make_Set(i);
		}
		for1(i,0,n*(n-1)/2){
			scanf("%d%d%d",&Edge[i].a,&Edge[i].b,&Edge[i].value);
		}
		sort(Edge,Edge+n*(n-1)/2,cmp);
		int lnum=0,sum=0;
		for1(i,0,n*(n-1)/2){
			if(Union(Edge[i].a,Edge[i].b)){
				lnum++;
				sum+=Edge[i].value;
			}
			if(lnum==n-1){//边数=顶点数-1
				break;
			}
		}
		pf(sum);
	}
	return 0;
}


</pre><pre name="code" class="cpp">例题：hdu 1233还是畅通工程的Prim和Kruskal两种AC代码
<span style="font-family: Arial, Helvetica, sans-serif;">Prim：</span>
#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<memory.h>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)                          //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> inline T Min(T a, T b) { return a < b ? a : b; }
template<class T> inline T Max(T a, T b) { return a > b ? a : b; }
using namespace std;

template<class T>
T Mint(T a, T b, T c) {
	if (a>b) {
		if (c>b)
			return b;
		return c;
	}
	if (c>a)
		return a;
	return c;
}

template<class T>
T Maxt(T a, T b, T c) {
	if (a>b) {
		if (c>a)
			return c;
		return a;
	}
	else if (c > b)
		return c;
	return b;
}

const int maxn=10010;
int T,n,m;
int a,b,c;
int map[maxn][maxn],low[maxn];
bool vis[maxn];

int Prim(){
	MEM1(vis);
	int ans=0,pos=1;
	vis[1]=1;
	for(int i=1;i<=n;i++){
		if(i!=pos)
			low[i]=map[pos][i];
	}
	for(int i=1;i<n;i++){
		int min=INT_MAX;
		for(int j=1;j<=n;j++){
			if(!vis[j]&low[j]<min){
					min=low[j];
					pos=j;
			}
		}
		vis[pos]=1;
		for(int j=1;j<=n;j++){
			if(!vis[j]&&low[j]>map[pos][j])
				low[j]=map[pos][j];
		}
		ans+=min;
	}
	return ans;
}


int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
	while(~sf(n)){
		if(!n)
			break;
		for1(i,0,n*(n-1)/2){
			scanf("%d%d%d",&a,&b,&c);
			map[a][b]=map[b][a]=c;
		}
		int ans=Prim();
		pf(ans);
	}
	return 0;
}



 

Kruskal：
 

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
#include<time.h>
#include<queue>
#include<stack>
#include<iterator>
#include<math.h>
#include<stdlib.h>
#include<limits.h>
#include<memory.h>
//#define ONLINE_JUDGE
#define eps 1e-8
#define INF 0x7fffffff
#define FOR(i,a) for((i)=0;i<(a);(i)++)                          //[i,a);
#define MEM(a) (memset((a),0,sizeof(a)))
#define sfs(a) scanf("%s",a)
#define sf(a) scanf("%d",&a)
#define sfI(a) scanf("%I64d",&a)
#define pf(a) printf("%d\n",a)
#define pfI(a) printf("%I64d\n",a)
#define pfs(a) printf("%s\n",a)
#define sfd(a,b) scanf("%d%d",&a,&b)
#define sft(a,b,c)scanf("%d%d%d",&a,&b,&c)
#define for1(i,a,b) for(int i=(a);i<b;i++)
#define for2(i,a,b) for(int i=(a);i<=b;i++)
#define for3(i,a,b)for(int i=(b);i>=a;i--)
#define MEM1(a) memset(a,0,sizeof(a))
#define MEM2(a) memset(a,-1,sizeof(a))
#define LL __int64
const double PI = acos(-1.0);
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<class T> inline T Min(T a, T b) { return a < b ? a : b; }
template<class T> inline T Max(T a, T b) { return a > b ? a : b; }
using namespace std;

template<class T>
T Mint(T a, T b, T c) {
	if (a>b) {
		if (c>b)
			return b;
		return c;
	}
	if (c>a)
		return a;
	return c;
}

template<class T>
T Maxt(T a, T b, T c) {
	if (a>b) {
		if (c>a)
			return c;
		return a;
	}
	else if (c > b)
		return c;
	return b;
}

const int maxn=100010;
int T,n,m;
int father[maxn],r[maxn];

struct kruskal{
	int a;//边的起点
	int b;//边的终点
	int value;//边的权值
}Edge[maxn];

bool cmp(kruskal a,kruskal b){
	return a.value<b.value;//按权值排序
}

//并查集
void Make_Set(int x){
	father[x]=x;
	r[x]=1;
}

int Findfather(int x){
	return x==father[x]?x:Findfather(father[x]);
}

bool Union(int a,int b){
	a=Findfather(a);
	b=Findfather(b);
	if(a==b)
		return false;
	else{
		if(r[a]>r[b]){
			father[b]=a;
			r[a]+=r[b];
		}
		else{
			father[a]=b;
			r[b]+=r[a];
		}
	}
	return true;
}



int main(){
#ifndef ONLINE_JUDGE
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
#endif
	while(~sf(n)){
		if(!n)
			break;
		for2(i,0,n){
			Make_Set(i);
		}
		for1(i,0,n*(n-1)/2){
			scanf("%d%d%d",&Edge[i].a,&Edge[i].b,&Edge[i].value);
		}
		sort(Edge,Edge+n*(n-1)/2,cmp);
		int lnum=0,sum=0;
		for1(i,0,n*(n-1)/2){
			if(Union(Edge[i].a,Edge[i].b)){
				lnum++;
				sum+=Edge[i].value;
			}
			if(lnum==n-1){//边数=顶点数-1
				break;
			}
		}
		pf(sum);
	}
	return 0;
}

 

 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  余浩媛
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
最小生成树：prim普里姆算法+Kruskal科鲁斯卡尔算法（修路问题为例）

				
			

			

				

					rookie123222的博客
				

				

					08-01
					
					615
					
				

			

		

		

			
				
Prim算法：

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex ），且其所有边的权值之和亦为最小。

最小生成树：



题目（修路问题）：




public class primAlgorithm {
    public static void main(String[] args) {
        char[] data = new char[]{'A', 'B', '..

			
		

	



                

              
                



	

		

			

				
					
【期末复习】例题说明Prim算法与Kruskal算法

				
			

			

				

					榕城候佳人的博客
				

				

					02-20
					
					655
					
				

			

		

		

			
				
找到顶点1,3,4,7,8,5中权值最小的边（1,2），则顶点1,3,4,7,8,6,5,2构成新的连通图。找到顶点1,3,4,7,8中权值最小的边（8,5），则顶点1,3,4,7,8,6,5构成新的连通图。找到顶点1,3,4,7,8中权值最小的边（8,6），则顶点1,3,4,7,8,6构成新的连通图。找到顶点1,3,4,7中权值最小的边（7,8），则顶点1,3,4,7,8构成新的连通图。找到顶点1,3,4中权值最小的边（4,7），则顶点1,3,4,7构成新的连通图。

			
		

	



                


  
              

                


	

		

			

				
					
最小生成树两大常用模板

				
			

			

				

					饮酒在风里的博客
				

				

					09-27
					
					427
					
				

			

		

		

			
				
稠密图： PRIM

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。

由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无...

			
		

	





	

		

			

				
					
【图解】Prim和Kruskal算法的区别

				
			

			

				

					weixin_61087354的博客
				

				

					05-09
					
					1万+
					
				

			

		

		

			
				
【贪心】Prim和Kruskal算法的区别



Kruskal算法和Prim算法的优劣

Kruskal算法，相较于Prim算法是基于点的操作，Kruskal算法是基于边的操作，思想也比Prim简单，更容易理解

Prim算法是采用从点方面考虑来构建MST的一种算法，Prim 算法在稠密图中比Kruskal优。

示例







Prim算法

从源点出发，把源点所有的边加入一个集合（称为待选边集合E{}） 图1
	从E{}中选出最短边，连接并移除，并将该点的所有的边加入E{}   图2
	...

			
		

	



		

			
		



	

		

			

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

				
			

			

				

					zkpj12的博客
				

				

					03-08
					
					607
					
				

			

		

		

			
				
最小生成树Prim算法和Kruskal算法实验报告1.问题2.解析1.Prim算法2.Kruskal算法3.设计Prim算法：Kruskal算法：4.分析Pime算法：Kruskal算法：5.源码
实验报告
课程名称	  《算法分析与设计》
实验日期	 2021年 3月8日 至  2021年 3 月15日
学生姓名	 钟恺
所在班级	   软工192
学号	  2019212212265
实验名称	     最小生成树Prim算法和Kruskal算法
实验地点	      精思苑2号楼208        

			
		

	





	

		

			

				
					
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现

				
			

			

				

					08-16
				

			

		

		

			
				
本文将详细介绍两种经典算法来解决最小生成树问题：Prim算法和Kruskal算法，并以C语言实现为例进行讲解。  ### Prim算法  Prim算法是一种贪心算法，其基本思想是从一个初始节点开始，逐步添加最短的边，直到连接到...

			
		

	





	

		

			

				
					
最小生成树 prim算法和Kruskal算法实现

				
			

			

				

					06-10
				

			

		

		

			
				
prim算法 Kruskal算法分别实现最小生成树

			
		

	





	

		

			

				
					
Prim与Kruskal算法的最小生成树matlab实现

				
			

			

				

					05-26
				

			

		

		

			
				
Prim算法和Kruskal算法是两种常用的求解最小生成树的方法，它们各有特点和适用场景。  1. **Prim算法**：  Prim算法是从一个顶点开始，逐步添加边来构建最小生成树。它每次选择与当前树连接且权重最小的边，直到所有...

			
		

	





	

		

			

				
					
JS使用Prim算法和Kruskal算法实现最小生成树

				
			

			

				

					12-02
				

			

		

		

			
				
最小生成树：在连通图的所有生成树中，所有边的权重和最小的生成树 本文使用的图如下：  它的最小生成树如下：  二、邻接矩阵  邻接矩阵：用来表示图的矩阵就是邻接矩阵，其中下标表示顶点，矩阵中的值表示边的权重...

			
		

	





	

		

			

				
					
python最小生成树kruskal与prim算法详解

				
			

			

				

					12-24
				

			

		

		

			
				
在Python中，有多种实现最小生成树的方法，其中最著名的两种是Kruskal算法和Prim算法。  **Kruskal算法**的主要思想是基于并查集（Disjoint Set）数据结构来避免形成环路。首先，将所有边按照权重从小到大排序。然后...

			
		

	





	

		

			

				
					
Kruskal算法和Prims算法＋例题

				
			

			

				

					qq_40938077的博客
				

				

					07-19
					
					3062
					
				

			

		

		

			
				
首先，这两个算法都是求最小生成树的算法。

首先，生成树是建立在无向图中的，对于有向图，则没有生成树的概念，所以接下来讨论的图均默认为无向图。对于一个有n个点的图，最少需要n-1条边使得这n个点联通，由这n-1条边组成的子图则称为原图的生成树。一般来说，一个图的生成树并不是唯一的（除非原图本身就是一棵树）。

在实际生活中我们常常会遇到这样一些问题：有若干个需要连接的点（不妨假设为一些村庄）和若干...

			
		

	





	

		

			

				
					
数据结构与算法（7-3）最小生成树（普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法）

				
			

			

				

					great_yzl的博客
				

				

					08-07
					
					1311
					
				

			

		

		

			
				
一、最小生成树简介

用途：找到拓扑图的最短路径之和。

注：最小生成树能够保证整个拓扑图的所有路径之和最小，但不能保证任意两点之间是最短路径。

应用：要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个之间都可以通信，但铺设光缆的费用很高，且各个城市之间铺设光缆的费用不同，因此另一个目标是要使铺设光缆的总费用最低。这就需要找到带权的最小生成树。



二、普里姆算法（Prim）

1、原理

把树视为一个整体（顶点）。











2、存储

2-1、图顶点和权：
...

			
		

	





	

		

			

				
					
简述Prim算法和Kruskal算法的相同与不同

				
			

			

				

					StevenDouglas的博客
				

				

					06-13
					
					6852
					
				

			

		

		

			
				
学完离散数学和数据结构中图的最小生成树算法，对两种经典算法普利姆算法和克鲁斯卡尔算法有一点自己的认识。

Prim普利姆算法：在总的边集合-顶点集合A中，添加与A中顶点相邻的且边权值最小的顶点进入A。算法实现需要两个数组，一个记录与当前顶点集合A相邻的边的值，另一个记录到达 顶点总集合-A中的顶点 的顶点序号。时间复杂度O(n2)，n为顶点数

Kruskal克鲁斯卡尔算法：按权值大小排列，由小到大依次加入边，若产生回路则舍弃该边，直到所有顶点都可达。算法实现需要两个数组，第一个数组是二维的，将边的起点/终

			
		

	





	

		

			

				
					
最小生成树———prim算法和kruskal算法详解

					
热门推荐

				
			

			

				

					SYITwin的博客
				

				

					08-23
					
					1万+
					
				

			

		

		

			
				
最小生成树之prim算法（转载出处）

边赋以权值的图称为网或带权图，带权图的生成树也是带权的，生成树T各边的权值总和称为该树的权。

   最小生成树（MST）：权值最小的生成树。

   生成树和最小生成树的应用：要连通n个城市需要n－1条边线路。可以把边上的权值解释为线路的造价。则最小生成树表示使其造价最小的生成树。

   构造网的最小生成树必须解决下面两个问题：

    1、尽可能选取...

			
		

	





	

		

			

				
					
图的最小生成树：Prim算法和Kruskal算法

				
			

			

				

					jinzhao1993的博客
				

				

					04-29
					
					1万+
					
				

			

		

		

			
				
1. 图的最小生成树

生成树的定义：如果连通图G的一个子图是一棵包含G的所有顶点的树，则该子图称为G的生成树。 
生成树是连通图的包含图中的所有顶点的极小连通子图。它并不唯一，从不同的顶点出发进行遍历，可以得到不同的生成树。

其中，权值最小的树就是最小生成树。

关于最小生成树最经典的应用模型就是城市通信线路网最小造价的问题：网络G表示n个城市之间的通信线路（其中顶点表示城市，边表示两个城市之

			
		

	





	

		

			

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

				
			

			

				

					beichengll的博客
				

				

					08-19
					
					2313
					
				

			

		

		

			
				
1、最小生成树：一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。最小生成树包括三个重要的性质： 
最小：边的权重和最小 
生成：最小生成树是从原树生成的，包含所有顶点，|v|-1条边都在图里 
树：最小生成树还必须是一棵树，无回路，V个顶点一定有|v|-1条边。 
最小生成树是连通的，而连通的图一定有一个最小生成树，这是充分必要的。

			
		

	





	

		

			

				
					
营销策划 -2024非遗大展预热引流策划方案.pptx

					
最新发布

				
			

			

				

					07-13
				

			

		

		

			
				
营销策划 -2024非遗大展预热引流策划方案.pptx

			
		

	





	

		

			

				
					
图的最小生成树 Prim算法和Kruskal算法的实验小结

				
			

			

				

					06-12
				

			

		

		

			
				
Prim算法和Kruskal算法都是求解图的最小生成树问题的经典算法，它们的思想和实现方法不同，下面是它们的实验小结。  1. Prim算法  Prim算法是一种贪心算法，它从图的某个点开始，逐步扩展生成树，直到生成整个图的...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值