最短路算法总结

已于 2024-09-30 11:17:31 修改
阅读量933 收藏 23
点赞数 18
分类专栏： C++算法专栏 # 搜索与图论 文章标签： 算法
于 2024-09-29 21:01:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62112384/article/details/142521903
版权

总体概要-最短路
图源ACWING

单源最短路

所有边权都是正数

朴素Dijkstra算法

题目

图源ACWING

解题思路

朴素的Dijkstra算法适用于点少边多的稠密图
具体思路如下图：
原链接https://www.acwing.com/solution/content/38318/
作者：Hasity
链接：https://www.acwing.com/solution/content/38318/
来源：AcWing

代码实现
#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;//邻接表存储图/链式前向星，w为边的权重
int state[N];//state 记录是否找到了源点到该节点的最短距离
int dist[N];//dist 数组保存源点到其余各个节点的距离
int n, m;//图的节点个数和边数

void add(int a, int b, int c)//插入边
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}

void Dijkstra()
{
    memset(dist, 0x3f, sizeof(dist));//dist 数组的各个元素为无穷大
    dist[1] = 0;//源点到源点的距离为置为 0
    for (int i = 0; i < n; i ++)
    {
        int t = -1;
        for (int j = 1; j <= n; j ++)//遍历 dist 数组，找到没有确定最短路径的节点中距离源点最近的点t
        {
            if (!state[j] && (t == -1 || dist[j] < dist[t]))
                t = j;
        }

        state[t] = 1;//state[i] 置为 1。

        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";
}

堆优化的Dijkstra算法

题目

图源ACWING

解题思路

堆优化的Dijkstra算法适用于点多边少的稀疏图
具体思路如下：
在这里插入图片描述
作者：Hasity
链接：https://www.acwing.com/solution/content/38318/
来源：AcWing

代码实现
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1.5e5 + 10;

int h[N], ne[N], e[N], w[N], idx;//邻接表储存，w为边的权重
int statue[N], dis[N];
int n, m;

typedef pair<int, int> PII;
priority_queue<PII, vector<PII>, greater<PII>> heap;//默认是一个最大堆，但可以通过传递第三个模板参数 greater<PII> 来将其改为最小堆
//默认按pair 的第一个元素（即节点的最短距离）来比较元素，并且总是优先处理距离最小的节点。这意味着堆顶的元素将是当前已知最短距离最小的节点。
void add(int a, int b, int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}

void Dijkstra()
{
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0;
    heap.push({0, 1});
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        int num = t.second;
        
        if(statue[num])
        {
            continue;
        }
        
        statue[num] = true;
        
        for(int i = h[num];i != -1;i = ne[i])
        {
            int j = e[i];
            dis[j] = min(dis[j], dis[num] + w[i]);
            heap.push({dis[j], j});
        }
    }
    
    if(dis[n] != 0x3f3f3f3f)
    {
        cout << dis[n];
    }
    else
    {
        cout << -1;
    }
}

