Better-OI

Dijstra

2026-04-05T00:00:00+00:00

Dijkstra 算法简介与 C++ 实现模板

一、算法概述

Dijkstra 算法是一种用于解决单源最短路径问题的经典算法。给定一个带权有向图或无向图，算法可以求出从源点到图中每个顶点的最短路径长度。其核心思想是贪心策略：每次选择当前距离源点最近的未处理节点，并更新其邻居的最短路径。

特点

适用于非负权重图（边权必须 ≥ 0）。
可以用于有向图或无向图。
时间复杂度：
- 使用数组实现：(O(V^2))
- 使用优先队列（最小堆）实现：(O(E \log V))，其中 (V) 为顶点数，(E) 为边数。

二、算法原理

初始化源点 dist[source] = 0，其他顶点距离为无穷大。
将所有顶点加入未处理集合（或使用优先队列维护）。
每次从集合中选取距离源点最小的顶点 u。
遍历 u 的邻居 v，尝试松弛边 (u, v)： [ \text{dist}[v] = \min(\text{dist}[v], \text{dist}[u] + \text{weight}(u, v)) ]
重复步骤 3-4，直到所有顶点处理完。

三、C++ 模板实现

这里给出使用 优先队列（min-heap） 的高效实现：

#include 
using namespace std;

const int INF = 1e9;  // 定义无穷大
const int MAXN = 100005;

struct Edge {
    int to, weight;
};

vector<Edge> adj[MAXN];  // 邻接表存储图
int dist[MAXN];          // 源点到各点最短距离
bool visited[MAXN];      // 标记是否已处理

