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

最新推荐文章于 2023-12-07 23:17:01 发布
最新推荐文章于 2023-12-07 23:17:01 发布
阅读量1.3k 收藏 14
点赞数 3
分类专栏： # 数据结构与算法 文章标签： 算法 数据结构 图搜索算法 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/great_yzl/article/details/119462940
版权

目录

一、最小生成树简介

二、普里姆算法（Prim） 

1、原理  

2、存储

2-1、图顶点和权：

2-3、 最小生成树：

3、Prim()函数

3-1、新顶点入树

3-2、保留最小权

3-3、 找到最小路径

3-4、判断退出或递归

 4、代码

三、克鲁斯卡尔算法

1、原理

2、过程

 2-1、存储结构

2-2、从小到大排边

2-3、Kruskal算法以及防止连通（防止连通是难点）

3、代码

参考资料

一、最小生成树简介

用途：找到连通图的最短路径之和。

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

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

最小生成树和最短路径区别：

最小生成树：连通图的最短路径。

最短路径：两任意结点之间（可以非邻接）的最短路径。

  

二、普里姆算法（Prim） 

1、原理  

把树视为一个整体（顶点），从根部（自选定）出发，一点一点向周围搜索，找到周围权最小的顶点（最小路径），把它纳入Prim树，把Prim树的整体视作一个根结点，继续往下递归搜索。

（欣赏下面的三样图）

1、

2、 

  3、

2、存储

2-1、图顶点和权：

//图（顶点和权）
typedef struct
{
	char vertex[MAXSIZE];
	int weight[MAXSIZE][MAXSIZE];			//权可以代替边（自身为0，相连有值，不相连无穷大）
}Graph;
Graph G;

不需要再加边，因为权=0即自身，权=无穷大即断开，所以不需要再加边来表示连接关系。

2-3、 最小生成树：

//最小生成树
typedef struct
{
	char vertex[MAXSIZE];				//最小生成树内部顶点
	int weight[MAXSIZE];				//最小生成树权重（内部为0，相连有值，不相连无穷大）
	int minway[MAXSIZE];				//最小生成树最短路径
}MST;
MST M;

3、Prim()函数

3-1、新顶点入树

最小生成树也是越积越多，顶点vertex纳入最小生成树，则M.vertex[index]=vertex，其对应权M.weight[index]=0。

M.vertex[]：存放最小生成树内部的顶点。

M.weight[]：存放最小生成树内部距离外界的最短路径。

3-2、保留最小权

把新入树的顶点的权和树本身的权进行比较，保留更小的一方（因为要生成的是最短路径和）。

3-3、 找到最小路径

记录从最小生成树内部的顶点连向外界顶点的最短路径（最小权），保留下来即为本次行走的权。（也是下一次需要纳入的权）（先纳入顶点，在找下一次纳入的权）

3-4、判断退出或递归

如果Prim()函数调用次数达到顶点长度则退出递归，否则一直递归调用Prim()函数。

//获取最小生成树的最小权值下标
int FindMin()
{
	int i, min = 0;
	for (i = 0; i < length; i++)
	{
		if (M.weight[i] != 0)			//跳过0（即跳过内部顶点）
		{
			if (M.weight[min] == 0 || M.weight[min] > M.weight[i])	//跳过0，取最小
				min = i;
		}
	}
	return min;
}

//普里姆算法
void Prim(char vertex, int index)				//放入根
{
	int i, j, min;
	//获取最小生成树新的顶点
	M.vertex[index] = vertex;				//新顶点
	//获取最小生成树新的权
	M.weight[index] = 0;					//新权（纳入最小生成树内部，为0）
	for (i = 0; i < length; i++)
	{   
		if (M.weight[i] > G.weight[index][i])		//获得最小权
		{
			M.weight[i] = G.weight[index][i];		//最小生成树的权
		}

		//标记最小路径
		if (M.weight[i] == 0)
			for (j = 0; j < length; j++)
			{
				//												行!=列(0)		 i和j不能都在最小生成树内（不能连接自己）		
				if (M.minway[index]>G.weight[i][j] && j!=i && ((M.weight[i]!=0)||(M.weight[j]!=0)))	//i != j
					M.minway[index] = G.weight[i][j];
			}
	}

	printf("%c %d   ", M.vertex[index], M.minway[index]);

	count++;
	//判断退出
	if (count >= length)
		return;
	//寻找下一个最小生成树下标（跳过0）
	min = FindMin();
	Prim(G.vertex[min], min);
}

 4、代码

