迪杰斯特拉--- 模板(求最短路径/输出路径/所有路径都可以走的做法)

最新推荐文章于 2023-10-24 21:14:48 发布
最新推荐文章于 2023-10-24 21:14:48 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： 图论 文章标签： dijkstra
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011644423/article/details/37956687
版权

1.0版

#include <iostream>
using namespace std;
 
const int maxnum = 100;
const int maxint = 999999;
 
// 各数组都从下标1开始
int dist[maxnum];     // 表示当前点到源点的最短路径长度
int prev[maxnum];     // 记录当前点的前一个结点
int c[maxnum][maxnum];   // 记录图的两点间路径长度
int n, line;             // 图的结点数和路径数
 
// n -- n nodes
// v -- the source node
// dist[] -- the distance from the ith node to the source node
// prev[] -- the previous node of the ith node
// c[][] -- every two nodes' distance
void Dijkstra(int n, int v, int *dist, int *prev, int c[maxnum][maxnum])
{
	int i,j;
	bool s[maxnum];    // 判断是否已存入该点到S集合中
	for(i=1; i<=n; ++i)
	{
		dist[i] = c[v][i];
		s[i] = 0;     // 初始都未用过该点
		if(dist[i] == maxint)
			prev[i] = 0;
		else
			prev[i] = v;
	}
	dist[v] = 0;
	s[v] = 1;
 
	// 依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
	// 一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
         // 注意是从第二个节点开始，第一个为源点
	for(i=2; i<=n; ++i)
	{
		int tmp = maxint;
		int u = v;
		// 找出当前未使用的点j的dist[j]最小值
		for(j=1; j<=n; ++j)
			if((!s[j]) && dist[j]<tmp)
			{
				u = j;              // u保存当前邻接点中距离最小的点的号码
				tmp = dist[j];
			}
		s[u] = 1;    // 表示u点已存入S集合中
 
		// 更新dist
		for(j=1; j<=n; ++j)
			if((!s[j]) && c[u][j]<maxint)
			{
				int newdist = dist[u] + c[u][j];
				if(newdist < dist[j])
				{
					dist[j] = newdist;
					prev[j] = u;
				}
			}
	}
}
 
// 查找从源点v到终点u的路径，并输出
void searchPath(int *prev,int v, int u)
{
	int que[maxnum];
	int tot = 1;
	que[tot] = u;
	tot++;
	int tmp = prev[u];
	while(tmp != v)
	{
		que[tot] = tmp;
		tot++;
		tmp = prev[tmp];
	}
	que[tot] = v;
	//输出路径
	for(int i=tot; i>=1; --i)
		if(i != 1)
			cout << que[i] << " -> ";
		else
			cout << que[i] << endl;
}
 
int main()
{
	int i,j;
//	freopen("input.txt", "r", stdin);
	// 各数组都从下标1开始
 
	// 输入结点数
	cin >> n;
	// 输入路径数
	cin >> line;
	int p, q, len;          // 输入p, q两点及其路径长度
 
	// 初始化c[][]为maxint
	for(i=1; i<=n; ++i)
		for(j=1; j<=n; ++j)
			c[i][j] = maxint;
 
	for(i=1; i<=line; ++i)  
	{
		cin >> p >> q >> len;
		if(len < c[p][q])       // 有重边
		{
			c[p][q] = len;      // p指向q
			c[q][p] = len;      // q指向p，这样表示无向图
		}
	}
 
	for(i=1; i<=n; ++i)
		dist[i] = maxint;
	//输出矩阵-------
	for(i=1; i<=n; ++i)
	{
		for(j=1; j<=n; ++j)
			printf("%8d", c[i][j]);
		printf("\n");
	}
 
	Dijkstra(n, 1, dist, prev, c);
 
	// 最短路径长度
	cout << "源点到最后一个顶点的最短路径长度: " << dist[n] << endl;
 
	// 路径
	cout << "源点到最后一个顶点的路径为: ";
	searchPath(prev, 1, n);
	return 0;
}
/*
测试数据：
4 4
1 2 1
2 3 1
3 4 1
1 4 4

*/

1.1版 任意两点(ps：未解决负权)

#include <iostream>
using namespace std;
 
const int maxnum = 100;
const int maxint = 999999;
 
// 各数组都从下标1开始
int dist[maxnum];     // 表示当前点到源点的最短路径长度
int prev[maxnum];     // 记录当前点的前一个结点
int c[maxnum][maxnum];   // 记录图的两点间路径长度
int n, line;             // 图的结点数和路径数
 
