单源最短路(优化篇之Dijkstra)

最新推荐文章于 2022-12-29 08:30:00 发布

Saul Zhang

最新推荐文章于 2022-12-29 08:30:00 发布

阅读量369

点赞数 1

分类专栏：算法刷题集文章标签：最短路 Dijkstra 优化

本文链接：https://blog.csdn.net/qq_37053885/article/details/94484979

版权

算法刷题集专栏收录该内容

96 篇文章 3 订阅

订阅专栏

最短路（hdu2544)

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 104625 Accepted Submission(s): 44973

1.Problem Description：

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input:输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output:对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output
3
2

2.基本思路

这道题由于只有100个城市，因此不采用任何优化，只采用最简单的Dijkstra便能通过。但为了能够理解Dijkstra的主要优化方法我们以该题为例在该题的基础上不断地进行优化，最终达到终极版本，当你掌握了终极版本的Dijkstra算法之后，你将对Dijkstra问题无所畏惧。

3.代码实现

3.1 $v e r s i o n - 1$ 裸Dijkstra算法【采用邻接链表和邻接矩阵进行存取均可，当图较为稀疏的时候采用邻接链表效率更高，但图较为稠密的时候采用邻接矩阵的效率更高，但一般情况下邻接链表的效率均更优】

#include <iostream>
#include <climits>
#include <vector>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){
                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                }
            }

            int Min = INT_MAX;
            for(int j=1;j<=n;j++){
                if(vis[j]!=0){
                    if(~dis[j]){
                        if(dis[j]<Min){
                            Min=dis[j];
                            newP = j;
                        }
                    }
                }
            }

            vis[newP] = 0;
        }
        cout<<dis[n]<<endl;
    }
    return 0;
}

首先提交一发，好了，这就是我们优化的起点
在这里插入图片描述

3.2 $v e r s i o n - 2$ 仔细想想，其实Dis[…]的更新并不一定是按顺序的，因此我们只需要在dis[N]更新完之后便可以得到最终个正确答案了。

#include <iostream>
#include <climits>
#include <vector>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){
                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                }
            }

            int Min = INT_MAX;
            for(int j=1;j<=n;j++){
                if(vis[j]!=0){
                    if(~dis[j]){
                        if(dis[j]<Min){
                            Min=dis[j];
                            newP = j;
                        }
                    }
                }
            }

            vis[newP] = 0;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;

    }
    return 0;
}

再提交一发！！
在这里插入图片描述
咦，好像没什么变化，估计是测试用例中特殊数据样例比较少，别急，后面还有大招呢，我们继续优化。

3.3 $v e r s i o n - 3$ 是时候分析一下上面算法的时间复杂度了，一看过去两层 $f o r$ 循环特别醒目，因此该算法的平均时间复杂度为 $O(n^2)$ 。我们来分析一下两层 $f o r$ 循环，第一层指的是最多一共需要选择除了起始点外的 $n - 1$ 个结点，因此这一层循环是至少需要的，不可简化的，而第二层循环的目的呢，主要是为了取出当前 $d i s [. . .]$ 数组中没有被访问过的城市中对应最小 $d i s [i]$ 的城市 $i$ ，因此其是一个求解最小值的过程，这里我们就可以考虑采用小顶堆进行优化，这样每次求最小值的时候，我们只需要取出堆顶的元素即可。分析算法可知，堆中元素最多可以到达 $M$ 个，也就是边的数量。因此该算法的时间复杂度为 $O (N l o g M)$

下面放出优化之后的代码:

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
#define N 101
using namespace std;

int dis[N];
int vis[N];

struct Node{
    int id;
    int cost;
    Node(int _id,int _cost){
        id = _id;
        cost = _cost;
    }
    operator < (const Node& ano)const{
        return cost > ano.cost;
    }
};

priority_queue<Node> Que;

struct Next{
    int city;
    int time;
    Next(int _city,int _time){
        city = _city;
        time = _time;
    }
};

