最短路径问题--Dijkstra算法的剖析

目录

最短路问题的分析：

补充说明：

解题步骤： 

朴素Dijkstra算法

题目：

实现代码 

堆优化的Dijkstra算法：

题目：

实现代码：

总结：

---

最短路问题的分析：

一.单源最短路问题

一般解决的问题是任意n个点到起点1的最短距离，此时源点一般固定。

(1).权值为正数

解决算法：朴素dijkstra算法+堆优化版本的dijkstra算法

(2).权值为负数

对于单源最短路问题

二.多源汇最短路问题

此时源点和终点都不确定。

补充说明：

最短路算法的特点 不会证明正确性 考察的侧重点是建图 算法的实现
稀疏图：边数m和点数n基本是一个数据级别 用邻接表存储
稠密图：边数m和点数n的平方基本一个数据级别 用邻接矩阵存储

解题步骤： 

今天主要分析权值为正的单源最短路问题，剖析dijkstra算法。

首先dijkstra算法的一般解题步骤为：

1.初始化距离 dis[1]=0 dis[i]=无穷
2.迭代 for i = 0-n
s:当前已经确定最短距离的点
t = 不在s中的距离最近的点

t加入s

用t更新其他点的距离 dis[i]>dis[t]+w 

---

朴素Dijkstra算法

题目：

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

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

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

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

数据范围

1≤n≤500,
1≤m≤105,
图中涉及边长均不超过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 = 510;
int n,m;
int g[N][N];//稠密图用邻接矩阵存储
int dist[N];//记录其他点到源点的最小距离
bool st[N];//用来判断某点的最小距离是否确定

//核心代码
int dijkstra(){
    //先初始化dist数组 等价于赋值 0x3f3f3f3f
    memset(dist,0x3f,sizeof(dist));
    //让源点的最小距离为0
    dist[1]=0;
    //每次迭代会确定一个点到源点的最小距离
    for(int i=0;i<n-1;i++){
        //因为编号从1开始 这里赋值0或-1都可 目的是为了后续判断t是否需要更新
        int t = -1;
        //遍历dist数组 找到未确定下来最小路径的点中 距离源点最小的那个点
        for(int j =1;j<=n;j++){
            //判断条件 满足未确定下来最短路径即不再st集合中
            //          当t未被更新时 或者当前路径不是最小的路径时更新
            if(!st[j]&&(t==-1 || dist[j]<dist[t])){
                t = j;//更新t
            }
        }
        //将此时的最小路径确定下来 加入st集合
        st[t] = true;
        //用当前的点的最小路径来修改图中其他点到源点的最小路径
        for(int j=1;j<=n;j++){
            dist[j] = min(dist[j],dist[t]+g[t][j]);
        }
    }
    //如果n号点到源点的距离为无穷大 此时为-1 表示两个点之间无通路
    if(dist[n]==0x3f3f3f3f) return -1;
    //返回最短路径
    return dist[n];
}
int main(){
    memset(g,0x3f,sizeof(g));
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        //这里取输入的g[a][b]和c之间最小值的原因是避免重边产生影响
        g[a][b] = min(g[a][b],c);
    }
    cout<<dijkstra()<<endl;
    return 0;
}

---

堆优化的Dijkstra算法：

题目：

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

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

输入格式

第一行包含整数 n 和 m。

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

输出格式

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

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

数据范围

1≤n,m≤1.5×105,
图中涉及边长均不小于 0，且不超过10000。
数据保证：如果最短路存在，则最短路的长度不超过 10^9。

输入样例：

3 3
1 2 2
2 3 1
1 3 4

输出样例：

3

实现代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N = 1.5e5+10;
int idx,h[N],e[N],ne[N];
int dist[N];//记录各个点到源点的最短距离
int w[N];//记录边的权重
bool st[N];//记录是否该点已经确认了到源点的最短路径
int n,m;
//使用小根堆对dijkstra算法实现优化 必须有边的权重和权重对应的点的编号 在此处使用pair存储
typedef pair<int,int> PII;
//图的邻接表存储时需要的插入函数 此时增加了更新边的权重
void add(int a,int b,int c){
    e[idx] = b,w[idx] =c;
    ne[idx] = h[a];
    h[a] = idx++;
}

int dijkstra(){
    //初始化dist数组
    memset(dist,0x3f,sizeof(dist));
    //将第一个节点的最短路径初始化为0
    dist[1] = 0;
    //定义小根堆的方式
    priority_queue<PII,vector<PII>,greater<PII>> heap;
    heap.push({0,1});//按照第一个元素从小到大排序 所以第一个元素必须是权重
    while(heap.size()){
        //此时t为距离源点最近的点对应的编号和权重
        //找到此时没有确定最短路径的节点中距离源点最近的点
        auto t = heap.top();
        //弹出该节点
        heap.pop();
        //获取该点对应的编号和到源点的距离
        int ver = t.second, distance = t.first;
        //如果该点已经被确定了最短路径 则continue 
        //在这里可能会有疑问为什么要有这一句continue 试想 如果3号点同时与1 2 两点相邻接 在1节点入队时已经
        //确定了它的最小路径 那么在2号节点入队时 有可能会使得3号点再被添加一次 所以此时需要加判断语句
        if(st[ver]) continue;
        //将该点的最短路径确定
        st[ver] = true;
        //遍历该点的邻接表
        for(int i= h[ver];i!=-1;i=ne[i]){
            //此时的i只是一个下标 j为i对应的节点
            int j =e[i];
            //如果最短路径可以更新
            if(dist[j]>dist[ver]+w[i]){
                //将距离更新
                dist[j] = dist[ver] +w[i];
                //将此元素（包括边和编号）都入队
                heap.push({dist[j],j});
            }
        }


    }
    //如果最后的n点与1号点的距离仍为无穷大 说明此时两点之间无通路 返回-1
    if(dist[n]==0x3f3f3f3f) return -1;
    return dist[n];
}
int main(){
    //初始化头节点的邻接表
    memset(h,-1,sizeof(h));
    cin>>n>>m;
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<dijkstra()<<endl;

    return 0;
}

---

总结：

假定编号个数为n 边的个数为m

1.朴素dijkstra算法用于解决稠密图场景，采用邻接矩阵存储。时间复杂度为O(n^2)。

2.堆优化的dijkstra算法用于解决稀疏图场景，采用邻接表存储。时间复杂度为O(mlogn)。