【知识点】图论续篇 - 最短路算法合集

于 2024-09-04 06:36:30 发布
阅读量316 收藏 4
点赞数 6
文章标签： 图论 算法 c++ 数据结构
本文链接：https://blog.csdn.net/Macw07/article/details/141877136
版权

我不会跟大家说我两个月前就写好了，只是今天才发出来。

本文概述

最短路算法，见名知意，就是用于求出图中从某个顶点到另一个顶点最短距离的算法。最短路算法的应用极其广泛。本文将会以求解最短路为中心，围绕着展开叙述一些常见的最短路算法的原理和应用。

根据最短路算法，我们大致地可以将算法分为两大类：

  1. 单源最短路径 Single Source Shortest Path：用于快速计算从某一个特定顶点出发到达任意一个点的距离。
  2. 多源最短路径 Multiple Source Shortest Path：用于快速计算任意两点之间的最短路径。

本文将会介绍的算法和各算法的特点如下：

  1. 深度优先搜索 Depth First Search：单源最短路径算法，可以求解从任意一点开始到另一点的最短路径，但该算法极其耗时。
  2. 广度优先搜索 Breadth First Search：单源最短路径算法，仅用于求解无权图。
  3. 迪克斯特拉算法 Dijkstra Algorithm：单源最短路径算法，是广度优先搜索算法的加强版。Dijkstra 算法不能处理带有负权边的情况，更不能处理带有负权回路的图。
  4. 贝尔曼福特算法 Bellman-Ford Algorithm：单源最短路径算法，可以用于处理又负权边的情况。对其进行队列优化后就变成了我们熟知的 SPFA 算法。
  5. 弗洛伊德算法 Floyd Algorithm：多源最短路径算法，基于动态规划思想，能够一次性求出图中任意两点之间的最短路径，但该算法的时间复杂度非常高，达到惊人的 O ( N 3 ) O(N^3) O(N3)。弗洛伊德算法能处理带有负权边的情况，但不能处理带有负权回路的图。

为了方便阅读，本文提供的所有代码均会使用 vector 实现的邻接表来存图。

场景引入

在下图中，有 7 7 7 条不同的边，每一条路径上方都标记了一个数值 T i T_i Ti​，代表通过该条路径所需要的时间。Macw 想知道从 1 1 1 号顶点到 5 5 5​ 号顶点所需要花费的最短时间。

在这里插入图片描述

不难看出，Macw 所需要花费的最短时间是 14 14 14 分钟，一条可行的方案是从 1 1 1 号顶点出发，途径 2 2 2， 3 3 3 号顶点到达顶点 5 5 5。虽然人脑可以很快的看出来，但是在庞大的数据量下，人的脑力就显得极其渺小。那对于计算机来说，我们如何能找到一条从 1 1 1 号节点到 5 5 5 号节点的路径呢？不妨让计算机暴力枚举出所有的可行路径和每条路径分别的耗时，取最小的那一条路径就可以了。深度优先搜索算法是一个选择。

深度优先搜索 Depth First Search

如上图所示，从 1 1 1 号节点到 5 5 5 号节点共有四条路径，每条路径和其分别耗时如下：

  1. 1 → 2 → 5 1\to 2\to 5 1→2→5，耗时 2 + 16 = 18 2 + 16 = 18 2+16=18 分钟。
  2. 1 → 2 → 3 → 5 1\to 2\to 3\to 5 1→2→3→5，耗时 2 + 7 + 5 = 14 2 + 7 + 5 = 14 2+7+5=14 分钟。
  3. 1 → 4 → 5 1\to 4\to 5 1→4→5，耗时 6 + 12 = 18 6 + 12 = 18 6+12=18 分钟。
  4. 1 → 4 → 3 → 5 1 \to 4\to 3\to 5 1→4→3→5，耗时 6 + 6 + 5 = 17 6 + 6 + 5 = 17 6+6+5=17 分钟。

其中第二个方案是最优解，耗时 14 14 14 分钟。因此，一个可行的算法方案是使用深度优先搜索暴力枚举出所有可行的路径并记录最小值即可，其代码实现如下：

// ans 用于记录答案，一开始把答案设置为无穷大。
int ans = 0x7f7f7f7f; 
// 记录一个点是否被访问过，防止出现循环。
int vis[105];
struct Edge{
    int to;
    int weight;
}; vector<Edge> G[105];

// 表示到 node 节点的耗时为 steps。
void dfs(int node, int steps){
    if (steps >= ans) // 最优性剪枝。
    // 如果走到目标答案，就更新结果并返回。
    if (node == terminal){
        ans = min(ans, steps);
        return ;
    }
	for (Edge next : G[node]){
        // 遍历从 node 开始所有的边。
        if (vis[next.to]) continue ;  // 被访问过了，就跳过。
    	vis[next.to] = 1;  // 将节点标记为已访问的状态。
        dfs(next.to, steps + next.weight);  // 继续递归。
        vis[next.to] = 0;  // 将节点标记为未访问的状态。
    }
    return ;
}

深度优先嗖嗖算法虽然很有效，但是该算法的运行效率太低下了，只适用于数据量较小的情况。假设图是一个二叉树树形结构，那么在最坏的情况下，这个算法的时间复杂度将会达到 O ( 2 N ) O(2^N) O(2N)。当每个顶点的度越多，深度优先搜索算法的时间复杂度就高。因此，在一般情况下，我们不会使用深度优先搜索。

