ACM -算法 | 堆优化Dijkstra算法

Dijkstra算法

对于一个边权为正的图，我们可以利用Dijkstra算法求出单源最短路径（SSSP），对于常规的Dijkstra算法，其复杂度为 $O(n^2)$ ,显然在 $n$ 较大的时候，可能导致耗时过长，通过优化我们可以获得一种更加快速的Dijkstra算法，时间复杂度为 $O(mlogn)$ 。

优化思想

在传统的Dijkstra算法中，在 d[n] 中寻找未被访问且最小的 d[i] 采用的是遍历数组的方式，这样会导致时间的复杂度变高，既然是输出最小的权值边，那么我们可以用STL中的 priority_queue 的优先队列来实现这一操作，可以实现加速。当然，为了实现这一操作，我们存储图也不再利用简单的邻接矩阵，而是先存储边的数据，再将边的数据存储到 vector 数组中，有点像邻接表,但不是邻接表。

代码

代码源于《算法竞赛入门经典（第2版）》（紫书）

struct Edge
{
    int from, to, dist;
    Edge(int u,int v,int d):from(u),to(v),dist(d){}
};

struct HeapNode{
    int d, u;
    bool operator <(const HeapNode & rhs) const{
        return d > rhs.d;
        //这里用>与上面operator所定义的相反是为了让优先队列中最小的值先pop
    }
};

struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool done[maxn];
    int d[maxn];
    int p[maxn];

    void init(int n){
        this->n = n;
        for (int i = 0; i < n; i++)
            G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int dist){
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s){
        priority_queue<HeapNode> Q;
        for (int i = 0; i < n;i++)
            d[i] = INF;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        Q.push((HeapNode){0, s});
        while(!Q.empty()){
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            if(done[u])
                continue;
            done[u] = true;
            for (int i = 0; i < G[u].size();i++){
                Edge &e = edges[G[u][i]];
                if(d[e.to] > d[u] + e.dist){
                    d[e.to] = d[u] + e.dist;
                    p[e.to] = G[u][i];
                    Q.push((HeapNode){d[e.to], e.to});
                }
            }
        }
    }
};

例题

看了上述的代码，不妨来做道题试试。
题目：J-free：https://ac.nowcoder.com/acm/contest/884/J
题意：给定一个图，有 $n$ 个点， $m$ 个边，每个边的权值为 $l$, 你可以让图上至多 $k$ 个边的权值变为 $0$，请问，在这样的操作过后，从顶点 $S$ 到顶点 $T$ 的最短路径是多少。
题解：在了解了上述的关于堆优化的Dijkstra算法过后，对于解这题很有帮助。由于到点的距离与 $k$ 有了关系，我们不能再用原先的一维数组 d[n] 来存储到各个点的距离的最短路径，而是要开一个二维数组 dis[n][m] ,其中 dis[i][j] 表示从源点到顶点 $i$ 在使 $j$ 个边的权值变成 $0$ 的情况下的最短路径。这样我们就很容易地可以获得答案了。那么要如何建立这个二维数组 dis[n][m] 呢，在原先的Dijkrstra算法中，我们向Q中push一个HeapNode的条件是 d[e.to] > d[u] + e.dist ,在这里由于多了一个考虑因素 $k$ ,所以我们的HeapNode中要增加一个变量ktime来表示删掉权值边的个数。同时，push的判定条件，也由原来的一个变成了两个，一个是在ktime不变的情况下是否push，另一个是在ktime+1的情况下是否push。这样就可以完美地构建出二维数组的 dis[n][m] 了。最后在寻找 $ans$ 时，只需要遍历 dis[T] 即可。
代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 5;
typedef long long ll;
#define INF 1e9 + 5
int n, m, S, T, k;
ll dis[maxn][maxn];
struct Edge
{
    int from, to, dist;
    Edge(int u,int v,int d):from(u),to(v),dist(d){}
};

struct HeapNode{
    int d, u, ktime;
    bool operator<(const HeapNode &rhs) const
    {
        return d > rhs.d;
    }
};

struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool done[maxn][maxn];

    void init(int n){
        this->n = n;
        for (int i = 0; i < n; i++)
            G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int dist){
        edges.push_back(Edge(from, to, dist));
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s){
        memset(dis, INF, sizeof(dis));
        priority_queue<HeapNode> Q;
        dis[s][0] = 0;
        memset(done, 0, sizeof(done));
        Q.push((HeapNode){0, s, 0});
        while (!Q.empty())
        {
            HeapNode x = Q.top();
            Q.pop();
            int u = x.u;
            int ktime = x.ktime;
            if (done[u][ktime])
                continue;
            done[u][ktime] = true;
            for (int i = 0; i < G[u].size();i++){
                Edge &e = edges[G[u][i]];
                if(dis[u][ktime]+e.dist<dis[e.to][ktime]){
                    dis[e.to][ktime] = dis[u][ktime] + e.dist;
                    Q.push((HeapNode){dis[e.to][ktime], e.to, ktime});
                }
                if(ktime<k&&dis[u][ktime]<dis[e.to][ktime+1]){
                    dis[e.to][ktime + 1] = dis[u][ktime];
                    Q.push((HeapNode){dis[e.to][ktime + 1], e.to, ktime + 1});
                }
            }
        }
    }
};

int main(){
    scanf("%d%d%d%d%d", &n, &m, &S, &T, &k);
    Dijkstra dij;
    dij.init(n);
    int a, b, l;
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &a, &b, &l);
        dij.AddEdge(a, b, l);
        dij.AddEdge(b, a, l);
    }
    dij.dijkstra(S);
    ll ans = INF;
    for (int i = 0; i <= k; i++)
    {
        ans = (ans < dis[T][i]) ? ans : dis[T][i];
    }
    printf("%lld", ans);
    return 0;
}