最短路算法：Dijkstra算法、Bellman-Ford算法、spfa算法和Floyd算法

最新推荐文章于 2022-12-30 00:28:10 发布
最新推荐文章于 2022-12-30 00:28:10 发布
阅读量1k 收藏 12
点赞数 2
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40586164/article/details/106856395
版权

文章目录

简介

单源最短路：求所有点到某源点的最短路径。
多源最短路：求所有点到某些/所有源点的最短路径。
最短路算法的分类：

单源最短路
    所有边权都是正数
        朴素的Dijkstra算法 O(v^2) 适合稠密图
        堆优化版的Dijkstra算法 O(elogv)适合稀疏图，set或手写堆:O(elogv)，优先队列:O(eloge)，因为差距在log内，所以可以忽略不计
    存在负权边
        Bellman-Ford O(ve) 可用于判断是否有负环：v次循环后，再进行一次循环仍有状态更新
        spfa 一般O(e),最坏O(ve)
多源最短路 
	 Floyd算法 O(v^3)

在这里插入图片描述稠密图用邻接矩阵存，稀疏图用邻接表存储。

稠密图： m 和 n² 一个数量级
稀疏图： m 和 n 一个数量级
 

1.Dijkstra算法

思路

Dijkstra算法采用的是一种贪心的策略，声明一个数组dist来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合：T，初始时，原点 s 的路径权重被赋为 0 （dist[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dist[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。
然后，从dist数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，OK，此时完成一个顶点，
然后，我们需要看看新加入的顶点是否可以到达其他顶点c并且看看通过该顶点到达其他点的路径长度是否比dist[c]小，如果是，那么就替换这些顶点在dist中的值。
然后，又从dist中找出最小值，重复上述动作，直到T中包含了图的所有顶点。

伪代码

集合S：当前已经确定最短距离的点
dist[1] = 0, dist[i] = 正无穷 (i不等于1)
for v: 1 ~ n
    找出不在S中的距离最近的点t(S中最小dist[t])
    把t放到S中
    用t更新其他点的距离(对t的所有边进行松弛操作)

 

1.1 朴素的Dijkstra算法

使用场景

适合于稠密图，时间复杂度O(n²)，用邻接矩阵(或邻接表)来存储。

算法模板

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int K) {
        const int INF = 0x3f3f3f3f;
        vector<vector<int>> g(n+1, vector<int>(n+1, INF));
        for (auto &v: times){//建立邻接矩阵
            g[v[0]][v[1]] = v[2];
        }
        vector<int> dist(n+1, INF); // 距离起始点的最短距离，节点1~n
        vector<bool> st(n+1, false); // 是否已经得到最优解
        dist[K] = 0; // 起始点
        for (int i = 0; i< n - 1; i++ ){
            int t = -1;
            for (int j = 1; j <=n; j++){ // 在还未确定最短路的点中，寻找到起始点距离最小的点 的点
                if (!st[j] && (t == -1 || dist[t] > dist[j])){ 
                    t = j;
                }
            }
            st[t] = true; // t号点的最短路已经确定
            for (int j = 1; j<=n; j++){ // 用t更新其他点的距离
                dist[j] = min(dist[j], dist[t] + g[t][j]); 
            }
        }
        int ans = *max_element(dist.begin()+1, dist.end());
        return ans == INF ? -1: ans;
    }
};

 

1.2 堆优化版的Dijkstra算法

使用场景

适合于稀疏图，用邻接表来存储数据，调用set或手写堆时间复杂度O(elogv)，调用优先队列时间复杂度O(eloge)。

模板

// first表示另一个端点， second表示距离/权重
using PII = pair<int, int>;
// dist[i]表示点i到k的最短路径
vector<int> dist;
vector<vector<PII>> graph;  // 邻接表；first表示另一个端点， second表示距离/权重
// n个顶点，edges[0]、edges[1]、edges[2]分别表示点u、v、两点距离
void Dijkstra(int n, vector<vector<int>>& edges, int k) {
    const int inf = 0x3f3f3f3f;
    dist = vector<int>(n + 1, inf);
    dist[k] = 0;
    vector<bool> exist(n + 1, 0);  // 最短距离是否已确定
    graph = vector<vector<PII>>(n + 1);
    for (const auto& vec : edges) {
        graph[vec[0]].push_back({ vec[1], vec[2] });
        graph[vec[1]].push_back({ vec[0], vec[2] });
    }
    priority_queue<PII, vector<PII>, greater<>> pq;
    pq.push({ 0, k });
    while (pq.size()) {
        auto [dis, v] = pq.top();
        pq.pop();
        if (exist[v])
            continue;  // v已经作为顶点，松驰过临边
        exist[v] = true;
        for (auto [u, d] : graph[v]) {
            if (d + dis < dist[u]) {
                dist[u] = d + dis;
                pq.push({ dist[u], u });
            }
        }
    }
}