//普里姆算法(Prim)————图的最小生成树
//把树视为一个整体（顶点），从根部（自选定）出发，一点一点向周围搜索，
//找到周围权最小的顶点（最小路径），把它纳入Prim树，把Prim树的整体视作一个根结点，
//继续往下递归搜索。
//自实现，目前有一定的缺点：时间复杂度O(n^3)有些高
/*测试：
ABCDEFGHI
B 10 F 11
C 18 I 12 G 16
B 18 I 8 D 22
C 22 I 21 G 24 H 16 E 20
D 20 H 7 F 26
A 11 G 17 E 26
B 16 D 24 F 17 H 19
D 16 E 7 G 19
B 12 C 8 D 21
*/
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

#define MAXSIZE 20
#define MAX 65535					//代表无穷大
int length = 0;							//顶点个数
int count = 0;							//计数Prim最小生成树元素个数

//图（顶点和权）
typedef struct
{
	char vertex[MAXSIZE];
	int weight[MAXSIZE][MAXSIZE];			//权可以代替边（自身为0，相连有值，不相连无穷大）
}Graph;
Graph G;

//最小生成树
typedef struct
{
	char vertex[MAXSIZE];				//最小生成树内部顶点
	int weight[MAXSIZE];				//最小生成树权重（内部为0，相连有值，不相连无穷大）
	int minway[MAXSIZE];				//最小生成树最短路径
}MST;
MST M;

//输入顶点
void InputVertex()
{
	int i;
	char ch;
	printf("请输入图的顶点：\n");
	scanf("%c", &ch);
	for (i = 0; i < MAXSIZE && ch != '\n'; i++)
	{
		G.vertex[i] = ch;
		scanf("%c", &ch);
	}
	length = i;
}

//图权重初始化
void GraphWeightInit()
{
	int i, j;
	for (i = 0; i < length; i++)
	{
		for (j = 0; j < length; j++)
		{
			if (i == j)							//指向自己
				G.weight[i][j] = 0;
			else
				G.weight[i][j] = MAX;	//无穷大
		}
	}
}

//根据数据查找图顶点下标
int FindIndex(char ch)
{
	int i;
	for (i = 0; i < length; i++)
	{
		if (G.vertex[i] == ch)
			return i;
	}
	return -1;
}

//获取最小生成树的最小权值下标
int GetMin()
{
	int i, min = 0;
	for (i = 0; i < length; i++)
	{
		if (M.weight[i] != 0)			//跳过0（即跳过内部顶点）
		{
			if (M.weight[min] == 0 || M.weight[min] > M.weight[i])	//跳过0，取最小
				min = i;
		}
	}
	return min;
}

//创建图
void CreateGraph()
{
	int i, j, index, weight;
	char ch;
	for (i = 0; i < length; i++)
	{
		printf("请输入%c的邻接顶点及权重（空格分隔，换行结束）：\n", G.vertex[i]);
		scanf("%c", &ch);
		while (ch != '\n')
		{
			while (ch == ' ')				//为空格
			{
				scanf("%c", &ch);			//输入字符
				continue;
			}
			index = FindIndex(ch);
			scanf("%d", &weight);		//输入权重
			while (weight == 32)		//32为空格的ASCII码
			{
				scanf("%d", &weight);
				continue;
			}
			G.weight[i][index] = weight;	//存入权重
			scanf("%c", &ch);				//(下一轮)输入字符
		}
	}
}

//最小生成树初始化
void MST_Init()
{
	for (int i = 0; i < length; i++)
	{
		M.weight[i] = MAX;							//权初始设置为无穷大（无邻接结点）
		M.minway[i] = MAX;						//最短路径值
	}
}

