迪杰斯特拉算法及变式（最短距离，打印路径，最短经过节点数）

问题描述

给定一个图，图的节点名称用(000 ~ N−1N - 1N−1)表示。NNN为图的节点个数，MMM为边的个数，SSS为起始点。

输入条件：
第一行输入 NMSN M SNMS。
其后MMM行，每行输入三个数，分别代表源节点、目标节点、边的距离。

输出条件：
请输出SSS到所有点的最短距离，并打印出每一步经过的节点名称（中间以空格隔开）。

测试样例：

输入：
4 5 0
0 1 1
1 3 2
0 3 4
0 2 2
2 3 1输出：
从 0 到 0 的最短距离是：0
所经过的路径是：
0
-----------------------------------
从 0 到 1 的最短距离是：1
所经过的路径是：
0 1
-----------------------------------
从 0 到 2 的最短距离是：2
所经过的路径是：
0 2
-----------------------------------
从 0 到 3 的最短距离是：3
所经过的路径是：
0 1 3
-----------------------------------输入：
5 8 0
0 1 10
0 3 20
0 4 100
1 2 10
2 4 10
3 2 10
3 4 10
1 4 20输出：
从 0 到 0 的最短距离是：0
所经过的路径是：
0
-----------------------------------
从 0 到 1 的最短距离是：10
所经过的路径是：
0 1
-----------------------------------
从 0 到 2 的最短距离是：20
所经过的路径是：
0 1 2
-----------------------------------
从 0 到 3 的最短距离是：20
所经过的路径是：
0 3
-----------------------------------
从 0 到 4 的最短距离是：30
所经过的路径是：
0 1 4
-----------------------------------

算法就不介绍了，慕课浙大数据结构讲的很好。
迪杰斯特拉算法能处理有权单源图的最短路径问题（边权重不能有负值）。

代码思路

建立邻接数组（邻接链表），并根据已知数据填充数组。
根据题目需求，建立checked数组、dist数组、path数组、count数组来分别保存节点是否被访问过、最短距离、上一跳、路线个数。并对这些数组做初始化。
进入大循环，找到一个未处理过，而且具有最小边的节点i（dist[i]最小）。

可以通过小顶堆来维护最小的边，也能直接遍历所有节点找出最小边。
如果找不到，说明图已经处理完了，直接退出。
如果找到了，将check[i]设为已访问。并访问其相邻节点。
遍历相邻节点j时，如果从起始点到i，再从i到j的距离比直接从起始点到j的距离短的话，更新起始点到j的距离，并将j的上一跳设置为i。
最后得到的dist数组，保存了起始点到所有点的最短距离。path数组保存了从起始点到所有点最短路径的上一跳。根据题目要求输出即可。

代码模板