设想在二维 N × M N \times M N×M 地图问题的情况下，我们怎么找到从入口到出口的最佳路径？一般情况下，我们会使用广度优先搜索的算法。广度优先搜索算法的复杂度远远低于深度优先搜索。

广度优先搜索算法 Breadth First Search

在一个无权图中（或图中所有边的权值均为 1 1 1）的情况下，我们会使用广度优先搜索算法来实现。广度优先搜索算法的代码也很简洁：

struct node{
    int pos;
    int steps;
}; queue<node> que;
struct Edge{
    int to;
    int weight;
}; vector<Edge> G[105];
// 记录一个点是否被访问过，防止出现循环。
int vis[105];

void bfs(int start){
    que.push(start)  // 将起点加入队列。
    while(!que.empty()){
        node t = que.front();
        que.pop();
        // 如果走到目标答案，就输出答案并终止循环。
        if (t.pos == terminal){
            cout << t.steps << endl;
            return ;
        }
        // 遍历从 t 开始所有的边。
        for (Edge next : G[t]){
            // 如果被访问过了，就略过。
            if (vis[next.to]) continue;
            vis[next.to] = 1;
            // 将新的节点加入到队列之中。
            que.push((node){next.to, t.steps + next.weight});
        }
    }
    return ;
}

我们已经知道，在一般的地图问题中广度优先搜索的效率非常高。那我们是否可以加以改进广度优先算法，让它适配带权图呢？答案是可以的，经过改编后的算法就是大名鼎鼎的 Dijkstra 算法。

迪克斯特拉算法 Dijkstra Algorithm

Dijkstra 算法是一种用于寻找图中从单一源节点到其他所有节点的最短路径的算法（即单源最短路径算法）。它适用于所有边权重为非负值的图。这个算法最早是被荷兰计算机科学家 艾兹赫尔·戴克斯特拉 (Edsger W. Dijkstra) 发明并提出的，因此用他的名字来命名该最短路算法。

Dijkstra 算法的基本思想是逐步扩展最短路径，直到覆盖所有节点。依旧以「场景引入」章节的图来举例子，虽然我们没有办法一下子立刻求解出从 1 1 1 号节点到 5 5 5 号节点的最短路径，但是如果我们能求出从 1 1 1 号节点到 5 5 5 号节点所有的前驱节点的最短路径，那么我们就可以立刻计算出从起点到 5 5 5 号节点最短路。

在这里插入图片描述

如上图所示， 5 5 5 号节点有三个前驱节点，分别是节点 V = { 2 , 3 , 4 } V = \{2, 3, 4\} V={2,3,4}，走到这三个节点的最短距离分别为两分钟、九分钟和六分钟。通过遍历这些前驱节点，我们就可以求出从起点到终点的最短路。显然，对于图中所有的节点，我们都需要按照一定的顺序依次对它们进行相同的操作。这样子，我们就可以求解出从起点开始到图中任意一个点的最短距离了。

Dijkstra 算法具体的实现流程如下：

  1. 初始化：
    • 创建一个数组，用于记录从源点开始到任意一点的距离。同时设定源节点的距离为 0 0 0，其他所有节点的距离为 + ∞ +\infty +∞​。
    • 将所有节点标记为未访问。
    • 使用一个优先队列来存储节点及到某一个节点当前所计算出的最短距离。
  2. 选择节点：
    • 从未访问的节点中选择当前距离最小的节点作为当前节点。
    • PS：如没有特殊情况，一开始这个节点应该是求解最短路问题的起点（起点与自己的距离应该是 0 0 0，正如初始化步骤中所提及的）。
  3. 更新节点：
    • 对于当前节点的每个邻居节点，计算从当前节点到该邻居节点的距离。
    • 如果这个距离小于已知的到该邻居节点的距离，则更新该邻居节点的距离。
    • 距离更新: 对于每个邻居节点，计算从起点到该邻居节点的距离，如果该距离小于已知的最短距离，则更新最短距离。
  4. 标记已访问：
    • 将当前节点标记为已访问，表示已经处理完了该节点。
    • PS：当节点被标记完已访问后，从起点到该节点的最短距离就已经被正式确定下来了，在后续的计算过程中该节点的距离将不会再被更新。标记节点已访问可以在「选择节点」步骤完成后时就进行。换句话说，第三步和第四步的顺序并不重要。
  5. 重复循环：
    • 重复上述提到的第 2-4 步，直到所有的点都被标记为已访问。

以下是使用 Dijkstra 算法对例题的模拟过程：

首先初始化距离数组，将源点的距离设置为 0 0 0，将除源点以外的所有点的距离设置为 + ∞ +\infty +∞。正无穷大表示到达该点的最短距离还未知。

在这里插入图片描述

从未访问的节点中选择当前距离最小的节点作为当前节点。在一开始，距离最小的节点就是源点本身。如下图，浅绿色表示当前选中的节点，黄色表示该节点的邻居节点。接下来就开始更新两个邻居节点距源点的最近距离。从 1 1 1 号点到 2 2 2 号点的最短距离为 2 2 2，而 2 2 2 号节点当前所记录的最短距离是 + ∞ +\infty +∞，比较发现 2 < + ∞ 2 < +\infty 2<+∞，因此将 2 2 2 号点的距离从原本的正无穷更新为 2 2 2。节点 4 4 4 也是如此，从起点到该节点的最短路径将由原本的正无穷更新为 6 6 6。

在这里插入图片描述

