Dijkstra算法详解

什么是Dijkstra算法

迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的,因此又 叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法,解决的是有权图中最 短路径问题。迪杰斯特拉算法主要特点是从起始点开始,采用贪心算法策略,每次遍 历到始点距离最近且未访问过的顶点的邻接节点,直到扩展到终点为止。

Dijkstra是求单源最短路问题的经典算法,单源最短路一般来说是求一个点到其他点的 最短距离,最常见的一种题型是求1号点到n号点的最短距离。

而单源最短路又分为两种,一种是边权全为正(正权值),另一种是存在负权边。Dijkstra 用来解决边权全为正的单源最短路问题,Dijkstra算法又分为朴素Dijkstra算法堆优化 的Dijkstra算法。朴素版的Dijkstra算法的时间复杂度是O(n²),适合于稠密图,堆优化版 的Dijkstra算 法的时间复杂度是O(mlogn),适合于稀疏图。

解决存在负权边的单源最短路的算法又分为两种,一个是Bellman-Ford,一个是SPFA, SPFA是Bellman-Ford算法的优化。

朴素版Dijkstra算法思路

  1. 先初始化距离,1号点到起点的距离是0,其他点到起点的距离是无穷大
  2. 第二步是一个迭代的过程,循环n次,找到没有确定最短距离且距离起点最近的点,用这个点更新其他点的距离,这个点同时也确定了最短距离。循环n次就可以确定n个点到起点的距离了

举个栗子

 以这个为例,一共三个点,绿色的数字表示点与点之间的距离,1号点到2号点的 距离是2,2号点到3号点的距离是1,1号点到3号点的距离是4,红色数字 表 示每个点到起点的距离。

按照朴素版Dijkstra算法的步骤,首先要初始化距离,1号点到起点的距离是0, 其他点到起点的距离是正无穷

然后我们就要循环3次,确定每个点到起点的距离

第一次循环

 第一次循环明显是1号点距离起点最近,所以我们用这个点更新一下和它相连的点 距离起点的距离,也就是2,3号点,更新之后2号点距离起点的距离是2,3号点距 离起点的距离是4

第二次循环

 

第二次循环发现是2号点距离起点最近,用2号点更新一下和它相连的点距离起点的距离,也就是3号点。3号点距离起点的距离在第一次循环时更新为4,这次我们用2号点更新时可以发现,3号点距离起点的距离可以更新为3,也就1->2->3 的路线的距离小于1->4的路线,所以把3号点距离起点的距离改为3

第三次循环

第三次循环只剩一个点3了,这个点可以确定最短距离是3,至此循环结束,所有的点距离起点的最短距离也就确定了

朴素版Dijkstra存储

上面说了朴素版Dijkstra算法适用于稠密图,稠密图用邻接矩阵来存

案例-Dijkstra求最短路1

给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 nn 号点,则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y 的有向边,边长为 z。

输出格式

输出一个整数,表示 1 号点到 n 号点的最短距离。

如果路径不存在,则输出 −1。

数据范围

1≤n≤500,
1≤m≤1e5,
图中涉及边长均不超过10000。

输入样例:

3 3
1 2 2
2 3 1
1 3 4

输出样例:

3

代码实现

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=515;
int dist[N];//每个点距离起点的距离
int g[N][N];//邻接矩阵
int n,m;
bool st[N];//存储已经确定最短路径的点
int dijkstra()
{
    //初始化每个点到起点的距离
    memset(dist,0x3f,sizeof dist);
    //1号点到起点的距离为0
    dist[1]=0;
    //循环n次确定n个点到起点的最短距离
    for(int i=0;i<n;i++)
    {
        //每次循环用t来存没有确定最短距离且距离起点最近的点
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dist[j]<dist[t]))
            t=j;
        }
        //确定了距离起点最近的点,将它标记
        st[t]=true;
        //用这个点更新和它相连的点距离起点的距离
        for(int j=1;j<=n;j++)
        dist[j]=min(dist[j],dist[t]+g[t][j]);
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    return dist[n];
}
int main()
{
    cin>>n>>m;
    //初始化邻接矩阵
    memset(g,0x3f,sizeof g);
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        //如果有重边的话,取最小的那条边,自环遍历不到不再考虑
        g[a][b]=min(g[a][b],c);
    }
    int t=dijkstra();
    cout<<t;
    return 0;
}

注意:对于自环是遍历不到的,而重边只取其中最短的一条

堆优化版Dijkstra算法

当图为稀疏图时,也就是点数和边数在一个数量级上时我们就要用上堆优化版的Dijkstra 算法了,什么是堆优化Dijkstra算法呢?朴素版的Dijkstra算法慢就慢在寻找没有确定 最短距离且距离起点最近的点这里,这里我们用来找可以提高速度,这个也就是堆优化Dijkstra算法了,堆优化Dijkstra也就是对朴素版的查找部分用堆来优化了一下。

堆有两种实现方法,一个是手写堆,一个是优先队列,这里我们用优先队列来做。

步骤和朴素版类似,这里就不赘述了。

堆优化Dijkstra存储

堆优化Dijkstra算法适用于稀疏图,稀疏图用邻接表来存。

案例-Dijkstra求最短路2

给定一个 n 个点 m 条边的有向图,图中可能存在重边和自环,所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离,如果无法从 1 号点走到 n 号点,则输出 −1。

输入格式

第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z,表示存在一条从点 x 到点 y 的有向边,边长为 z。

输出格式

输出一个整数,表示 1 号点到 n 号点的最短距离。

如果路径不存在,则输出 −1。

数据范围

1≤n,m≤1.5*1e5,
图中涉及边长均不小于 0,且不超过 10000。
数据保证:如果最短路存在,则最短路的长度不超过 1e9。

输入样例:

3 3
1 2 2
2 3 1
1 3 4

输出样例:

3

代码实现 

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=1e6+10;
typedef pair<int,int>pll;//存储距离和编号,用于小根堆
int h[N],e[N],ne[N],idx,w[N];//邻接表,w数组表示权重,idx是两个点之间的桥梁
int n,m;
int dist[N];//每个点距离起点的距离
bool st[N];
//邻接表模板
void add(int a,int b,int c)
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
int dijkstra()
{
    //初始化距离,1号点距离为0
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    //小根堆,自动升序排列
    priority_queue<pll,vector<pll>,greater<pll>> heap;
    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];//获得编号
            //如果这个点距离起点的距离可以更新的话
            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()
{
    cin>>n>>m;
    //初始化h数组
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        //这里不考虑重边
        add(a,b,c);
    }
    int t=dijkstra();
    cout<<t;
    return 0;
}

 注意:初始化点与点之间的距离时不用考虑重边的问题,我们这里用邻接表存储,会遍历所有的重边,会选择距离最小的重边更新到起点的距离

这类题不用考虑是无向图还是有向图,因为无向图是特殊的有向图,无向图可以看成有一个去的路也有一个回来的路

如有错漏之处,敬请指正! 

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:数字20 设计师:CSDN官方博客 返回首页
评论

打赏作者

真的没事鸭

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值