int main()
{
    memset(h, -1, sizeof h);
    
    cin >> n >> m;
    
    int a, b, c;
    
    while(m -- )
    {
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    
    Dijkstra();
    
    return 0;
}

存在负权边

Bellman_Ford算法

题目

图源ACWING

解题思路

Bellman_Ford 算法思路

  1. for n次 (for循环几次就代表走了几次)
  2. 备份dis数组到back
  3. for 所有边 a,b,w (遍历所有边)
  4. dist[b] = min(dist[b],back[a] + w)

注意：back[] 数组是上一次迭代后 dist[] 数组的备份，由于是每个点同时向外出发，因此需要对 dist[] 数组进行备份，若不进行备份会因此发生串联效应，影响到下一个点

代码实现

为什么要备份dis到back：
在这里插入图片描述
** 为什么是if(dis[n] > 0x3f3f3f3f / 2) **
在这里插入图片描述
图源https://www.acwing.com/solution/content/14088/

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

using namespace std;

const int N = 510, M = 1e4 + 10;

struct Edge{
    int a;
    int b;
    int w;
}e[M];//储存图，代表a指向b的边，权重为w

int dis[N], back[N];//dis为点到原点的距离，back为dis备份
int n, k, m;

void bellman_ford()
{
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0;
    
    for(int i = 0;i < k;i ++ )//循环k次代表走了k次，符合题目最多走k次的要求
    {
        memcpy(back, dis, sizeof dis);//备份dis数组，详见上方解释
        for(int j = 0;j < m;j ++ )//遍历所有的边
        {
            int a = e[j].a;
            int b = e[j].b;
            int w = e[j].w;
            
            dis[b] = min(dis[b], back[a] + w);//更新距离
        }
    }
    
    if(dis[n] > 0x3f3f3f3f / 2)//详见上方代码解释
    {
        cout << "impossible";
    }
    else
    {
        cout << dis[n];
    }
}

int main()
{
    cin >> n >> m >> k;
    
    int a, b, c;
    
    for(int i = 0;i < m;i ++ )
    {
        scanf("%d%d%d", &a, &b, &c);
        e[i] = {a, b, c};
    }
    
    bellman_ford();
    
    return 0;
}

SPFA算法

题目

图源ACWING

SPFA基本思路
  1. 建立一个队列，初始时队列里只有起始点。
  2. 再建立一个数组记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。
  3. 再建立一个数组，标记点是否在队列中。队头不断出队，计算始点起点经过队头到其他点的距离是否变短，如果变短且被点不在队列中，则把该点加入到队尾。
  4. 重复执行直到队列为空。在保存最短路径的数组中，就得到了最短路径。
代码实现
#include<iostream>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1e5 + 10;

int h[N], e[N], w[N], ne[N], idx;//邻接表储存点
int dis[N];
queue<int> q;
int n, m;
bool state[N];//state用来标记该点是否在队列q中

void add(int a, int b, int c)
{
    e[idx] = b;
    w[idx] = c;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}

void spfa()
{
    memset(dis, 0x3f, sizeof dis);
    dis[1] = 0;
    q.push(1);
    state[1] = true;
    
    while(q.size())
    {
        int t = q.front();
        q.pop();
        
        state[t] = false;
        
        for(int i = h[t];i != -1;i = ne[i])//遍历与其相连的所有点的距离
        {
            int j = e[i];
            if(dis[j] > dis[t] + w[i])//被更新的点才放入队列中
            {
                dis[j] = dis[t] + w[i];
                if(!state[j])
                {
                    q.push(j);
                    state[j] = true;
                }
            }
        }
    }
    
    if(dis[n] != 0x3f3f3f3f)
    {
        cout << dis[n];
    }
    else
    {
        cout << "impossible";
    }
}

int main()
{
    memset(h, -1, sizeof h);
    
    cin >> n >> m;
    
    int a, b, c;
    
    while(m -- )
    {
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }
    
    spfa();
    
    return 0;
}

为什么bellman-ford算法写成 if(dist[n] > 0x3f3f3f/2) return -1; ，spfa确是 == 。难道不应该都是 if(dist[n] > 0x3f3f3f/2) return -1; 吗？
：因为队列里都是由起点更新到的点，不存在bellman-ford算法中未更新的点同样被边更新的情况。（bellman_ford是全部点都在试图更新距离，而SPFA是只由被更新的点来更新其他点的距离）

为什么要用state来标记某个点是否在队列中
:多个相同的点在队列中等待没有意义，距离都会被更新，属于一种优化方式；同时在取出该点的时候将其标记为false，也是因为该点的距离可能被多次更新（存在负权边）

阶段总结

  • Dijkstra算法是用当前距离最短的点去更新与其相连的点的距离
  • SPFA是用上次更新的点去更新与其相连的点的距离
  • Bellman_Ford算法则是非常暴力的每次更新所有点的距离
  • 在有负权边的情况下,SPFA的时间复杂度比Bellman_Ford算法的时间复杂度小,优先选用SPFA
  • Bellman_Ford算法适用于有限制步数的条件的题目,SPFA无法做到

多源汇最短路

Floyd算法

题目

图源ACWING

基本思路

解题思路，动态规划的思想
假设节点序号是从1到n。
假设f[0][i][j]是一个n*n的矩阵，第i行第j列代表从i到j的权值，如果i到j有边，那么其值就为ci,j（边ij的权值）。
如果没有边，那么其值就为无穷大。

f[k][i][j]代表（k的取值范围是从1到n），在考虑了从1到k的节点作为中间经过的节点时，从i到j的最短路径的长度。

比如，f[1][i][j]就代表了，在考虑了1节点作为中间经过的节点时，从i到j的最短路径的长度。
分析可知，f[1][i][j]的值无非就是两种情况，而现在需要分析的路径也无非两种情况，i=>j，i=>1=>j：
【1】f[0][i][j]：i=>j这种路径的长度，小于，i=>1=>j这种路径的长度
【2】f[0][i][1]+f[0][1][j]：i=>1=>j这种路径的长度，小于，i=>j这种路径的长度
形式化说明如下：
f[k][i][j]可以从两种情况转移而来：
【1】从f[k−1][i][j]转移而来，表示i到j的最短路径不经过k这个节点
【2】从f[k−1][i][k]+f[k−1][k][j]转移而来，表示i到j的最短路径经过k这个节点

总结就是：f[k][i][j]=min(f[k−1][i][j],f[k−1][i][k]+f[k−1][k][j])
从总结上来看，发现f[k]只可能与f[k−1]有关。

作者：lkm
链接：https://www.acwing.com/solution/content/20441/
来源：AcWing

代码实现

#include<iostream>
#include<algorithm>

using namespace std;

const int N = 210;
int dis[N][N];//dis[i][j]代表从i到j的最短距离
int n, m, k;

void Floyd()
{
    for(int q = 1;q <= n;q ++ )//i与j可以互换顺序但最外层q不能动
    {
        for(int i = 1;i <= n;i ++ )
        {
            for(int j = 1;j <= n;j ++ )
            {
                dis[i][j] = min(dis[i][j], dis[i][q] + dis[q][j]);
            }
        }
    }
}

int main()
{
    cin >> n >> m >> k;
    
    for(int i = 1;i <= n;i ++ )
    {
        for(int j = 1;j <= n;j ++ )
        {
            if(i == j)//一个点到他本身的最短距离就是0
            {
                dis[i][j] = 0;
            }
            else
            {
                dis[i][j] = 0x3f3f3f3f;
            }
        }
    }
    
    
    int x, y, z;
    
    while(m -- )
    {
        scanf("%d%d%d", &x, &y, &z);
        dis[x][y] = min(dis[x][y], z);//由于存在重边，取多个边中最短的一个即可
    }
    
    Floyd();
    
    while(k -- )
    {
        scanf("%d%d", &x, &y);
        if(dis[x][y] > 0x3f3f3f3f / 2)
        {
            cout << "impossible" << endl;
        }
        else
        {
            cout << dis[x][y] << endl;
        }
    }
    
    return 0;
}
最短路算法总结（超详细~）
wmy0217_的博客
04-11 3万+
文章目录最短路算法框架朴素Dijkstra算法堆优化版Dijkstra算法 最短路算法框架 最短路有五种算法，分别适用不同的情况。 单源最短路： 求一个点到其他点的最短路 多源最短路： 求任意两个点的最短路 稠密图用邻接矩阵存，稀疏图用邻接表存储。 稠密图： m 和 n2 一个级别 稀疏图： m 和 n 一个级别 朴素Dijkstra算法 Dijkstra算法是通过 n 次循环来确定 n 个点...
图论最短路算法总结
Eleanore__的博客
07-21 493
1.1 朴素版dijkstra在学习这几个算法之前，我们首先要知道，这些算法是用来求最短路的，那什么是最短路呢，最短路就是，一个图中，一个点到另外一个点所经过边的权重之和最小的路径就是最短路。了解了这个之后，我们还要知道最短路问题分为单源最短路，求图中一个点到其他点的最短路；多元最短路，求图中任意两个点的最短路。在学习这几个算法之前，我们还要了解两个数据结构，邻接矩阵和邻接表，这两个都是用来描述图的，解释了图中顶点之间的关系。
五大最短路算法总结
qq_34771124的博客
09-20 450
最短路算法总结 目录 1.Floyd（n^3) 2.bellman-ford(nm) n: 点数 m:边数 3.dijikstra(n^2) n：点数 4.spfa(Km) K:约为2的常数 m:边数 5.Johnson
最短路算法总结（图论）
2404_87273268的博客
09-10 897
最短路算法基本思想、C++实现
最短路算法详解
qq_59539549的博客
06-25 2694
图的最短路算法
两种最短路算法总结
不知所云的博客
03-16 385
最短路算法 这里只总结两种最短路算法，第一是：Dijkstra，第二是：SPFA； 这两种算法都用了队列优化，Dijkstra是优先队列，SPFA是普通队列； Dijkstra 先介绍第一种，也是用的最多的一种最短路算法：Dijkstra； 这种算法的思想就是先根据给定的起点 s ，找到这个点 s 所能连的点，更新一下所能连到的点的路径，然后放入优先队列里面；优先队列维护两个东西，一个是起点 s...
动态最短路_动态最短路算法程序_
10-03
总结起来，动态最短路算法结合线性规划提供了一种有效的方法来寻找图中的最短路径，尤其适用于处理大型复杂网络。通过理解线性规划模型的构建和解析相关文件，我们可以实现并优化这一过程，为实际问题找到高效的解决...
算法文档无代码最短路算法及其应用
04-15
总结来说，无代码最短路算法及其应用是图论和算法应用领域中的重要分支，它借助工具和平台，使非专业编程人员也能利用最短路算法解决现实世界中的问题。通过了解这些算法的基础知识和实际应用案例，可以更好地认识到...
动态规划最短路算法总结——以【Layout】差分约束为例
LJFYYJ的博客
04-15 942
动态规划最短路算法总结 ——以【Layout】差分约束为例 一.差分约束的概念 如果一个系统由nnn个变量和mmm个不等式组成，并且这mmm个不等式对应的系数矩阵每一行有且仅有一个1和-1，其它的都为0，这样的系统成为差分约束系统。 将不等式x[i]−x[j]≤a[k]x[i]−x[j]≤a[k]x[i]-x[j]\leq a[k] 变形为x[i]≤x[j]+a[k]x[i]≤x[j]...
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 541
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
Java 插入排序
最新发布
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
10-08 124
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 823
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 726
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
生成哈夫曼树
TTz012的博客
10-08 77
例如：由叶子节点：5 15 40 30 10，生成的最优二叉树如下图所示，该树的最短带权路径长度为：40 * 1 + 30 * 2 + 5 * 4 + 10 * 4 = 205。所谓树的带权路径长度，就是树中所有的叶节点的权值乘上其到根节点的路径长度（若根节点为 0 层，叶节点到根节点的路径长度为叶节点的层数）二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 801
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1232
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
ICPC-day2(圆方树)
m0_74315028的博客
10-08 93
每次询问两点x, y，求是否存在一个n的排列，使得第一个元素为x，最后一个元素为y，且排列的任意一个前缀、任意一个后缀都连通。可以用圆方树缩点将其变成一颗树，再判断这颗树是否是一条链，x,y是否在这条链的两侧。其实就是求这两个点是否存在两个不相同的路径，同时两者路径的交集是n。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值