//普里姆算法
void Prim(char vertex, int index)				//放入根
{
	int i, j, min;
	//获取最小生成树新的顶点
	M.vertex[index] = vertex;				//新顶点
	//获取最小生成树新的权
	M.weight[index] = 0;					//新权（纳入最小生成树内部，为0）
	for (i = 0; i < length; i++)
	{
		if (M.weight[i] > G.weight[index][i])		//刷新最小权
		{
			M.weight[i] = G.weight[index][i];			//覆盖最小生成树的权
		}

		//找到最小路径（最小生成树）
		if (M.weight[i] == 0)					//最小生成树内部
			for (j = 0; j < length; j++)
			{
				//												  行!=列(0)		 i和j不能都在最小生成树内（不能连接自己）(i在内, j在外)		
				if (M.minway[index] > G.weight[i][j] && j != i && ((M.weight[i] != 0) || (M.weight[j] != 0)))	//i != j
					M.minway[index] = G.weight[i][j];
			}
	}

	printf("%c -> %d  -> ", M.vertex[index], M.minway[index]);

	count++;
	//判断退出
	if (count >= length)
		return;
	//寻找下一个最小生成树下标（跳过0）
	min = GetMin();
	Prim(G.vertex[min], min);						//递归Prim()函数
}

//输出测试
void Print()
{
	for (int i = 0; i < length; i++)
	{
		printf("\n%c结点邻接结点：\t", G.vertex[i]);
		for (int j = 0; j < length; j++)
		{
			if (G.weight[i][j] != 0 && G.weight[i][j] != MAX)		//有邻接结点
			{
				printf("%c %d\t", G.vertex[j], G.weight[i][j]);
			}
		}
	}
}

int main()
{
	InputVertex();				//输入顶点

	GraphWeightInit();		//图权重初始化

	CreateGraph();				//创建图

	MST_Init();					//最小生成树初始化

	printf("\n最小生成树路径及权（Prim算法）：\n");
	Prim(G.vertex[0], 0);		//普里姆算法（最小生成树）

	//Print();						//测试输出

	return 0;
}

（这个算法是自实现的，时间复杂度有些高，O(n^3)，先暂时不去优化，继续往后学吧）

三、克鲁斯卡尔算法

1、原理

以边为基础，从小到大依次选出最短路径，产生最小生成树。

原理图：

第1步:将边<E,F>加入R中。

边<E,F>的权值最小，因此将它加入到最小生成树结果R中。

第2步:将边<C,D>加入R中。

上一步操作之后，边<C,D>的权值最小，因此将它加入到最小生成树结果R中。

第3步:将边<D,E>加入R中。

上一 步操作之后，边<D,E>的权值最小，因此将它加入到最小生成树结果R中。

第4步:将边<B,F>加入R中。

上一步操作之后，边<C,E>的权值最小，但<C,E>会和已有的边构成回路;因此，跳过边<C,E>。同理，跳过边<C,F>.将边<B,F>加入到最小生成树结果R中。

第5步:将边<E,G>加入R中。

上一步操作之后，边<E,G>的权值最小，因此将它加入到最小生成树结果R中。

第6步:将边<A,B>加入R中。

上一步操作之后，边<F,G>的权值最小，但<F,G>会和已有的边构成回路;因此，跳过边<F,G>。同理，跳过边<B,C>.将边<A,B>加入到最小生成树结果R中。

此时，最小生成树构造完成!它包括的边依次是: <E,F> <C,D> <D,E><B,F>  <E,G> <A,B>.

2、过程

 2-1、存储结构

1、图的顶点

//图的顶点
char vertex[MAXSIZE];

2、图的边、克鲁斯卡尔（最小生成树数组）

//图的边（以边为主体，装入两端顶点及权）
typedef struct Edge
{
	int begin;
	int end;
	int weight;
}Edge;
Edge E[MAXSIZE];			//边数组
Edge K[MAXSIZE];			//Kruskal数组

2-2、从小到大排边

克鲁斯卡尔算法按照边的大小顺序，从小到大排列，需要有序的边

2-3、Kruskal算法以及防止连通（防止连通是难点）

图不能相互连通，否则那就不叫“生成树”了。

首先begin和end是两个顶点，分别在边weight的左右。