【注】因为每个边都可能添加到堆中，所以严格来说是O(eloge)时间复杂度。如果想要严格O(elogn)，可以使用红黑树set实现，通过删除set中旧节点，来保证不会有重复节点。
 

2.Bellman-Ford算法

2.1 算法思想

在这里插入图片描述
【注】上述公式适用于无边数限制，如果有边数K限制，则循环K次，上述松弛操作修改为：dis[v]=min(dist[v],pre[u]+w);//pre为上一次循环的结果

【证明】
设dp(k, v)表示最多经过k个节点中转由src到v的最低花费；
则dp(k, v) = min{dp(k-1, v), dp(k-1, u) + cost(u, v), dp(k-1,w)+ cost(u,w),…}
(u,w,…为v的所有邻接节点)

2.2 应用

在这里插入图片描述

2.3 代码

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int K) {
        const int INF=0x3f3f3f3f;
        vector<int> dis(n,INF);
        dis[src]=0;
        for(int i=0;i<=K;i++){
            vector<int> pre=dis;
            for(auto flight:flights){
                dis[flight[1]]=min(dis[flight[1]],pre[flight[0]]+flight[2]);
            }
        }
        return dis[dst]==INF?-1:dis[dst];
    }
};

时间复杂度O(ve)。

3.spfa算法

在这里插入图片描述

3.1 算法思路

在这里插入图片描述

3.2 算法步骤

在这里插入图片描述

3.3 使用场景

在这里插入图片描述

3.4 spfa算法求负环

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;

typedef pair<int, int> PII;
unordered_map<int, vector<PII>> edges; // 邻接表
int n, m; // n个点，m条边
const int N = 2010;
int dist[N]; // 到起始点的最小距离
bool st[N];  // 在队列中是否存在
int cnt[N]; // 记录最短路的边数

bool spfa(){
    queue<int> q;
    for (int i = 1; i <=n; i++){ // 所有点入队列；负环可能存在在所有点出发的最短路上
        q.push(i);
        st[i] = true;
    }

    while (!q.empty()){
        int u = q.front();
        q.pop();
        st[u] = false; // 不在队列

        for (auto &e: edges[u]){
            int v = e.first, w = e.second;
            if (dist[v] > dist[u] + w){
                dist[v] = dist[u] + w; // 更新最短路 权值
                cnt[v] = cnt[u] + 1; // 更新经过的边数
                // 存在负环；边数>=n,经过的点>=n+1;根据抽屉原理得，最短路存在负环
                if (cnt[v] >= n) return true; 
                if (!st[v]){
                    q.push(v);
                    st[v] = true;
                }
            }
        }
    }
    return false;
}

int main(){
    cin >> n >> m;
    while (m--){ // 构造图
        int u, v, w; 
        cin >> u>> v>> w;
        edges[u].push_back({v, w});
    }
    if (spfa()) puts("Yes");
    else puts("No");
    return 0;
}

4.Floyd算法

4.1 代码

求多源汇最短路径

for (int k = 1; k<=n; k++)
    for (int i = 1; i<=n; i++)
        for (int j =1; j<=n; j++)
            d[i][j] = min(d[i][j], d[i][k] + d[k][j]);

4.2 算法原理

floyd算法是基于动态规划的
在这里插入图片描述

 
 
 

5. 例题

