图的应用--最小生成树

最新推荐文章于 2023-06-01 18:41:50 发布
最新推荐文章于 2023-06-01 18:41:50 发布
阅读量3.9k 收藏 84
点赞数 19
分类专栏： 数据结构 文章标签： 最小生成树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songsongL/article/details/95859328
版权

文章目录

  • 最小生成树

    在一个连通网的所有生成树中，各边的代价之和最小的那颗生成树称为该连通网的最小代价生成树，简称为最小生成树。

    最小生成树主要有两种算法，普利姆（Prim）算法 && 克鲁斯卡尔（Kruskal）算法

  • 普利姆（Prim）算法

    普里姆算法在找最小生成树时，将顶点分为两个集合，一类是在查找的过程中已经包含在树中的顶点集U，另一类V（总-U）顶点集。
    从U与V中找一条权值最小的边，同时将V中的顶点并入U中。
    可以看出，普利姆（Prim）算法逐步增加U中的顶点，可称为加点法。

    • 辅助数组

      	typedef struct{
		vertexType adjvex;			//最小边在U中的顶点 
		arcType lowcost;			//最小边的权值 
	}ClosEdge;
	
	ClosEdge closedge[MVNum];
	```

    该辅助数组记录着集合U中到集合V中的最小权值边。

    • 普利姆（Prim）算法

      需要注意的是： V中的点并入了U中时，需要更新U到V的权值。更新后辅助数组中可能存着U中不同的顶点到V的距离。然后选择最小的作为最小生成树的。

      有点抽象，举个例子说明，结合着代码看：
      在这里插入图片描述
      该图以这样的邻接矩阵存着：Z是一个足够大的值
      在这里插入图片描述
      一开始：以V0为起点。closedge[ ]数组如下所示：
      在这里插入图片描述
      0是在集合U中的标志，找到最小权值1，对应的V集合中的顶点是下标2位置确定的顶点V3。当然V3与V1连接。
      此时应该更新V3并入之后，closedge[ ]数组的变化。
      两段划线的相比，取其小的更新closedge[ ]数组：在这里插入图片描述
      得到更新后的closedge[ ]数组：
      在这里插入图片描述
      找到最小权值4，对应的V集合中的顶点是下标5位置确定的顶点V6。当然V6与V3连接。
      然后将V6并入U集合中，这样以此类推。。。

    int Prim(Graph g, vertexType u) {			//分成两堆。U集合与V集合(总-U) 
	int weight=0;							//累计最小生成树的权值 
	int i,j,k;
	
	k=FindPos(g,u);  						//以u为起点，确定u的位置 

    for (i = 0; i < g->vexnum; i++) {
        if(i!=k){
        	closedge[i]={u,g->Arc[k][i]}; 	//u顶点到，i位置确定的顶点，的权值，初始化为邻接表中对应的值 
		}
    }   
   
	closedge[k].lowcost=0;   				// 初始时U集合只有u点，在U集合里，就记为0 

	for (j = 1; j < g->vexnum; j++) {
		
		k=Min(g,closedge);					//找到最小权值。当然也就知道顶点 
		
		vertexType u0 = closedge[k].adjvex; //最小边在U中的顶点 
		vertexType v0 = g->vertex[k];		//最小边在V中的顶点 
		printf("%c,%c\n",u0,v0);
		
		weight=weight+g->Arc[FindPos(g,u0)][k];				//最小生成树的权值 
		
		closedge[k].lowcost=0;								//将k确定的顶点放入集合U中 
		
		for (i = 0; i < g->vexnum; i++) {   				//由于k顶点加入U中，检查k到其他顶点的权值是否比k加入之前小  
			if (g->Arc[k][i] < closedge[i].lowcost) {
			    closedge[i] ={g->vertex[k],g->Arc[k][i]};	// 更新
			}
		}
	}   
	return weight;  
}

    回到顶部

    • 具体代码：

    #include<iostream>
#include<stdlib.h>
using namespace std;

#define MVNum 10				//最大顶点数 
#define MAXINT 32768			//表示极大值
 
typedef int arcType;
typedef char vertexType;

typedef struct MNode{
	vertexType vertex[MVNum];	//存储顶点 
	arcType Arc[MVNum][MVNum];	//邻接矩阵，存储边 
	int vexnum,arcnum;
}GraphNode,*Graph;

int Init(Graph &G){
	G=(GraphNode *)malloc(sizeof(GraphNode));
	G->vexnum=0;
	G->arcnum=0;
	if(G) return 1;
	else cout<<"初始化出错！"<<endl;
	return 0;
}

int FindPos(Graph G,char a){//查找位置 
	int pos=-1;
	for(int i=0;i<G->vexnum;i++){
		if(G->vertex[i]==a){
			pos=i;
		}
	}
	return pos;
}

void CreateUDN(Graph G)			//创建无向网
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		i,j,
		weight;					//权值 
	char a,
		 b,
		 ch;					//顶点 
		 
	for(i = 0;i<MVNum; i++){ 	//初始化弧
        for(j = 0;j<MVNum; j++){
            G->Arc[i][j] = MAXINT;
        }
    }

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  //顶点个数
    cout<<"请输入对应的弧（ab与ba是一样的边）和权值，以###结束"<<endl;
    cin>>a>>b>>weight;
    while(a!='#' && b!='#'){
        cout<<a<<"-"<<b<<":"<<weight<<endl;
        pos1=FindPos(G,a);
        pos2=FindPos(G,b);
        printf("位置a:%d,位置b:%d\n",pos1,pos2);
        if(pos1!= -1 && pos2!= -1){  //忽略不存在的顶点
            G->Arc[pos1][pos2] = weight;
            G->Arc[pos2][pos1] = weight;
            G->arcnum++;
        }
        cin>>a>>b>>weight;
    }
}

void PrintGraph(Graph g) {
    cout << "图的顶点为:" << endl;
    for (int i = 0; i < g->vexnum; i++) {
        cout << g->vertex[i] << " ";
    }
    cout << endl;
    cout << "图的邻接矩阵为:" << endl;
    for (int i = 0; i < g->vexnum; i++) {
        for (int j = 0; j < g->vexnum; j++) {
            printf("%10d ",g->Arc[i][j]);
        }
        cout << endl;
    }
}


typedef struct{
	vertexType adjvex;			//最小边在U中的顶点 
	arcType lowcost;			//最小边的权值 
}ClosEdge;

ClosEdge closedge[MVNum];

int Min(Graph g,ClosEdge a[]){
	int j=0;
	int min=MAXINT;
	for(int i=0;i<g->vexnum;i++){
		if(a[i].lowcost!=0 && a[i].lowcost<min){
			min=a[i].lowcost;
			j=i;
		}
	}
	return j;
}

int Prim(Graph g, vertexType u) {			//分成两堆。U集合与V集合(总-U) 
	int weight=0;							//累计最小生成树的权值 
	int i,j,k;
	
	k=FindPos(g,u);  						//以u为起点，确定u的位置 

    for (i = 0; i < g->vexnum; i++) {
        if(i!=k){
        	closedge[i]={u,g->Arc[k][i]}; 	//u顶点到，i位置确定的顶点，的权值，初始化为邻接表中对应的值 
		}
    }   
   
	closedge[k].lowcost=0;   				// 初始时U集合只有u点，在U集合里，就记为0 

	for (j = 1; j < g->vexnum; j++) {
		
		k=Min(g,closedge);					//找到最小权值。当然也就知道顶点 
		
		vertexType u0 = closedge[k].adjvex; //最小边在U中的顶点 
		vertexType v0 = g->vertex[k];		//最小边在V中的顶点 
		printf("%c,%c\n",u0,v0);
		
		weight=weight+g->Arc[FindPos(g,u0)][k];				//最小生成树的权值 
		
		closedge[k].lowcost=0;								//将k确定的顶点放入集合U中 
		
		for (i = 0; i < g->vexnum; i++) {   				//由于k顶点加入U中，检查k到其他顶点的权值是否比k加入之前小  
			if (g->Arc[k][i] < closedge[i].lowcost) {
			    closedge[i] ={g->vertex[k],g->Arc[k][i]};	// 更新
			}
		}
	}   
	return weight;  
}

int main(){
    Graph G = NULL;
    Init(G);
    CreateUDN(G);
	PrintGraph(G);
	cout<<"权值"<<Prim(G,'1')<<endl;
    return 0;
}

    回到顶部

    • 运行结果：

在这里插入图片描述
在这里插入图片描述
回到顶部

  • 克鲁斯卡尔（Kruskal）算法

    克鲁斯卡尔（Kruskal）算法在找最小生成树时，先将边按权值大小排好序，在直接去拿最小的权值边，只需保证拿来的边不能产生回路即可。当拿了（n-1）条边且没有回路，就能构成最小生成树。
    可以看出，克鲁斯卡尔（Kruskal）算法逐步增加生成树的边，可称为加边法。

    而保证拿来的边不能产生回路，需要一个辅助数组，初始时，数组里存着每个顶点不同的标记，即n个连通分量。当拿来一条边，看看这条边依附的两个顶点的标记相不相等，如果等，则说明在一个连通分量里，即会产生回路。不相等，则能构成最小生成树的边。

    • 克鲁斯卡尔（Kruskal）算法

      当确定了一条边时，需要将v2顶点及其与v2标记一样的顶点的标记改为v1的标记，因为他们在一个连通分量里。
      还是上面那个网，当克鲁斯卡尔（Kruskal）算法选到这一步时，即将选择顶点3和6，不仅6要改为3的标记，4也要改为3的标记。所以需要用循环判断去改变标记。
      在这里插入图片描述
    int Kruskal(Graph G)    //最小生成树，克鲁斯卡尔算法
{
	int i,j;
	int V1,V2; 
	int vs1,vs2; 
	int weight=0;     //累计最小生成树权值 
	Sort(G,G->edges);
	for (i = 0; i < G->vexnum; i++){
		Vexset[i] = i;
	}

	for (i = 0; i < G->arcnum; i++)
	{
		V1 = FindPos(G, G->edges[i].initial);
		V2 = FindPos(G, G->edges[i].end);
		
		vs1=Vexset[V1];
		vs2=Vexset[V2];
		
		if (vs1 != vs2)			//若相等，说明有环
		{
			weight= weight+ G->edges[i].weight;  //累计最小生成树权值 
			printf("(%c,%c):%d\n", G->edges[i].initial, G->edges[i].end, G->edges[i].weight);//打印边和权值
			for(j=0;j<G->vexnum;j++){	//之所以要循环，就是因为有时(边变多时)，要改变标记的点不止一个。 
				if(Vexset[j]==vs2){
					Vexset[j]=vs1;
				}					
			}
		}
	}
	return weight; 
}

    回到顶部

    • 具体代码：

    #include<iostream>
#include<stdlib.h>
using namespace std;

#define MVNum 10			//最大顶点数 
 
typedef int arcType;
typedef char vertexType;

typedef struct edge{
    vertexType initial;		//类似邻接矩阵横坐标 
    vertexType end;			//类似邻接矩阵纵坐标 
    arcType weight;			//权值
}Edge;

typedef struct MNode{
	vertexType vertex[MVNum];	//存储顶点 
	Edge edges[MVNum]; 			//类似邻接矩阵
	int vexnum,arcnum;
}GraphNode,*Graph;

int Vexset[MVNum];

int Init(Graph &G){
	G=(GraphNode *)malloc(sizeof(GraphNode));
	G->vexnum=0;
	G->arcnum=0;
	if(G) return 1;
	else cout<<"初始化出错！"<<endl;
	return 0;
}

int FindPos(Graph G,char a){//查找位置 
	int pos=-1;
	for(int i=0;i<G->vexnum;i++){
		if(G->vertex[i]==a){
			pos=i;
		}
	}
	return pos;
}

void CreateUDN(Graph G)			//创建无向网
{
	int num=0,					//控制输入顶点数 
		pos1,pos2,				//确认顶点位置 
		weight;					//权值 
	char  ch;					//顶点 
	Edge e;						//边 

    printf("请输入顶点(不超过10个，以#结束):\n");
    cin>>ch;
    while(ch!='#' && num <10){
        G->vertex[num] = ch;
        cin>>ch;
        num++;
    }
    G->vexnum = num;  //顶点个数
    cout<<"请输入对应的弧（ab与ba是一样的边）和权值，以###结束"<<endl;
    cin>>e.initial>>e.end>>e.weight;
    int k=0;
    while(e.initial!='#' && e.initial!='#'){
        cout<<e.initial<<"-"<<e.end<<":"<<e.weight<<endl;
        G->arcnum++;
        G->edges[k] = e;
        cin>>e.initial>>e.end>>e.weight;
        k++;
    }
}

void PrintGraph(Graph g) {
    cout << "图的顶点为:" << endl;
    for (int i = 0; i < g->vexnum; i++) {
        cout << g->vertex[i] << " ";
    }
    cout << endl;
    cout << "图的边为:" << endl;
    for (int j = 0; j < g->arcnum; j++) {
        printf("起点%c，终点%c,权值%8d\n",g->edges[j].initial,g->edges[j].end,g->edges[j].weight);
    }
}

void Sort(Graph g,Edge a[]){
	Edge temp;		
	for(int i=1;i<g->arcnum;i++){
		for(int j=0;j<g->arcnum-i;j++){
			if(a[j].weight>a[j+1].weight){
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
}

int Kruskal(Graph G)    //最小生成树，克鲁斯卡尔算法
{
	int i,j;
	int V1,V2; 
	int vs1,vs2; 
	int weight=0;     //累计最小生成树权值 
	Sort(G,G->edges);
	for (i = 0; i < G->vexnum; i++){
		Vexset[i] = i;
	}

	for (i = 0; i < G->arcnum; i++)
	{
		V1 = FindPos(G, G->edges[i].initial);
		V2 = FindPos(G, G->edges[i].end);
		
		vs1=Vexset[V1];
		vs2=Vexset[V2];
		
		if (vs1 != vs2)			//若相等，说明有环
		{
			weight= weight+ G->edges[i].weight;  //累计最小生成树权值 
			printf("(%c,%c):%d\n", G->edges[i].initial, G->edges[i].end, G->edges[i].weight);//打印边和权值
			for(j=0;j<G->vexnum;j++){	//之所以要循环，就是因为有时(边变多时)，要改变标记的点不止一个。 
				if(Vexset[j]==vs2){
					Vexset[j]=vs1;
				}					
			}
		}
	}
	return weight; 
}
 
int main()
{
    Graph G = NULL;
    Init(G);
    CreateUDN(G);
	PrintGraph(G);
	cout<<"最小生成树权值"<<Kruskal(G);
    return 0;
}

    回到顶部

songsongL
关注
  • 19
    点赞
  • 踩
  • 84
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣刷题之旅：高阶篇（四）—— 最小生成树算法
欢迎来到“Python算法探索”，我是GT算法工程师，一名热爱计算机算法的博主。在这里，我们将一起深入探索Python世界中的各种算法，从基础到高级，从理论到实践。我参加过很多算法比赛，积累了丰富的经验，希望通过这个播客与你分享。让我们一起用Python探
02-12 479
本文介绍了力扣刷题之旅的高阶篇（）—— 最小生成树算法。通过一道关于最小生成树的题目，我们学习了如何使用Kruskal算法找到加权无向图中的最小生成树，并给出了Python代码示例。最小生成树算法在实际应用中具有广泛的用途，如网络设计、电路设计等。通过不断刷题和学习算法知识，我们可以提高自己的编程能力和解决问题的能力。
最小生成树Prim算法（邻接矩阵）
乘风破浪2014
05-15 4578
#include #include #include #define INFINITY INT_MAX #define OK 1 #define MAXNODE 100 using namespace std; typedef char VertexType; typedef struct { int adj; }ArcType; typedef struct { ArcTy
【最小生成树模型】
最新发布
武帝为此的博客
06-01 1557
最小生成树（Minimum Spanning Tree，简称MST）是图论中的经典问题之一，它在实际应用中有着广泛的应用。本文将介绍最小生成树模型的原理和应用，并通过一个实战项目来演示如何使用Python实现最小生成树算法。
数据结构之图的应用（1）——最小生成树
m0_63932570的博客
05-01 1199
在学完图的存储结构和两种遍历后，相信大家对于图也有了自己的理解了吧，下面我们继续来讲讲图的应用方面吧，应用方面其实有很多很多，但课本好像只列举四种——最小生成树，最短路径，拓扑排序和关键路径。下面我们就一一来分享给大家吧。今天这期文章主要分享一下最小生成树。 最小生成树。 生成树：是由n个顶点，n-1条边，将一个连通图连接起来，不形成回路 可以分为深度优先生成树和广度优先生成树。 概念：最小生成树（minimum spanning tree）是由n个顶点，n-1条边，将一个连通图连接起来，不形成回路
3.3.1 最小生成树的典型应用
esjiang的博客
03-07 4739
命题: Kruskal算法的正确性 证明: 假设不选择“Prim选择的边”, 即选择了红色虚线的边, 那么我们再连接“Prim算法选择的边”, 可以构成环, 然后再删掉红色虚线边, 一定可以使树中权值之和减小, 与当前选择是权值和最小的方案, 矛盾.(因为prim算法计算加边的时候, 保证了选择的边权最小) ...
最小生成树----源码
07-04
最小生成树是图论中的一个重要概念，用于解决网络流问题，特别是在有向或无向图中寻找连接所有顶点的最经济路径。在实际应用中，例如城市交通规划、电路设计、网络通信等领域都有广泛的应用。这个压缩包提供的源代码...
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
最小生成树（Minimum Spanning Tree, MST）问题就是其中之一，它旨在找到一个加权无向图中的边子集，使得这些边连接了图中的所有顶点，且这些边的总权重最小。本文将详细介绍两种经典算法来解决最小生成树问题：Prim...
图算法-最小生成树和单源顶点最短路径
03-21
本主题聚焦于两个核心的图算法：最小生成树（Minimum Spanning Tree, MST）和单源顶点最短路径（Single Source Shortest Path, SSSP）。接下来，我们将深入探讨这两个概念以及如何通过编程实现它们。 最小生成树...
MATLAB源码集锦-最小生成树Kruskal算法代码
02-14
最小生成树是图论中的一个重要概念，用于寻找连接无向图中所有顶点的边集，使得这组边的总权重最小。Kruskal算法是一种经典的解决最小生成树问题的方法，由Joseph B. Kruskal在1956年提出。在MATLAB环境中实现...
图论- 生成树- 曼哈顿距离最小生成树.rar
09-16
在实际应用中，由于曼哈顿距离的特性，可能会出现多个具有相同总距离的最小生成树，此时需要根据具体应用场景来选择合适的解。例如，在网络设计中可能要考虑其他因素，如路径的可靠性或费用等。 压缩包中的"图论- ...
最小生成树算法及其应用
08-06
最小生成树是图论中的经典问题,也是一个重要部分，一般书上往往只介绍求最小生成树的算法，而忽略了更精彩的算法应用部分。本文将对最小生成树算法及其应用作全面的分析说明，使大家对此有更加深刻的认识。本文分三部分：一、基础篇，主要介绍基础概念、求最小生成树的一般算法和常用算法。二、应用篇，具体问题具体分析，侧重于思考和证明的过程。三、总结
图论（5）最小生成树简单应用
weixin_64197656的博客
01-28 494
最小生成树简单应用
3.3.1最小生成树的典型应用
重生之我是cxk的博客
11-21 702
3.3.1最小生成树的典型应用
ACM入门-最小生成树及其应用
TGX的博客
12-14 1371
前置知识 邻接矩阵、并查集 什么是最小生成树？ 今天要讲解的算法是最小生成树，那么什么是最小生成树呢？由于是面向新手的算法教程，尽量用大白话来讲清楚最小生成树这个定义。 假定有这么一个问题，有6个城市，城市之间有一些道路，修道路需要花费不同的金额，现在要你选择其中一些道路，使得所有城市可以互相到达（联通）且花费最小。这个问题的答案就是最小生成树，我们把这个问题抽象为一张图，每个城市是一个点，城市与城市的道路是一条无向边。 如何求解这个问题？ Prim算法 算法思路：将所有城市分为两个集合，一个集合X是已经
《数据结构与算法》（十三）- 图的应用：最小生成树
程序园@大Null
11-10 1237
目录前言1. 最小生成树1.1 普里姆（Prim）算法1.2 克鲁斯卡尔（Kruskal）算法2. 总结 前言 部分内容摘自程杰的《大话数据结构》 1. 最小生成树   假设你是电信的实施工程师，需要为一个镇的九个村庄架设通信网络做设计，村庄位置大致如下图，其中 v0_00​~v8_88​ 是村庄，之间连线的数字表示村与村间的可通达的直线距离，比如 v0_00​ 至 v1_11​ 就是 10 公里（个别如 v0_00​ 与 v6_66​，v6_66​ 与v8_88​，v5_55​ 与 v7_77​ 未测算
图的应用——如何构造最小生成树
syh的技术记录
05-18 4741
目录1. 图的基本概念2. 什么是最小生成树？3. 普利姆算法 1. 图的基本概念 1.什么是图？ 图由顶点和边组成，表示为G（V,E），其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。根据边是否有方向，可分为有向图和无向图。 2. 邻接点 两结点之间通过边相连，则互为邻接点。如在上面的无向图中，（1，3），（2，5）等都为邻接点。 3. 顶点的度 顶点的度指的是与顶点v相连的边的数目。对于无向图来讲，只有度的概念，而对于有向图来讲，可分为入度和出度。入度是指向该顶点的边的条数，出
最小生成树
guihailiuli的专栏
12-01 9183
对于连通图G，如果其全部顶点和一部分边构成一个子图，若这一部分边刚好是图中所有顶点连通，且又不形成回路，则称子图G1是原图G的一颗生成树。 对于同一个图，可以有多个不同的生成树，例如下图，是一个带权的无向图，当然它的生成树不知这两种： 由上图可以看出生成树是将原图的全部顶点以最小的边连通的子图，对于有n个顶点的连通图，生成树有n-1条边，若边数小于此数就不可能将各顶点连
3.3.2 最小生成树的扩展应用
esjiang的博客
03-07 227
回顾下最小生成树的理论基础 解释 假设选蓝色箭头的边, 再连上红色边, 因为红色边权 <= 蓝色边, 因此可以去掉蓝色边, 连接红色边, 边权之和会减小 解释 当前已经有一些连通块, 那么连通块之间的最短边, 一定在生成树里 假设连接两个连通块权值最小的边, 左右两个点已经在某个连通块里, 此时如果不选最小的边, 由于这两个了连通块最终会被连通, 被其他路径连通, 因此在其他路径上一定存在边权>= 最小边的边, 因此去掉下面的蓝色边, 加入上面的蓝色边, 边权之和会减小, 不影响连通
力扣 面试题14- II. 剪绳子 II 快速幂+贪心
xiji333的博客
04-22 296
https://leetcode-cn.com/problems/jian-sheng-zi-ii-lcof/submissions/ 思路：指数爆炸，取333为底。 class Solution { public: const int mod=1e9+7; using ll=long long; ll qpow(int a,int b) { ll...
最小生成树-kruskal算法 抽象形态
05-15
最小生成树-Kruskal算法是一种计算无向图最小生成树的方法。其抽象形态是通过建立边的规则来构建最小生成树。算法首先将每个顶点看作一个独立的子树，然后将边按权重从小到大进行排序。依次考虑每一条边，若这条边...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值