[Acwing算法基础] 3.5 堆优化的Dijkstra算法

堆优化版针对稀疏图做了优化。距离更新操作和朴素的Dijkstra算法一样，只是换了一种表达。

算法思路

算法步骤

见Acwing 笔记

1. 一号点的距离初始化为零，其他点初始化成无穷大。
2. 将一号点放入堆中。
3. 不断循环，直到堆空。每一次循环中执行的操作为：弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。用该点更新临界点的距离，若更新成功（距离变小）就加入到堆中。
   

1. 图的邻接表存储

邻接表存储的代码如下：

int h[N], e[N], ne[N], idx, w[N];

//在a节点之后插入一个b节点，权重为c
void add(int a, int b, int c) {
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx++;
}

2. 堆优化后的节点更新

不断循环，直到堆空。每一次循环中执行的操作为：弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。用该点更新临界点的距离，若更新成功（距离变小）就加入到堆中。

while (heap.size())
{
    auto t = heap.top();//取距离源点最近的点
    heap.pop();

    int ver = t.second, distance = t.first;//ver:节点编号，distance:源点距离ver 的距离

    if (st[ver]) continue;//如果距离已经确定，则跳过该点
    st[ver] = true;

    for (int i = h[ver]; i != -1; i = ne[i])//更新ver所指向的节点距离
    {
        int j = e[i];
        if (dist[j] > dist[ver] + w[i])
        {
            dist[j] = dist[ver] + w[i];
            heap.push({dist[j], j});//距离变小，则入堆
        }
    }
}

如果终点的距离使正无穷，那么表示终点无路径可以到达，返回-1；否则，返回dist[n]。

if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];

完整代码

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

using namespace std;
typedef pair<int, int> PII; //<离起点的距离， 节点编号>

const int N = 150010;
int h[N], e[N], ne[N], idx, w[N];
int dist[N];
bool st[N];
int n, m;

//在a节点之后插入一个b节点，权重为c
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);
//    1号节点距离为0
    dist[1] = 0;
//    建立一个小根堆
    priority_queue<PII, vector<PII>, greater<PII>> heap;
//    1号节点插入堆
    heap.push({0, 1});
    while (heap.size()) {
//        取出堆顶顶点
        auto t = heap.top();
//        并删除
        heap.pop();
//        取出节点编号和节点距离
        int ver = t.second, distance = t.first;
//        如果节点被访问过，则跳过
        if (st[ver])continue;
        st[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i]) {
//            取出节点编号
            int j = e[i];
//            dist[j] 大于从t过来的距离
            if (dist[j] > distance + w[i]) {

                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f)return -1;
    return dist[n];
}

int main() {
    memset(h, -1, sizeof h);
    cin >> n >> m;
    while (m--) {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c);
    }
    cout << dijkstra() << endl;
    return 0;
}

未优化的代码

#include<iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510, M = 100010;

int h[N], e[M], ne[M], w[M], idx;//邻接矩阵存储图
int state[N];//state 记录是否找到了源点到该节点的最短距离
int dist[N];//dist 数组保存源点到其余各个节点的距离
int n, m;//图的节点个数和边数

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

void Dijkstra()
{
    memset(dist, 0x3f, sizeof(dist));//dist 数组的各个元素为无穷大
    dist[1] = 0;//源点到源点的距离为置为 0
    for (int i = 0; i < n; i++)
    {
        int t = -1;
        for (int j = 1; j <= n; j++)//遍历 dist 数组，找到没有确定最短路径的节点中距离源点最近的点t
        {
            if (!state[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        }

        state[t] = 1;//state[i] 置为 1。

        for (int j = h[t]; j != -1; j = ne[j])//遍历 t 所有可以到达的节点 i
        {
            int i = e[j];
            dist[i] = min(dist[i], dist[t] + w[j]);//更新 dist[j]
        }


    }
}

int main()
{
    memset(h, -1, sizeof(h));//邻接矩阵初始化

    cin >> n >> m;
    while (m--)//读入 m 条边
    {
        int a, b, w;
        cin >> a >> b >> w;
        add(a, b, w);
    }

    Dijkstra();
    if (dist[n] != 0x3f3f3f3f)//如果dist[n]被更新了，则存在路径
        cout << dist[n];
    else
        cout << "-1";
}