void dijkstra(int source, int n) {
    for (int i = 1; i <= n; i++) {
        dist[i] = INF;
        visited[i] = false;
    }

    dist[source] = 0;
    // 优先队列存储 pair<距离, 节点>
    priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> pq;
    pq.push({0, source});

    while (!pq.empty()) {
        int u = pq.top().second;
        pq.pop();

        if (visited[u]) continue;  // 已处理则跳过
        visited[u] = true;

        for (auto &edge : adj[u]) {
            int v = edge.to, w = edge.weight;
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

int main() {
    int n, m;
    cin >> n >> m; // n个顶点，m条边
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        adj[u].push_back({v, w});
        // 若是无向图，加上这一行
        // adj[v].push_back({u, w});
    }

    int source;
    cin >> source;

    dijkstra(source, n);

    for (int i = 1; i <= n; i++) {
        if (dist[i] == INF) cout << "INF\n";
        else cout << dist[i] << "\n";
    }

    return 0;
}

Bellman-Ford

2026-04-05T00:00:00+00:00

Bellman-Ford 简介

Bellman-Ford 是解决 单源最短路 的经典算法。
它和 Dijkstra 最大的区别是：

Dijkstra 不能处理负边
Bellman-Ford 可以处理负边
并且 Bellman-Ford 还能判负环

这里的“负环”是指：从源点可达的某个环，环上边权和小于 0。
如果存在这种环，那么最短路就不存在，因为你可以在这个环上无限绕，使路径长度越来越小。

核心思想

设 dist[s]=0，其余点为正无穷。

然后进行若干轮“松弛”操作。
对于每条边 u -> v (w)，尝试更新：

[ dist[v] = \min(dist[v], dist[u] + w) ]

为什么这样做是对的？

因为：

第 1 轮后，可以得到“至多经过 1 条边”的最短路
第 2 轮后，可以得到“至多经过 2 条边”的最短路
…
第 n-1 轮后，可以得到“至多经过 n-1 条边”的最短路

一个不含环的最短路径，最多只会经过 n-1 条边，所以做 n-1 轮就够了。

为什么能判负环

如果做完 n-1 轮后，还能继续松弛某条边，说明存在一条“更优路径”需要经过至少 n 条边。

而一个含 n 条边的路径，在 n 个点的图中一定经过了重复点，也就是经过了环。
还能继续变优，说明这个环是负环。

因此：

做完 n-1 轮后
再检查一遍所有边
若还能松弛，则存在 从源点可达的负环

适用场景

Bellman-Ford 常用于：

图中有负边
需要判断负环
某些题目建图后边数不算特别大
作为 SPFA 的理论基础

时间复杂度

设点数为 n，边数为 m`：

时间复杂度：O(nm)
空间复杂度：O(n + m)

这比堆优化 Dijkstra 的 O(m log n) 慢很多，所以在没有负边时一般不用它。

标准 OI 模板

这是最常见的竞赛写法：边集数组。

#include 
using namespace std;

const int N = 5005;
const long long INF = 1e18;

struct Edge {
    int u, v;
    long long w;
} e[10005];

long long dist[N];

bool bellman_ford(int n, int m, int s) {
    for (int i = 1; i <= n; i++) dist[i] = INF;
    dist[s] = 0;

    // 做 n-1 轮松弛
    for (int i = 1; i <= n - 1; i++) {
        bool updated = false;
        for (int j = 1; j <= m; j++) {
            int u = e[j].u, v = e[j].v;
            long long w = e[j].w;
            if (dist[u] != INF && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                updated = true;
            }
        }
        if (!updated) break; // 提前结束优化
    }

    // 判负环：若还能松弛，则存在从 s 可达的负环
    for (int j = 1; j <= m; j++) {
        int u = e[j].u, v = e[j].v;
        long long w = e[j].w;
        if (dist[u] != INF && dist[v] > dist[u] + w) {
            return false; // 有负环
        }
    }
    return true; // 无负环
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, s;
    cin >> n >> m >> s;
    for (int i = 1; i <= m; i++) {
        cin >> e[i].u >> e[i].v >> e[i].w;
    }

    if (!bellman_ford(n, m, s)) {
        cout << "Negative cycle\n";
    } else {
        for (int i = 1; i <= n; i++) {
            if (dist[i] == INF) cout << "INF ";
            else cout << dist[i] << " ";
        }
        cout << '\n';
    }

    return 0;
}

模板细节解释

1. 为什么用边集而不是邻接表

Bellman-Ford 每一轮都要把 所有边扫一遍。
所以直接存边最方便：

struct Edge {
    int u, v;
    long long w;
};

每轮直接枚举 e[j] 即可。

2. 为什么要写 `dist[u] != INF`

if (dist[u] != INF && dist[v] > dist[u] + w)

这是为了防止：

u 根本不可达
INF + w 参与运算导致错误

这是 Bellman-Ford 里必须写的判断。

3. 提前结束优化

bool updated = false;
...
if (!updated) break;

如果某一轮没有任何更新，说明最短路已经稳定了，后面不用再做。
这个优化在很多题里很有用。

一个简单例子

图：

1 -> 2 (2)
1 -> 3 (5)
2 -> 3 (-4)

源点 1。

初始：

dist[1]=0
dist[2]=INF
dist[3]=INF

第 1 轮松弛：

1 -> 2：dist[2]=2
1 -> 3：dist[3]=5
2 -> 3：dist[3]=min(5, 2+(-4))=-2

结果：

dist[1]=0
dist[2]=2
dist[3]=-2

这就是 Bellman-Ford 可以处理负边的体现。

和 Dijkstra 的对比

Dijkstra

不能有负边
速度快
常用于非负权图最短路

Bellman-Ford

能处理负边
能判负环
复杂度高

所以竞赛里一般是：

没有负边：优先 Dijkstra
有负边 / 需要判负环：Bellman-Ford 或 SPFA

Bellman-Ford 的一个常见变形

有时题目要求：

最多经过 k 条边的最短路

这种题 Bellman-Ford 很适合做，因为“第 i 轮表示最多经过 i 条边”。

但这时要注意：
需要用一个 备份数组，避免同一轮中新更新的信息继续被用到。

模板如下：

#include 
using namespace std;

const int N = 505;
const long long INF = 1e18;

struct Edge {
    int u, v;
    long long w;
} e[10005];

long long dist[N], backup[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, k, s;
    cin >> n >> m >> k >> s;
    for (int i = 1; i <= m; i++) {
        cin >> e[i].u >> e[i].v >> e[i].w;
    }

    for (int i = 1; i <= n; i++) dist[i] = INF;
    dist[s] = 0;

    for (int i = 1; i <= k; i++) {
        for (int j = 1; j <= n; j++) backup[j] = dist[j];
        for (int j = 1; j <= m; j++) {
            int u = e[j].u, v = e[j].v;
            long long w = e[j].w;
            if (backup[u] != INF) {
                dist[v] = min(dist[v], backup[u] + w);
            }
        }
    }

    for (int i = 1; i <= n; i++) {
        if (dist[i] == INF) cout << "INF ";
        else cout << dist[i] << " ";
    }
    cout << '\n';

    return 0;
}

竞赛里要注意的坑

1. `INF` 要开大

一般用：

const long long INF = 1e18;

不要随便开 1e9，边权和路径长度可能很大。

2. 判负环只判“从源点可达”的负环

因为代码里写了：

if (dist[u] != INF && ...)

所以只有从 s 能走到的负环才会被检测到。
这通常正是单源最短路题目要的。

如果题目要判图中 任意位置 是否存在负环，常见做法是：

建一个超级源点，向所有点连权值 0 的边
再跑 Bellman-Ford / SPFA 判负环

3. “恰好 k 条边” 和 “最多 k 条边” 不一样

Bellman-Ford 分层意义天然对应“最多”。
如果题目问“恰好”，需要额外设计状态。

一句话总结

Bellman-Ford 本质上是：

通过反复枚举所有边，逐步扩大允许经过的边数，从而求出单源最短路；同时可借助第 n 轮是否还能松弛来判断负环。

Floyd

2026-04-05T00:00:00+00:00

Floyd 算法简介

Floyd 算法（也叫 Floyd-Warshall 算法）是用来求 图中任意两点的最短路径 的动态规划算法。

适用图：带权图（可有负权边，但不能有负环）
时间复杂度：(O(n^3))
空间复杂度：(O(n^2))

算法原理

假设图有 n 个顶点，编号 1~n。
设 dist[i][j] 表示 从 i 到 j 的最短路距离。

Floyd 算法的核心思路是 逐步引入中间节点：

初始化：

[ \text{dist}[i][j] = \begin{cases} 0 & i=j \ w(i,j) & i \neq j\text{且有边} \ INF & i \neq j\text{且无边} \end{cases} ]

动态规划：

[ \text{dist}[i][j] = \min(\text{dist}[i][j], \text{dist}[i][k] + \text{dist}[k][j]) ]

其中，k 表示允许经过的中间节点，算法从 k = 1 到 k = n 逐步更新 dist[i][j]。

算法特点

能处理 负边权，但不能有负环。
能求 任意两点的最短路。
简单实现就是三重循环 (O(n^3))。
也可以同时维护路径信息（next 数组）来输出路径。

OI 风格 C++ 模板

#include 
using namespace std;

const int N = 505;
const long long INF = 1e18;

long long dist[N][N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    // 初始化
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (i == j) dist[i][j] = 0;
            else dist[i][j] = INF;
        }
    }

    for (int i = 0; i < m; i++) {
        int u, v;
        long long w;
        cin >> u >> v >> w;
        dist[u][v] = min(dist[u][v], w); // 如果有多条边取最小
        // 如果是无向图：
        // dist[v][u] = min(dist[v][u], w);
    }

    // Floyd 三重循环
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (dist[i][k] != INF && dist[k][j] != INF)
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
            }
        }
    }

    // 输出
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if (dist[i][j] == INF) cout << "INF ";
            else cout << dist[i][j] << ' ';
        }
        cout << '\n';
    }

    return 0;
}

算法说明

初始化
- 对角线为 0
- 无边的点对设为 INF
- 有多条边取最小权值
三重循环
- 外层 k：允许中间点的编号
- 中间 i：起点
- 内层 j：终点
  更新 dist[i][j]，允许路径经过 k 节点。
判负环
- 若 dist[i][i] < 0，说明存在负环。
- 可以在循环中或者循环后判断。
路径恢复（可选）
- 用 next[i][j] 记录 i 到 j 的下一个节点。
- 最终可以回溯输出最短路径。

使用场景

稠密图：边数接近 (n^2)
需要求任意两点最短路
存在负边，但无负环
需要路径重构

和 Dijkstra / Bellman-Ford 对比

算法	时间复杂度	能处理负边	能判负环	单源/多源
Dijkstra (堆优化)	O(E log V)	❌	❌	单源
Bellman-Ford	O(VE)	✅	✅	单源
Floyd	O(V^3)	✅	✅	多源

稀疏图：Dijkstra > Bellman-Ford
稠密图：Floyd > Dijkstra
负边或负环：Bellman-Ford 或 Floyd

SPFA

2026-04-05T00:00:00+00:00

SPFA 简介

SPFA，全称一般写作 Shortest Path Faster Algorithm。
它可以看作是 Bellman-Ford 的队列优化版，用来求解 单源最短路，并且：

可以处理负边
可以判负环
在很多普通数据下跑得比 Bellman-Ford 快
但 最坏复杂度仍然很差

在 OI 圈里，SPFA 是一个“很经典，但也很危险”的算法：

能写
要会判负环
但不能无脑拿来跑最短路

一、SPFA 是怎么来的

Bellman-Ford 每一轮都要扫一遍所有边，总共扫 n-1 轮，所以复杂度是：

[ O(nm) ]

但实际上，并不是每条边每次都会产生贡献。
只有那些 刚被更新过的点，它们的出边才有可能继续松弛别人。

于是就有了 SPFA 的想法：

如果某个点 u 的最短路刚刚变小
那么把 u 放进队列
只去检查 u 的出边
若更新了相邻点 v，再把 v 入队

也就是说：

只处理“可能继续产生贡献”的点。

这就是 SPFA 的核心优化。

二、核心思想

设 dist[s] = 0，其余点设为正无穷。

维护一个队列，初始把源点 s 放进去。
每次取出队首点 u，扫描它的所有出边 u -> v (w)：

如果

[ dist[v] > dist[u] + w ]

那么更新 dist[v]。
如果 v 当前不在队列中，就把 v 加入队列。

这样不断进行，直到队列为空，说明当前已经没有点能继续松弛别人了。

三、为什么它是对的

本质上，SPFA 仍然在做 Bellman-Ford 的“松弛”。

区别仅仅在于：

Bellman-Ford：机械地反复扫描所有边
SPFA：只扫描那些“刚被更新”的点的出边

所以 SPFA 并没有改变最短路的正确性基础，它只是减少了很多无效松弛。

四、时间复杂度

这是 SPFA 最需要注意的地方。

理论最坏复杂度

[ O(nm) ]

也就是说，最坏情况下和 Bellman-Ford 一个级别。
而且在一些专门构造的数据下，它会非常慢，甚至被卡爆。

实际表现

在很多随机图、普通图、部分实际题目中，SPFA 常常比较快。
所以它是一个“平均看着不错，但最坏不稳”的算法。

五、适用场景

SPFA 常见用途：

单源最短路，图中有负边
判负环
某些差分约束建图题
图规模不太极端，或者题目数据对 SPFA 友好

但要记住：

没有负边时，一般优先用 Dijkstra
只为了最短路而不是负环，SPFA 往往不是第一选择
被卡常/卡复杂度的题，SPFA 可能寄

六、标准 OI 模板

1. 单源最短路模板

#include 
using namespace std;

const int N = 100005;
const long long INF = 1e18;

struct Edge {
    int to;
    long long w;
};

vector<Edge> g[N];
long long dist[N];
bool inq[N];

void spfa(int s, int n) {
    for (int i = 1; i <= n; i++) {
        dist[i] = INF;
        inq[i] = false;
    }

    queue<int> q;
    dist[s] = 0;
    q.push(s);
    inq[s] = true;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        inq[u] = false;

        for (auto e : g[u]) {
            int v = e.to;
            long long w = e.w;
            if (dist[u] != INF && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                if (!inq[v]) {
                    q.push(v);
                    inq[v] = true;
                }
            }
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m, s;
    cin >> n >> m >> s;

    for (int i = 1; i <= m; i++) {
        int u, v;
        long long w;
        cin >> u >> v >> w;
        g[u].push_back({v, w});
    }

    spfa(s, n);

    for (int i = 1; i <= n; i++) {
        if (dist[i] == INF) cout << "INF ";
        else cout << dist[i] << " ";
    }
    cout << '\n';

    return 0;
}

七、模板解释

1. `inq[]` 是干什么的

bool inq[N];

表示某个点当前是否在队列中。

作用是避免一个点被重复入队很多次。
如果没有这个数组，某些点可能连续被塞进队列，常数会很难看。

2. 为什么出队时要 `inq[u] = false`

int u = q.front(); q.pop();
inq[u] = false;

因为这个点已经不在队列里了。
这样之后若它再次被更新，还能重新入队。

3. 为什么不用 `vis[]`

Dijkstra 里常见“确定最短路后不再变化”的贪心性质。
但 SPFA / Bellman-Ford 没有这个性质，所以不能写：

“某点处理过一次就永远不管了”

它可能被后续负边继续更新。

八、负环判定

这是 SPFA 很重要的用途。

判定原理

如果一个点的最短路被更新了太多次，就说明可能经过了负环。

更准确地说：

若从源点出发，某个点被松弛次数达到 n
说明存在一条至少含 n 条边的更优路径
根据抽屉原理，这条路径中必然有环
还能继续变优，因此这个环是负环

判负环模板（从源点可达）

#include 
using namespace std;

const int N = 100005;
const long long INF = 1e18;

struct Edge {
    int to;
    long long w;
};

vector<Edge> g[N];
long long dist[N];
bool inq[N];
int cnt[N]; // 记录每个点被松弛的次数

bool spfa(int s, int n) {
    for (int i = 1; i <= n; i++) {
        dist[i] = INF;
        inq[i] = false;
        cnt[i] = 0;
    }

    queue<int> q;
    dist[s] = 0;
    q.push(s);
    inq[s] = true;
    cnt[s] = 1;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        inq[u] = false;

        for (auto e : g[u]) {
            int v = e.to;
            long long w = e.w;
            if (dist[u] != INF && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                cnt[v] = cnt[u] + 1;
                if (cnt[v] >= n) return false; // 存在负环
                if (!inq[v]) {
                    q.push(v);
                    inq[v] = true;
                }
            }
        }
    }
    return true; // 无负环
}

不过上面这种写法里 cnt[v] = cnt[u] + 1 更像“路径边数估计法”，竞赛中更常见的写法其实是“入队次数”统计：

更常用的负环判定模板

#include 
using namespace std;

const int N = 100005;
const long long INF = 1e18;

struct Edge {
    int to;
    long long w;
};

vector<Edge> g[N];
long long dist[N];
bool inq[N];
int cnt[N]; // 记录每个点入队次数

bool spfa(int s, int n) {
    for (int i = 1; i <= n; i++) {
        dist[i] = INF;
        inq[i] = false;
        cnt[i] = 0;
    }

    queue<int> q;
    dist[s] = 0;
    q.push(s);
    inq[s] = true;
    cnt[s]++;

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        inq[u] = false;

        for (auto e : g[u]) {
            int v = e.to;
            long long w = e.w;
            if (dist[u] != INF && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                if (!inq[v]) {
                    q.push(v);
                    inq[v] = true;
                    cnt[v]++;
                    if (cnt[v] >= n) return false; // 有负环
                }
            }
        }
    }

    return true;
}

这个版本在题目里最常见。

九、如果要判“图中任意负环”

上面模板判的是：

从源点 s 可达的负环

如果题目要求判整张图是否存在任意负环，常用做法有两个。

做法一：超级源点

建一个新点 0，向所有点连一条权值 0 的边，然后从 0 跑 SPFA。

这样整张图所有点都可达，就能检测整图负环。

做法二：所有点初始入队

更常见的写法是：

把所有点都放进队列
dist[i] = 0
直接开始跑

模板如下：

bool detect_negative_cycle(int n) {
    queue<int> q;
    for (int i = 1; i <= n; i++) {
        dist[i] = 0;
        inq[i] = true;
        cnt[i] = 1;
        q.push(i);
    }

    while (!q.empty()) {
        int u = q.front();
        q.pop();
        inq[u] = false;

        for (auto e : g[u]) {
            int v = e.to;
            long long w = e.w;
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                if (!inq[v]) {
                    q.push(v);
                    inq[v] = true;
                    cnt[v]++;
                    if (cnt[v] >= n) return true;
                }
            }
        }
    }
    return false;
}

十、SPFA 和 Bellman-Ford 的关系

可以把它们理解成：

Bellman-Ford：暴力扫所有边
SPFA：只扫“最近被更新的点”的出边

所以 SPFA 是 Bellman-Ford 的优化实现，而不是另一个完全不同的理论体系。

十一、SPFA 和 Dijkstra 的对比

Dijkstra

只能处理 非负边
复杂度优秀
最短路首选

SPFA

可以处理负边
能判负环
最坏复杂度不稳

所以竞赛里通常是：

无负边：Dijkstra
有负边/判负环：Bellman-Ford 或 SPFA
卡 SPFA：要小心题目是否故意针对它

十二、常见优化

SPFA 有两个很经典的启发式优化。

1. SLF（Small Label First）

如果新入队点的 dist 比队首还小，就插到队首。
这样更小的点优先处理，有时会快很多。

一般用 deque 实现。

模板

void spfa(int s, int n) {
    for (int i = 1; i <= n; i++) {
        dist[i] = INF;
        inq[i] = false;
    }

    deque<int> q;
    dist[s] = 0;
    q.push_back(s);
    inq[s] = true;

    while (!q.empty()) {
        int u = q.front();
        q.pop_front();
        inq[u] = false;

        for (auto e : g[u]) {
            int v = e.to;
            long long w = e.w;
            if (dist[u] != INF && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                if (!inq[v]) {
                    if (!q.empty() && dist[v] < dist[q.front()]) q.push_front(v);
                    else q.push_back(v);
                    inq[v] = true;
                }
            }
        }
    }
}

2. LLL（Large Label Last）

如果队首点的距离过大，就把它扔到队尾。
这个优化也比较经典，但实现和收益常常不如 SLF 直观。

OI 里最常见的是：

普通队列版
deque + SLF 版

十三、典型应用：差分约束

SPFA 在差分约束里非常常见。

例如约束：

[ x_v - x_u \le w ]

可以转化为一条边：

[ u \to v,\ w ]

然后：

求可行解
判是否无解（有负环）

这类题里 SPFA 经常出现，因为：

图里可能有负边
需要判负环
不一定是单纯的最短路问题

十四、竞赛里常见坑

1. 别把 SPFA 当万能最短路

很多新手会觉得：

“SPFA 能负边，也能正边，那我以后全用它。”

这是不对的。
因为在无负边图上，Dijkstra 通常更稳、更快，也更不容易被卡。

2. 最坏复杂度真的可能炸

不是说“理论最坏”，而是 真的有人专门卡 SPFA。
尤其在一些老题、模板题、出题人熟悉数据构造的题里，SPFA 很危险。

3. 判负环时计数别写错

最常见两种计数：

记录入队次数 cnt[v]
记录路径边数估计

一般推荐用 入队次数，更稳、更常见。

4. `INF` 要够大

const long long INF = 1e18;

图上边权可能很大，距离也可能累加很大，别用太小的无穷。

5. 判整图负环和判源点可达负环不是一回事

从源点出发跑：只能判源点可达部分
整图判负环：要超级源点或所有点初始化入队

这个在题目里非常容易看漏。

十五、一句话理解 SPFA

SPFA 的本质就是：

把 Bellman-Ford 中“无脑扫描所有边”改成“只从最近被更新的点继续扩展”，从而减少很多无效松弛。

十六、总结

SPFA 的关键词可以概括为：

单源最短路
可处理负边
可判负环
Bellman-Ford 队列优化
最坏复杂度不稳

你可以把它记成下面这张口袋版：

什么时候用

有负边
需要判负环
差分约束

什么时候别乱用

普通非负边最短路
题目可能卡复杂度
大图高强度数据

最常用模板

普通队列 SPFA
判负环版 SPFA
deque + SLF 优化版

Better-OI

Dijstra

Dijkstra 算法简介与 C++ 实现模板

一、算法概述

特点

二、算法原理

三、C++ 模板实现

Bellman-Ford

Bellman-Ford 简介

核心思想

为什么能判负环

适用场景

时间复杂度

标准 OI 模板

模板细节解释

1. 为什么用边集而不是邻接表

2. 为什么要写 dist[u] != INF

3. 提前结束优化

一个简单例子

和 Dijkstra 的对比

Dijkstra

Bellman-Ford

Bellman-Ford 的一个常见变形

竞赛里要注意的坑

1. INF 要开大

2. 判负环只判“从源点可达”的负环

3. “恰好 k 条边” 和 “最多 k 条边” 不一样

一句话总结

Floyd

Floyd 算法简介

算法原理

算法特点

OI 风格 C++ 模板

算法说明

使用场景

和 Dijkstra / Bellman-Ford 对比

SPFA

SPFA 简介

一、SPFA 是怎么来的

二、核心思想

三、为什么它是对的

四、时间复杂度

理论最坏复杂度

实际表现

五、适用场景

六、标准 OI 模板

1. 单源最短路模板

七、模板解释

1. inq[] 是干什么的

2. 为什么出队时要 inq[u] = false

3. 为什么不用 vis[]

八、负环判定

判定原理

判负环模板（从源点可达）

更常用的负环判定模板

九、如果要判“图中任意负环”

做法一：超级源点

做法二：所有点初始入队

十、SPFA 和 Bellman-Ford 的关系

十一、SPFA 和 Dijkstra 的对比

Dijkstra

SPFA

十二、常见优化

1. SLF（Small Label First）

模板

2. LLL（Large Label Last）

十三、典型应用：差分约束

十四、竞赛里常见坑

1. 别把 SPFA 当万能最短路

2. 最坏复杂度真的可能炸

3. 判负环时计数别写错

4. INF 要够大

5. 判整图负环和判源点可达负环不是一回事

十五、一句话理解 SPFA

十六、总结

什么时候用

什么时候别乱用

最常用模板

2. 为什么要写 `dist[u] != INF`

1. `INF` 要开大

1. `inq[]` 是干什么的

2. 为什么出队时要 `inq[u] = false`

3. 为什么不用 `vis[]`

4. `INF` 要够大