此时， 1 1 1 号节点已经处理完成了，我们将该节点标记为已访问（图中用深绿色表示）。接下来，我们从未访问的节点当中选择一个距离最小的节点作为当前节点。如下图，未访问的节点有 V = { 2 , 3 , 4 , 5 } V = \{2, 3, 4, 5\} V={2,3,4,5}，其当前的距离分别为 D i s = { 2 , + ∞ , 6 , + ∞ } Dis = \{2, +\infty, 6, +\infty\} Dis={2,+∞,6,+∞}，因此我们选择 2 2 2 号节点作为新的当前节点，因为该节点是所有未访问节点当中距离源点距离最小的那个节点。

在这里插入图片描述

从 2 2 2 号节点开始，更新该节点的所有邻居节点。对于 5 5 5 号节点，原本的距离是 + ∞ +\infty +∞，但从源点出发，经过 2 2 2 号节点的距离为 2 + 16 = 18 2 + 16 = 18 2+16=18，显然这个距离比原本的正无穷大更优，因此更新该节点的最短距离为 18 18 18。对于 3 3 3 号节点也是如此，从源点出发经过 2 2 2 号节点的最短距离是 2 + 7 = 9 2 + 7 = 9 2+7=9，因此将 3 3 3 号节点的距离更新为 9 9 9。

在这里插入图片描述

将 2 2 2 号节点标记为已访问。接下来再从未访问的节点中选择一个距离最近的节点，现在未访问的节点有 V = { 3 , 4 , 5 } V = \{3, 4, 5\} V={3,4,5}，其中 4 4 4 号节点的距离最短，因此选择 4 4 4 号节点作为当前节点。从 4 4 4 号节点出发可以到达的节点只有 3 3 3 号节点，如果从源点出发经过 4 4 4 号节点再到 3 3 3 号节点的距离为 6 + 6 = 12 6 + 6 = 12 6+6=12，这显然比当前 3 3 3 号的距离更大，因此这不是一个更优的解，本轮将不再更新 3 3 3 号节点的最短距离。

在这里插入图片描述

将 4 4 4 号节点标记为已访问。现在再从未访问的节点中选择一个距离最小的节点作为当前节点，因此我们将选择 3 3 3 号节点作为当前节点。我们发现从源点出发经过 3 3 3 号节点到 5 5 5 号节点的距离为 9 + 5 = 14 9 + 5 = 14 9+5=14，这比 5 5 5 号节点当前记录的 18 18 18 更优，因此更新 5 5 5 号节点的最短距离。

在这里插入图片描述

将 3 3 3 号节点标记为已访问。

在这里插入图片描述

选择 5 5 5 号节点作为当前节点。由于 5 5 5 号节点没有任何的后继节点，因此循环结束。将 5 5 5 号节点标记为已访问。

在这里插入图片描述

至此，所有的节点都标记为已访问，Dijkstra 算法结束。此时距离数组记录的值就是从源点出发到各个点的最短距离。

在这里插入图片描述

在下方代码中，为了快速的找到当前距离最小的节点，我们将会使用 C++ 自带的优先队列 (Priority Queue) 数据结构来实现。

完整的 Dijkstra 求解最短路的代码如下（对应例题：洛谷 - P4779 【模板】单源最短路径（标准版） 和 ACGO - A569.单源最短路径1）：

#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
#define int long long
using namespace std;

const int N = 1e6;

int n, m, s;
int u, v, w;
struct Edge{
    int to;
    int weight;
}; vector<Edge> G[N];
struct node{
    int position;
    int distance;
    // 优先队列优化，按照 distance 从小到大进行排序。
    bool friend operator < (node a, node b){
        return  a.distance > b.distance;
    }
};
// dis 数组用于记录从起点开始到任意一个点的最短路。
// vis 数组用于记录一个节点是否已经被访问过了。
int dis[N], vis[N];

void dijkstra(int origin){
    // 初始化：将所有非起点外的点都初始化为正无穷大。
    for (int i=1; i<=n; i++) 
        dis[i] = 2147483647;
    dis[origin] = 0;

    // 优先队列初始化：一开始将起点加入队列。
    priority_queue<node> que;
    que.push((node){origin, 0});
    
    while(que.size()){
        node t = que.top();
        que.pop();
        
        // 如果节点被访问过了，则略过。否则标记该节点为已访。
        if (vis[t.position]) continue;
        vis[t.position] = 1;  // 也可以写在最后。

        // 遍历所有的邻居节点。
        for (Edge next : G[t.position]) {
            int to = next.to;
            int w = next.weight;
            // 如果存在一条更优秀的路径，则更新最短路。
            if (dis[to] > w + dis[t.position]){
                dis[to] = w + dis[t.position];
                // 将节点加入到优先队列之中。
                que.push((node){to, w + dis[t.position]});
            }
        }
    }
    return ;
}

signed main(){
    // 输入输出优化。
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    // 读入题目数据并建图。
    cin >> n >> m >> s;
    for (int i=1; i<=m; i++){
        cin >> u >> v >> w;
        G[u].push_back((Edge){v, w});
    }

    // 运行最短路算法。
    dijkstra(s);

    // 输出结果，如果 dis 还是正无穷大，则证明改节点无法到达。
    for (int i=1; i<=n; i++) 
        cout << (dis[i] == 2147483647 ? -1 : dis[i]) << " ";
    return 0;
}

