Dijkstra求最短路

Dijkstra求最短路

如果图中存在负权边，则不要使用 Dijkstra 来求最短路。

重边和自环

如果题目中表明所给的图存在重边与自环。

在求最短路径的问题中，

如果自环边权重是 正数，显然它不会出现在最短路径中。如果自环边是 负数，则需要考虑出现在最短路中。

如果是稠密图，使用了邻接矩阵来存边，则因为求最短路，所以我们对于重边，只需要存储最小的那个重边即可。 但如果是稀疏图，使用了邻接表来存边的话，则不需要对重边进行特殊处理。

朴素版 Dijkstra 算法

一般需要使用朴素版 Dijkstra 算法的图论问题都是 稠密图，我们需要使用 邻接矩阵 来存 边。

使用一个一维数组 dist[i] 表示 i 号点到起点的距离，并且初始化 dist[1] = 0，其余 dist 点初始化为 $+\infty$

。

s 表示当前已确定最短距离的点。

以上过程的原理是贪心思想。

int dijkstra() {
    memset(d, 0x3f, sizeof d);
    d[1] = 0;
    
    for (int i = 0; i < n; ++i) { // 迭代 n 次
        
        int t = -1; // 整体上，在所有 不在集合 s 的点中，寻找 d[j] 值最小的点
        for (int j = 1; j <= n; ++j) {
            if (!s[j] && (t == -1 || d[t] > d[j])) { //寻找不在集合s中的，距离最短的点
                t = j;
            }
        }
        

        s[t] = true; // 已经找到了一个不在集合 s 中的距离最近的点 t，现在将它放入集合 s。

        for (int j = 1; j <= n; ++j) { // 用 t 更新其它点到起点的距离
            d[j] = min(d[j], d[t] + w[t][j]);
        }
    }

    if (d[n] == 0x3f3f3f3f) return -1; // 说明没有1 ~ n 的最短路
    else return d[n];
}

朴素版 Dijkstra 时间复杂度

for i 1 ~ n 循环了 n 次。确定不在 s 中的，距离最近的点，需要一个 for 循环 n次 。用 t 更新其它点的距离也需要一个 for 循环 n 次。因此，朴素版 Dijkstra 算法的时间复杂度是 $O(n^2)$。

堆优化版 Dijkstra

如果是一个稀疏图，且图的点数超过 $10^5$ 。朴素版 Dijkstra 就会超时。应该使用 堆优化的 Dijkstra，且用 邻接表存储图。

首先分析朴素版 Dijkstra 的性能瓶颈。

在 外层 for 循环下，寻找 “不在 s 中的，距离最近的点”，一共运算了 $n^2$ 次；

“s <-- t” 时间复杂度 $O(1)$。所以，一共运算了 n 次。

“用 t 更新其它点的距离” 因为 点 t 并非与所有点都有边，每次 for 循环只会寻找 t 的相邻点。所以整体上，一共运算了 m 次。

经过上述分析，我们知道，最耗时的步骤是 寻找 ”不在 s 中的，距离最近的点。“

在一堆数中寻找最小的数字，我们可以使用 堆 来寻找。时间复杂度是 $O(1)$。

但是在堆中修改一个数的时间复杂度是 $O(logn)$ 。所以 ”用 t 更新其它点的距离” 这一步每次都是 logn 。因此，堆优化的 Dijkstra 算法的时间复杂度是 $O(mlogn)$ ，其中 m 表示 边数。

堆的实现

可以手写堆，也可以使用 C++ STL 的优先队列。但是两者在实现和时间复杂度上有一点点小学问。

手写堆的好处是 n 个点的堆只需要 n 个元素，并且修改 堆 中任意一个元素的时间复杂度是 $O(logn)$。

STL 优先队列的好处是简单、容易写。但是由于底层实现是依靠冗余，也就是意味着每次你使用 STL 优先队列的修改操作实际上是直接在 堆 中插入一个新的元素，因此空间复杂度是 O(m)，m 表示边数。所以，STL 优先队列修改元素的时间复杂度是 O(log m)。

但是，如果 $m$ 远远小于 $n^2$ （稀疏图），则 log m <= 2log n，时间复杂度还是 $O(logn)$。

当你使用堆优化的 Dijkstra 时，往往是因为点数 n 超过了 $10^5$ ，且是稀疏图（你想想，如果点数超过 $10^5$ ，在算法题中，往往不能用一个二维数组来存所有边，因为空间不够。）。因此，堆优化的 Dijkstra 往往使用 STL 优先队列，而不用手写堆。

代码实现

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>

using namespace std;

typedef pair<int, int> PII;

const int N = 150010, M = 2 * N;
int e[M], ne[M], idx, h[N], w[M];
int n, m;

int d[N];
bool st[N];

void init() {
    memset(h, -1, sizeof h);
}

void add(int a, int b, int z) {
    e[idx] = b;
    ne[idx] = h[a];
    w[idx] = z;
    h[a] = idx++;
}

int dijkstra_optimization_by_heap() {
    memset(d, 0x3f, sizeof d);
    d[1] = 0;

    priority_queue<PII, vector<PII>, greater<PII>> heap; // heap 表示小根堆。第二个参数表示堆使用什么容器来实现，其它容器也可以，但是使用vector会比较好。
    heap.push({0, 1}); // 将 1 号点放入堆中

    while (heap.size()) {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;
        if (st[ver] == true) continue; // 说明是 STL 堆中的冗余备份
        st[ver] = true;

        for (int i = h[ver]; ~i; i = ne[i]) {
            int next = e[i];

            if (d[next] > d[ver] + w[i]) {
                d[next] = d[ver] + w[i];
                heap.push({d[next], next});
            }
        }
    }

    if (d[n] == 0x3f3f3f3f) return -1;
    else return d[n];
}

int main()
{
    init();
    scanf("%d%d", &n, &m);

    int x, y, z;
    for (int i = 1; i <= m; ++i) {
        scanf("%d%d%d", &x, &y, &z);
        add(x, y, z);
    }

    int ans = dijkstra_optimization_by_heap();

    if (ans != -1) printf("%d\n", ans);
    else puts("-1");
}

参考：AcWing