在这里插入图片描述
【方法一】朴素Dijkstra

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int K) {
        const int INF = 0x3f3f3f3f;
        vector<vector<int>> g(n+1, vector<int>(n+1, INF));
        for (auto &v: times){//建立邻接矩阵
            g[v[0]][v[1]] = v[2];
        }
        vector<int> dist(n+1, INF); // 距离起始点的最短距离
        vector<bool> st(n+1, false); // 是否已经得到最优解
        dist[K] = 0; // 起始点
        for (int i = 0; i< n - 1; i++ ){
            int t = -1;
            for (int j = 1; j <=n; j++){ // 在还未确定最短路的点中，寻找到起始点距离最小的点 的点
                if (!st[j] && (t == -1 || dist[t] > dist[j])){ 
                    t = j;
                }
            }
            st[t] = true; // t号点的最短路已经确定
            for (int j = 1; j<=n; j++){ // 用t更新其他点的距离
                dist[j] = min(dist[j], dist[t] + g[t][j]); 
            }
        }
        int ans = *max_element(dist.begin()+1, dist.end());
        return ans == INF ? -1: ans;
    }
};

【方法二】堆优化的Dijkstra

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        const int INF = 0x3f3f3f3f;
        typedef pair<int, int> PII; // first:距离; second: 几号点
        vector<int> dist(N+1, INF); // 距离起始点的最短距离
        vector<vector<PII>> graph(n+1); // 邻接表；u->v,权重w
        set<PII,greater<PII>> iset;
        for (auto &t: times){ // 初始化邻接表
            graph[t[0]].push_back({t[2],t[1]});
        }
        iset.insert({0,K});
        dist[K] = 0;
        while(iset.size()){
            PII t= *iset.begin();
            iset.erase(iset.begin());
            int ver=t.second, distance= t.first;
            for (auto &p: graph[ver]){
                if (dist[p.second] > distance + p.first){ // 用t去更新其他点到起始点的最短距离
                    iset.erase({dist[p.second],p.second});
                    dist[p.second] = distance + p.first;
                    iset.insert({dist[p.second], p.second});
                }
            }
        }
        int ans = *max_element(dist.begin()+1, dist.end());
        return ans == INF ? -1: ans;
    }
};

【方法三】Bellman-Ford算法

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        const int INF=0x3f3f3f3f;
        vector<int> distoK(N+1,INF);
        distoK[K]=0;
        for(int i=0;i<N;i++){
        	vector<int> pre=distoK;
            for(vector<int> &time:times){
                distoK[time[1]]=min(distoK[time[1]],pre[time[0]]+time[2]);
            }
        }
        int res=*max_element(distoK.begin()+1,distoK.end());
        return res==INF?-1:res;
    }
};

【方法四】SPFA

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        const int INF = 0x3f3f3f3f;
        typedef pair<int, int> PII; // first:距离; second: 几号点
        vector<int> dist(N+1, INF); // 距离起始点的最短距离
        dist[K]=0;//初始点，容易忘
        vector<vector<PII>> graph(N+1); // 邻接表；u->v,权重w
        for (auto &t: times){ // 初始化邻接表
            graph[t[0]].push_back({t[2],t[1]});
        }
        queue<int> modifyque;
        modifyque.push(K);
        vector<bool> st(N+1, false); // 是否在队列中,避免重复进队列
        st[K] = true; 
        while(!modifyque.empty()){
            int tmp=modifyque.front();
            modifyque.pop();
            st[tmp]=false;
            for(PII &p:graph[tmp]){
                int cost=p.first;
                int dest=p.second;
                if(dist[tmp]+cost<dist[dest]){
                    dist[dest]=dist[tmp]+cost;
                    if(!st[dest]){
                        modifyque.push(dest);
                        st[dest]=true;
                    }
                }
            }
        }
        int ans = *max_element(dist.begin()+1, dist.end());
        return ans == INF ? -1: ans;
    }
};

【方法五】floyd算法

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        const int INF = 0x3f3f3f3f;
        vector<vector<int>> d(N+1, vector<int>(N+1, INF));
        for (int i = 1; i<=N; i++) d[i][i] = 0;

        for (auto &t: times){
            d[t[0]][t[1]] = min(d[t[0]][t[1]], t[2]);
        }

        for (int k = 1; k<=N; k++){
            for (int i = 1; i<=N; i++){
                for (int j =1; j<=N; j++){
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
                }
            }
        }
        int ans = 0;
        for (int i =1; i<=N; i++){
            ans = max(ans, d[K][i]);
        }
        return ans > INF/2 ? -1: ans;
    }
};