// n -- n nodes
// v -- the source node
// dist[] -- the distance from the ith node to the source node
// prev[] -- the previous node of the ith node
// c[][] -- every two nodes' distance
void Dijkstra(int n, int v, int *dist, int *prev, int c[maxnum][maxnum])
{
	int i,j;
	bool s[maxnum];    // 判断是否已存入该点到S集合中
	for(i=1; i<=n; ++i)
	{
		dist[i] = c[v][i];
		s[i] = 0;     // 初始都未用过该点
		if(dist[i] == maxint)
			prev[i] = 0;
		else
			prev[i] = v;
	}
	dist[v] = 0;
	s[v] = 1;
 
	// 依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
	// 一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
         // 注意是从第二个节点开始，第一个为源点
	for(i=2; i<=n; ++i)
	{
		int tmp = maxint;
		int u = v;
		// 找出当前未使用的点j的dist[j]最小值
		for(j=1; j<=n; ++j)
			if((!s[j]) && dist[j]<tmp)
			{
				u = j;              // u保存当前邻接点中距离最小的点的号码
				tmp = dist[j];
			}
		s[u] = 1;    // 表示u点已存入S集合中
 
		// 更新dist
		for(j=1; j<=n; ++j)
			if((!s[j]) && c[u][j]<maxint)
			{
				int newdist = dist[u] + c[u][j];
				if(newdist < dist[j])
				{
					dist[j] = newdist;
					prev[j] = u;
				}
			}
	}
}
 
// 查找从源点v到终点u的路径，并输出
void searchPath(int *prev,int v, int u)
{
	int que[maxnum];
	int tot = 1;
	que[tot] = u;
	tot++;
	int tmp = prev[u];
	while(tmp != v)
	{
		que[tot] = tmp;
		tot++;
		tmp = prev[tmp];
	}
	que[tot] = v;
	//输出路径
	for(int i=tot; i>=1; --i)
		if(i != 1)
			cout << que[i] << " -> ";
		else
			cout << que[i] << endl;
}
 
int main()
{
	int i,j;
//	freopen("input.txt", "r", stdin);
	// 各数组都从下标1开始
 
	// 输入结点数
	cin >> n;
	// 输入路径数
	cin >> line;
	int p, q, len;          // 输入p, q两点及其路径长度
 
	// 初始化c[][]为maxint
	for(i=1; i<=n; ++i)
		for(j=1; j<=n; ++j)
			c[i][j] = maxint;
 
	for(i=1; i<=line; ++i)  
	{
		cin >> p >> q >> len;
		if(len < c[p][q])       // 有重边
		{
			c[p][q] = len;      // p指向q
			c[q][p] = len;      // q指向p，这样表示无向图
		}
	}
 
	for(i=1; i<=n; ++i)
		dist[i] = maxint;
	//输出矩阵-------
	for(i=1; i<=n; ++i)
	{
		for(j=1; j<=n; ++j)
			printf("%8d", c[i][j]);
		printf("\n");
	}
	int begin,end;
	printf("输入起点和终点\n");
	scanf("%d%d",&begin,&end);
	Dijkstra(end, begin, dist, prev, c);
 
	// 最短路径长度
	cout << "点A到点B的最短路径长度: " << dist[n] << endl;
 
	// 路径
	cout << "点A到点B的路径为: ";
	searchPath(prev, begin, end);
	return 0;
}
/*
测试数据：
4 4
1 2 1
2 3 1
3 4 1
1 4 4
2 2
cout<<
2
2->3->4
*/


if 题目要求的是每两点之间的路都可以走或可以求的话，用下面方法


#include <iostream>
using namespace std;

const int maxnum = 100;
const int maxint = 999999;
 struct Point{
	double x;
	double y;
	double len;
}p[250];
// 各数组都从下标1开始
int dist[maxnum];     // 表示当前点到源点的最短路径长度
int prev[maxnum];     // 记录当前点的前一个结点
int c[maxnum][maxnum];   // 记录图的两点间路径长度
int n, line;             // 图的结点数和路径数

// n -- n nodes
// v -- the source node
// dist[] -- the distance from the ith node to the source node
// prev[] -- the previous node of the ith node
// c[][] -- every two nodes' distance
void Dijkstra(int n, int v, int *dist, int *prev, int c[maxnum][maxnum])
{
	int i,j;
	bool s[maxnum];    // 判断是否已存入该点到S集合中
	for(i=1; i<=n; ++i)
	{
		dist[i] = c[v][i];
		s[i] = 0;     // 初始都未用过该点
		if(dist[i] == maxint)
			prev[i] = 0;
		else
			prev[i] = v;
	}
	dist[v] = 0;
	s[v] = 1;

	// 依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
	// 一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
         // 注意是从第二个节点开始，第一个为源点
	for(i=2; i<=n; ++i)
	{
		int tmp = maxint;
		int u = v;
		// 找出当前未使用的点j的dist[j]最小值
		for(j=1; j<=n; ++j)
			if((!s[j]) && dist[j]<tmp)
			{
				u = j;              // u保存当前邻接点中距离最小的点的号码
				tmp = dist[j];
			}
		s[u] = 1;    // 表示u点已存入S集合中

		// 更新dist
		for(j=1; j<=n; ++j)
			if((!s[j]) && c[u][j]<maxint)
			{
				int newdist = dist[u] + c[u][j];
				if(newdist < dist[j])
				{
					dist[j] = newdist;
					prev[j] = u;
				}
			}
	}
}