vector<Next> Vec[N];

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){

        if(n==0&&m==0)
            break;
        while(!Que.empty())
            Que.pop();

        //init
        for(int i=1;i<=n;i++)
            dis[i]=-1,vis[i]=-1,Vec[i].clear();

        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            Vec[A].push_back(Next(B,C));
            Vec[B].push_back(Next(A,C));
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 0;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=0;j<Vec[newP].size();j++){

                int city = Vec[newP][j].city;
                int time = Vec[newP][j].time;
                if(vis[city]==0)
                    continue;
                if(dis[city]==-1||dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                    Que.push(Node(city,dis[city]));
                }
            }

            while(!Que.empty()){

                if(vis[Que.top().id]!=-1){
                    Que.pop();
                    continue;
                }
                newP = Que.top().id;
                Que.pop();
                break;
            }

            vis[newP] = 0;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;

    }
    return 0;
}

在这里插入图片描述
3.4 $v e r s i o n - 4$ 到这里应该已经能过绝大部分的题目了，但仔细想想还有没有优化的空间呢？有的，因为我们采用了vector来作为邻接链表存储图的结构，而vector是STL封装的高级数据结构，因此访问时间一般比简单的整数数组来的慢，因此这里可以采用链式前向星来存取整图的结构，对于卡常的代码还是值得尝试采用该种方法来试一试。先贴出代码和运行结果：

#include <iostream>
#include <climits>
#include <vector>
#include <queue>
#include <memory.h>
#define N 101
#define M 10001
using namespace std;

struct Node{
    int id;
    int cost;
    Node(int _id,int _cost){
        id = _id;
        cost = _cost;
    }
    operator < (const Node& ano)const{
        return cost > ano.cost;
    }
};

struct Edge{
    int next;//下条同起点的边的编号
    int to;//该边的终止点的编号
    int w;//该边所具有的权重
}edge[M];

priority_queue<Node> Que;

int dis[N];
int vis[N];
int head[N];
int tot;

void init() {
    tot = 0;
    memset(head, -1, sizeof(head));
}

void add_Edge(int u,int v,int w){
    edge[tot].to=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;
}

int main()
{
    int n,m;
    int A,B,C;

    while(cin>>n>>m){
        //init
        init();
        for(int i=1;i<=n;i++)
            vis[i]=0,dis[i]=0x3f3f3f3f;

        if(n==0&&m==0)
            break;

        while(!Que.empty())
            Que.pop();


        for(int i=0;i<m;i++){
            cin>>A>>B>>C;
            add_Edge(A,B,C);
            add_Edge(B,A,C);
        }

        int newP = 1;
        dis[newP] = 0;
        vis[newP] = 1;

        //dijkstra
        for(int i=0;i<n-1;i++){
            for(int j=head[newP];~j;j=edge[j].next){
                int city = edge[j].to;
                int time = edge[j].w;
                if(vis[city]!=1&&dis[city]>dis[newP]+time){
                    dis[city] = dis[newP]+time;
                    Que.push(Node(city,dis[city]));
                }
            }

            while(!Que.empty()){

                if(vis[Que.top().id]!=0){
                    Que.pop();
                    continue;
                }
                newP = Que.top().id;
                Que.pop();
                break;
            }

            vis[newP] = 1;
            if(newP==n)break;
        }

        cout<<dis[n]<<endl;
    }
    return 0;
}

在这里插入图片描述
最终运行的时间没有多大的变化，主要还是该问题的数据规模比较小，但规模比较大的时候效果就比较明显了。

关于前向星有以下两篇文章值得参考：
https://blog.csdn.net/acdreamers/article/details/16902023
https://blog.csdn.net/lookqaq/article/details/81304637

最后为了证明优化的意义，不凡请各位看官移步hdu3790亲自感受一下优化的魅力之所在。
以下是我最终AC的代码：https://paste.ubuntu.com/p/gtW7ypFhRG/

4.Summary：

最后让我们一起来总结一下，这篇文章的优化过程，首先我们采用了裸Dijkstra的代码直接跑通，随后观察到可以判断终点的更新来提前终止算法，接下来我们分析了前面算法的时间复杂度，采用小顶堆来选取最小距离的结点将复杂度从 $O(n^2)$ 直接降到了 $O (N l o g M)$ 。最后，我们考虑采用链式前向星来优化图的存储，相比于Vector数据结构存储图，其访问图中边的效率得到了提高，以上。

Saul Zhang

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
单源最短路(优化篇之Dijkstra)

最短路（hdu2544)Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 104625 Accepted Submission(s): 449731.Problem Description：在每年的校赛里，所有进入决赛的同学都...
复制链接

扫一扫