Dijkstra算法+打印路径

原理

Dijkstra 算法（中文名：迪杰斯特拉算法）是由荷兰计算机科学家 Edsger Wybe Dijkstra 提出。该算法常用于路由算法或者作为其他图算法的一个子模块。举例来说，如果图中的顶点表示城市，而边上的权重表示城市间开车行经的距离，该算法可以用来找到两个城市之间的最短路径。
设G=(V,E)是一个带权有向图，把图中顶点集合V分为两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将加入到集合S中，直到全部顶点都加入到S中，算法就结束了）,
第二组为其余未确定最短路径的顶点集合（用U表示）,按最短路径的的递增次序依次把第二组中的顶点加入S中。在加入的过程中，总保持从源点v到S中各个顶点的最短路径长度不大于从源点v到U中任何路径的长度。
此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前路径的最短长度。

一般用于求单源无负权最短路径

算法步骤

1）初始时，只包括源点，即S = {v}，v的距离为0。U包含除v以外的其他顶点，即：U ={其余顶点}，若v与U中顶点u有边，则(u,v)为正常权值，若u不是v的出边邻接点,则(u,v)权值 ∞;
2）从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。
3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。
4）重复步骤b和c直到所有顶点都包含在S中。

朴素Dijkstra（邻接矩阵）

测试常量

private static final int N = Integer.MAX_VALUE;   // 最大值
    private static char[] vexs = {'0', '1', '2', '3', '4', '5', '6', '7', '8'};       // 顶点集合
    private static int[][] matrix = {
            {0, 1, 5, N, N, N, N, N, N},
            {1, 0, 3, 7, 5, N, N, N, N},
            {5, 3, 0, N, 1, 7, N, N, N},
            {N, 7, N, 0, 2, N, 3, N, N},
            {N, 5, 1, 2, 0, 3, 6, 9, N},
            {N, N, 7, N, 3, 0, N, 5, N},
            {N, N, N, 3, 6, N, 0, 2, 7},
            {N, N, N, N, 9, 5, 2, 0, 4},
            {N, N, N, N, N, N, 7, 4, 0}};

朴素Dijkstra算法代码(O(n2)).

参数定义：
prev[j：经过点j
dist[j]：到j点距离

public static void dijkstra(int vs) {
        int[] prev = new int[vexs.length];
        int[] dist = new int[vexs.length];
        boolean[] visit = new boolean[vexs.length];
//初始化
        for (int i = 0; i < vexs.length; i++) {
            prev[i] = 0;
            dist[i] = matrix[vs][i];
        }

        visit[vs] = true;
        dist[vs] = 0;
        for (int i = 1; i < vexs.length; i++) {
            int min = N, k = 0;
            for (int j = 0; j < vexs.length; j++) {
                if (!visit[j] && min > dist[j]) {
                    k = j;
                    min = dist[j];
                }
            }

            if (min == N) break;
            visit[k] = true;
            for (int j = 0; j < vexs.length; j++) {
                if (matrix[k][j] == N) continue;
                if (!visit[j] && dist[j] > min + matrix[k][j]) {
                    prev[j] = k;
                    dist[j] = min + matrix[k][j];
                }
            }
        }
        // 打印dijkstra最短路径的结果
        System.out.printf("dijkstra(%c): \n", vexs[vs]);
        for (int i = 0; i < vexs.length; i++)
            System.out.printf("  shortest(%c, %c)=%d , p =%d\n", vexs[vs], vexs[i], dist[i], prev[i]);
    }

堆优化 Dijkstra（邻接表）

堆优化的主要思想就是使用一个优先队列（就是每次弹出的元素一定是整个队列中最小的元素）来代替最近距离的查找，用邻接表代替邻接矩阵，这样可以大幅度节约时间开销。

这也是一种在图论中十分常见的存图方式，与数组存储单链表的实现一致（头插法）。

这种存图方式又叫「链式前向星存图」。

适用于边数较少的「稀疏图」使用，当边数量接近点的数量，即  时，可定义为「稀疏图」。

int[] he = new int[N], e = new int[M], ne = new int[M], w = new int[M];
int idx;

void add(int a, int b, int c) {
    e[idx] = b;
    ne[idx] = he[a];
    he[a] = idx;
    w[idx] = c;
    idx++;
}
首先 idx 是用来对边进行编号的，然后对存图用到的几个数组作简单解释：

he 数组：存储是某个节点所对应的边的集合（链表）的头结点；
e  数组：由于访问某一条边指向的节点；
ne 数组：由于是以链表的形式进行存边，该数组就是用于找到下一条边；
w  数组：用于记录某条边的权重为多少。
因此当我们想要遍历所有由 a 点发出的边时，可以使用如下方式：

for (int i = he[a]; i != -1; i = ne[i]) {
    int b = e[i], c = w[i]; // 存在由 a 指向 b 的边，权重为 c
}

    void dijkstra() {
        // 起始先将所有的点标记为「未更新」和「距离为正无穷」
        Arrays.fill(vis, false);
        Arrays.fill(dist, INF);
        // 只有起点最短距离为 0
        dist[k] = 0;
        // 使用「优先队列」存储所有可用于更新的点
        // 以 (点编号, 到起点的距离) 进行存储，优先弹出「最短距离」较小的点
        PriorityQueue<int[]> q = new PriorityQueue<>((a,b)->a[1]-b[1]);
        q.add(new int[]{k, 0});
        while (!q.isEmpty()) {
            // 每次从「优先队列」中弹出
            int[] poll = q.poll();
            int id = poll[0], step = poll[1];
            // 如果弹出的点被标记「已更新」，则跳过
            if (vis[id]) continue;
            // 标记该点「已更新」，并使用该点更新其他点的「最短距离」
            vis[id] = true;
            for (int i = he[id]; i != -1; i = ne[i]) {
                int j = e[i];
                if (dist[j] > dist[id] + w[i]) {
                    dist[j] = dist[id] + w[i];
                    q.add(new int[]{j, dist[j]});
                }
            }
        }
    }
}