参考：
https://leetcode-cn.com/problems/network-delay-time/solution/dan-yuan-zui-duan-lu-po-su-de-dijkstra-dui-you-hua/

Owl丶
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
所有的基础最短路问题 dijkstra、堆优化dijkstra、bellman-ford、SPFA、Floyd
m0_50564748的博客
02-26 3382
一、朴素Dijkstra算法 整体思想： 1.找到与起点s最近的且未确认最短路径的顶点(记为u)，访问并加入集合st(确定了最短路的集合)。 2.之后，令u为中介点，优化起点s与所有经过u可以到达的顶点v的最短距离。 算法模板： //朴素Dijkstra 邻接矩阵存储稠密图 int g[N][N];//g[a][b]:a->b的权重 int dist[N];//dist[i]:起点到i的距离 b......
Python 图_系列之纵横对比 Bellman-Ford 和 Dijkstra 最短路径算法
y6123236的专栏
04-07 1947
1. 前言 因无向、无加权图的任意顶点之间的最短路径由顶点之间的边数决定，可以直接使用原始定义的广度优先搜索算法查找。 但是，无论是有向、还是无向，只要是加权图，最短路径长度的定义是：起点到终点之间所有路径中权重总和最小的那条路径。 如下图所示，A 到 C 的最短路径并不是 A 直接到 C（权重是 9），而是 A 到 B 再到 C（权重是 7）。所以，需要在广度优先搜索算法的基础上进行算法升级后才能查找到。 加权图的常用最短路径查找算法有： 贝尔曼-福特（Bellman-Ford）算法 Dijkstra
Bellman Ford算法详解
shsbsns的博客
12-30 596
Bellman Ford算法是最短路算法之一。适用于拥有负权边的最短路问题。本文将回答学习该算法时出现的疑惑。
几个最短路径算法Floyd、Dijkstra、Bellman-Ford、SPFA的比较
dinongxu8804的博客
02-12 1187
几大最短路径算法比较 July、二零一一年二月十二日。----------------------------------- 几个最短路径算法的比较：Floyd 求多源、无负权边的最短路。用矩阵记录图。时效性较差，时间复杂度O(V^3)。Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任...
最短路径算法（Floyd，Dijkstra，Blleman Ford）
m0_48630721的博客
03-19 553
最短路径算法
算法刷题提高阶段-图论1
12-24
例如，Dijkstra和SPFA适用于稠密图，而Bellman-Ford和Floyd-Warshall则在稀疏图上表现更好。 通过观看"3.1.1 单源最短路的建图方式.mp4"这个视频，你将更深入地理解如何构建图以及如何应用上述算法来寻找单源最短...
最短路全家桶（Floyd,Dijkstra,SPFA）
06-02
相比于Bellman-Ford算法，SPFA在实践中通常更快，但其最坏情况下的时间复杂度仍为O(n^2)。SPFA对于稀疏图，即边的数量远小于节点数量的情况，表现良好。 链式前向星存图是一种常用的图存储结构，它使用邻接表而非...
算法刷题提高阶段-图论2
最新发布
12-24
而面对可能存在的负权重边时，Bellman-Ford或Floyd-Warshall就更合适。 在这个“算法刷题提高阶段-图论2”的学习中，通过观看“3.1.2 单源最短路的综合应用.mp4”视频，你将深入理解这些算法的工作原理，并通过实例...
ACM算法类型大纲 思维导图全
07-30
1. 最短路径：Dijkstra、Bellman-Ford、Floyd-Warshall、SPFA、Euler图、最小生成树（Kruskal、Prim、次小生成树、最大生成树等）、最大流最小割。 2. 强连通分量、双连通分量、割边、割点、桥。 3. 二分图匹配：...
最短路径(Floyd算法和Dijkstra算法和Bellman-Ford算法)
weixin_30575309的博客
08-09 123
完全最短路径(Floyd算法)：[复杂度：O(n^3)] // 矩阵mat初始值INT_MAX // 结果 mat[i][j] 为点i到j的最短路径 // mat[i][j] == INT_MAX时候为不可到达 void Floyd(int n) { int i, j, k; for (k = 1; k <= n; k++) for (i = 1;...
最短路 floyd dijkstra bellman-ford总结
爱梦者的心之旅
03-21 572
第五章 2 图的遍历最短路 2 一．搜索 2 二．Dijkstra算法 5 三．邻接表 9 四． Bellman-ford 9 神奇的树 11 一． 堆排序 11 第五章 图的遍历最短路 一．搜索 1.Floyd 2.Dijkstra 3.Bellman-ford 从理解的难度来划分2 3 1 4 Floyd借助的是数组表示 图形的遍历分为有向图和无向图
Dijkstra、Bellman-ford
沉默的大多数
08-26 601
1.Dijkstra邻接矩阵实现（时间少） 时间复杂度 O(n²) 空间复杂度 O(n²) 不能出现负权边。 #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cmath&gt; #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;cst...
最短路算法详解
weixin_34018202的博客
05-24 368
很早就想写一下最短路的总结了，但是一直懒，就没有写，这几天又在看最短路，虽没什么长进，但还是加深了点理解。 于是就想写一个大点的总结，要写一个全的。 在本文中因为邻接表在比赛中不如前向星好写，而且前向星效率很可观。所以，本文的代码存图方式只有两种：前向星 or 邻接矩阵。 本文包含如下内容： 1、Bellman-Ford算法 　　　2、Dijkst...
最短路径 Floyd算法 Dijkstra算法 Bellman-Ford（贝尔曼）算法
a_lonely_dancer的博客
08-24 4240
相信大家应该对最短路径算法很感兴趣吧！不感兴趣也没关系，我们一起来看看下面的例子。最短路径应该是在众多算法中。最常用的一类算法。为什么这样说呢？？ 例如： 1.乘汽车旅行的人总希望找出到目的地的尽可能的短的行程。如果有一张地图并在图上标出每对十字路口之间的距离，如何找出这一最短行程？ 2.某省自从实行了很多年的畅通工程计划后，终于修建了很多路。不过路多了也不好，每次要从一个
最短路问题 - dijkstra算法、Bellman_Ford算法、SPFA模板、Floyd算法
m0_37579232的博客
04-26 768
寻找最短路径指的是找出从图中某个结点出发到达另一个结点所经过的边的权重之和最小的那条路径。这里的最短路不仅仅指一般意义上的距离最短，还可以引申到时间，费用等最小。 算法中的最短路问题类型： 1:单源最短路：给定一个源结点，求出这个点到其他所有点的最短路径，有Dijkstra和Bellman-ford两种算法，Dijkstra只能求解所有边权都为正的情况，Bellman-ford可以求解边权为正或...
Bellman-ford算法详解——负权环分析
热门推荐
anlian523的博客
07-07 2万+
算法描述 输入：图（V,E）和起点original 输出：从original到其他任意节点的最短路径（长度和最短路径构成） 适用条件 Bellman-ford算法适用于单源最短路径，图中边的权重可为负数即负权边，但不可以出现负权环。 负权边：权重为负数的边。 负权环：源点到源点的一个环，环上权重和为负数。 算法复杂度：O(VE) 算法步骤 dist[]：从o...
Graph | 单源最短路径：Bellman-Ford算法 与 Dijkstra算法
weixin_43787043的博客
04-27 678
单源最短路径问题：在图G<V,E,W>中，计算起始点 s 到图内每个节点v 的最短路径长度（边权重之和）。 1、问题概述 首先，最短路径具有 OSP 最优子结构性质： 最短路径中的子路径也是最短路径。 ????有一个特殊点说明：如果图 G 内包含从 s 可以到达的权重为负值的环路（负环），则计算最短路径是无意义的。且不失一般性，我们可以认为最短路径上是没有环路的，即全是简单...
最短路算法 ：Bellman-ford算法 & Dijkstra算法 & floyd算法 & SPFA算法详解&BFS
booyoungxu的专栏
03-12 1060
1、Bellman-Ford算法 2、Dijkstra算法(代码 以邻接矩阵为例) && Dijkstra + 优先队列的优化(也就是堆优化) 3、floyd-Warshall算法(代码 以邻接矩阵为例) 4、SPFA(代码 以前向星为例) 5、BFS 求解最短路+路径还原 松弛操作：if(dis[i]>dis[k]+G[k][i])//其中dis[i]是其他的路径，dis[k

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值