防止连通原理：一个树上的任何结点，都可以追溯到相连通的尾部，如果追溯到的尾部元素，和新添加的元素一样，那么则会产生连通，此时这两个结点不能连接。

这里设置了一个circle[]数组，为了防止连通。

追溯尾部元素的代码：

//根据顶点查找到尾（下标追溯）
int FindTail(char ch)
{
	int index = FindIndex(ch);
	while (circle[index] != -1)
	{
		index = circle[index];	//追溯到尾（下标追溯）
	}
	return index;				//返回尾（没有连接顶点的话返回自身）
}

Kruskal算法代码：

//克鲁斯卡尔(Kruskal)算法
//难点：是否连通判断：需要追溯到尾，如果连通的话它们有共同的尾
void Kruskal()
{
	int i, now = 0, tail = 0;					//检测连通（头和尾）

	for (i = 0; i < length_e; i++)			//遍历每条边
	{
		tail = FindTail(E[i].begin);			//获取下标并追溯到尾（无连通则返回自身）
		now = FindTail(E[i].end);			//获取下标并追溯到尾
		//未连通，正常添加
		if (tail != now)
		{
			circle[tail] = now;							//尾连通（标识连通）
			K[count_k].begin = E[i].begin;		//左顶点
			K[count_k].end = E[i].end;			//右顶点
			K[count_k].weight = E[i].weight;	//中间边权
			printf("%c -- %d --%c\t", K[count_k].begin, K[count_k].weight, K[count_k].end);
			count_k++;
		}
	}
}

3、代码

//克鲁斯卡尔(Kruskal)算法
//测试案例：
/*ABCDEFG
12
12 AB
14 AG
16 AF
7 BF
9 FG
10 BC
8 EG
6 CF
2 EF
5 CE
3 CD
4 DE*/

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

#define MAXSIZE 20
#define MAX 65535
int length_v = 0;						//顶点个数
int length_e = 0;						//边个数
int circle[MAXSIZE] = { -1 };		//判断是否连通（里面的元素定位vertex[ ]中的元素）
int count_k;								//计数克鲁斯卡尔顶点

//图的顶点
char vertex[MAXSIZE];

//图的边（以边为主体，装入两端顶点及权）
typedef struct Edge
{
	int begin;
	int end;
	int weight;
}Edge;
Edge E[MAXSIZE];			//边数组
Edge K[MAXSIZE];			//Kruskal数组


//输入顶点
void InputVertex()
{
	int i;
	char ch;
	printf("请输入图的全部顶点(换行结束)：\n");
	scanf("%c", &ch);
	for (i = 0; i < MAXSIZE && ch != '\n'; i++)
	{
		vertex[i] = ch;
		scanf("%c", &ch);
	}
	length_v = i;
}

//创建图
void CreateGraph()
{
	int weight = 0;
	char ch;
	printf("请输入边的数量：\n");
	scanf("%d", &length_e);
	printf("请分别输入边的权重和左右顶点：\n");
	for (int i = 0; i < length_e; i++)		//每一条边
	{
		printf("第%d条边：\t", i + 1);
		scanf("%d", &weight);					//权重
		while (weight == 32 && weight == 13)		//空格判断（32为空格的ASCII码，13为回车的ASCII码）
			scanf("%d", &weight);
		E[i].weight = weight;

		scanf("%c", &ch);				//第一个顶点
		while (ch == ' ')
			scanf("%c", &ch);
		E[i].begin = ch;

		scanf("%c", &ch);				//第一个顶点
		while (ch == ' ')
			scanf("%c", &ch);
		E[i].end = ch;
	}
}

//排序（按照边的权重，从低到高）
void Sort()
{
	int i, j, min;
	Edge temp;
	for (i = 0; i < length_e; i++)
	{
		min = i;
		for (j = i; j < length_e; j++)
		{
			if (E[min].weight > E[j].weight)
				min = j;
		}
		if (min != i)
		{
			temp = E[min];
			E[min] = E[i];
			E[i] = temp;
		}
	}
}

//根据顶点查找下标
int FindIndex(char ch)
{
	for (int i = 0; i < length_v; i++)
	{
		if (ch == vertex[i])
			return i;
	}
	return -1;
}