// 查找从源点v到终点u的路径，并输出
void searchPath(int *prev,int v, int u)
{
	int que[maxnum];
	int tot = 1;
	que[tot] = u;
	tot++;
	int tmp = prev[u];
	while(tmp != v)
	{
		que[tot] = tmp;
		tot++;
		tmp = prev[tmp];
	}
	que[tot] = v;
	//输出路径
	for(int i=tot; i>=1; --i)
		if(i != 1)
			cout << que[i] << " -> ";
		else
			cout << que[i] << endl;
}

int main()
{
	int i,j;
//	freopen("input.txt", "r", stdin);
	// 各数组都从下标1开始

	// 输入结点数
//	cin >> n;
	// 输入路径数
//	cin >> line;
	double x1,y1,x2,y2;
	cin>>x1>>y1>>x2>>y2;
	double p, q, len;          // 输入p, q两点及其路径长度

	// 初始化c[][]为maxint
	for(int i=1;;i++){
		cin>>p[i].x>>p[i].y;
	}
	for(i=1; i<=n; ++i)
		for(j=1; j<=n; ++j)
			c[i][j] = maxint;

	for(i=1; i<=line; ++i)
	{
		cin >> p >> q >> len;
		if(len < c[p][q])       // 有重边
		{
			c[p][q] = len;      // p指向q
			c[q][p] = len;      // q指向p，这样表示无向图
		}
	}

	for(i=1; i<=n; ++i)
		dist[i] = maxint;
	//输出矩阵-------
	for(i=1; i<=n; ++i)
	{
		for(j=1; j<=n; ++j)
			printf("%8d", c[i][j]);
		printf("\n");
	}
	int begin,end;
	printf("输入起点和终点\n");
	scanf("%d%d",&begin,&end);
	Dijkstra(end, begin, dist, prev, c);

	// 最短路径长度
	cout << "点A到点B的最短路径长度: " << dist[n] << endl;

	// 路径
	cout << "点A到点B的路径为: ";
	searchPath(prev, begin, end);
	return 0;
}
/*
测试数据：
4 4
1 2 1
2 3 1
3 4 1
1 4 4
2 2
cout<<
2
2->3->4
*/


