Dijkstra + 堆优化

最新推荐文章于 2024-07-23 20:28:13 发布

President~wolf

最新推荐文章于 2024-07-23 20:28:13 发布

阅读量1.2k

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/weixin_63496008/article/details/124309682

版权

L2-001 紧急救援 (25 分)

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式：

输入第一行给出 44 个正整数 NN、MM、SS、DD，其中 N(2≤N≤500)N(2≤N≤500) 是城市的个数，顺便假设城市的编号为 0∼(N−1)0∼(N−1)；MM是快速道路的条数；SS 是出发地的城市编号；DD 是目的地的城市编号。
第二行给出 NN 个正整数，其中第 ii 个数是第 ii 个城市的救援队的数目，数字间以空格分隔。随后的 MM 行中，每行给出一条快速道路的信息，分别是：城市 11、城市 22、快速道路的长度，中间用空格分开，数字均为整数且不超过 500500。输入保证救援可行且最优解唯一。

输出格式：

第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从 SS 到 DD 的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例：

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例1：

2 60
0 1 3

解题思路：

求单源最短路径，可使用堆优化的 DijkstraDijkstra 算法(非负权图不推荐使用 SpfaSpfa)，可以用优先队列代替堆，递归法打印路径。

参考代码：

#include<bits/stdc++.h>
using namespace std;
#define maxn 505
#define maxm 250005
#define INF 1234567890
int n,m,k,s,d,c[maxn],cnt,head[maxn],vis[maxn],dis[maxn],cis[maxn],a[maxn],pre[maxn];
struct Edge{int u,v,w,next;}edge[maxm];
struct node
{
    int w,t,now;
    inline bool operator<(const node &x)const
    {
        if(w==x.w)return t<x.t;
        return w>x.w;
    }
};
priority_queue<node>q;
inline void add(int u,int v,int w)
{
    edge[++cnt].u=u;
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt;
}
inline void printPath(int x)
{
    if(x==s){cout<<x;return;}
    printPath(pre[x]);
    cout<<' '<<x;
}
inline void Dijkstra()
{
    for(int i=0;i<=n;i++)
    {
        dis[i]=INF;
        vis[i]=0;
    }
    dis[s]=0;
    a[s]=1;
    cis[s]=c[s];
    q.push((node){0,cis[s],s});
    while(!q.empty())
    {
        node x=q.top();
        q.pop();
        int u=x.now;
        if(vis[u])continue;
        vis[u]=1;
        for(int i=head[u];i;i=edge[i].next)
        {
            int v=edge[i].v;
            if(dis[v]>dis[u]+edge[i].w)
            {
                dis[v]=dis[u]+edge[i].w;
                a[v]=a[u];
                pre[v]=u;
                cis[v]=cis[u]+c[v];
                q.push((node){dis[v],cis[v],v});
            }
            else if(dis[v]==dis[u]+edge[i].w)
            {
                a[v]+=a[u];
                if(cis[v]<cis[u]+c[v])
                {
                    cis[v]=cis[u]+c[v];
                    pre[v]=u;
                    q.push((node){dis[v],cis[v],v});
                }
            }
        }
    }
}
int main()
{
    cin>>n>>m>>s>>d;
    for(int i=0;i<n;i++)cin>>c[i];
    int u,v,w;
    for(int i=1;i<=m;i++)
    {
        cin>>u>>v>>w;
        add(u,v,w);
        add(v,u,w);
    }
    Dijkstra();
    cout<<a[d]<<' '<<cis[d]<<endl;
    printPath(d);
    return 0;
}

Dijkstra + 堆优化

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

基本原理

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

效率分析

　　相较于 SpfaSpfa，DijkstraDijkstra 算法更为稳定而不易被卡。普通的 DijkstraDijkstra 算法的期望时间复杂度为 O(V2)O(V2) ，其中 VV 是结点数。而加了堆优化的 DijkstraDijkstra 算法的复杂度可以降到 O((V＋E)logV)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＞G＝＜V,E＞，一个源点 SS ，求点 SS 到图中所有点的最短距离。

#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;
}

President~wolf

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Dijkstra + 堆优化

L2-001 紧急救援 (25 分)作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。输入格式：输入第一行给出44个正整数NN、MM、SS、DD，其中N(2≤N≤500)N(2≤N≤500)是城市的个数，顺便假设城市的编号为0∼(N−1)0∼(N...
复制链接

扫一扫