【图论】bellman-ford 算法 + spfa 算法（基于队列优化）单源最短路（code c++）

---

一、前言

图为点和边的集合

边方向 -> 有向无向边

边权值 -> 是否有负权边

以及边是否成环，对点来说的出入度

存图方式

邻接矩阵
邻接表
链式前向星

最短路径算法

floyd——多源，时间复杂度 O(n^3)
dijkstra——单源，推荐因为快 + 稳定，不能负权边
belllman-ford——单源，允许负权边，不能有负环，最差时间复杂度 O(nm)
spfa（基于队列优化的 bellman-ford）——单源，允许负权边，不能有负环，最差时间复杂度 O(nm)

题目

---

二、算法原理

bellman-ford、spfa 算法关系

spfa 算法是 bellman-ford 算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。spfa 最坏情况下复杂度和朴素 bellman-ford 相同，为 O(nm)。

spfa 算法通俗介绍

适用范围：给定的图存在负权边，这时 dijkstra 算法便没有了用武之地，而 bellman-ford 算法的复杂度过高，spfa 算法便派上用场了。我们约定有向加权图 G 不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

大致流程：用一个队列来进行维护。初始时将源点加入队列。每次从队列中取出一个顶点，并与所有与它相邻的顶点进行松弛，若某个相邻的顶点松弛成功，则将其入队。重复这样的过程直到队列为空时算法结束。

---

三、程序代码

朴素 bellman-ford code c++

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

struct edge {
    int s, e, v; // 边起点, 边终点, 边权
};

int n, m, s, edg_cnt, ans[100005]; // 点数, 边数, 单源起点, 边的编号, 到该点的总权值
edge edg[200005];

void add_edg(int a, int b, int c) {
    edg[edg_cnt].s = a;
    edg[edg_cnt].e = b;
    edg[edg_cnt].v = c;
    ++edg_cnt;
}

int main() { // 朴素 bellman-ford 算法
    memset(ans, 0x3f, sizeof(ans));
    scanf("%d%d%d", &n, &m, &s);
    for (int i = 0; i < m; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add_edg(a, b, c);
        add_edg(b, a, c);
    }
    ans[s] = 0;
    for (int i = 1; i < n; ++i) { // 最多 n - 1 轮，故最坏时间复杂度 O(nm)
        int f = 0;
        for (int j = 0; j < edg_cnt; ++j) {
            if (ans[edg[j].e] > ans[edg[j].s] + edg[j].v) {
                ans[edg[j].e] = ans[edg[j].s] + edg[j].v;
                f = 1;
            }
        }
        if (f == 0) {
            break;
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (ans[i] != 0x3f3f3f3f) {
            printf("%d\n", ans[i]);
        } else {
            printf("-1\n");
        }
    }
    return 0;
}

spfa code c++

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

struct Edg {
    int e, v, next;
};

int n, m, s, edg_cnt, head[100005], ans[100005], mark[100005];
Edg edg[200005];

void add_edg(int a, int b, int c) {
    edg[edg_cnt].e = b;
    edg[edg_cnt].v = c;
    edg[edg_cnt].next = head[a];
    head[a] = edg_cnt;
    ++edg_cnt;
    return ;
}

int main() {
    memset(head, -1, sizeof(head));
    memset(ans, 0x3f, sizeof(ans));
    scanf("%d%d%d", &n, &m, &s);
    for (int i = 0; i < m; ++i) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add_edg(a, b, c);
        add_edg(b, a, c);
    }
    ans[s] = 0;
    queue<int> que;
    que.push(s);
    while (!que.empty()) {
        int tmp = que.front();
        que.pop();
        mark[tmp] = 0;
        for (int i = head[tmp]; i != -1; i = edg[i].next) {
            int e = edg[i].e, v= edg[i].v;
            if (ans[e] > ans[tmp] + v) {
                ans[e] = ans[tmp] + v;
                if (mark[e] == 0) {
                    que.push(e);
                    mark[e] = 1;
                }
            }
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (ans[i] == 0x3f3f3f3f) {
            printf("-1\n");
        } else {
            printf("%d\n", ans[i]);
        }
    }
    return 0;
}

---

四、结论

代码示例，有问题留言。

---