如何科学地判断负环和求有负权图的最短路（几乎完更）
主要内容复读自 EI 的博客。部分符号可能会有不同。
起因是这样的，想做一道 0/1 分数规划+判负环的题，结果发现出题人卡了 bfs 判负环，放了 dfs 判负环过。遂到谷群求教 dfs 判负环的有关事宜，结果被群友教育了，于是就来学了qwq。
（虽然说这个算法只能做整数边权的图，做不了上面那道题
目标：\(O(m\sqrt{n}\log|w|)\) 时间内对整数边权的有向图判断负环/求出最短路。
1. 前置知识
首先我们要对原来的图进行一些改造。
1. Pricing
如果你学过 Johnson 全源最短路 的话，那你应该知道这样一个操作：
如果能对每个点 \(i\) 求出点权 \(p(i)\)，使得 \(\forall u,v:w_p(u,v):=w(u,v)+p(u)-p(v)\geqslant0\)，那么我们可以更新边权为 \(w_p(u,v)\)，然后在新的图上跑 dijkstra。
如果你不会这个操作，这里是对该方法的简单解释。
注意到对于任意一条 $s$ 到 $t$ 的路径都有 $w_p(s,v_0)+w_p(v_0,v_1)+\cdots+w_p(v_k,t)=w(s,v_0)+w(v_0,v_1)+\cdots+w(v_k,t)+p(s)-p(t)$，由 $p(s)-p(t)$ 是定值知该操作对最短路径没有影响。又有保证了 $\forall u,v:w_p(u,v)\geqslant0$，于是我们就能使用 dijkstra 算法了。另外如果进行了一些赋权操作后出现了负环，那么原来的图也必定存在负环（证明方法同上，因为是环路，所有的 \(p\) 值都消掉了）
很不幸的是在 Johnson 全源最短路中，我们的做法是先跑了一遍 SPFA，所以这个求法对我们的问题没有帮助。
2. Scaling
但是如果图的边权是整数，那么如果你学过弱多项式复杂度费用流，你会知道这样的操作：
令 \(w'(u,v):=\left\lceil\dfrac{w(u,v)}{2}\right\rceil\)，则 \(w(u,v)=\begin{cases}2w'(u,v),&w(u,v)\bmod2=0\\2w'(u,v)-1,&w(u,v)\bmod2=1\end{cases}\)
此时我们先对调整后的边权求出权值 \(p'(i)\)，那么我们令 \(p(i)=2p'(i)\)，则容易发现 \(w_p(u,v)=w(u,v)+p(u)-p(v)\geqslant-1\)。
此时我们就将问题转化为了在 \(O(m\sqrt{n})\) 时间内调整 \(p(i)\) 使 \(\forall u,v:w_p(u,v)\geqslant0\)。
对上述方法的一些补充
Q1: 你这个操作会不会导致误判负环啊。A1: 首先如果直接将边权除以二什么都不会影响。对于奇数我们做上取整相当于将边权增加了 \(0.5\)，那么只要原来的图里没有负环，新的图里也不会有负环。这样我们就不会出现误判负环的情况。
Q2: 你没说上面算法的递归终点啊。
A2: 事实上上述操作的目的是将边权都变成非负的。注意到 \(\left\lceil-\dfrac{1}{2}\right\rceil=0\)，事实上进行足够多次上述操作后负数都会变成 \(0\)，这时图中所有的边权都是非负的，令 \(p(i)\equiv0\) 即可。
然后你还需要一些离散数学知识。
3. Dilworth 定理相关
温馨提示：该部分内容较多。建议先粗略阅读，学完算法后再来这里看具体细节。
Dilworth 定理参考自北大的《组合数学》。后面的那个定理是我自己证的。
实际上这部分内容就有些剧透的意味了。
直接上定理：
设有限偏序集 \((X,\leqslant)\) 的宽度为 \(m\)，则存在划分 \(X=\bigcup\limits_{i=1}^{m}C_i\)，使得每一个 \(C_i\) 都是链。
我们可以用 OI 中的东西来简单理解：
考虑一个有限 DAG。在这里我们定义 DAG 中的链为一个点集，其中任意取出两个点 \(x,y\)，必有 \(x\) 能到达 \(y\) 或 \(y\) 能到达 \(x\)（也就是说链可以使不连续的）。相对地，我们定义 DAG 中的反链为一个点集，其中从该点集中的任何一个点经该 DAG 都不能到达点集中的其他任何一个点。特别地，单独的一个点既是链又是反链。我们定义这条反链的长度为这个点集的大小，同时定义一个 DAG 的宽度为这个 DAG 的最长反链的长度。
然后这个定理的意思就是宽度为 \(m\) 的 DAG 一定可以被划分成不相交的 \(m\) 个链。（实际上划分就已经有不相交的意思了）
事实上还有一个类似的定理，不过证明起来简单地多。
定理：我们称 DAG 的高度为 DAG 中最长链的长度，则高度为 $n$ 的 DAG 能被划分为 $n$ 个反链。证明：我们每次取出 DAG 中所有出度为 \(0\) 的点，这些点显然构成了一个反链。并且因为 DAG 中所有的极大链（即不存在其他的链使这条链包含于它）都一定包含一个出度为 \(0\) 的点，而最长链一定是极大链，故操作后的 DAG 的高度一定为 \(n-1\)。重复上述操作即得结论。
我们来证明一下 Dilworth 定理。不妨还是用 DAG 的语言进行叙述。
考虑使用数学归纳法。
- 如果 DAG 中只有 \(1\) 个点，显然成立。
- 假设原结论对有 \(1,2,\cdots,k-1\) 个点的 DAG 都成立，我们来考虑有 \(k\) 个点的 DAG。首先我们取一条极大链（即不存在其他的链使这条链包含于它） \(C\)，我们考虑去掉这个链后的 DAG。
- 若去掉这个链后的 DAG 的宽度是 \(m-1\)，那么原结论成立。
- 否则，去掉链后的 DAG 的宽度一定是 \(m\)。这个时候我们考虑去掉链后的 DAG 的一个反链 \(A=\{a_1,a_2,\cdots,a_m\}\)。然后，我们定义 \(S^-\) 为原 DAG 上能到达 \(A\) 中的点的集合， \(S^+\) 为从 \(A\) 中的点经原 DAG 上的边能到达的点的集合。特别地，\(A\) 中的点同属两个集合。容易发现 \(S^-\cup S^+\) 就是原 DAG，并且 \(S^-\cap S^+=A\)。这个时候我们就可以根据归纳假设，将 \(S^-\) 和 \(S^+\) 都划分为 \(m\) 个链。记包含了 \(a_i\) 的链为 \(S_i^-\) 和 \(S_i^+\)，容易发现将 \(S_i^-\) 和 \(S_i^+\) 通过 \(a_i\) 拼成一条新链，原来的 DAG 就被划分为了 \(m\) 个链。
关于证明中的两个“容易发现”
1.1 反证，首先 \(S^-\cup S^+\) 中的点一定在原 DAG 上。若存在原 DAG 上的点 \(x\) 满足 \(x\notin S^-\) 且 \(x\notin S^+\)，则 \(A\cup \{x\}\) 是一个反链，有原 DAG 的宽度至少为 \(m+1\)，矛盾。故 \(S^-\cup S^+\) 就是原 DAG。
1.2 首先 \(A\) 中的点一定属于 \(S^-\cap S^+\)。另一方面，设 \(x\in S^-\cap S^+\)，则存在 \(a_i,a_j\) 满足 \(x\) 能到达 \(a_i\)，\(a_j\) 能到达 \(x\)，故 \(a_j\) 能到达 \(a_i\)。因为 \(A\) 是反链，故只能有 \(a_i=a_j\)，即 \(x\) 能到达 \(a_i\) 且 \(a_i\) 能到达 \(x\)。又因为这是个 DAG，于是必有 \(x=a_i\)，即 \(x\in A\)。故 \(S^-\cap S^+=A\)。
2 我们来证明 \(a_i\) 在 \(S_i^-\) 中出度为 \(0\)。反证，若存在 \(x\in S_i^-\) 使 \(a_i\) 能到达 \(x\) 且 \(x\) 不为 \(a_i\)。由 \(S^-\) 定义知存在 \(a_j\) 使 \(x\) 能到达 \(a_j\)。故 \(a_i\) 能到达 \(a_j\) 且 \(a_i\neq a_j\)，这与 \(A\) 是反链矛盾。同理可证 \(a_i\) 在 \(S_i^+\) 中入度为 \(0\)。由此即得 \(S_i^-\cup S_i^+\) 是链。
放一张图（我自己画的）直观理解：
如左图，这是一个宽度为 \(3\) 的 DAG。我们第一步操作是选出了一条极大链（红色），然后发现去掉极大链后的 DAG 宽度还是 \(3\)。于是我们从去掉极大链后的 DAG 中取出一条反链（绿色），并定义 \(S^-\)（蓝色）和 \(S^+\)（黄色）。
然后看右图，根据归纳假设将两个集合分别划分成 \(3\) 条链，然后这些链可以通过中间的反链连接起来成为一条长链，于是原来的 DAG 就被划分为了 \(3\) 条链。
有了 Dilworth 定理，我们就可以证明下面的结论了：
对于一个结点数为 \(mn\) 的 DAG，必然存在长度至少为 \(m\) 的链或长度至少为 \(n\) 的反链。
证明：假设最长链的长度为 \(h\)，最长反链的长度为 \(w\)。反证，假设有 \(h<m\) 且 \(w<n\)。根据 Dilworth 定理，我们可以将原 DAG 划分成 \(w\) 个链 \(C_1,C_2,\cdots,C_w\)。计算 DAG 中的结点个数 \(S\)，得 \(S=|C_1|+|C_2|+\cdots+|C_w|\leqslant hw<mn\)，矛盾。原命题得证。
显然的推论：结点数为 \(n\) 的 DAG 中链和反链的最大长度必然有一个大于等于 \(\sqrt{n}\)。
2. 算法
我们只考虑原图中边权是 \(-1\) 和 \(0\) 的部分。严谨地说，我们记原图为 \(G=(V,E)\)，定义 \(E_p=\{(u,v)|w_p(u,v)\leqslant0\},\ V_p=\{v|\exist u:(u,v)\in E'\or(v,u)\in E'\},\ G_p=(V_p,E_p)\)。
然后我们对 \(G_p\) 进行缩点。容易发现若 \(G_p\) 的一个 SCC 中存在负边，那么一定会存在一个负环。若原图不存在负环，那么每个 SCC 中的边边权都是 \(0\)，不会产生任何影响，直接缩掉就行了。这样我们将 \(G_p\) 转化为了较容易处理的 DAG。
我们发现 DAG 有这样的一个性质：
取一个点集 \(S\)，使 \(\forall s\in S\)，\(s\) 经 \(G_p\) 可达的点都在 \(S\) 中。这样由 \(S\) 连出的边的边权都是正的。
然后我们将 \(S\) 内所有点的 \(p\) 值减 \(1\)。容易发现这个操作有两点影响：
- 我们成功地将连入 \(S\) 的负边变成了 \(0\) 边。
我们成功地让 S 连出的边权是 1 的边变成了 0 边，于是上面取子图缩点的步骤要从头再来。
好吧至少我们没有产生新的负边。
容易发现如果我们定义 \(S_u\) 为点 \(u\) 先经过一条 \(-1\) 边，再经 \(G_p\) 能到达的所有点（不包含 \(u\) 本身），那么我们就处理掉了一个点连出的所有负边。但这样做复杂度将高达 \(O(nm)\)。于是我们考虑一次处理掉多个点。
对于上面的方法，我们先对这个 DAG 定义一个图 \(K=(V_K,E_K)\)。\(V_K\) 由所有含有边权为 \(-1\) 的出边的点组成。\(E_K\) 的定义是这样的：对于 \(u,v\in V_K\)，若有 \(u\) 能先经过一条边权为 \(-1\) 的边，再通过 DAG 能够到达 \(v\)，则我们由 \(u\) 向 \(v\) 连一条边。那么接下来我们就对 \(K\) 进行操作。
进行具体操作之前我们先来画一下图，明确一下定义。
如图是缩完点后的 \(G_p\)，这是个 DAG。我们在这个 DAG 上定义了图 \(K\)（红色的点和边）。很明显 \(K\) 也是个 DAG。但是这张图里并没有画出 \(K\) 所有的边，这些红边只是描述了 \(K\) 上的可达性。也就是说在上面的图里，如果能从一个红点经红边到达另一个红点，那么在真正的 \(K\) 中这两个点之间就会连一条边。
然后我们就可以对 \(K\) 进行操作了。我们的方法是对 \(K\) 中的链和反链分别设计算法。
先看简单的反链。
考虑一个反链 \(A\)，根据定义，从其中任意取出两点 \(u,v\)，有 \(u\notin S_v\) 且 \(v\notin S_u\)。此时直接对 \(S:=\bigcup\limits_{u\in A}S_u\) 进行操作，那么从这条反链连出的所有的负边就都被处理掉了。容易发现复杂度是简单的 \(O(m)\)。
再来看链的情况。
考虑链 \(C=\{u_1,u_2,\cdots,u_n\}\)。根据性质我们不妨设 \(\forall 1\leqslant i\leqslant n-1: u_{i+1}\in S_{u_i}\)。我们的方法是，考虑定义这样一个点集 \(T_u\)，它由。然后依次对 \(T_{u_n},T_{u_{n-1}},\cdots,T_{u_1}\) 进行操作。
首先我们容易发现一开始有 \(T_{u_n}\subset T_{u_{n-1}}\subset\cdots\subset T_{u_1}\)。
但是，值得注意的是，在我们执行了若干个操作后，尚未执行操作的点集会发生变化。但仍然满足上述包含关系。
链和反链上的算法都讲完了，现在让我们把它们合起来。
前面说过结点数为 \(n\) 的 DAG 中链和反链的最大长度必然有一个大于等于 \(\sqrt{n}\)。我们只需要 \(O(m)\) 在 DAG 上做一次 dp 求每个点连出的最长链（这个是非常简单的），然后检查极大点构成的反链。这样我们就能一次处理掉根号个数的点。
事实上如果我们这么做的话，算法在根号次数内就会完成（这个证明我就不会了qaq
蒯来了 EI 的证明
经过 $\sqrt{|K|}$ 轮，集合大小每轮乘以一个不超过 $1 - \frac 1{\sqrt{|K|}}$ 的因子，那么集合变成原来的 $\leq 1/\mathrm{e}$ 倍，那么经过 $$\sum_{i\geq 0} \sqrt{\frac{|K|}{\mathrm{e}^i}} \leq \frac 1{1 - \mathrm {e}^{-1/2}} \sqrt{|K|}$$ 轮之后一定完成。3. 代 码 实 现
如果前面的理论部分还有细节不清楚，我们最后再讲解一下 EI 的实现。
#include <bits/stdc++.h>
using namespace std;
const int V = 5005, E = 5005;
int N, M;
int u[E], v[E], w[E];
int p[V];
bool mark[V];
vector<pair<int, int>> G[V], G2[V];
int t, N2;
stack<int> stk;
int dfn[V], low[V], belongs[V], topo[V];
void tarjan(int u) {
dfn[u] = low[u] = ++t; stk.push(u);
for (const auto &e : G[u]) {
int v = e.first, w = e.second + p[u] - p[v];
if (w > 0) continue;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (belongs[v] == -1) {
low[u] = min(low[u], dfn[v]);
}
}
if (dfn[u] == low[u]) {
topo[N2++] = u;
int v;
do {
v = stk.top(); stk.pop();
belongs[v] = u;
} while (v != u);
}
}
bool SCC() {
t = N2 = 0;
memset(dfn, 0, sizeof(dfn));
memset(mark, 0, sizeof(mark));
memset(belongs, -1, sizeof(belongs));
for (int i = 0; i != N; ++i) G2[i].clear();
for (int i = 0; i != N; ++i) if (!dfn[i]) tarjan(i);
#ifdef ELEGIA_DEBUG
int marks = 0;
#endif // ELEGIA_DEBUG
for (int i = 0; i != N; ++i) for (const auto &e : G[i]) {
int j = e.first, w = e.second + p[i] - p[j];
if (w < 0) {
if (belongs[i] == belongs[j]) return true;
mark[belongs[i]] = true;
#ifdef ELEGIA_DEBUG
++marks;
#endif // ELEGIA_DEBUG
}
G2[belongs[i]].emplace_back(belongs[j], w);
}
#ifdef ELEGIA_DEBUG
cerr << "marks: " << marks << endl;
#endif // ELEGIA_DEBUG
return false;
}
int vis[V], pref[V], sec[V], len[V], chn[V];
vector<int> delay[V];
void chain(int start) {
int len = 0;
while (start != -1) {
chn[++len] = start;
start = sec[start];
}
memset(vis, 0, sizeof(vis));
queue<int> q;
for (int i = len; i; --i) {
int s = chn[i];
for (const auto &e : G2[s]) {
int v = e.first, w = e.second;
if (vis[v] || w >= 0) continue;
vis[v] = i;
q.push(v);
}
for (int u : delay[i]) if (!vis[u]) {
vis[u] = i;
q.push(u);
}
delay[i].clear();
while (!q.empty()) {
int u = q.front(); q.pop();
for (const auto &e : G2[u]) {
int v = e.first, w = e.second;
if (w > 0) {
if (w < i) delay[i - w].push_back(v);
continue;
}
if (vis[v]) continue;
vis[v] = i;
q.push(v);
}
}
}
}
bool refine() {
while (true) {
{
bool flag = false;
for (int u = 0; u != N; ++u) {
for (const auto &e : G[u]) {
int v = e.first, w = e.second + p[u] - p[v];
if (w < 0) {
flag = true;
break;
}
}
if (flag) break;
}
if (!flag) return false;
}
if (SCC()) return true;
memset(len, 0, sizeof(len));
memset(pref, -1, sizeof(pref));
memset(sec, -1, sizeof(sec));
int longest = -1;
for (int i = 0; i != N2; ++i) {
int u = topo[i];
for (const auto &e : G2[u]) {
int v = e.first, w = e.second;
if (w > 0) continue;
if (pref[v] != -1 && len[v] > len[u]) {
len[u] = len[v];
pref[u] = pref[v];
}
}
if (mark[u]) {
int opt = 0;
for (const auto &e : G2[u]) {
int v = e.first, w = e.second;
if (w >= 0) continue;
if (pref[v] != -1 && len[v] > opt) {
opt = len[v];
sec[u] = pref[v];
}
}
if (++opt > len[u]) {
len[u] = opt;
pref[u] = u;
} else sec[u] = -1;
}
if (longest == -1 || len[u] > len[longest])
longest = u;
}
int size = 0;
queue<int> q;
memset(vis, 0, sizeof(vis));
for (int i = N2 - 1; i >= 0; --i) {
int u = topo[i];
if (vis[u] || !mark[u]) continue;
++size;
for (const auto &e : G2[u]) {
int v = e.first, w = e.second;
if (!vis[v] && w < 0) {
vis[v] = true;
q.push(v);
}
}
while (!q.empty()) {
int u = q.front(); q.pop();
for (const auto &e : G2[u]) {
int v = e.first, w = e.second;
if (!vis[v] && w <= 0) {
vis[v] = true;
q.push(v);
}
}
}
}
#ifdef ELEGIA_DEBUG
cerr << "antichain: " << size << ", chain: " << len[longest] << endl;
#endif // ELEGIA_DEBUG
if (size < len[longest]) chain(longest);
for (int i = 0; i != N; ++i)
p[i] -= vis[belongs[i]];
}
}
bool priceScaling() {
int L = 0;
for (int i = 0; i != M; ++i)
while ((1 << L) <= -w[i]) ++L;
memset(p, 0, sizeof(p));
for (int d = L - 1; d >= 0; --d) {
for (int i = 0; i != N; ++i) G[i].clear();
for (int i = 0; i != N; ++i) p[i] *= 2;
for (int i = 0; i != M; ++i)
G[u[i]].emplace_back(v[i], -((-w[i]) >> d));
if (refine()) return true;
#ifdef ELEGIA_DEBUG
cerr << "finish scaling 2^" << d << endl;
#endif // ELEGIA_DEBUG
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr); cout.tie(nullptr);
cin >> N >> M;
for (int i = 0; i != M; ++i) {
cin >> v[i] >> u[i] >> w[i];
--u[i]; --v[i];
}
if (priceScaling()) {
cout << "NO\n";
} else for (int i = 0; i != N; ++i)
cout << p[i] << " \n"[i == N - 1];
return 0;
}
