Dijkstra算法图文详解（直接理解！！！）

算法介绍

• 算法特点

  迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短 路径问题，算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

• 算法思路

  定义一个Dis数组用来存起点s到所有点的最短距离，visited数组用来标记节点是否访问到，定义一个集合T中用来保存已经找到最短距离的节点。使用邻接表在存储每个边的长度。
  初始时DIs的每个值为Dis<s,m>，为起点到每个点的距离，同时s点不能到达的点设为无穷大，开始集合T中只有起点s。
  好的，现在开始从Dis中选择未被访问节点对应的最短的边，并把该点加入到T中。此时完成一个顶点，接着看这个顶点是否可以到达其他节点并比较新到这些节点的距离是否比起点直接到达短，如果短的话就更新Dis中的距离。
  如此循环，直到每个顶点都被访问时循环结束。

实例解释

图上解释的比较快，我来详细解释一下。
1.初始化Dis中的值，把节点1加入T中，寻找Dis中未访问顶点相邻最短的边，可以看出是<1,2>这条边最短（INF为无穷大，索引0代表1号节点）。

节点索引	0	1	2	3	4	5
长度	0	7	9	INF	INF	14

2.把节点2加入T中，遍历与节点2相邻的节点，此时如果Dis[1]+<2,3>小于Dis[2],则需要更新Dis[2]的值；同理，如果Dis[1]+<2,4>小于DIs[3],则需要更新Dis[3]的值。
此时表格为：

节点索引	0	1	2	3	4	5
长度	0	7	9	22	INF	14

3.再次寻找Dis中未访问顶点相邻最短的边，即<1,3>边，把节点3加入T中，遍历与节点3相邻的节点，如果Dis[2]+<3,4>小于Dis[3]，则需要更新Dis[3]的值；如果Dis[2]+<3,6>小于Dis[5]，则需要更新Dis[5]的值。
此时表格为：

节点索引	0	1	2	3	4	5
长度	0	7	9	20	INF	11

4…再次寻找Dis中未访问顶点相邻最短的边，把节点6加入T中，遍历与6相邻的节点，如果Dis[5]+<6,5>小于Dis[4],更新Dis[4]的值.
此时表格为：

节点索引	0	1	2	3	4	5
长度	0	7	9	20	20	11

5.同理把节点4和5加入T中，分别比较对应的Dis加上相邻边的长度是否大于相应边出度节点的Dis，判断是否需要更新。
最终的表格为：

节点索引	0	1	2	3	4	5
长度	0	7	9	20	20	11

代码解释

给大家一道题训练一波一道Dijkstra练习题网址
下面是上面实例的代码
我计算的是节点1到5的最短路径 和最短路径的路径
输入：
第一行分别是节点数、邻接边数、起点、终点
第二行以后都是边的起点、终点、长度

6  9  0  4
0  1  7
0  2  9
0  5  14
1  2  10
1  3  15
2  3  11
2  5  2
3  4  6
4  5  9

#include"stdio.h"
#include"stdlib.h"
#include"iostream"
#include<algorithm>
#include<math.h>
#include<string>
#include<queue>
using namespace std;
#define INF 99999999
int N, M, S, D;
int mapp[510][510]; //邻接矩阵
int Dis[510]; //最短距离数组
bool used[510] = { 0 }; //标志
int pre[510]; //前驱节点
int cnt[510]; //节点i同长路径数目
vector<int> path;

void dijkstra(int s)
{
	fill(Dis, Dis + N, INF);
	fill(used, used + N, false);
	fill(pre, pre + N, -1);
	Dis[s] = 0;
	cnt[s] = 1;
	while (1)
	{
		int v = -1;
		for (int u = 0; u < N; u++)
		{
			if (!used[u] && (v == -1 || Dis[u] < Dis[v]))
				v = u;
		}
		if (v == -1)
			break;
		used[v] = true;
		for (int u = 0; u < N; u++)
		{
			if (mapp[v][u] == INF)
				continue;
			if (Dis[u] > Dis[v] + mapp[v][u])
			{
				Dis[u] = Dis[v] + mapp[v][u];
				pre[u] = v;
				cnt[u] = cnt[v];
			}
			else
			{
				if (Dis[u] == Dis[v] + mapp[v][u])
				{
					cnt[u] += cnt[v];
				}
			}
		}
	}
	cout << "最短路径的数目：" << cnt[D] << endl;
	int k = D;
	while (k != S)
	{
		path.push_back(k);
		k = pre[k];
	}
	path.push_back(k);
	reverse(path.begin(), path.end());
	cout << "最短路径为：";
	for (int i = 0; i < path.size(); i++)
	{
		if (i != 0) printf("->");
		printf("%d", path[i]);
	}
	cout << endl;
}

int main()
{
	scanf("%d%d%d%d", &N, &M, &S, &D);
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
			mapp[i][j] = INF;
	for (int i = 0; i < M; i++)
	{
		int x, y;
		scanf("%d%d", &x, &y);
		scanf("%d", &mapp[x][y]);
		mapp[y][x] = mapp[x][y];  //有向图去掉改句
	}
	dijkstra(S);
	system("pause");
	return 0;
}