数据结构应用实例(四)——最小生成树

于 2024-09-10 16:57:42 发布
阅读量852 收藏 18
点赞数 15
分类专栏： 数据结构基础 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouchangyu1221/article/details/91353238
版权

Content：

一、问题描述

  利用 prim 算法和 kruskal 算法实现最小生成树问题；

二、算法思想

  首先判断图是否连通，只有在连通的情况下才进行最小树的生成；

三、代码实现

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define maxx 999999
#pragma warning(disable:4996)

typedef struct arc//弧
{	
	int index;//指向节点编号
	float weight;//边的权值
	struct arc *next;
}AR;

typedef struct edge
{
	int i,j;//边的起点和终点编号
	float edge;//边的权值
}EG;

typedef struct MyGraph
{
	int type;//0表示无向图，1表示有向图
	int arcnum,vexnum;//边的个数、顶点个数
	char **vexname;//存放顶点名称的二维数组	
	AR *N;//表头数组
	float **A;//邻接矩阵，这里使用float型
	EG *E;//存放边的三元组
}GH;


int findvex(char *s,GH *G);//找到图G中名称为s的节点编号，并将其返回
void creatGraph(GH *G);//创建图G
void showGraph(GH *G);//以邻接表的形式显示图G

int isconnect(GH *G);//判断图G是否连通，是则返回1，否则返回0
int BFSvisit(int start,GH *G);//对图G从start号点开始广度优先遍历，返回访问过的节点个数

void prim(GH *G,int start);//利用prim算法，求图G中以start为起点的最小生成树
void showTree(AR *N,char **vexname,int n);//显示最小生成树，N表示表头数组，vexname中存放顶点名称，n表示节点数量

void kruskal(GH *G);//利用kruskal算法，求图G中的最小生成树
void heapsort(EG *E, int n);//对含有n条边的三元组E进行堆排序
void adjust(int index, EG *E, int n);//对利用顺序表E表示的含有n个节点的完全二叉树的index号节点进行筛选
void changeflag(int m,int y,int *flag, AR *N,int n);//将图G中m号节点所在的连通分支上的点的flag统一赋值为y，N为表头数组，n表示原图中节点个数


int main(void)
{
	GH *G;
	int begin;//起点编号
	//创建图
	G=(GH *)malloc(sizeof(GH));
	creatGraph(G);
	printf("图的邻接表形式:\n");
	showGraph(G);

	//if (!isconnect(G))
	//{
	//	printf("该图不连通，不具有最小生成树.\n");
//		exit(-1);
//	}
	printf("该图连通，寻找最小生成树:\n");
	printf("\n\n====================prim算法========================\n");
	printf("请输入起点编号(-1结束):");
	scanf("%d", &begin);
	while (begin != -1)
	{
		prim(G, begin);
		printf("请输入起点编号(-1结束):");
		scanf("%d", &begin);
	}

	printf("\n\n================kruskal算法========================\n");
	kruskal(G);

	free(G);
	return 0;
}


int findvex(char *s,GH *G)//找到图G中名称为s的节点编号，并将其返回
{
	for(int i=0;i<G->vexnum;i++)
	{
		if(strcmp(s,G->vexname[i])==0)
			return i;
	}
	printf("该点不存在\n");
	exit(-1);
}