//根据顶点查找到尾（下标追溯）
int FindTail(char ch)
{
	int index = FindIndex(ch);
	while (circle[index] != -1)
	{
		index = circle[index];	//追溯到尾（下标追溯）
	}
	return index;					//返回尾（没有连接顶点的话返回自身）
}

//循环数组初始化
void Circle_Init()
{
	for (int i = 0; i < length_v; i++)
	{
		circle[i] = -1;
	}
}

//克鲁斯卡尔(Kruskal)算法
//难点：是否连通判断：需要追溯到尾，如果连通的话它们有共同的尾
void Kruskal()
{
	int i, now = 0, tail = 0;					//检测连通（头和尾）

	for (i = 0; i < length_e; i++)			//遍历每条边
	{
		tail = FindTail(E[i].begin);			//获取下标并追溯到尾（无连通则返回自身）
		now = FindTail(E[i].end);			//获取下标并追溯到尾
		//未连通，正常添加
		if (tail != now)
		{
			circle[tail] = now;							//尾连通（标识连通）
			K[count_k].begin = E[i].begin;		//左顶点
			K[count_k].end = E[i].end;			//右顶点
			K[count_k].weight = E[i].weight;	//中间边权
			printf("%c -- %d --%c\t", K[count_k].begin, K[count_k].weight, K[count_k].end);
			count_k++;
		}
	}
}

//逐边遍历（测试输出）
void Traverse_Edge()
{
	int i;
	for (i = 0; i < length_e; i++)
	{
		printf("\n第%d条边：\t 权重：%d\t 顶点1：%c\t 顶点2：%c\t ", i + 1, E[i].weight, E[i].begin, E[i].end);
	}
}

int main()
{
	InputVertex();			//输入顶点

	CreateGraph();			//创建图

	Sort();						//排序

	Circle_Init();				//循环数组初始化
	printf("克鲁斯卡尔算法计算最小生成树：\n");
	Kruskal();					//克鲁斯卡尔(Kruskal)算法

	//Traverse_Edge();		//逐边遍历（测试输出）

	return 0;
}

参考资料

https://blog.csdn.net/guozhangjie1992/article/details/106821932?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522162833230916780261971711%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=162833230916780261971711&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_v2~rank_v29-2-106821932.pc_search_result_control_group&utm_term=%E5%85%8B%E9%B2%81%E6%96%AF%E5%8D%A1%E5%B0%94%E8%BF%9E%E9%80%9A%E5%88%A4%E6%96%AD&spm=1018.2226.3001.4187 

https://www.bilibili.com/video/BV1jW411K7yg?p=64