james_cil
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MATLAB轻松绘制地图路线-Dijkstra(迪杰斯特拉)算法最短路径规划
05-06
博客：MATLAB轻松绘制地图路线——Dijkstra(迪杰斯特拉)算法最短路径规划 所用工程文件
算法之迪杰特斯拉（dijkstra）非常详细介绍
临风暖阳的博客
04-18 646
算法之迪杰特斯拉详细介绍
数据结构--迪杰斯特拉（Dijkstra）算法
m0_74939592的博客
10-24 6275
迪杰斯特拉算法 ，建议收藏 ，反复观看。
C语言 最短路径 迪杰斯特拉（Dijkstra）算法
m0_73070900的博客
06-01 3015
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。
【迪杰斯特拉(Dijkstra)算法】
ice_masters的博客
05-09 695
首先大家前提时是都了解图算法中的深度优先搜索（DFS）和广度优先搜索（BFS）算法。（Depth-First-Search），简称 DFS。最直观的例子就是“走迷宫”。假设你站在迷宫的某个岔路口，然后想找到出口。你随意选择一个岔路口来走，走着走着发现走不通的时候，你就回退到上一个岔路口，重新选择一条路继续走，直到最终找到出口。这种走法就是一种深度优先搜索策略。Breadth-first-Search），简称 BFS。是从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点。
最短路径算法-迪杰斯特拉(Dijkstra)算法（记录最短路径和距离）
weixin_56273009的博客
06-17 684
令集合S={u}，对于集合V-S中的所有顶点x，初始化dist[i]=map[u][i],如果源点u到顶点i有边相连，初始化p[i]=u(i的前驱是u),否则p[i]=-1。如果dist[j]>dist[t]+map[t][j],则dist[j]=dist[t]+map[t][j]，记录顶点j的前驱为t，p[j]=t，转（3）。设置地图的带权邻接矩阵为map[][]，即如果从源点u到顶点i有边，就令map[u][i]=的权值，否则map[u][i]=∞；将顶点t加入集合S，同时更新V-S。
C++用Dijkstra(迪杰斯特拉)算法求最短路径
08-31
Dijkstra（迪杰斯特拉）算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。下面这篇文章就给大家介绍关于C++用Dijkstra算法...
Python实现迪杰斯特拉算法并生成最短路径的示例代码
01-21
def Dijkstra(network,s,d):#迪杰斯特拉算法算s-d的最短路径，并返回该路径和代价 print(Start Dijstra Path……) path=[]#s-d的最短路径 n=len(network)#邻接矩阵维度，即节点个数 fmax=999 w=[[0 for i in ...
迪杰斯特拉求最短路径问题
04-22
迪杰斯特拉算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都...
算法之迪杰斯特拉（dijkstra）非常详细介绍
热门推荐
PRML_MAN的博客
03-07 8万+
迪杰斯特拉（dijkstra）算法是单源最短路径问题的求解方法。单源最短路径就在给出一个固定网络，指定一个原点s，一个目标点e，求这两个点之间的最短路径。举个栗子来理解一下。 小明上学的时候，从家到学校的道路非常多，小明为了减少路上骑车的时间，因此，想找出一个最短的路径。他构造一个网络图，如下： 小明是一个很喜欢动脑筋的同学，他开始研究如何才能找出最优的路径呢？ 1）所有的点到家的距离都进行初始化： 2）每次选择距离家最短的一个点，然后用这个点的距离更新其他相邻点到家的距离，如果比当前的点小，则更新节点
单元最短路经 Dijkstra算法 可输出路径
01-27
略作修改，不仅可算出路径，而且可以将路径打印。
迪杰斯特拉求并且输出最短路径
05-27
功能：无向图，输出邻接矩阵，求出最短路径后输出最短路径。
迪杰斯特拉（Dijkstra）算法
Mustan_的博客
01-27 645
（1）Dijkstra算法用于求解最短路问题，且所有的边权都必须为正（2）Dijkstra算法有朴素版本和堆优化版本两种；一般来说，如果是稠密图，就用朴素的，如果是稀疏图，就用堆优化的（3）稠密图或者点数比较少时一般用邻接矩阵，稀疏图或者点数比较多时一般用邻接表（邻接矩阵在有重边时要取最小值，邻接表则不用考虑重边）
最短路径算法——Dijkstra
Passerby_XX的博客
07-23 348
Dijkstra单源最短路算法
最短路径算法Dijstra及优化
qq_55729911的博客
04-15 3914
1.算法简介 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 2.算法流程 迪杰斯塔拉的思想比较容易理解，是采用的纯粹的贪心，但一般我们不需要证明贪心。有兴趣的可以看看这篇文章，里面提到了贪心，这里不再细说。这里我们采用邻接矩阵进行图存储。 注：图片
解决最短路径问题 之 迪杰斯特拉(Dijkstra)算法 (距离+输出路径)
Legendaryfisher‘s Stack
08-06 2742
带权图 为了研究最短路径，首先引入带权边，带权图的概念： 设图G=<V,E>（无向图或有向图），给定W:E->R，对于G的每一条边e，称W(e）为边e的权，这样的图称为带权图，记为G=<V,E,W>. 当e=(u,v)或e=<u,v>时，把W(e)记作W(u,v). 设P是G中的一条通路，P中所有边的权之和称作P的长度，记作W(P）. 即W(P）=∑\su...
Dijkstra算法+打印路径
不知名民工
08-26 2146
原理 Dijkstra 算法（中文名：迪杰斯特拉算法）是由荷兰计算机科学家 Edsger Wybe Dijkstra 提出。该算法常用于路由算法或者作为其他图算法的一个子模块。举例来说，如果图中的顶点表示城市，而边上的权重表示城市间开车行经的距离，该算法可以用来找到两个城市之间的最短路径。 设G=(V,E)是一个带权有向图，把图中顶点集合V分为两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了）,
dijkstra算法：堆优化 + 输出所有最短路径（得到所有最优解）
weixin_45745854的博客
08-10 3811
迪杰斯特拉算法的改进：堆优化 + 输出所有的最短路径
数据结构——迪杰斯特拉（Dijkstra）算法
qq_51231048的博客
10-31 1万+
迪杰斯特拉算法又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 以下是数据结构中关于迪杰斯特拉算法的操作（编程风格参考严蔚敏版数据结构）。
C语言迪杰斯特拉算法求带权有向图最短路径
最新发布
12-03
以下是C语言实现迪杰斯特拉算法求带权有向图最短路径的示例代码： ```c #include #include #define V 6 // 图中顶点数 #define INFINITY INT_MAX // 定义正无穷 // 找到未包含在最短路径树中的距离最小的顶点 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值