单源最短路模板整理（dij+bellman-ford+spfa）

于 2023-09-09 10:20:25 发布
阅读量113 收藏 1
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linlinlin098765/article/details/132773268
版权
本文介绍了迪杰斯特拉(Dijkstra)算法，一种用于求解正权有向图中最短路径的贪心策略，以及其伪代码实现。同时，对比了Dijkstra与SPFA（队列优化的Bellman-Ford）算法，讨论了它们的时间复杂性和适用场景。
摘要由CSDN通过智能技术生成

单源最短路径

dijkstra

  • 初介绍

迪杰斯特拉算法采用的是一种贪心的策略。用于求解从源点到其余各点的最短距离。
注意：用dijkstra求解时边权必须为正

  • 步骤如下

  1. 用一个 dist 数组保存源点到其余各个节点的距离，dist[i] 表示源点到节点 i 的距离。初始时，dist 数组的各个元素为无穷大。

  2. 用一个状态数组 st 记录是否找到了源点到该节点的最短距离，st[i] 如果为真，则表示找到了源点到节点 i 的最短距离，st[i] 如果为假，则表示源点到节点 i 的最短距离还没有找到。初始时，st各个元素为假。
    在这里插入图片描述

  3. 初始化:源点到源点的距离为 0。即dist[1] = 0。
    在这里插入图片描述

  4. 遍历 dist 数组，找到一个节点，这个节点是：没有确定最短路径的节点中距离源点最近的点。假设该节点编号为 i，此时就找到了源点到该节点的最短距离，st[i] 置为 1。
    在这里插入图片描述

  5. 遍历 i 所有可以到达的节点 j，如果 dist[j] 大于 dist[i] 加上 i -> j 的距离，即 dist[j] > dist[i] + w[i][j]（w[i][j] 为 i -> j 的距离） ，则更新 dist[j] = dist[i] + w[i][j]。
    在这里插入图片描述

  6. 重复 4、5 步骤，直到所有节点的状态都被置为 1。此时 dist 数组中，就保存了源点到其余各个节点的最短距离。
    在这里插入图片描述

  • 伪代码

int dist[n],st[n]; //dist记录的是从源点到点i的最短距离，st记录这个点的最短距离有没有被找到
dist[1] = 0；//第一个点（或源点）到自己的距离为0
state[1] = 1;//标记这个点的最短距离已经被找到了
for(i:1 ~ n) //每个点的最短距离都要找，所以遍历所有的点
{
t <- 找到没有确定最短路径的节点中距离源点最近的点进行更新
st[t] = 1; //更新后打个标记
更新 dist; //对当前点的dist值进行更新
}

  • 代码实现——朴素版

代码：

#include<iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510, M = 100010;

int h[N], e[M], ne[M], w[M], idx;//邻接表存储图
int state[N];//state 记录是否找到了源点到该节点的最短距离
int dist[N];//dist 数组保存源点到其余各个节点的距离
int n, m;//图的节点个数和边数

void add(int a, int b, int c)//插入边
{
    //边的终点是b
    e[idx] = b;
    //边的权值是c
    w[idx] = c;
    //下一个指向h[a]
    ne[idx] = h[a];
    //把当前节点放在以a开头的链表的最前面
    h[a] = idx++;
}