打印路径

 // 打印Dijkstra最短路径的结果
        System.out.printf("bellman(%c): \n", vexs[vs]);
        for (int i = 0; i < vexs.length; i++) {
            System.out.printf("  shortest(%c, %c)=%d , p =%d \t", vexs[vs], vexs[i], dist[i], prev[i]);
            StringBuilder sb = new StringBuilder();
            sb.append(i);
            for (int j = i; j != vs && prev[j] != -1; j = prev[j]) {
                sb.append(">--");
                sb.append(prev[j]);
            }
            System.out.println(sb.reverse());
        }

缺陷

若u→v间存在一条负权回路（负权回路含义为：如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路），那么只要无限次地走这条负权回路，便可以无限制地减少它的最短路径权值，这就变相地说明最短路径不存在。一个不存在最短路径的图，Dijkstra 算法无法检测出这个问题，其最后求解的dist[]也是错的。

对比

Dijkstra: 不含负权。运行时间依赖于优先队列的实现，如 O((∣V∣+∣E∣)log∣V∣)
SPFA: 无限制。运行时间O(k⋅∣E∣) (k≪∣V∣)
Bellman-Ford：无限制。运行时间O(∣V∣⋅∣E∣)
ASP: 无圈。运行时间O(∣V∣+∣E∣)
Floyd-Warshall: 无限制。运行时间O(∣V∣^3)

Dijkstra：适用于权值为非负的图的单源最短路径，用斐波那契堆的复杂度O(E+VlgV)

BellmanFord：适用于权值有负值的图的单源最短路径，并且能够检测负圈，复杂度O(VE)

SPFA：适用于权值有负值，且没有负圈的图的单源最短路径，论文中的复杂度O(kE)，k为每个节点进入Queue的次数，且k一般<=2，但此处的复杂度证明是有问题的，其实SPFA的最坏情况应该是O(VE).

Floyd：每对节点之间的最短路径。

这里给出结论：

(1)当权值为非负时，用Dijkstra。

(2)当权值有负值，且没有负圈，则用SPFA，SPFA能检测负圈，但是不能输出负圈。

(3)当权值有负值，而且可能存在负圈，则用BellmanFord，能够检测并输出负圈。

(4)SPFA检测负环：当存在一个点入队大于等于V次，则有负环，后面有证明。