void creatGraph(GH *G)//创建图G
{
	int i,j,k,n,m;
	float edge;
	char filename[]="graph.txt";
	char str[10],str1[10];
	FILE *fp;
	AR *p;

	fp=fopen(filename,"r");
	if(!fp)
	{
		printf("文件打开失败!\n");
		exit(-1);
	}

	//读取图的类型和节点数量
	fscanf(fp,"%d%d",&G->type,&n);	
	G->vexnum=n;
	//分配空间
	G->vexname=(char **)malloc(n*sizeof(char *));
	G->N=(AR *)malloc(n*sizeof(AR));
	G->A=(float **)malloc(n*sizeof(float *));
	//初始化A和N
	for (i = 0; i < n; i++)
	{
		G->N[i].next = NULL;
		G->A[i] = (float *)malloc(n*sizeof(float));
		for (j = 0; j < n; j++)
			G->A[i][j]=maxx;
	}

	//读取顶点名称
	for(i=0;i<n;i++)
	{
		fscanf(fp,"%s",str);
		//先分配空间
		G->vexname[i]=(char *)malloc(strlen(str)*sizeof(char));
		strcpy(G->vexname[i],str);
	}    
	
	//读取边
	fscanf(fp,"%d",&m);
	G->arcnum=m;//边的个数
	G->E=(EG *)malloc((m+1)*sizeof(EG));//0号位置不存放数据
	for(k=1;k<=m;k++)
	{
		fscanf(fp,"%s%s%f",str,str1,&edge);
		i=findvex(str,G);
		j=findvex(str1,G);

		//邻接表中添加节点
		p=(AR *)malloc(sizeof(AR));
		p->index=j;
		p->weight=edge;
		p->next=G->N[i].next;
		G->N[i].next=p;
		//邻接矩阵
		G->A[i][j]=edge;
		//三元组
		G->E[k].i=i;
		G->E[k].j=j;
		G->E[k].edge=edge;
		if(G->type==0)
		{
			//邻接表中添加节点
			p=(AR *)malloc(sizeof(AR));
			p->index=i;
			p->weight=edge;
			p->next=G->N[j].next;
			G->N[j].next=p;
			//邻接矩阵
			G->A[j][i]=edge;
		}
	}
	fclose(fp);
}

void showGraph(GH *G)//以邻接表的形式显示图G
{
	int i;
	AR *p; //用于遍历
	for (i = 0; i < G->vexnum; i++)
	{
		printf("%s",G->vexname[i]);
		p=G->N[i].next;
		while (p)
		{
			if (G->type == 1)
				printf("-->");
			else
				printf("--");
			printf("%s(%.2f)",G->vexname[p->index],p->weight);
			p=p->next;
		}
		printf("\n");
	}
	printf("\n");
}


int isconnect(GH *G)//判断图G是否连通，是则返回1，否则返回0
{
	int k;
	k=BFSvisit(0,G);//k：广度优先遍历访问到的节点个数
	if(k==G->vexnum)
		return 1;
	else
		return 0;
}

int BFSvisit(int start,GH *G)//对图G从start号点开始广度优先遍历，返回访问过的节点个数
{
	int i,n;
	int *visit;
	int *q;
	int front,rear;
	AR *p;

	//空间分配
	n=G->vexnum;
	visit=(int *)malloc(n*sizeof(int));
	q=(int *)malloc(n*sizeof(int));

	//初始化
	for(i=0;i<n;i++)
		visit[i]=0;	
	visit[start]=1;
	q[0]=start;
	front=0;
	rear=1;

	while(front!=rear)
	{
		p=G->N[q[front]].next;//对出队点的直接后继进行遍历
		//printf("%s\n",G->vexname[q[front]]);	
		front++;
		while (p)
		{
			if (visit[p->index] == 0)//如果未被访问，添加访问标记，入队
			{
				visit[p->index]=1;
				q[rear]=p->index;
				rear++;
			}
			p=p->next;
		}		
	}

	free(visit);
	free(q);
	return rear;//返回广度优先遍历访问到的节点个数
}