import java.util.Arrays;
import java.util.Scanner;/*** @Auther: Erekilu* @Date: 2020-06-04*/
public class Dijkstra
{private static final int MAX = 0x3f3f3f3f;public static void main(String[] args){Scanner in = new Scanner(System.in);int count = in.nextInt();int number = in.nextInt();int source = in.nextInt();int[][] line = new int[number][3];for (int i = 0 ; i < number ; i++){line[i][0] = in.nextInt();line[i][1] = in.nextInt();line[i][2] = in.nextInt();}new Dijkstra().road(count, line, source);}/*** 给出单源无向图，计算从起始节到所有节点的最短距离，并打印路径** @param count  节点总数* @param line   边和权重的集合*               [[0, 1, 5], [1, 2, 7], [0, 2, 10]]表示从节点0到节点1的距离是5，节点1到节点2的距离是7，节点0到节点2的距离是10* @param source 起始节点*/public void road(int count, int[][] line, int source){// 邻接矩阵int[][] graph = new int[count][count];// 使用最大值填充邻接矩阵for (int[] slide : graph){Arrays.fill(slide, MAX);}// 初始化邻接矩阵for (int[] L : line){graph[L[0]][L[1]] = L[2];graph[L[1]][L[0]] = L[2];}// 定义距离数组，dist[i]表示从起始点到i的最短距离int[] dist = new int[count];Arrays.fill(dist, MAX);dist[source] = 0;// 定义前驱节点记录，path[i]代表i的前驱节点int[] path = new int[count];path[source] = -1;// checked[i]标识第i个节点是否被处理过int[] checked = new int[count];while (true){// 在所有节点中选择一个距离source最短的节点int tmpMin = MAX;int tmpIndex = -1;for (int i = 0 ; i < count ; i++){// 如果这个节点被处理过，跳过这个节点if (checked[i] == 1)continue;if (dist[i] < tmpMin){tmpMin = dist[i];tmpIndex = i;}}// 如果没找到，退出循环if (tmpIndex == -1)break;// 如果找到了，将checked[i]设为访问过checked[tmpIndex] = 1;// 遍历其所有相邻节点for (int i = 0 ; i < count ; i++){int near = graph[tmpIndex][i];// 第一个是判断这个边是否存在// 第二个是判断对应节点是否处理过// 第三个是判断新的距离是否比旧的距离短if (near != MAX && checked[i] == 0 && dist[tmpIndex] + near < dist[i]){// 更新距离和前驱节点dist[i] = dist[tmpIndex] + near;path[i] = tmpIndex;}}}// 打印最短距离，打印路径for (int i = 0 ; i < count ; i++){System.out.println("从 " + source + " 到 " + i + " 的最短距离是：" + dist[i]);System.out.println("所经过的路径是：");printRoad(path, i);System.out.println("\n-----------------------------------");}}/*** 打印从起始点到目标节点的路径* @param path 前驱数组* @param target 目标节点*/private void printRoad(int [] path, int target){if (path[target] == -1) {System.out.print(target + " ");return;}printRoad(path, path[target]);System.out.print(target + " ");}}

拓展问题：最短路径的条数

如何输出最短路径的个数？
例如从a到e有三种路径可以走，就应该输出3。

不妨分析一下，如果用一个数组count[i]来表示起始点到i的最短路径个数。那么这个count[i]应该如何统计？

当距离要更新时：count[i]=count[pre]count[i] = count[pre]count[i]=count[pre]
当距离相等时：count[i]=count[i]+count[pre]count[i] = count[i] + count[pre]count[i]=count[i]+count[pre]

画个图比较好理解，当起始点到i的距离更新为更小时，最短路径个数要和起始点到先序节点pre的个数一致。当出现了相等的距离时，总数就多了先序节点那么多个（这时不能直接加一，出现一条重复路径后，前面的一堆路径都能通过这个路径走，所以要加上前面一堆路径的个数，也就是count[pre]）。

实现过程也比较容易：

新建count数组并初始化。
在遍历某个节点的相邻节点时，不能只在值更小的时候更新count数组，还要在值相等的情况下更新count数组。

替换后的road方法（只有两处有更新，标记在代码中了）：

public void road(int count, int[][] line, int source)
{// 邻接矩阵int[][] graph = new int[count][count];// 使用最大值填充邻接矩阵for (int[] slide : graph){Arrays.fill(slide, MAX);}// 初始化邻接矩阵for (int[] L : line){graph[L[0]][L[1]] = L[2];graph[L[1]][L[0]] = L[2];}// 定义距离数组，dist[i]表示从起始点到i的最短距离int[] dist = new int[count];Arrays.fill(dist, MAX);dist[source] = 0;// 定义前驱节点记录，path[i]代表i的前驱节点int[] path = new int[count];path[source] = -1;// pathCount[i]统计从起始点到i有多少条最短路径int[] pathCount = new int[count]; <================保存距离数组pathCount[source] = 1;// checked[i]标识第i个节点是否被处理过int[] checked = new int[count];while (true){// 在所有节点中选择一个距离source最短的节点int tmpMin = MAX;int tmpIndex = -1;for (int i = 0 ; i < count ; i++){// 如果这个节点被处理过，跳过这个节点if (checked[i] == 1)continue;if (dist[i] < tmpMin){tmpMin = dist[i];tmpIndex = i;}}// 如果没找到，退出循环if (tmpIndex == -1)break;// 如果找到了，将checked[i]设为访问过checked[tmpIndex] = 1;// 遍历其所有相邻节点for (int i = 0 ; i < count ; i++){int near = graph[tmpIndex][i];// 第一个是判断这个边是否存在// 第二个是判断对应节点是否处理过// 第三个是判断新的距离是否比旧的距离短 ↓↓↓↓↓↓↓↓↓这段内容有变化↓↓↓↓↓↓↓↓↓if (near != MAX && checked[i] == 0 && dist[tmpIndex] + near <= dist[i]){                               // ↑↑↑↑↑↑↑↑小于号变为小于等于↑↑↑↑↑↑↑↑if (dist[tmpIndex] + near == dist[i]) {pathCount[i] += pathCount[tmpIndex];} else {pathCount[i] = pathCount[tmpIndex];}// ↑↑↑↑↑↑↑↑pathCount的更新↑↑↑↑↑↑↑↑// 更新距离和前驱节点dist[i] = dist[tmpIndex] + near;path[i] = tmpIndex;}}}for (int i = 0 ; i < count ; i++){System.out.println("最短路径个数为：" + pathCount[i]);System.out.println("从 " + source + " 到 " + i + " 的最短距离是：" + dist[i]);System.out.println("所经过的路径是：");printRoad(path, i);System.out.println("\n-----------------------------------");}
}

如果要打印所有的最短路径，只需将path数组从int []变为int [][]，遇到相同距离就添加进去。打印的话打印所有前驱节点，然后这些前驱节点继续递归打印所有前驱节点即可。

拓展问题：打印经过节点数最少的最短路径

在有多条最短路径的情况下，只选择经过节点数最少的最短路径。

这个问题可以转化为双重条件，主条件是距离，副条件是节点数。

优先判断距离。距离相等的情况下，再判断节点数大小。

典型迪杰斯特拉变式：PTA 旅游规划（有权单源最短路径）