void Dijkstra()
{
    //dist 数组的各个元素为无穷大
    memset(dist, 0x3f, sizeof(dist));
    //从源点到自己的距离为0
    dist[1] = 0;//源点到源点的距离为置为 0
    //处理其他节点
    for (int i = 0; i < n; i++)
    {
       //找到没有确定最短路径的节点中距离源点最近的点t
        int t = -1;
        for (int j = 1; j <= n; j++)//遍历 dist 数组
        {
            //如果这个点的最短路还没找到并且是所有未被更新的距离中最小的
            if (!st[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        }

        st[t] = 1;//标记这个点要更新了
        //遍历 i 所有可以到达的节点 j，如果 dist[j] 大于 dist[i] 加上 i -> j 的距离，即 dist[j] > dist[i] + w[i][j]（w[i][j] 为 i -> j 的距离） ，则更新 dist[j] = dist[i] + w[i][j]。
        for (int j = h[t]; j != -1; j = ne[j])//遍历 t 所有可以到达的节点 i
        {
            int i = e[j];
            dist[i] = min(dist[i], dist[t] + w[j]);//更新 dist[j]
        }
    }
}

int main()
{
    memset(h, -1, sizeof(h));//邻接表初始化

    cin >> n >> m;
    while (m--)//读入 m 条边
    {
        int a, b, w;
        cin >> a >> b >> w;
        add(a, b, w);
    }

    Dijkstra();
    if (dist[n] != 0x3f3f3f3f)//如果dist[n]被更新了，则存在路径
        cout << dist[n];
    else
        cout << "-1";
}

作者：Hasity

  • 代码实现——堆优化版

  • 为何有堆优化的说法？

看一下算法的时间复杂度：

for(i:1 ~ n) //n次
{
t <- 没有确定最短路径的节点中距离源点最近的点; //每次遍一遍历dist数组，n次的复杂度是O(n^2)
state[t] = 1;
更新 dist; //每次遍历一个节点的出边，n次遍历了所有节点的边，复杂度为O(e)
}
算法的主要耗时的步骤是从dist 数组中选出：没有确定最短路径的节点中距离源点最近的点 t。只是找个最小值而已，没有必要每次遍历一遍dist数组。

在一组数中每次能很快的找到最小值，很容易想到使用小根堆。可以使用库中的小根堆（推荐）或者自己编写。

因此，堆优化主要用于每次在未被更新的点中求出最小值


#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>//堆的头文件

using namespace std;

typedef pair<int, int> PII;//堆里存储距离和节点编号，第一维为距离，第二维是记录哪个点

const int N = 1e6 + 10;

int n, m;//节点数量和边数
int h[N], w[N], e[N], ne[N], idx;//邻接表存储图
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()
{
    //初始化：所有边的dist值初始化为无穷打，源点的距离做更新
    memset(dist, 0x3f, sizeof dist);//距离初始化为无穷大
    dist[1] = 0;
    //建立一个小根堆，用于求出最小值
    priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆
    //把求出dist最小值的点放进堆中
    heap.push({0, 1});//插入距离和节点编号
   
    while (heap.size())
    {
        //auto自动定义数据类型
        //取出堆顶赋值给t，再将它弹出
        auto t = heap.top();//取距离源点最近的点
        heap.pop();
        
        //记录一下当前这个点（这个哪个点，赋值给ver，这个点的dist是多少，赋值给distance）
        int ver = t.second, distance = t.first;//ver:节点编号，distance:源点距离ver 的距离

        //看这个点是否已经被算出来，如果被算出来了，就不管它
        if (st[ver]) continue;//如果距离已经确定，则跳过该点
        //没被算出来，就先标记一下
        st[ver] = true;

        //用这个点来更新与它直接相连的点的距离
        for (int i = h[ver]; i != -1; i = ne[i])//更新ver所指向的节点距离
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});//距离变小，则入堆
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);
   //建边之前要初始化表头！！！
    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    cout << dijkstra() << endl;

    return 0;
}

使用小根堆后，找到 t 的耗时从 O(n^2) 降为了 O(1)。每次更新 dist 后，需要向堆中插入更新的信息。所以更新dist的时间复杂度有 O(e) 变为了 O(elogn)。总时间复杂度有 O(n^2) 变为了 O(n + elongn)。适用于稀疏图。

总结

迪杰斯特拉算法适用于求正权有向图中，源点到其余各个节点的最短路径。注意：图中可以有环，但不能有负权边。
在这里插入图片描述

bellman-ford

Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛。
在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
因此也可以用来做负环的判断，负环就一个环上，边权之和为负值。

- 初介绍