由于该算法是基于优先队列实现的，优先队列求出最小值的复杂度为 O ( l o g 2 ( V ) ) O(log_2(V)) O(log2​(V))（使用了二叉堆优化），因此 Dijkstra 的时间复杂度约为 O ( ( V + E ) × l o g 2 V ) O((V + E) \times log_2{V}) O((V+E)×log2​V)，其中 V V V 代表图中顶点的数量， E E E 代表图中边的数量。相比之下，Dijkstra 算法的运行效率非常优越。该算法也是在求解最短路问题中应用最广泛的算法之一。

贝尔曼福特算法 Bellman-Ford Algorithm

Bellman-Ford 算法也是一种用于求解单源最短路径问题的算法，特别适用于含有负权边的图。与 Dijkstra 算法不同，Bellman-Ford 算法能够检测到负权重环路的存在。

Bellman-Ford 的算法思想是通过 松弛操作 (Relaxation) 逐步找到从源点到所有其他顶点的最短路径。对一条边进行松弛操作指的是检查一条边/图上的路径是否能提供更短的路径。如果可以，那么就更新答案。

该算法会重复对图中的所有边进行松弛操作，总共执行 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1 次，其中 ∣ V ∣ \lvert V\rvert ∣V∣ 是图中顶点的数量。

Bellman-Ford 算法具体的实现流程如下：

  1. 初始化：
    • 创建一个数组，用于记录从源点开始到任意一点的距离。同时设定源节点的距离为 0 0 0，其他所有节点的距离为 + ∞ +\infty +∞​。
  2. 松弛操作：
    • 对于每一条边 ( u , v ) (u, v) (u,v)，和这条边的权重 w ( u , v ) w(u, v) w(u,v)，如果可以使得 d i s u + w ( u , v ) < d i s v dis_u + w(u, v) < dis_v disu​+w(u,v)<disv​，则将 d i s v dis_v disv​ 更新为 d i s u + w ( u , v ) dis_u + w(u, v) disu​+w(u,v)。其中， d i s i dis_i disi​ 表示编号为 i i i 节点的距离。
    • 重复上述步骤 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1 次。
  3. 检测是否存在负环：
    • 再次对所有边执行松弛操作。如果发现某条边 ( u , v ) (u, v) (u,v) 仍能使 d i s u + w ( u , v ) < d i s v dis_u + w(u, v) < dis_v disu​+w(u,v)<disv​ 成立，则说明图中存在负权重环路。
    • 换句话说，如果一个图不存在负环，则这张图的边在经历最多 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1 次松弛操作后将不能再进行松弛了。

以下是使用 Bellman-Ford 算法对例题的模拟过程：

首先初始化距离数组，将源点的距离设置为 0 0 0，将除源点以外的所有点的距离设置为 + ∞ +\infty +∞。正无穷大表示到达该点的最短距离还未知。

在这里插入图片描述

选择一条边，对该边尝试进行一次松弛操作。如下图（红色的边表示当前选中的边），通过这一条边可以将从源点到 2 2 2 号点的距离从正无穷大缩短至 2 2 2，因此更新新的距离。

在这里插入图片描述

以次类推，依次遍历并尝试松弛所有的边。当每一条边经历 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1 次松弛操作后，算法结束。此时距离数组记录的值就是从源点出发到各个点的最短距离。

在这里插入图片描述

完整的 Bellman-Ford 求解最短路的代码如下（对应例题：洛谷 - P4779 【模板】单源最短路径（标准版） 和 ACGO - A569.单源最短路径1，由于标准版的 Bellman-Ford 算法运行效率低下，因此不保证可以通过所有的测试点）：

#include <iostream>
#include <algorithm>
#include <vector>
#define int long long
using namespace std;

const int N = 1e6;

int n, m, s, dis[N];
struct Edge{
    int from, to;
    int weight;
}; vector<Edge> edges; 

void bellman_ford(int origin){
    // 初始化：将所有非起点外的点都初始化为正无穷大。
    for (int i=1; i<=n; i++) 
        dis[i] = 2147483647;
    dis[origin] = 0;

    // 由于图中保证不存在负环，则循环 n-1 遍即可。
    for (int i=1; i<=n-1; i++){
        for (Edge edge : edges){
            // 进行松弛操作。
            dis[edge.to] = min(dis[edge.to], dis[edge.from] + edge.weight);
        }
    }
    return ;
}

signed main(){
    // 输入输出优化。
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    // 读入题目数据并建图。
    cin >> n >> m >> s;
    for (int i=1, u, v, w; i<=m; i++){
        cin >> u >> v >> w;
        edges.push_back((Edge){u, v, w});
    }

    // 运行最短路算法。
    bellman_ford(s);

    // 输出结果，如果 dis 还是正无穷大，则证明改节点无法到达。
    for (int i=1; i<=n; i++) 
        cout << (dis[i] == 2147483647 ? -1 : dis[i]) << " ";
    return 0;
}

使用 Bellman-Ford 算法判断负环的方法如下（对应例题：ACGO - A551.单源最短路径2）：

// 其他地方都不需要作改动，只改动核心松弛部分就可以了。
// 在进行第n轮松弛的时候，如果某一条边还可以松弛那么就说明这个图中存在负环。

for (int i=1; i<=n; i++){
    for (Edge edge : edges){
        // 进行松弛操作。
        if (dis[edge.from] + edge.weight < dis[edge.to]){
            // 如果在第 n 次还是可以对其进行松弛操作，那么就证明有负环。
            if (i == n){
                cout << "no solution" << endl;
                exit(0);
            }
            dis[edge.to] = dis[edge.from] + edge.weight;
        }
    }
}

