Dijkstra + 堆优化

Dijkstra + 堆优化

　　\(Dijkstra\) 算法又称“迪杰斯特拉”或“迪克斯特拉”算法，是由荷兰计算机科学家 \(Edsger\) \(Wybe\) \(Dijkstra\) 提出，通常用于求不含负权边的单源最短路径。

基本原理

　　首先用 \(dis\) 数组记录起点到每个结点的最短路径，再用一个集合 \(T\) 保存已经找到最短路径的结点，然后从 \(dis\) 数组中选择最小值，则该值就是源点 \(s\) 到该值对应的结点 \(u\) 的最短路径，把该结点 \(u\) 加入到 \(T\) 中，并且用结点 \(u\) 当前的最短路径估计值对离开结点 \(u\) 所指向的结点 \(v\) 进行松弛操作，即判断是否有 \(dis[v]>dis[u]+w\)（\(w\) 是连接 \(u\) 与 \(v\) 的边的长度），若有，则更新 \(dis[v]\)。这样不断从 \(dis\) 数组中选择最小值对应的结点来进行松弛操作，直至所有结点都在集合 \(T\) 中为止。
　　同时，我们发现在 \(dis\) 数组中选择最小值时，我们可以用一些数据结构来进行优化。相对于线段树和平衡数来说，\(STL\) 里的堆有着常数小，码量小等优点，并且堆的一个妙妙的性质就是可以在 \(n \log{n}\) 的时限内满足堆顶是堆内元素的最大（小）值，因此，我们可以选择使用堆来优化 \(Dijkstra\) 算法。

效率分析

　　相较于 \(Spfa\)，\(Dijkstra\) 算法更为稳定而不易被卡。普通的 \(Dijkstra\) 算法的期望时间复杂度为 \(O(V^2)\) ，其中 \(V\) 是结点数。而加了堆优化的 \(Dijkstra\) 算法的复杂度可以降到 \(O((V＋E)\log{V})\) ，在稠密图中表现得更为优秀。

核心代码

ll n,m,s,cnt,head[maxn],dis[maxn];
bool vis[maxn];
struct Edge{ll u,v,w,next;}edge[maxm];
struct node
{
    ll w,now;
    inline bool operator<(const node &x)const
                                            /*重载运算符（大根堆）*/
    {
        return w>x.w;
    }
};
inline void add(ll u,ll v,ll w)             /*链式前向星存图*/
{
    edge[++cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt;
}
inline void Dijkstra()
{
    priority_queue<node>q;                  /*优先队列优化*/
    for(ll i=1;i<=n;i++)
        dis[i]=INF,vis[i]=0;                /*初始距离设为INF,访问标记置为0*/
    dis[s]=0;
    q.push((node){0,s});                    /*源点入队*/
    while(!q.empty())
    {
        node x=q.top();                     /*队首元素出队*/
        q.pop();
        ll u=x.now;
        if(vis[u])continue;                 /*如果已遍历过就跳过*/
        vis[u]=1;
        for(ll i=head[u];i;i=edge[i].next)  /*寻找与所有以队首结点 u 为起点的边*/
        {
            ll v=edge[i].v,w=edge[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;            /*松弛操作*/
                q.push((node){dis[v],v});   /*入队*/
            }
        }
    }
}

例题解析

洛谷 P4779 【模板】单源最短路径（标准版）

　　给出一个有向图 \(G＝＜V,E＞\) ，一个源点 \(S\) ，求点 \(S\) 到图中所有点的最短距离。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define maxn 100005
#define maxm 200005
#define INF 1234567890
template<class T>inline bool read(T &x)
{
    x=0;register char c=getchar();register bool f=0;
    while(!isdigit(c)){if(c==EOF)return false;f^=c=='-',c=getchar();}
    while(isdigit(c))x=(x<<3)+(x<<1)+(c^48),c=getchar();
    if(f)x=-x;
    return true;
}
template<class T>inline void print(T x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)print(x/10);
    putchar(x%10^48);
}
template<class T>inline void print(T x,char c){print(x),putchar(c);}
ll n,m,s,cnt,head[maxn],dis[maxn];
bool vis[maxn];
struct Edge{ll u,v,w,next;}edge[maxm];
struct node
{
    ll w,now;
    inline bool operator<(const node &x)const
    {
        return w>x.w;
    }
};
inline void add(ll u,ll v,ll w)
{
    edge[++cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt;
}
inline void Dijkstra()
{
    priority_queue<node>q;
    for(ll i=1;i<=n;i++)
        dis[i]=INF,vis[i]=0;
    dis[s]=0;
    q.push((node){0,s});
    while(!q.empty())
    {
        node x=q.top();
        q.pop();
        ll u=x.now;
        if(vis[u])continue;
        vis[u]=1;
        for(ll i=head[u];i;i=edge[i].next)
        {
            ll v=edge[i].v,w=edge[i].w;
            if(dis[v]>dis[u]+w)
            {
                dis[v]=dis[u]+w;
                q.push((node){dis[v],v});
            }
        }
    }
}
int main()
{
    read(n),read(m),read(s);
    ll u,v,w;
    for(ll i=1;i<=m;i++)
    {
        read(u),read(v),read(w);
        add(u,v,w);
    }
    Dijkstra();
    for(ll i=1;i<n;i++)print(dis[i],' ');
    print(dis[n],'\n');
    return 0;
}