给定一张有向图,若对于图中的某一条边 (x, y,z),有dist[y]≤ dist[x]+z 成立，则称该边满足三角形不等式。若所有边都满足三角形不等式，则dist数组就是所求最短路。

我们先介绍基于迭代思想的Bellman-Ford算法。它的流程如下:

1.扫描所有边(x, y,z)，若dist[y] > dist[x]＋z,则用dist[x]+z更新dist[y]。
2.重复上述步骤,直到没有更新操作发生。

Bellman-Ford算法的时间复杂度为O(nm)。

  • 明确一下松弛的概念。

考虑节点u以及它的邻居v，从起点跑到v有好多跑法，有的跑法经过u，有的不经过。

经过u的跑法的距离就是distu+u到v的距离。

所谓松弛操作，就是看一看distv和distu+u到v的距离哪个大一点。

如果前者大一点，就说明当前的不是最短路，就要赋值为后者，这就叫做松弛。

  • 为何可以来判断负环呢？

更新n-1次，意味着至少经过了n个点；如果还能够更新，则意味着经过的点数要多于n个，即有至少有1个点要被经过两次，为和这个点要经过两次呢？原因只有dist值会在经过后变小，多经过边而总值变小，又重复经过点，可说明有负环存在。

(通俗的来讲就是：假设 1 号点到 n 号点是可达的，每一个点同时向指向的方向出发，更新相邻的点的最短距离，通过循环 n-1 次操作，若图中不存在负环，则 1 号点一定会到达 n 号点，若图中存在负环，则在 n-1 次松弛后一定还会更新)

#include<iostream>
#include<cstring>
using namespace std;

const int N=510,M=10010;

struct Edge{
    int a;
    int b;
    int w;
}e[M];//把每个边保存下来即可
int dist[N];
int back[N];//备份数组放置串联
int n,m,k;//k代表最短路径最多包涵k条边

int bellman_ford(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++){//k次循环
        memcpy(back,dist,sizeof dist);
        for(int j=0;j<m;j++){//遍历所有边
            int a=e[j].a,b=e[j].b,w=e[j].w;
            dist[b]=min(dist[b],back[a]+w);//使用backup:避免给a更新后立马更新b,这样b一次性最短路径就多了两条边出来
        }

    }
    if(dist[n]>0x3f3f3f3f/2) return -1;
    else return dist[n];

}

int main(){
    scanf("%d%d%d",&n,&m,&k);
    for(int i=0;i<m;i++){
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        e[i]={a,b,w};
    }
    int res=bellman_ford();
    if(res==-1) puts("impossible");
    else cout<<res;


    return 0;
}

在这里插入图片描述

标题spfa

实际上，SPFA算法在国际上通称为“队列优化的 Bellman-Ford算法”，仅在中国大陆流行“SPFA 算法”的称谓。请读者回顾0x26节对“广搜变形”的讨论与总结。

spfa算法文字说明：

  1. 建立一个队列，初始时队列里只有起始点。

  2. 再建立一个数组记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。

  3. 再建立一个数组，标记点是否在队列中。

  4. 队头不断出队，计算始点起点经过队头到其他点的距离是否变短，如果变短且被点不在队列中，则把该点加入到队尾。取出队头节点x，扫描它的所有出边 (x, y,z)，若 dist[y] > dist[x]＋z，则使用dist[x]＋z更新dist[y]。同时，若y不在队列中，则把y 入队。

  5. 重复执行直到队列为空。
    6

  6. 在保存最短路径的数组中，就得到了最短路径。

在任意时刻,该算法的队列都保存了待扩展的节点。每次入队相当于完成一次 dist数组的更新操作，使其满足三角形不等式。一个节点可能会入队、出队多次。最终，图中节点收敛到全部满足三角形不等式的状态。这个队列避免了Bellman-Ford 算法中对不需要扩展的节点的冗余扫描，**在随机图上运行效率为0(km)级别，其中k 是一个较小的常数。**但在特殊构造的图上，该算法很可能退化为 0(nm)，必须谨慎使用。

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 100010;