void prim(GH *G, int start)//利用prim算法，求图G中以start为起点的最小生成树
{
	int i,n;
	int *pre;
	float *weight;	
	AR *N,*p;
	float min;
	int next;

	n=G->vexnum;
	pre=(int *)malloc(n*sizeof(int));//前驱数组
	weight=(float *)malloc(n*sizeof(float));//距生成树的最短距离，值为0.0表示属于生成树
	N=(AR *)malloc(n*sizeof(AR));//表头数组，用于存放最小生成树	

	//1.初始化
	for (i = 0; i < n; i++)
	{
		if (G->A[start][i] < maxx)
			pre[i] = start;			
		else
			pre[i] = -1;
		weight[i] = G->A[start][i];
		N[i].next=NULL;
	}
	weight[start]=0;//起点放到生成树中

	//2.寻找距离已生成树最近的顶点
	min=maxx;
	for (i = 0; i < n; i++)
	{
		if (weight[i] != 0 && weight[i] < min)//从与原图中与最小生成树连通的节点中选择
		{
			min=weight[i];
			next=i;
		}
	}

	while (min < maxx)
	{
		weight[next]=0;//3.放入最小生成树中
		//相应地添加节点
		p=(AR *)malloc(sizeof(AR));
		p->index=next;
		p->weight=G->A[pre[next]][next];
		p->next=N[pre[next]].next;
		N[pre[next]].next=p;
		if (G->type == 0)
		{
			p=(AR *)malloc(sizeof(AR));
			p->index=pre[next];
			p->weight=G->A[pre[next]][next];
			p->next=N[next].next;
			N[next].next=p;
		}

		//4.更新weight和pre
		p=G->N[next].next;
		while (p)
		{
			if (weight[p->index] != 0 && weight[p->index] > p->weight)
			{
				weight[p->index]=p->weight;
				pre[p->index]=next;
			}
			p=p->next;
		}

		//继续寻找
		min=maxx;
		for (i = 0; i < n; i++)
		{
			if (weight[i] != 0 && weight[i] < min)
			{
				min=weight[i];
				next=i;
			}
		}
	}

	//结果显示
	showTree(N,G->vexname,n);

	free(pre);
	free(weight);
	free(N);
}

void showTree(AR *N, char **vexname, int n)//显示最小生成树，N表示表头数组，vexname中存放顶点名称，n表示节点数量
{
	int i;
	AR *p;
	printf("最小生成树的邻接表形式如下:\n");
	for (i = 0; i < n; i++)
	{	
		p=N[i].next;
		if (p)
		{
			printf("%s", vexname[i]);
			while (p)
			{
				printf("--%s(%.2f)", vexname[p->index], p->weight);
				p = p->next;
			}
			printf("\n");
		}
	}
	printf("\n");
}


void kruskal(GH *G)//利用kruskal算法，求图G中的最小生成树
{
	int i;
	int m,n;
	int p,q;
	int *flag;	
	AR *N,*t;

	m=G->arcnum;
	n=G->vexnum;
	flag=(int *)malloc(n*sizeof(int *));//位于同一连通分量的节点的flag值相同
	N=(AR *)malloc(n*sizeof(AR));//表头数组，用于存放最小生成树

	//1.初始化
	for (i = 0; i < n; i++)
	{
		flag[i] = i;//各自为营
		N[i].next = NULL;
	}

	//2.对存放边的三元组G->E进行堆排序
	heapsort(G->E,m);

	//3.挑取边
	for (i = 1; i <= m; i++)
	{   //读取两端节点编号
		p=G->E[i].i;
		q=G->E[i].j;
		if(flag[p]!=flag[q])//4.若两端位于不同的连通分支，表示该边可选
		{
			changeflag(q,flag[p],flag,N,n);//将q号节点所在的连通分支上的点的flag改为flag[p]
			//相应地添加节点
			t=(AR *)malloc(sizeof(AR));
			t->index=q;
			t->weight=G->A[p][q];
			t->next=N[p].next;
			N[p].next=t;
			//无向图需要双边添加节点
			if (G->type == 0)
			{
				t = (AR *)malloc(sizeof(AR));
				t->index=p;
				t->weight=G->A[p][q];
				t->next=N[q].next;
				N[q].next=t;
			}
		}
	}
	
	//结果显示
	showTree(N,G->vexname,n);

	free(flag);
	free(N);
}

void heapsort(EG *E, int n)//对含有n条边的三元组E进行堆排序
{
	int i;
	//首先调整所有的父节点
	for (i = n / 2; i >= 1; i--)
		adjust(i,E,n);
	//然后进行n-1趟堆排序，找出n-1个最大值
	for (i = 1; i <= n - 1; i++)
	{   //首先进行首尾交换
		E[0]=E[1];
		E[1]=E[n-i+1];
		E[n-i+1]=E[0];
		//然后进行调整
		adjust(1,E,n-i);
	}
}