最小生成树：prim普里姆算法+Kruskal科鲁斯卡尔算法（修路问题为例）
rookie123222的博客
08-01 714
Prim算法： 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex ），且其所有边的权值之和亦为最小。 最小生成树： 题目（修路问题）： public class primAlgorithm { public static void main(String[] args) { char[] data = new char[]{'A', 'B', '..
最小生成树--kruskal算法
weixin_53377155的博客
01-30 916
最小生成树–kruskal算法 ps：定理等非原创，参考资料--《信息学奥赛一本通（c++版）》。本文归总，代码皆原创，感谢阅览。 定理 首先，要知道树的一个定理：n各点用n - 1条边连接成一个连通块，形成的图形只可能是树，没有别的可能。 树的作用 就是用来解决如何用最小的“代价”用n - 1条边连接n个点的问题。 kruskal算法 一.定义 Kruskal（克鲁斯卡尔）算法是一种巧妙利用并查集来求最小生成树的算法。（bz:如果没学过 不熟悉并查集，可以先去补补课，以下放一些并查集基本操作代码&lt
并查集的相关知识详解 Come baby!!!
qq_48508278的博客
10-23 246
一：并查集的相关知识 这道题用到了并查集，所以我就学了一下并查集，所以把自己的见解也分享给大家（建议 先看视频 再浏览 博客 再自己敲一遍 学习效率高而已，我总是乱着来 以为看几篇博客就会了，其实最后还是老老实实 去B站看大佬讲解视频 才搞懂） 1:并查集 查集是一种树型的数据结构， 用于处理一些不相交集合（Disjoint Sets）的合并及查询问题 1：查询元素a和元素b是否属于同一组 2：合并元素a和元素b所在组 （将有相同元素的元素 合并为一个组 ） 3：需要初始化一个数组存放父节点，其索引值
7-3 最小生成树的唯一性(Kruskal)
asasa666的博客
08-22 1127
Kruskal拓展应用
最小生成树 - Kruskal
大漠知秋的加油站
07-14 373
Kruskal 是一个简单、易于理解的算法，效率比 Prim 低，对要求不高的场景可以使用。以上的关键点在于要判断两点之间的边如果被选中了，是否会形成环？这里可以使用 在遍历的过程中把已经相连的点进行，而是否可以进行相连（选中这条边作为最小生成树的一员）就要看两点是否已经在一个并集上，如果在，则不能相连，因为会形成环，否则可以相连，并进行。 测试 show:......
数据结构--最小生成树Prim 普里姆算法，Kruskal 克鲁斯卡尔算法
Welcome to one zone of Tushan BeiFeng
12-07 650
1.Analyse 来自两位科学家。 生成最小生成树，从0顶点出发，最小生成树包含所以顶点>_<,这个作业难道好像就是似乎改个矩阵？ 最好还是把最小生成树变成一条路线，这样就不用去，自己找路线了。 题目图如图 2.源自老师的Code Print 1Prim #include <stdio.h> #define MAXV 20 //最多顶点数 #defin...
C++实现最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法
08-07
1、最小生成树的概念； 2、Prim算法及其实现； 3、Kruskal算法及其实现； 4、图的表示； 5、边的表示； 6、优先队列priority_queue的自定义排序 7、大根堆、小根堆的区别 8、结构体的构建 面向对象： 有一定C++基础...
【数据结构】图的最小生成树（普里姆Prim算法、克鲁斯卡尔Kruskal算法）（C语言）
weixin_51450101的博客
02-19 5895
一个连通图的生成树是指一个极小连通子图，它含有图中的全部顶点，但只有足以构成一棵树的 n-1 条边。在一个连通网的所有生成树中，各边代价之和最小的那棵生成树称为该连通网最小代价生成树（MST），简称为最小生成树。 利用普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法可以生成一个连通网的最小代价生成树。
最小生成树——普里姆算法(Prim算法)和克鲁斯卡尔算法(Kruskal算法)
youngurt的博客
07-23 3010
一、普里姆算法 （1）将v0到其他顶点的所有边当作侯选边； （2）重复一下步骤n-1次，使得其他n-1个顶点被并入到生成树中。 ①从侯选边中挑选出权值最小的边输出，并将与该边另一端相接的顶点v并入生成树中； ②考查所有剩余顶点vi，如果(v,vi)的权值比lowcost[vi]小，则用(v,vi)的权值更新lowcost[vi]。 /*邻接矩阵的结构定义*/ typedef struct{ int no; //顶点编号 //char info; //顶点其他信息 }VertexType; type
【数据结构与算法】最小生成树之普里姆(Prim)算法和克鲁斯卡尔(Kruskal)算法
热门推荐
青竹雾色间.的博客
05-31 1万+
最小生成树(Minimum Spanning Tree,简称MST)是一个无向连通图中包含所有顶点的最短边集。在许多实际问题中，找到一个最小生成树对于理解和解决这些问题至关重要。本文将介绍最小生成树的概念、求解方法以及其在实际应用中的一些例子。
Java最小生成树：Prim(普里姆)算法、Kruskal(克鲁斯卡尔)算法、案例、思路分析、代码实现
turbo小世界
06-14 789
文章目录Prim(普里姆)算法案例：修路问题(最小生成树). 思路分析. 代码分析Kruskal(克鲁斯卡尔)算法案例：修公路站牌问题(最小生成树). 思路分析. 代码实现. 终点解释 Prim(普里姆)算法 案例：修路问题(最小生成树) 有一乡有7个村庄（A,B,C,D,E,F,G）现在需要修路把7个村庄连通，各个村庄的距离用边线表示(权)，比如A-B距离5公里。问：如何修路保证各个村庄都能连通，且总的修建公路总里程最短？ 修路问题的本质就是最小生成树问题，最小生成树(Minimum Cost Sp
最小生成树MST(Kruskal‘s or Prim‘s Algorithm) pta
wzx_442011334的博客
06-10 852
Kruskal's algorithm is an algorithm in graph theory that finds a minimum spanning tree for a connected undirected weighted graph.There are two numbers(n, m) in first line, n means how many points are there, and m means how many edges are there(n
最小生成树MST,prim和kruskal算法
Travor Philip的blog
08-23 384
最小生成树问题 描述：给出一个连通无向图 G=(u,v)G=(u,v)G=(u,v)和边权重函数 w:E→Rw:E→Rw:E→R，希望找出它的最小生成树，即找出一个无环子集使得所有结点都被连接且边权之和最短。 生成过程 MST（G，w） initialize A with empty set while A doesn't form a MST find an edge (u,v) that is safe for A A = A union {(u,v)} return A 其中A是某个最小生成树的
最小生成树笔记（Prim算法&&Kruskal算法）
陈进士学习的博客
08-07 144
最小生成树算法的目标是找到满足上述条件的最优解，常用的算法包括。这些算法可以在连通无向图中找到最小生成树，并且在不同应用中具有重要的应用价值，如网络设计、电路布线、城市规划等。
prim普里姆函数c语言,Prim算法（普里姆算法）
weixin_42635064的博客
05-21 764
描述：一个连通图的生成树是指一个极小连通子图，它含有图中的全部顶点，但只有足以构成一棵树的 n-1 条边。我们把构造连通网的最小代价生成树成为最小生成树。而Prim算法就是构造最小生成树的一种算法。定义：假设N = (P，{E})是连通网，TE是N上最小生成树中边的集合。算法从U = {U0}(U0属于V)。开始重复执行下述操作：在所有u属于U，v属于V-U的边(u,v)属于E中找到一条代价最小的...
Prim普里姆和Kruskal克鲁斯卡尔算法（最小生成树）
weixin_44806108的博客
05-22 718
Prim普里姆和Kruskal克鲁斯卡尔算法（最小生成树）
头歌数据结构图的最小生成树算法
05-26
根据给定文件的信息，本文将深入探讨两种构造最小生成树的经典算法——普里姆(Prim)算法与克鲁斯卡尔(Kruskal)算法，并通过具体的代码实现来展示这两种算法的应用场景与实现细节。 ### 一、最小生成树概念 #### ...
prim算法
Ignorance
10-25 778
prim算法： 第一步：先任意选择一个点作为  最小生成树 的起始点。 第二步：然后找出所有点中 到 最小生成树 的最小距离的点。又加入最小生成树 第三步：然后再更新 所有点 到最小生成树的 距离。 再重复第二三步。一直到n个点都被加入进来了。 例题:hdu 1102 #include #include using namespace std; #define INF 0x1
Prim
佛系更新
05-05 866
文章目录前言一、Prim算法二、AcWing 858. Prim算法求最小生成树本题分析AC代码三、时间复杂度 前言 复习acwing算法基础课的内容，本篇为讲解基础算法：Prim，关于时间复杂度：目前博主不太会计算，先鸽了，日后一定补上。 一、Prim算法 Prim算法是用来计算最小生成树的算法，把最后的树当成一个集合，开始时，所有的点到树的距离都是ox3f3f3f3f，然后一开始任选一个点加入树中，然后用该点更新其他点的距离，然后之后的每次都是选择距离最近的点加入树中并更新所有点的距离 举一个例子.
【六】【数据结构】Prim算法，最小生成树，最小生成树权值和，最小生成树路径，代码的简单实现，深度解析
最新发布
m0_74163972的博客
12-07 1311
创建judgment数组，所有元素置0，judgment[i]=0表示顶点i在非树集合中，judgment[i]=1表示顶点i在树集合中。创建path数组，所有元素置-1，path[i]=n表示顶点i的前驱顶点是n。memset是计算机中C/语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值， 这个函数通常为新申请的内存做初始化工作。函数解释：将s中当前位置后面的n个字节 用 ch 替换并返回 s。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_(*^▽^*)_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值