int n, m;
int h[N], w[N], e[N], ne[N], idx;
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 spfa()
{
    memset(dist, 0x3f, sizeof dist); 
    dist[1] = 0; //起点距自己的距离为 0 

    queue<int> q;
    //队列中放的是点的标号
    q.push(1); //起点加入队列
    st[1] = true; //起点在队列里了

    while (q.size()) //如果队列不空
    {
        int t = q.front(); //取出队头
        q.pop(); //删掉队头

        st[t] = false;//这个点已经不在队列里边了

        for (int i = h[t]; i != -1; i = ne[i]) //更新 t 的所有邻边
        {
            int j = e[i]; //取出当前邻边的节点
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j]) //如果 j 不在队列里边
                {
                    q.push(j); //加入队列
                    st[j] = true; //在队列里了
                }
            }
        }
    }

    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);

    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    int t = spfa();

    if (t == 0x3f3f3f3f/2) puts("impossible");
    else printf("%d\n", t);

    return 0;
}


作者：半瓶可乐

- spfa的优化

SLF优化（Small Label First）

LLL优化（Large Label Last）

参照这里！

https://zhuanlan.zhihu.com/p/536519369

lilihihihi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
蓝桥杯CJ2-11-图论最短路径问题 Bellman-Ford算法+SPFA.pdf
02-18
SPFA（Shortest Path Faster Algorithm）是对Bellman-Ford算法的一种改进，主要用于加速单源最短路径问题的求解过程。SPFA同样能够处理含有负权重边的图，但要求图中不存在负权重循环。它的核心思想是利用队列来存储...
洛谷【模板】单源最短路径
qq_17807067的博客
10-08 619
洛谷【模板】单源最短路径
dijkstra算法(单源最短路径) python实现
Aiven
11-23 1万+
代码1： 用最原始的方式实现dijkstra，就是每次从costs里面找最短路径的点，再遍历这个点的边，更新最短路径。由于每次都要从costs里面找最短路径，时间复杂读为O(n^2)。 # dijjkstra算法(原生最短路径，还未优化) def dij(start, graph): n = len(graph) # 初始化各项数据，把costs[start]初始化为0，其他为无穷...
最短路径——迪杰斯特拉算法
m0_72579201的博客
02-10 2890
日常生活中常常涉及最短路径问题，如在一个城市交通网中，如何选取从起点到达终点的路径，才能使这一趟旅程的路程最短？或所需时间最少？或所需交通费用最低？诸如此类问题都可以抽象为求解图的最短路径问题。我们把图的顶点表示为城市的交通站点，边表示交通站点间的路径，边的权值表示为交通站点间的路径的距离、所需时间或费用等等，则上述问题放映到图上就是，如何求解图顶点间权值之和最小的路径。
图论之路径还原
yiqzq的博客
04-12 321
假设prv[i]=j,表示i的前驱节点是j，即i是由j走过来的，每次dij更新操作的时候，就同时更新prv。 然后根据挑战上所述，floyd 和bellman算法也可以用这种方法求解。vector<int> path; int t = end; //这里end代表终点 for (; t != -1; t = prv[t]) //每次将当前的位置加入path直到到尽头-1，且-1
Dijkstra 路径还原
xiao酱油的博客
02-07 239
《挑战程序设计竞赛》，初级篇–图// Dijkstra 路径还原 #include <iostream> #include <cstdio> #include <cstring> #include <vector> #include <algorithm> using namespace std; #define maxv 101 #define maxe 101 #define INF 9999i
C++计算任意权值的单源最短路径（Bellman-Ford）
12-20
Bellman-Ford算法是一种用于寻找图中单源最短路径的算法，尤其适用于处理带有负权重的边的情况。与Dijkstra算法不同，Dijkstra算法不能处理负权重，因为它依赖于优先队列来选择当前距离最小的节点进行扩展。而...
091-Bellman-Ford.cs
最新发布
03-24
C#，图论与图算法，有向图单源最短路径的贝尔曼·福特（Bellman Ford）算法与源代码 贝尔曼·福特（Bellman Ford）算法是一种用于计算带权有向图中单源最短路径（SSSP：Single-Source Shortest Path）的算法。该算法...
BellmanFord_bellman-ford_
10-04
**贝尔曼-福特算法（Bellman-Ford Algorithm）详解** 在图论中，单源最短路径问题是一个经典的问题，即寻找从一个指定顶点（源点）到图中所有其他顶点的最短路径。贝尔曼-福特算法是解决这类问题的一种有效方法，...
单源最短路径 DIJ算法（无堆优化）
Mollnn
07-17 1111
单源最短路径 DIJ算法（无堆优化）
pta紧急救援java,PTA——城市间紧急救援
weixin_42452328的博客
03-25 478
PTA——城市间紧急救援作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。输入格式：输入第一行给出4个正整数N、M、S、D，其中N(2≤N≤500)是城市的个...
最短路径--dijkstra算法、弗洛伊德（Floyd）算法（带路径输出）
热门推荐
我爱加菲猫
06-09 2万+
最短路径 求最短路径重要性不言而喻，下面直接分析两个算法。 分类： 1：从某个源点到其余个点的最短路径 迪杰斯特拉（Dijkstra）算法 2：每一对之间的最短路径 弗洛伊德（Floyd）算法 一：存储结构 邻接矩阵（这里不再重复讲了，请参考）： https://blog.csdn.net/weixin_39956356/article/details/80470091 相关代...
P4779 【模板】单源最短路径（标准版）（dijkstra)
qq_63955296的博客
03-04 404
题目背景 2018 年 7 月 19 日，某位同学在NOI Day 1 T1 归程一题里非常熟练地使用了一个广为人知的算法求最短路。 然后呢？ 100 \rightarrow 60100→60； \text{Ag} \rightarrow \text{Cu}Ag→Cu； 最终，他因此没能与理想的大学达成契约。 小 F 衷心祝愿大家不再重蹈覆辙。 题目描述 给定一个 nn 个点，mm 条有向边的带非负权图，请你计算从 ss 出发，到每个点的距离。 数据保证你能从 ss 出发到任意点。 ..
最短路——【模板】单源最短路径（标准版）（dijkstra）
linjiayina的博客
09-03 731
题目链接 最短路——【模板】单源最短路径（标准版）（dijkstra） 题目描述 给定一个 n 个点，m 条有向边的带非负权图，请你计算从 s 出发，到每个点的距离。 数据保证你能从 s 出发到任意点。 输入格式 第一行为三个正整数 n,m,s。第二行起 m 行，每行三个非负整数 ui,vi,wi，表示从 ui 到 vi 有一条权值为 wi 的有向边。 输出格式 输出一行 n 个空格分隔的非负整数，表示 s 到每个点的距离。 输入输出样例 输入 4 6 1 1 2 2 2 3 2 2 4 1 1 3 5 3
P3371 【模板】单源最短路径（弱化版）
lxh0113的博客
01-30 507
如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。
P3371 【模板】单源最短路径（弱化版）（dijkstra模板题 ）
goblin的博客
04-01 871
P3371 【模板】单源最短路径（弱化版）（dijkstra模板题 ）
图论专题--P4779 【模板】单源最短路径（标准版）
Silver_Bullet的博客
01-02 121
图论 dijkstra算法
洛谷 P3371 【模板】单源最短路径
liangzihao1的博客
02-11 819
题目描述如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。输入输出格式输入格式： 第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。输出格式： 一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达
负权边单源最短路：Bellman-Ford算法与图论应用
"任意边权的单源最短路-刘汝佳 lcy推荐图论学习PPT" 在图论中，单源最短路径问题是一个经典的问题，它旨在找到从一个特定起点到图中所有其他节点的最短路径。当我们面临边权重可能是负数的情况时，Dijkstra算法不再...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值