void adjust(int index, EG *E, int n)//对利用顺序表E表示的含有n个节点的完全二叉树的index号节点进行筛选
{
	int i,j;
	i=index;
	j=2*i;
	E[0]=E[i];//哨兵
	while (j <= n)
	{
		if (j + 1 <= n)//保证j始终指向较大的孩子
		{
			if(E[j+1].edge>E[j].edge)
				j=j+1;
		}
		if (E[j].edge > E[0].edge)//如果大于哨兵
		{
			E[i]=E[j];//将值赋给父节点
			i=j;//更新循环变量
			j=2*i;
		}
		else//E[j].edge <= E[0].edge
			break;//跳出循环
	}
	//i没有孩子或者E[j].edge <= E[0].edge
	E[i]=E[0];
}

void changeflag(int m,int y,int *flag, AR *N,int n)//将图G中m号节点所在的连通分支上的点的flag统一赋值为y，N为表头数组，n表示原图中节点个数
{   //利用BFS，访问m号节点所在的连通分支，更改其flag值
	int *q;
	int front,rear;
	AR *p;

	q=(int *)malloc(n*sizeof(int));
	//初始化
	flag[m]=y;
	q[0]=m;
	front=0;
	rear=1;

	while (front != rear)
	{
		p=N[q[front]].next;
		front++;
		while (p)
		{
			if (flag[p->index] != y)
			{
				flag[p->index]=y;
				q[rear]=p->index;
				rear++;
			}
			p=p->next;
		}
	}
	free(q);
}

四、两种算法的比较

  两种算法从不同的角度提出了最小生成树的构造方法：
  Prim 算法从选节点的角度出发，每次都选距离生成树最近的节点，从而保证了最后的结果为最小生成树，时间复杂度与顶点个数 N 有关；每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为 O ( N 2 ) O(N^2) O(N2)；
  Kruskal 算法从另一个角度出发，选取边，每次都选取权值最小的、添加之后不构成圈的边进行添加，同样保证了结果为最小生成树，时间复杂度与边的个数 e 有关；为方便后续处理，首先对边按权值大小进行排序，时间复杂度为 O ( e l o g 2 e ) O(elog_2e) O(elog2​e)，然后对每条边进行判断并决定是否添加，e 次操作，所以总的时间复杂度为 O ( e l o g 2 e ) O(elog_2e) O(elog2​e)；
  综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；

五、小结

1、 首先进行一次 BFS，返回遍历到的节点数目，据此判断图是否连通，非连通图不具有最小生成树；
2、 对于 prim 算法，将最小生成树中的节点的 weight[i] 置为0，表示其在最小生成树中；
3、 最小生成树中每增添一个节点，更新其直接后继的 weight 和 pre；
4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；
5、 在执行 kruskal 算法时，可对 E 按照边的权值进行堆排序，避免了从邻接矩阵中再次读取边的操作，降低了算法的时间复杂度；
6、 通过 BFS 来实现某一连通分支上所有点的 flag 值的更改；

