堆优化版dijkstra

题目描述

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式

输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围

$1\le n,m\le 1.5\times 105$,
图中涉及边长均不小于 0，且不超过 10000。

输入样例

3 3
1 2 2
2 3 1
1 3 4

输出样例

3

---

算法：(堆优化版dijkstra) $O(mlogn)$

朴素版dijkstra过程

1. 在未确定的最短路中找一个最小值并确定最短路 $O(n^2)$。
2. 在确定的最短路终点做一个标记 $O(n)$。
3. 用起点到此次确定最短路点的距离 + 这个点到其他点的距离去更新起点到其他点的距离（在距离更短的前提下更新）邻接表:$O(m)$, 邻接矩阵:$O(n^2)$。

堆优化版dijkstra过程—> 对应朴素版过程此处只写如何优化

1. 找最小值用小根堆找 $O(logn)$。
2. 不变 $O(n)$。
3. 更新时为方便直接插入即可 $O(mlogn)$。

实现具体细节

1. 由于每次找的是起点到k点的最短距离因此堆中需存2个值一个为k点一个为起点到k点距离（可用结构体储存）。
2. 由于调用小根堆的STL比较麻烦，因此在写结构体比较函数时反着来。
3. 由于每次更新变为了插入，因此可能在一个点的最短路已经被确定了后在出现，这时直接跳过。

---

C++ 代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef struct Node {
    int node, dis;
    bool operator < (Node p) const {
        return dis > p.dis;
    }
}Node;
const int N = 2e5 + 10;
int dist[N], h[N], e[N], w[N], ne[N], idx; 
bool st[N];
int n, m;

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

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<Node> q;
    Node p = {1, 0};
    q.push(p);
    while(q.size()) {
        p = q.top();
        q.pop();
        if(st[p.node]) {
            continue;
        }
        st[p.node] = 1;
        for(int i = h[p.node]; i != -1; i = ne[i]) {
            if(dist[e[i]] > dist[p.node] + w[i]) {
                dist[e[i]] = dist[p.node] + w[i];
                q.push({e[i], dist[p.node] + w[i]});
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) {
        return -1;
    }
    return dist[n];
}

int main() {
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    while (m -- ) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    printf("%d\n", dijkstra());
    return 0;
}