迪杰斯特拉算法

最新推荐文章于 2023-12-07 11:12:22 发布
最新推荐文章于 2023-12-07 11:12:22 发布
阅读量430 收藏 1
点赞数 4
分类专栏： 算法 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45768871/article/details/104886751
版权

迪杰斯特拉算法介绍

迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。
它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。

基本思想

通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。

此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该顶点到起点s的距离)。

初始时，S中只有起点s；U中是除s之外的顶点，并且U中顶点的路径是"起点s到该顶点的路径"。然后，从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 然后，再从U中找出路径最短的顶点，并将其加入到S中；接着，更新U中的顶点和顶点对应的路径。 … 重复该操作，直到遍历完所有顶点。

操作步骤

(1) 初始时，S只包含起点s；U包含除s外的其他顶点，且U中顶点的距离为"起点s到该顶点的距离"[例如，U中顶点v的距离为(s,v)的长度，然后s和v不相邻，则v的距离为∞]。

(2) 从U中选出"距离最短的顶点k"，并将顶点k加入到S中；同时，从U中移除顶点k。

(3) 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离，是由于上一步中确定了k是求出最短路径的顶点，从而可以利用k来更新其它顶点的距离；例如，(s,v)的距离可能大于(s,k)+(k,v)的距离。

(4) 重复步骤(2)和(3)，直到遍历完所有顶点。

单纯的看上面的理论可能比较难以理解，下面通过实例来对该算法进行说明。

迪杰斯特拉算法图解

在这里插入图片描述
以上图G4为例，来对迪杰斯特拉进行算法演示(以第4个顶点D为起点)。
在这里插入图片描述

初始状态：

S是已计算出最短路径的顶点集合，U是未计算除最短路径的顶点的集合！
第1步：将顶点D加入到S中。
此时，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。 注:C(3)表示C到起点D的距离是3。

第2步：将顶点C加入到S中。

上一步操作之后，U中顶点C到起点D的距离最短；因此，将C加入到S中，同时更新U中顶点的距离。以顶点F为例，之前F到D的距离为∞；但是将C加入到S之后，F到D的距离为9=(F,C)+(C,D)。
此时，S={D(0),C(3)}, U={A(∞),B(23),E(4),F(9),G(∞)}。

第3步：将顶点E加入到S中。

上一步操作之后，U中顶点E到起点D的距离最短；因此，将E加入到S中，同时更新U中顶点的距离。还是以顶点F为例，之前F到D的距离为9；但是将E加入到S之后，F到D的距离为6=(F,E)+(E,D)。
此时，S={D(0),C(3),E(4)}, U={A(∞),B(23),F(6),G(12)}。

第4步：将顶点F加入到S中。

此时，S={D(0),C(3),E(4),F(6)}, U={A(22),B(13),G(12)}。

第5步：将顶点G加入到S中。

此时，S={D(0),C(3),E(4),F(6),G(12)}, U={A(22),B(13)}。

第6步：将顶点B加入到S中。

此时，S={D(0),C(3),E(4),F(6),G(12),B(13)}, U={A(22)}。

第7步：将顶点A加入到S中。

此时，S={D(0),C(3),E(4),F(6),G(12),B(13),A(22)}。

最终

起点D到各个顶点的最短距离就计算出来了：A(22) B(13) C(3) D(0) E(4) F(6) G(12)。

Dijkstra(迪杰斯特拉)

/*
 * Dijkstra最短路径。
 * 即，统计图(G)中"顶点vs"到其它各个顶点的最短路径。
 *
 * 参数说明：
 *        G -- 图
 *       vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
 *     prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
 *     dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
 */