因为 Bellman-Ford 算法要对每条边进行 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1 次松弛操作，并且还需要判断一次是否存在负环，因此该算法的时间复杂度为 O ( V × E ) O(V \times E) O(V×E)，其中 V V V 是顶点数， E E E 是边数。Bellman-Ford 的时间复杂度相对来说比较高，因此在没有负环的时候仍然推荐使用 Dijkstra 最短路算法作为首选方案。

SPFA 算法 Shortest Path Faster Algorithm

SPFA (Shortest Path Faster Algorithm) 算法是 Bellman-Ford 算法的改进版本，专门用于加速单源最短路径的计算。该算法通过队列机制减少了不必要的松弛操作，从而提高了代码的运行效率。SPFA算法在实践中表现出优异的性能，特别是在稀疏图中。

SPFA 算法利用一个队列来存储需要松弛的顶点，并且每个顶点在队列中最多出现一次。通过这种机制，SPFA 算法避免了对所有边进行多余的松弛操作，从而提高了效率。

但 SPFA 算法也有缺陷，在一些特殊的情况下，可能会出现卡死的情况（有一句古话：关于 SPFA，它死了）。在最坏的情况下，SPFA 的复杂度高达 O ( V × E ) O(V\times E) O(V×E)（就是普通 Bellman-Ford）算法的运行效率。但该算法在大多数情况下表现优异，通常情况该算法的平均时间复杂度在 O ( V + E ) O(V + E) O(V+E) 附近，其中 V V V 是图中顶点的数量， E E E 是图中边的数量。

SPFA 算法具体的实现流程如下：

  1. 初始化：

    • 创建一个数组，用于记录从源点开始到任意一点的距离。同时设定源节点的距离为 0 0 0，其他所有节点的距离为 + ∞ +\infty +∞​。

    • 初始化一个队列（不需要是优先队列，普通队列即可）。将源点加入到队列之中。

    • 初始化一个数组用来记录某个顶点是否在队列之中。在程序开始时，源点应该被标记为已经入队。

  2. 松弛操作：

    • 对于每一条边 ( u , v ) (u, v) (u,v)，和这条边的权重 w ( u , v ) w(u, v) w(u,v)，如果可以使得 d i s u + w ( u , v ) < d i s v dis_u + w(u, v) < dis_v disu​+w(u,v)<disv​，则将 d i s v dis_v disv​ 更新为 d i s u + w ( u , v ) dis_u + w(u, v) disu​+w(u,v)。其中， d i s i dis_i disi​ 表示编号为 i i i 节点的距离。
    • 如果成功进行了松弛操作，且顶点 v v v 不在队列之中，那么将顶点 v v v 加入到队列之中。

  3. 重复执行：

    • 重复第二部的操作，直到队列为空。
    • PS：如果某个点加入了队列 ∣ V ∣ \lvert V\rvert ∣V∣ 次，则说明该图存在负环，应该立结束程序。

以下是使用 SPFA 算法对例题的模拟过程：

首先初始化距离数组，将源点的距离设置为 0 0 0，将除源点以外的所有点的距离设置为 + ∞ +\infty +∞。正无穷大表示到达该点的最短距离还未知。同时，将源点加入到队列之中，并将源点标记为已加入队列。

在这里插入图片描述

选择队首元素（在当前情况就是 1 1 1 号节点），松弛与 1 1 1 号节点相邻的两条边。从 1 1 1 号节点出发，到 2 2 2 号节点和 4 4 4 号节点的距离都比正无穷大要小，因此更新这两个节点的距离。与此同时，由于 2 2 2 号节点和 4 4 4 号节都不在队列中，因此将这两个节点加入到队列。

在这里插入图片描述

弹出位于队首的 1 1 1 号元素，选择位于队首的 2 2 2 号元素，松弛与 2 2 2 号节点相邻的两条边。从 2 2 2 号节点出发，到 3 3 3 号节点和 5 5 5 号节点的距离都比正无穷大要小，因此更新这两个节点的距离。与此同时，由于 3 3 3 号节点和 5 5 5 号节都不在队列中，因此将这两个节点加入到队列。

在这里插入图片描述

弹出位于队首的 2 2 2 号元素，选择位于队首的 4 4 4 号元素，松弛与 4 4 4 号节点相邻的两条边。从 4 4 4 号节点出发，到 3 3 3 号节点和 5 5 5 号节点的距离都比原本要远，因此不更新任何节点，也不将任何节点加入到队列当中。

在这里插入图片描述

弹出位于队首的 4 4 4 号元素，选择位于队首的 3 3 3 号元素，松弛与 3 3 3 号节点相邻的两条边。从 3 3 3 号节点出发，到 5 5 5 号节点的距离为 9 + 5 = 14 9 + 5 = 14 9+5=14，比原本的 18 18 18 要更优，因此更新 5 5 5 号节点。但由于 5 5 5 号节点已经被加入到了队列之中，因此不再重复加入。

在这里插入图片描述

弹出位于队首的 3 3 3 号元素，选择位于队首的 5 5 5 号元素，由于该节点不存在任何的后继节点，因此不做任何操作，直接将 5 5 5 号节点弹出队列。至此，队列为空，SPFA 算法结束。

在这里插入图片描述