cyzhou1221
关注
  • 15
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小生成树——Kruskal算法
小天狼星_布莱克 的博客
08-11 1255
KruskalKruskalKruskal算法是一种用于解决最小生成树问题的贪心算法。最小生成树问题是指在一个连通图中找到一棵包含所有顶点的树，且树的边权重之和最小。KruskalKruskalKruskal算法的基本思想是从图中的边集合中选择权重最小的边，并且保证选择的边不会构成环，直到选择了n−1n-1n−1条边为止（nnn为图中顶点的个数）。
数据结构_图的最小生成树（prim和kruskal算法）
qq_2210007943的博客
08-09 468
数据结构_图的应用一级目录二级目录三级目录 一级目录 二级目录 三级目录
【最小生成树模型】
最新发布
武帝为此的博客
06-01 1645
最小生成树（Minimum Spanning Tree，简称MST）是图论中的经典问题之一，它在实际应用中有着广泛的应用。本文将介绍最小生成树模型的原理和应用，并通过一个实战项目来演示如何使用Python实现最小生成树算法。
数据结构之图的应用（1）——最小生成树
m0_63932570的博客
05-01 1229
在学完图的存储结构和两种遍历后，相信大家对于图也有了自己的理解了吧，下面我们继续来讲讲图的应用方面吧，应用方面其实有很多很多，但课本好像只列举四种——最小生成树，最短路径，拓扑排序和关键路径。下面我们就一一来分享给大家吧。今天这期文章主要分享一下最小生成树。 最小生成树。 生成树：是由n个顶点，n-1条边，将一个连通图连接起来，不形成回路 可以分为深度优先生成树和广度优先生成树。 概念：最小生成树（minimum spanning tree）是由n个顶点，n-1条边，将一个连通图连接起来，不形成回路
b+树时间复杂度_数据结构与算法——最小生成树
weixin_39687621的博客
11-24 800
1 引言在之前的文章中已经详细介绍了图的一些基础操作。而在实际生活中的许多问题都是通过转化为图的这类数据结构来求解的，这就涉及到了许多图的算法研究。例如：在n个城市之间铺设光缆，以保证这n个城市中的任意两个城市之间都可以通信。由于铺设光缆的价格很高，且各个城市之间的距离不同，这就使得在各个城市之间铺设光缆的价格不同。那么如何选择铺设线路的方案，才能使费用最低呢？这就涉及到我们今天...
【数据结构与算法】最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法
热门推荐
青竹雾色间.的博客
05-31 1万+
最小生成树(Minimum Spanning Tree,简称MST)是一个无向连通图中包含所有顶点的最短边集。在许多实际问题中，找到一个最小生成树对于理解和解决这些问题至关重要。本文将介绍最小生成树的概念、求解方法以及其在实际应用中的一些例子。
图论（5）最小生成树简单应用
weixin_64197656的博客
01-28 628
最小生成树简单应用
数据结构的实现——最小生成树算法.pdf
08-07
在文章《数据结构的实现——最小生成树算法》中，作者于文新和张霞采用了邻接矩阵作为图的存储结构。邻接矩阵是一种用二维数组表示图的方式，其中数组中的元素表示图中各个顶点之间边的权值。文章具体阐述了如何在...
数据结构与算法——最小生成树
墨鱼菜鸡
09-09 1181
1 引言 在之前的文章中已经详细介绍了图的一些基础操作。而在实际生活中的许多问题都是通过转化为图的这类数据结构来求解的，这就涉及到了许多图的算法研究。 例如：在n个城市之间铺设光缆，以保证这n个城市中的任意两个城市之间都可以通信。由于铺设光缆的价格很高，且各个城市之间的距离不同，这就使得在各个城市之间铺设光缆的价格不同。那么如何选择...
【贪心法】最小生成树
m0_67394360的博客
06-18 356
上期热榜第三好文：??上课老师讲的经典贪心法问题：哈夫曼编码 小科普： 一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。中文名最小生成树适用领域应用图论知识的实际问题外文名Minimum Spanning Tree,MST应用学科计算机，数学（图论），数据结构提出者Kruskal（克鲁斯卡尔）Prim（普里姆）算 法Kruskal算法，Prim算法设G=(V,E)是无向连通带权图。E中每条边(v,w)的权为c[v][w] 生成树：如果G的子
最小生成树算法及其应用
08-06
最小生成树是图论中的经典问题,也是一个重要部分，一般书上往往只介绍求最小生成树的算法，而忽略了更精彩的算法应用部分。本文将对最小生成树算法及其应用作全面的分析说明，使大家对此有更加深刻的认识。本文分三部分：一、基础篇，主要介绍基础概念、求最小生成树的一般算法和常用算法。二、应用篇，具体问题具体分析，侧重于思考和证明的过程。三、总结
数据结构实例（内含17个详细经典实例）
05-15
数据结构实践教程：内含17个经典数据结构实例 根据五个不同数据结构，对每个结构都有2~4个经典实例。每个实例都有项目简介、设计思路、数据结构、完整程序、运行结果五个部分，可以直接拿来做一篇课程设计。实例名称有：学生成绩管理系统、考试报名管理、约瑟夫生者死者游戏、迷宫旅行游戏、八皇后问题、停车场管理、单词检索统计程序、Internet网络通路、家谱管理、
最小生成树详解（模板 + 例题）
zgdlxs的博客
02-10 5975
1.什么是最小生成树 一个图中可能存在多条相连的边,我们一定可以从一个图中挑出一些边生成一棵树。这仅仅是生成一棵树,还未满足最小,当图中每条边都存在权重时,这时候我们从图中生成一棵树(n - 1 条边)时,生成这棵树的总代价就是每条边的权重相加之和。 一个有N个点的图，边一定是大于等于N-1条的。图的最小生成树，就是在这些边中选择N-1条出来，连接所有的N个点。这N-1条边的边权之和是所有方案中最小的。 2.最小生成树的应用 要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个...
最小生成树（Kruskal和Prim算法）
H0_0P的博客
08-19 969
转载自 勿在浮沙筑高台http://blog.csdn.net/luoshixian099/article/details/51908175 最小生成树（Kruskal和Prim算法） 关于图的几个概念定义： 连通图：在无向图中，若任意两个顶点vi与vj都有路径相通，则称该无向图为连通图。 强连通图：在有向图中，若任意两个顶点vi与vj都有路径相通，则称该有向图为强连通图。 连通网...
ACM入门-最小生成树及其应用
TGX的博客
12-14 1391
前置知识 邻接矩阵、并查集 什么是最小生成树？ 今天要讲解的算法是最小生成树，那么什么是最小生成树呢？由于是面向新手的算法教程，尽量用大白话来讲清楚最小生成树这个定义。 假定有这么一个问题，有6个城市，城市之间有一些道路，修道路需要花费不同的金额，现在要你选择其中一些道路，使得所有城市可以互相到达（联通）且花费最小。这个问题的答案就是最小生成树，我们把这个问题抽象为一张图，每个城市是一个点，城市与城市的道路是一条无向边。 如何求解这个问题？ Prim算法 算法思路：将所有城市分为两个集合，一个集合X是已经
遗传算法应用（实例详细演示最小生成树的prufer编码和Cayley定理）
qq_43391414的博客
04-05 2506
prufer编码：用n-2位自然数唯一的表达出一棵n个节点的生成树。而且两者相互可逆，即给定一颗生成树的连接方式，可以唯一确定这棵树的编码。 Cayley定理：n个顶点的完全图中有nn−2n^{n-2}nn−2棵不同的生成树。 显然这两个描述具有很强的联系，n个顶点编号为1,2,…n。有n-2个位置，随便填入1,2,…n中的一个数，这有nn−2n^{n-2}nn−2种可能。 所以我们要证明Cayley定理，只需要证明prufer编码。 prufer编码 1.设有如下生成树（n=6)，根据prufer编码，我
最小生成树 Prim算法的实现及应用
mmdev
07-29 424
关于prim算法 先把有的点放于一个集合（或者数组）里，这个集合里存放的是所有走过的点。初始值为0或者false表示还没有点 声明一个一维数组用于记录各点的权值[可理解为起始点到目标点的距离]， 声明一个二维数组用于记录某点到某一点的权值，如果这两点不可达到，则设置为无穷大 具体执行过程： 先从某一点开始，把这一个开始的点放于声明的一个数组或者集合里，表明这一点已经被访问过。然后再从余下的n-1个...
【算法题归纳合集】图论-最小生成树的典型应用
一只快乐的小蒟蒻~
02-05 959
一、AcWing 1140. 最短网络 【题目描述】 农夫约翰被选为他们镇的镇长！ 他其中一个竞选承诺就是在镇上建立起互联网，并连接到所有的农场。 约翰已经给他的农场安排了一条高速的网络线路，他想把这条线路共享给其他农场。 约翰的农场的编号是111，其他农场的编号是2∼n2∼n2∼n。 为了使花费最少，他希望用于连接所有的农场的光纤总长度尽可能短。 你将得到一份各农场之间连接距离的列表，你必须找出能连接所有农场并使所用光纤最短的方案。 【输入格式】 第一行包含一个整数nnn，表示农场个数。 接下来nnn行，
最小生成树算法总结
wmy0217_的博客
04-14 1199
文章目录最小生成树算法框架朴素版primkruskal 最小生成树算法框架 什么是最小生成树？ 一个图有 n 个结点，很多条边。最小生成树需要包含原图中的 n 个结点，并且有保持图连通的最少的边，且使这个树的权值达到最小。 遇到稠密图就用朴素版prim，稀疏图就用kruskal即可，堆优化版的prim没有必要掌握。 朴素版prim 朴素版 prim 和 dijkstra 算法很像。 dijks...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值