void dijkstra(MGraph G , int vs)
{
	int i, j, k = 0;//-- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
	int prev[MAX_VEX_NUM]; //前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
	int dist[MAX_VEX_NUM]; //长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
	int min;
	int tmp;
	int flag[MAX_VEX_NUM];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

	// 初始化
	for (i = 1; i <= G.vexnum; i++)
	{
		flag[i] = 0;              // 顶点i的最短路径还没获取到。
		prev[i] = 0;              // 顶点i的前驱顶点为0。
		dist[i] = G.arcs[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
	}

	// 对"顶点vs"自身进行初始化
	flag[vs] = 1;
	dist[vs] = 0;

	// 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
	for (i = 1; i <= G.vexnum; i++)
	{
		// 寻找当前最小的路径；
		// 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
		min = MAX_NUM;
		for (j = 1; j <= G.vexnum; j++)
		{
			if (flag[j] == 0 && dist[j] < min)
			{
				min = dist[j];
				k = j;
			}
		}
		// 标记"顶点k"为已经获取到最短路径
		flag[k] = 1;

		// 修正当前最短路径和前驱顶点
		// 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
		for (j = 1; j <= G.vexnum; j++)
		{
			
			tmp = (G.arcs[k][j] == MAX_NUM ? MAX_NUM : (min + G.arcs[k][j])); // 防止溢出
			if (flag[j] == 0 && (tmp < dist[j]))
			{  //判断新路径是否小于当前路径
				dist[j] = tmp; //到该顶点的最小路径
				prev[j] = k;
			}
		}
	}

	// 打印dijkstra最短路径的结果
	printf("dijkstra(%c): \n", G.vexs[vs]);
	for (i = 1; i <= G.vexnum; i++)
		printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}
邻接矩阵
#define MAX_VEX_NUM 30    //最大顶点数

#define MAX_NUM 65535
typedef char VertextType;
typedef enum { DG, UDG }GraphKind; //判定图的类型，有向或无向
typedef struct
{
	VertextType vexs[MAX_VEX_NUM]; //存放结点的char行数组
	int arcs[MAX_VEX_NUM][MAX_VEX_NUM]; //存放边的数组
	int vexnum, arcnum;//结点数，边数
	GraphKind Type;//存放图的类型
}MGraph;

//索引判断
int index(char vex, MGraph* mg)
{
	int i;
	for (i = 1;i <= mg->vexnum;i++)
	{
		if (mg->vexs[i] == vex)
			return i;
	}
	return 0;

}

//生成邻接矩阵
void Creat_MG(MGraph* mg)
{
	int type, i, j, k, v1_index, v2_index, weight = 0;
	char v1, v2, ch;
	printf("please input graph type 0.DG 1.UDG. input nums:");
	scanf_s("%d", &type);  //输入图的类型
	if (type == 0)
		mg->Type = DG;
	else if (type == 1)
	{
		mg->Type = UDG;
	}
	else
	{
		printf("please input 0 or 1!!!");
		return;
	}
	printf("Please input vexnum:");
	scanf_s("%d", &mg->vexnum); //输入结点数
	printf("Please input arcnum:");
	scanf_s("%d", &mg->arcnum);//输入边数
	ch = getchar();
	for (i = 1;i <= mg->vexnum;i++)
	{
		printf("please input %d vex:", i);
		scanf_s("%c", &mg->vexs[i], 1);//循环存放每个结点
		ch = getchar();
	}
	for (i = 1;i <= mg->vexnum;i++)
		for (j = 1;j <= mg->vexnum;j++)
			mg->arcs[i][j] = MAX_NUM;//初始化边，全部设为MAX_NUM
	for (i = 1;i <= mg->vexnum;i++)
		mg->arcs[i][i] = 0;//初始化边，全部设为0
	for (k = 1;k <= mg->arcnum;k++)
	{
		printf("Please input %d arc(vex1,vex2):", k);
		scanf_s("%c %c %d", &v1, 1, &v2, 1, &weight);
		v1_index = index(v1, mg);//索引该结点对应的位置
		v2_index = index(v2, mg);//索引该结点对应的位置
		if (mg->Type == 1)//如果是无向图
		{
			mg->arcs[v1_index][v2_index] = weight;
			mg->arcs[v2_index][v1_index] = weight;//将矩阵的对应的值1
		}
		else
			mg->arcs[v1_index][v2_index] = weight;
		ch = getchar();
	}
}
void Print_MG(MGraph* mg)
{
	int i, j;
	if (mg->Type == 0)
		printf("Is Direct Graph\n");
	else
		printf("Is UNDirect Graph\n");
	for (i = 1;i <= mg->vexnum;i++)
	{
		for (j = 1;j <= mg->vexnum;j++)
		{
			if (mg->arcs[i][j] == MAX_NUM)
			{
				printf("∞  ");
			}
			else
			{
				printf("%-4d", mg->arcs[i][j]);//遍历输出矩阵
			}

		}
		printf("\n");
	}
}
完整代码
#include<stdio.h>
#include<stdlib.h>
#define MAX_VEX_NUM 30    //最大顶点数

#define MAX_NUM 65535
typedef char VertextType;
typedef enum { DG, UDG }GraphKind; //判定图的类型，有向或无向
typedef struct
{
	VertextType vexs[MAX_VEX_NUM]; //存放结点的char行数组
	int arcs[MAX_VEX_NUM][MAX_VEX_NUM]; //存放边的数组
	int vexnum, arcnum;//结点数，边数
	GraphKind Type;//存放图的类型
}MGraph;

//索引判断
int index(char vex, MGraph* mg)
{
	int i;
	for (i = 1;i <= mg->vexnum;i++)
	{
		if (mg->vexs[i] == vex)
			return i;
	}
	return 0;

}

//生成邻接矩阵
void Creat_MG(MGraph* mg)
{
	int type, i, j, k, v1_index, v2_index, weight = 0;
	char v1, v2, ch;
	printf("please input graph type 0.DG 1.UDG. input nums:");
	scanf_s("%d", &type);  //输入图的类型
	if (type == 0)
		mg->Type = DG;
	else if (type == 1)
	{
		mg->Type = UDG;
	}
	else
	{
		printf("please input 0 or 1!!!");
		return;
	}
	printf("Please input vexnum:");
	scanf_s("%d", &mg->vexnum); //输入结点数
	printf("Please input arcnum:");
	scanf_s("%d", &mg->arcnum);//输入边数
	ch = getchar();
	for (i = 1;i <= mg->vexnum;i++)
	{
		printf("please input %d vex:", i);
		scanf_s("%c", &mg->vexs[i], 1);//循环存放每个结点
		ch = getchar();
	}
	for (i = 1;i <= mg->vexnum;i++)
		for (j = 1;j <= mg->vexnum;j++)
			mg->arcs[i][j] = MAX_NUM;//初始化边，全部设为MAX_NUM
	for (i = 1;i <= mg->vexnum;i++)
		mg->arcs[i][i] = 0;//初始化边，全部设为0
	for (k = 1;k <= mg->arcnum;k++)
	{
		printf("Please input %d arc(vex1,vex2):", k);
		scanf_s("%c %c %d", &v1, 1, &v2, 1, &weight);
		v1_index = index(v1, mg);//索引该结点对应的位置
		v2_index = index(v2, mg);//索引该结点对应的位置
		if (mg->Type == 1)//如果是无向图
		{
			mg->arcs[v1_index][v2_index] = weight;
			mg->arcs[v2_index][v1_index] = weight;//将矩阵的对应的值1
		}
		else
			mg->arcs[v1_index][v2_index] = weight;
		ch = getchar();
	}
}
void Print_MG(MGraph* mg)
{
	int i, j;
	if (mg->Type == 0)
		printf("Is Direct Graph\n");
	else
		printf("Is UNDirect Graph\n");
	for (i = 1;i <= mg->vexnum;i++)
	{
		for (j = 1;j <= mg->vexnum;j++)
		{
			if (mg->arcs[i][j] == MAX_NUM)
			{
				printf("∞  ");
			}
			else
			{
				printf("%-4d", mg->arcs[i][j]);//遍历输出矩阵
			}

		}
		printf("\n");
	}
}

/*
 * Dijkstra最短路径。
 * 即，统计图(G)中"顶点vs"到其它各个顶点的最短路径。
 *
 * 参数说明：
 *        G -- 图
 *       vs -- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
 *     prev -- 前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
 *     dist -- 长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
 */

void dijkstra(MGraph G , int vs)
{
	int i, j, k = 0;//-- 起始顶点(start vertex)。即计算"顶点vs"到其它顶点的最短路径。
	int prev[MAX_VEX_NUM]; //前驱顶点数组。即，prev[i]的值是"顶点vs"到"顶点i"的最短路径所经历的全部顶点中，位于"顶点i"之前的那个顶点。
	int dist[MAX_VEX_NUM]; //长度数组。即，dist[i]是"顶点vs"到"顶点i"的最短路径的长度。
	int min;
	int tmp;
	int flag[MAX_VEX_NUM];      // flag[i]=1表示"顶点vs"到"顶点i"的最短路径已成功获取。

	// 初始化
	for (i = 1; i <= G.vexnum; i++)
	{
		flag[i] = 0;              // 顶点i的最短路径还没获取到。
		prev[i] = 0;              // 顶点i的前驱顶点为0。
		dist[i] = G.arcs[vs][i];// 顶点i的最短路径为"顶点vs"到"顶点i"的权。
	}

	// 对"顶点vs"自身进行初始化
	flag[vs] = 1;
	dist[vs] = 0;

	// 遍历G.vexnum-1次；每次找出一个顶点的最短路径。
	for (i = 1; i <= G.vexnum; i++)
	{
		// 寻找当前最小的路径；
		// 即，在未获取最短路径的顶点中，找到离vs最近的顶点(k)。
		min = MAX_NUM;
		for (j = 1; j <= G.vexnum; j++)
		{
			if (flag[j] == 0 && dist[j] < min)
			{
				min = dist[j];
				k = j;
			}
		}
		// 标记"顶点k"为已经获取到最短路径
		flag[k] = 1;

		// 修正当前最短路径和前驱顶点
		// 即，当已经"顶点k的最短路径"之后，更新"未获取最短路径的顶点的最短路径和前驱顶点"。
		for (j = 1; j <= G.vexnum; j++)
		{
			
			tmp = (G.arcs[k][j] == MAX_NUM ? MAX_NUM : (min + G.arcs[k][j])); // 防止溢出
			if (flag[j] == 0 && (tmp < dist[j]))
			{  //判断新路径是否小于当前路径
				dist[j] = tmp; //到该顶点的最小路径
				prev[j] = k;
			}
		}
	}

	// 打印dijkstra最短路径的结果
	printf("dijkstra(%c): \n", G.vexs[vs]);
	for (i = 1; i <= G.vexnum; i++)
		printf("  shortest(%c, %c)=%d\n", G.vexs[vs], G.vexs[i], dist[i]);
}

int main()
{
	MGraph MG;
	Creat_MG(&MG);
	Print_MG(&MG);
	dijkstra(MG, 1);
	return 0;
}

在这里插入图片描述

A --> C 的最短路径 3
A --> C --> B 的最短路径 5
A --> C --> D 的最短路径 6
A --> C --> E 的最短路径 7
A --> C --> D --> F 的最短路径 9

在这里插入图片描述

妙趣前端
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DijkstraAlgorithm(迪杰斯特拉算法)
colzry的博客
02-03 1万+
迪杰斯特拉(Dijkstra)算法介绍 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 最短路径 最短路径问题是图论研究中的一个经典算法问题，旨在寻找图（由结点和路径组成的）中两结点之间的最短路径，大致可以分为如下几种问题，可无论如何分类问题，其本质思想还是不变的，即，求两点间的最短距离。 a) 确定起点的最短路径问题 - 即已知起始结点，求最短路径的问题。 b) 确定终点的最短
最短路径问题---Dijkstra算法详解
热门推荐
William
03-08 84万+
前言 Nobody can go back and start a new beginning,but anyone can start today and make a new ending. Name:Willam Time:2017/3/8 1、最短路径问题介绍 问题解释： 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径，称为最短路径 解决问题的算法：...
迪杰斯特拉(Dijkstra)算法
xiaoxi_hahaha的博客
11-29 8万+
一 算法介绍 迪杰斯特拉算法是由荷兰计算机科学家在1956年发现的算法，此算法使用类似广度优先搜索的方法解决了带权图的单源最短路径问题。它是一个贪心算法。 二 核心思想 1. 选定一个点，这个点满足两个条件：1.未被选过，2.距离最短 2. 对于这个点的所有邻近点去尝试松弛 三 算法步骤 首先，可以设置两个集合分别是A和B，A用来存放已经求出最短路径的点，B用来存放还未计算出最短路径的点，接下来就可以开始做题啦！！！ 我们从图中任选一点来解题，假设我们将源点source选择..
迪杰斯特拉（Dijkstra)算法最通俗易懂的讲解
goodxin_ie的博客
03-21 18万+
一、问题定义 求解单元点的最短路径问题：给定带权有向图G和源点v，求v到G中其他顶点的最短路径 限制条件：图G中不存在负权值的边 二、思想 划重点，迪杰斯特拉最最朴素的思想就是按长度递增的次序产生最短路径。即每次对所有可见点的路径长度进行排序后，选择一条最短的路径，这条路径就是对应顶点到源点的最短路径。 Tips：可见点就是从源点开始按广度优先算法遍历顶点的过程中，搜索到的...
Dijkstra算法图文详解
YiYeZhiNian的博客
12-31 4万+
Dijkstra算法算是贪心思想实现的，首先把起点到所有点的距离存下来找个最短的，然后松弛一次再找出最短的，所谓的松弛操作就是，遍历一遍看通过刚刚找到的距离最短的点作为中转站会不会更近，如果更近了就更新距离，这样把所有的点找遍之后就存下了起点到其他所有点的最短距离。 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 这样一个有权图，Dijkstra算法可以计算任意节点到其他节点的最短
最短路问题迪杰斯特拉算法PPT课件.pptx
10-12
"迪杰斯特拉算法PPT课件" 迪杰斯特拉算法是解决最短路问题的一种常用方法。该算法以埃德斯格·迪杰斯特拉命名，是一种常用的图算法，用于计算从图中的某个节点到其他所有节点的最短路径。 问题的提法及应用背景： ...
zdlj.rar_迪杰斯特拉_迪杰斯特拉算法
09-21
在"zdlj.rar_迪杰斯特拉_迪杰斯特拉算法"压缩包中，包含了一个名为"zdlj.cpp"的文件，我们可以推断这是一个C++实现的迪杰斯特拉算法。这个程序可能是作者根据教科书上的代码进行改编的，可能包含了一些个人的优化和...
Python实现迪杰斯特拉算法过程解析
09-24
迪杰斯特拉（Dijkstra）算法是一种用于解决单源最短路径问题的算法，尤其适用于有权值非负的有向图。它通过贪心策略，每次扩展当前已知最短路径，逐步找到从源节点到所有其他节点的最短路径。在Python中实现Dijkstra...
数据结构迪杰斯特拉算法程序
10-14
迪杰斯特拉算法的基本思想是使用贪心策略，每次选取当前未访问节点中距离源节点最近的一个进行访问，并更新其相邻节点的距离。算法的核心在于维护一个优先队列（通常用最小堆实现），存储待处理的节点并根据它们到源...
数据库课程设计《火车出行路线规划及售票系统》迪杰斯特拉算法实现
01-04
首先，迪杰斯特拉算法是一种著名的图论算法，由荷兰计算机科学家艾兹格·迪杰斯特拉提出。它的主要目标是在加权有向或无向图中寻找从源节点到其余所有节点的最短路径。在火车出行路线规划中，每个城市可以被视为图中...
图解迪杰斯特拉（Dijkstra）最短路径算法
ZER00000001的博客
06-22 7万+
【干货满满！】在介绍最短路径之前我们首先要明白两个概念：什么是源点，什么是终点？在一条路径中，起始的第一个节点叫做源点；终点：在一条路径中，最后一个的节点叫做终点；注意！源点和终点都只是相对于一条路径而言，每一条路径都会有相同或者不相同的源点和终点。而最短路径这个词不用过多解释，就是其字面意思：在图中，对于非带权无向图而言，从源点到终点边最少的路径（也就是BFS广度优先的方法）；而对于带权图而言，从源点到终点权值之和最少的路径叫最短路径；最短路径应用：道路规划；我们最关心的就是去实现寻找最短路径，通过实现.
数据结构--迪杰斯特拉（Dijkstra）算法
m0_74939592的博客
10-24 8013
迪杰斯特拉算法 ，建议收藏 ，反复观看。
图解迪杰斯特拉算法（最短路径问题）
Ronz 的博客
02-06 4万+
一、单源最短路径问题 如上图给定一个带权图 G = <V，E>，其中每条边（vi，vj）上的权 W[vi，vj] 是一个非负实数。另外，给定 V 中的一个顶点 s 充当源点。现在要计算从源点 s 到所有其他各顶点的最短路径，这个问题通常称为单源最短路径（single-source shortest paths）问题。 用一句话总结来说，单源最短路径就是：从图的某一点（源点）出发，到达其余各顶点（终点）的最短路径。 解决单源最短路径问题的一个常用算法是迪杰斯特拉算法，它是由 E.W.Dijkst
Dijkstra(迪杰斯特拉)算法
xdpcxq的专栏
12-07 5100
0->7->6->5->2 = 8 + 1 + 2 + 4 = 15 , 节点 2 已有值 12，127->6->8 = 8 + 1 + 6 = 15 , 节点 8 已有值 15，15=15，因此 节点 8 的 距离、前序节点保持不变。0->1->2->8 = 4 + 8 + 2 = 14 , 节点 8 已有值 15，15>14，因此 节点 8 的 距离 标为。0->7 = 8 , 节点 7 此时为 ∞，因此 节点 7 的 距离 标为。
图论：Dijkstra算法——最详细的分析，图文并茂，一次看懂！
普罗米修斯的博客
08-25 4万+
Dijstra算法
Dijkstra（迪杰斯特拉）算法
菜鸡工坊
09-08 2174
Dijkstra 迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 算法思路 指定一个节点，例如我们要计算 ‘A’ 到其他节点的最短路径 引入两个集合（S、U），S集合包含已求出的最短路径的点（以及相应的最短长度），U集合包含未求出最短路径的点（以及A到该点的路径，注...
克鲁斯卡尔算法(Kruskal算法)求最小生成树
qq_45768871的博客
03-15 9938
克鲁斯卡尔算法(Kruskal算法)求最小生成树 克鲁斯卡尔算法，从边的角度求网的最小生成树，时间复杂度为O(eloge)。和普里姆算法恰恰相反，更适合于求边稀疏的网的最小生成树。 对于任意一个连通网的最小生成树来说，在要求总的权值最小的情况下，最直接的想法就是将连通网中的所有边按照权值大小进行升序排序，从小到大依次选择。 由于最小生成树本身是一棵生成树，所以需要时刻满足以下两点： 1.生成树中任...
迪杰斯特拉算法使用前提
最新发布
03-27
迪杰斯特拉算法是一种用于解决单源最短路径问题的算法，它可以找到从一个起点到其他所有节点的最短路径。使用迪杰斯特拉算法的前提是： 1. 图的表示：迪杰斯特拉算法适用于带权重的有向图或无向图。图可以使用邻接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值