完整的 SPFA 求解最短路的代码如下（对应例题：洛谷 - P4779 【模板】单源最短路径（标准版） 和 ACGO - A569.单源最短路径1，由于标准版的 SPFA 算法最坏的情况会被卡死，因此不保证可以通过所有的测试点）：

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#define int long long
using namespace std;

const int N = 1e6;

int n, m, s, dis[N], inque[N];
struct Edge{
    int to;
    int weight;
}; vector<Edge> G[N];

void SPFA(int origin){
    // 初始化：将所有非起点外的点都初始化为正无穷大。
    for (int i=1; i<=n; i++) 
        dis[i] = 2147483647;
    dis[origin] = 0;

    // 将源点加入到队列之中。
    queue<int> que;
    que.push(origin);
    inque[origin] = 1;

    // 循环直至队列不为空。
    while(!que.empty()){
        int t = que.front();
        inque[t] = 0;
        que.pop();
        for (Edge next : G[t]){
            // 进行松弛操作。
            if (dis[t] + next.weight < dis[next.to]){
                dis[next.to] = dis[t] + next.weight;
                // 如果不在队列之中，就将点加入队列。
                if (!inque[next.to]){
                    que.push(next.to);
                    inque[next.to] = 1;
                }
            }
        }
    }
    return ;
}

signed main(){
    // 输入输出优化。
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);

    // 读入题目数据并建图。
    cin >> n >> m >> s;
    for (int i=1, u, v, w; i<=m; i++){
        cin >> u >> v >> w;
        G[u].push_back((Edge){v, w});
    }

    // 运行最短路算法。
    SPFA(s);

    // 输出结果，如果 dis 还是正无穷大，则证明改节点无法到达。
    for (int i=1; i<=n; i++) 
        cout << (dis[i] == 2147483647 ? -1 : dis[i]) << " ";
    return 0;
}

使用该算法判断负环，只需要判断是否存在一个节点被加入了超过 ∣ V ∣ − 1 \lvert V\rvert - 1 ∣V∣−1​ 次即可。完整的 SPFA 判断是否存在负环的代码如下（对应例题：洛谷 - P3385 【模板】负环）：

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#define int long long
using namespace std;

const int N = 1e6;

int T, n, m, s;
int cnt[N], dis[N], inque[N];
struct Edge{
    int to;
    int weight;
}; vector<Edge> G[N];

void SPFA(int origin){
    // 初始化：将所有非起点外的点都初始化为正无穷大。
    for (int i=1; i<=n; i++) 
        dis[i] = 2147483647;
    dis[origin] = 0;

    // 将源点加入到队列之中。
    queue<int> que;
    que.push(origin);
    inque[origin] = 1;

    // 循环直至队列不为空。
    while(!que.empty()){
        int t = que.front();
        cnt[t] += 1;
        inque[t] = 0;
        que.pop();
        if (cnt[t] >= n){
            cout << "YES" << endl;
            return ;
        }
        for (Edge next : G[t]){
            // 进行松弛操作。
            if (dis[t] + next.weight < dis[next.to]){
                dis[next.to] = dis[t] + next.weight;
                // 如果不在队列之中，就将点加入队列。
                if (!inque[next.to]){
                    que.push(next.to);
                    inque[next.to] = 1;
                }
            }
        }
    }
    cout << "NO" << endl;
    return ;
}

void solve(){
     // 读入题目数据并建图。
    cin >> n >> m;
    for (int i=1; i<=n; i++){
        G[i].clear();
        inque[i] = 0;
        cnt[i] = 0;
    }
    for (int i=1, u, v, w; i<=m; i++){
        cin >> u >> v >> w;
        G[u].push_back((Edge){v, w});
        if (w >= 0) G[v].push_back((Edge){u, w});
    }
    SPFA(1);  // 判断是否存在负环。
}

signed main(){
    // 输入输出优化。
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> T; while(T--) solve();
    return 0;
}

弗洛伊德算法 Floyd Algorithm

Floyd 算法运用了动态规划的思想，该算法用于求解所有顶点对之间的最短路径问题。Floyd 算法适用于带权有向图，可以处理负权重边，但不能处理图中含有负权重环的情况。

Floyd l算法通过三重循环迭代地更新最短路径。设定一个二维矩阵 D i s Dis Dis，其中 D i s i , j Dis_{i, j} Disi,j​ 表示从顶点 i i i 到顶点 j j j 的最短路径权重。初始时，将直接相连的顶点的距离设置为边的权重，没有直接连接的顶点距离设为无穷大，顶点到自身的距离设为 0 0 0。

该算法的核心思想是，检查每一对顶点 ( i , j ) (i, j) (i,j) 是否可以通过另一个顶点 k k k（作为中转节点） 使得从 i i i 节点到 j j j 节点的路径更优。如果通过 k k k 可以使路径更短，则更新 D i s i , j Dis_{i, j} Disi,j​。

因此可以得到状态转移方程： D i s i , j = min ⁡ ( D i s i , k + D i s k , j , D i s i , j ) Dis_{i, j} = \min(Dis_{i, k} + Dis_{k, j}, Dis_{i, j}) Disi,j​=min(Disi,k​+Disk,j​,Disi,j​)。

综上所述，Floyd 的代码如下（对应例题：洛谷 - B3647 【模板】Floyd）：

#include <iostream>
#define int long long
using namespace std;

int n, m, dis[105][105];

void init(){
    for (int i=1; i<=n; i++){
        for (int j=1; j<=n; j++){
            dis[i][j] = 2147483647;
        }
        dis[i][i] = 0;
    }
    return ;
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    cin >> n >> m;
    
    init();  // 初始化。

    // 读入数据与建图。
    for (int i=1, u, v, w; i<=m; i++){
        cin >> u >> v >> w;
        dis[u][v] = dis[v][u] = min(dis[u][v], w);
    }

    // 进行动态规划。
    for (int k=1; k<=n; k++){
        for (int i=1; i<=n; i++){
            for (int j=1; j<=n; j++){
                dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
            }
        }
    }

    // 输出最短路。
    for (int i=1; i<=n; i++){
        for (int j=1; j<=n; j++){
            cout << dis[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

Floyd 算法的时间复杂度在 O ( N 3 ) O(N^3) O(N3)，其中 N N N 表示图中顶点的数量。因此该算法的执行效率是极其低的，在没有特殊情况下，尽量避免使用该算法。但如果遇到多源最短路径的题目，Floyd 算法还是首选方案。

Dijkstra 算法和 SPFA 算法的主要区别

  1. 处理负权边：
    • SPFA：可以处理负权边，并且在某些情况下表现出色。SPFA还可以检测负权环。
    • Dijkstra：无法处理负权边，因为 Dijkstra 算法假设已经找到的最短路径，且不会被后续路径更新。
  2. 队列机制：
    • SPFA：使用一个队列来存储需要处理的顶点。顶点可能多次进入队列，但每次只有在更短路径被发现时才重新入队。
    • Dijkstra：使用优先队列（通常是最小堆）来存储顶点，以确保每次处理的顶点是当前最短路径确定的顶点。
  3. 时间复杂度：
    • SPFA：在实际应用中通常表现良好，平均时间复杂度为 O ( V + E ) O(V + E) O(V+E)，但最坏情况下为 O ( V × E ) O(V\times E) O(V×E)。
    • Dijkstra：使用最小堆实现时，时间复杂度为 O ( ( V + E ) × l o g 2 V ) O((V + E)\times log_2V) O((V+E)×log2​V)。

本期讲解了常见的几种求解最短路问题的算法，共计 8409 字。谢谢阅读。

Macw07
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图论-最短路-BF算法
Stay hungry...
05-08 1089
原来一直把好多算法当黑箱子用，但是做题中发现肯定不会考原算法的，我们必须要掌握算法的精髓思路，然后改造它，其实并不难，不要方就行。 今天先看BF算法，思路非常简单，代码也好理解。#include <iostream>using namespace std;const int INF = 1e9 + 7; const int MAX_V = 100; const int MAX_E = 100;st
数据结构------最短路弗洛伊德算法（Flody)
m0_62749134的博客
06-30 1516
Foldy算法动态规划，详解代码，优缺分析！
搜索与图论 --- 最短路 - SPFA 算法、Floyd 算法
weixin_60569662的博客
07-19 1817
第一步，只要队列不空，队列里面还有节点变小的话，先从队列里面取出队头，然后把队头删掉，第二步遍历t的所有出边，如果t变小的话，所有以t为起点的边的终点都有可能变小，更新t的所有出边，例如t→b，距离是w，第三步，如果更新成功的话，把待更新的点b加入队列，加入之前需要判断一下，如果队列之前已经有b的话，b就不用再重复加入了。基本思路就是更新过谁，再拿谁来更新别人，一个点如果没有被更新过的话，那么它再去更新别人一定是没有效果的，只有我变小了，我后面的人才会变小。...
图论学习-最短路模型
麒麟001号的博客
02-07 2664
这里只是我对于最短路模型学习的一个记录，不正确的地方希望大家指出。 文章目录最短路模型一、 什么是最短路？1.1 概念1.2 基本术语二、主要模型2.1 dijkstra2.1.1 步骤2.1.2 画图理解2.1.3 为什么dijkstra不能处理负权边？2.2 堆优化的dijkstra2.3 bellman_ford2.3.1 三角形不等式2.3.2 步骤2.3.3 代码实现2.4 spfa2.4.1 步骤2.4.2 代码实现2.4.3 主要问题2.5 floyd三、练习题目四、参考 最短路模型 一、 什
图论--最短路的五种算法 适用情况 及 复杂度
wow_awsl_qwq的博客
01-25 739
稠密图：边多的图： m=n^2（n是点数，m是边数） 只考虑有向图，把无向图当成有向图 Dijkstra:贪心 Floyd：动态规划
图的应用--最短路算法
m0_63533811的博客
03-18 1681
本节适合对最短路稍有了解的读者阅读。最短路是图论这一节中重要的应用，涉及到了相当多的算法。当然这些算法可以不用全部掌握，但最少要略知一二。最短路问题求解主要有两个方向，一个是单源最短路，还有一个是多源最短路（就是是否只有一个起点）。单源最短路求解方法包含了Dijkstra算法，Bellman-ford算法和SPFA算法，而多源最短路问题主要就是用Floyd算法解决，但其时间复杂度较高，代码较为简单，一般算法竞赛中考的比较少（目前本蒟蒻是这样认为的）。 算法分类大概如下所示： 首先是Dijkstra算
图论--最短路--Floyd（含路径输出）
日拱一卒,功不唐捐
10-23 2686
#include<bits/stdc++.h> using namespace std; #define INF 0x3f3f3f3f #define maxn 1005 int D[maxn][maxn]; int P[maxn][maxn]; int N,M; //顶点数边数 int S,E; //起点终点 void Floyd() { for(int k=1;k&l...
图论-最短路Dijkstra算法详解超详 有图解
xxxxxiao123的博客
04-12 4092
整体来看dij就是从起点开始扩散致整个图的过程，为什么说他稳定呢，是因为他每次迭代，都能得到至少一个结点的最短路。（不像SPFA，玄学复杂度） 但是他的缺点就是不能处理带负权值的边，和代码量稍稍复杂。 dij算法（采用方法邻接表+优先队列优化）复杂度O(mn)降为O(mlogn) 不多哔哔，我们直接看图解： 核心：每次去往距离起点最近的那个点，并且是第一次访问 图中用黄色来标记哪些点已经走过。 之...
图论 ——五种最短路算法
qq_46056407的博客
03-29 9425
文章目录 前言 一、最短路是什么？ 二、朴素Dijkstra算法 三、堆优化版Dijkstra算法 四、Bellman-Ford算法 五、Spfa算法 六、Floyd算法 总结 前言 本篇文章讲的是图论里的最短路问题，如果你还没有图论的基础知识，可以看看我之前的文章： DFS（深度优先算法）BFS(广度优先算法）邻接表和邻接矩阵、树的遍历 （DFS和BFS） 这些都是关于图论的基本知识。 一、最短路是什么？ 最短路径： 从某个点A（位置）到另一个点B(位置)的最..
图论算法 --Dijkstra
爱媳妇儿爱编程
06-02 2836
Dijkstra算法是一种用于寻找图中单源最短路径的贪心算法。
图论- 最短路- Floyd 算法.rar
09-16
Floyd-Warshall算法是解决图论中找到所有节点对最短路径的有效工具。其核心在于通过迭代所有可能的中间节点来不断优化路径。尽管它的时间复杂度较高，但在处理大规模且边关系丰富的图时，其简单性和全面性使其成为一...
图论- 最短路- Johnson 算法.rar
09-16
图论是计算机科学和数学中的一个重要分支，它研究如何用图形来表示对象之间的关系。在图论中，最短路径问题是一个经典的...同时，实践编程实现也是巩固理论知识的有效手段，可以帮助我们更好地理解算法的实际运行过程。
图论- 最短路- Dijkstra 算法.rar
09-16
Dijkstra算法是图论中求解单源最短路径问题的一个经典算法，由荷兰计算机科学家艾兹格·迪科斯彻于1956年提出。这个算法适用于有向图和无向图，并且可以处理带有非负权重的边。 Dijkstra算法的基本思想是从一个起点...
图论- 最短路- Bellman-Ford 算法与 SPFA.rar
09-16
图论是计算机科学中的一个重要分支，它研究网络中节点间的关系和路径问题。在图论中，最短路径问题是一个核心话题，特别是在处理交通、网络通信等实际问题时。本资料包聚焦于两种解决最短路径问题的算法：Bellman-...
美赛常用模型（层次分析法、多属性决策模型、灰色预测模型、图论模型-Dijkstra算法、图论模型-Floyd算法等）
03-01
层次分析法、多属性决策模型、灰色预测模型、图论模型-Dijkstra算法、图论模型-Floyd算法、模拟退火模型、种群竞争模型、排队论模型、线性规划模型、非线性规划与01规划模型 、主成分分析 、聚类分析、多元回归分析...
每日刷题（图论）
2301_80314483的博客
09-02 661
这道题需要我们使用Floyd算法，因为计算全源最短路径需要三层循环，但是没完枚举传送门的建设也需要两重循环，五重循环必定超时，所以我们需要将它优化成四重循环，我们发现建设传送门时只对以传送门建设点为中转点的边有影响，所以我们可以优化为四重循环。看数据范围知道需要用到Floyd算法，但是道路是不能直接用的，需要等到连接道路的两个村庄重建好才可以使用，所以这需要按照时间依次加入中转点，再更新dis数组。所以我们需要用两个数组来维护答案最小值，dis数组和维护的边权最大值，下面是AC代码。
打卡第60天------图论
GodLoveMe的博客
08-30 555
一刷的时候，能理解 原理，知道Bellman_ford 解决不同场景的问题。今天大家会感受到 Bellman_ford 算法系列在不同场景下的应用。二刷的时候自己尝试独立去写，三刷的时候 才能有一定深度理解各个最短路算法。一、Bellman_ford 队列优化算法（又名SPFA）尽管前面的道路很困难，但是依然要坚持下去✊。，照着代码随想录能抄下来代码就好，就算达标。三、bellman_ford之单源有限最短路。二、bellman_ford之判断负权回路。
图论（2）
最新发布
2301_81684056的博客
09-03 141
度统计的是一个节点上又多少条边度=出度+入度出度：统计以该节点为起始点箭头指向外面的边的条数入度：统计箭头指向该节点的边数度为1的节点为悬挂节点，边为悬挂边用矩阵计算节点的度。
【图论简介】
m0_52796585的博客
08-30 1292
图论是一门数学分支，主要研究图（Graph）的性质、结构和应用。图论在计算机科学、网络理论、优化问题、生物信息学等多个领域都有广泛的应用。本文将简要介绍图论的基本概念、常见算法及其在实际中的应用。图论作为一门数学工具，在处理各种关系网络和优化问题中发挥着重要作用。通过理解图的结构和掌握常见算法，我们可以在复杂的实际问题中找到有效的解决方案。随着数据量的增加和网络复杂性的提升，图论的研究和应用前景将更加广阔。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值