初级图论全解

这篇文章，搬运了此篇，但是MARKDOWN重修。建议还是看原本。
搬运目的：为了宣传上述文章，帮助更多人。

基本定义

边导出子图：选出若干条边，以及这些边所连接的所有顶点组成的图称为 边导出子图。
点导出子图：选出若干个点，以及两端都在该点集的所有边组成的图称为 点导出子图。
闭合子图：定义在有向图上。点集 V
导出的 闭合子图 是所有 V
可达的点的点导出子图。其精确定义为若 x
在子图内，则 x
的所有出点和出边均在子图内的原图子图；等价于每个点能到的所有点都在子图中。

1. 最短路

最短路是图论最基本的一类问题。

下文记 disu
表示从源点到节点 u
的最短路，n
为节点数 |V|
，m
为边数 |E|
。

1.1 Bellman-Ford

Bellman-Ford 是一种非常暴力的求解最短路的方法（BF 之于 dijkstra 如同 FF 之于 dinic）。

称一轮 松弛 为对于每一条边 (u,v)
，用 disu+wu,v
更新 disv
。我们断言每轮至少有一个节点的最短路被更新，松弛 n−1
轮即可。

正确性证明：设源点为 1
。在 1→u
的最短路 1→p1→⋯→u
中，对于每个节点 pi
，1→p1→⋯→pi
也一定是 1→pi
的最短路，反证法易证。所以一个节点的最短路一定由另一个节点的最短路扩展而来。因为最短路最多有 n−1
条边，而第 i
轮松弛会得到边数为 i
的最短路，故至多只需松弛 n−1
轮。

该算法还可以判断一张图上是否存在负环。如果在第 n
轮松弛时仍有节点的最短路被更新，那么图存在负环。

算法的时间复杂度为 O(nm)
。

1.2 Dijkstra

dijkstra 是基于 贪心 的最短路算法，适用于 非负权图。

称 扩展 节点 u
为对于 u
的所有出边 (u,v)
，用 disu+wu,v
更新 disv
。

在已经得到最短路的节点中，取出没有扩展过的距离源点最近（即 dis
最小）的节点并扩展。因为没有负权边，所以取出的节点的最短路长度单调不降。

如何判断一个节点已经取到了最短路？实际上不需要判断，每次取出的节点恰取到了其最短路。根据边权非负以及 dijkstra 的贪心算法流程，可以通过归纳法与反证法证明这一点。

归纳假设已经扩展过的节点 p1,p2,⋯,pk−1
在扩展时均取到了其最短路。pk
为没有被扩展的 dis
最小的节点。

pk
的最短路一定由 pi(1≤i 的最短路扩展而来，不可能出现 dis(pi)+w(pi,pk+1)+w(pk+1,pk) 的情况。否则由于边权非负，w(pk+1,pk)≥0
，所以 dis(pi)+w(pi,pk+1) ，即当前 dis(pk+1) ，与 dis(pk)
的最小性矛盾。

初始令源点的 dis
为 0
，假设成立，因此算法正确。

取出 dis
最小的节点的过程可以用优先队列 priority_queue 维护。每次扩展 u
时，若 disu+wu,v ，那么将 (v,disu+wu,v)
即节点编号和它更新后的 dis
作为二元组丢进优先队列。尝试取出节点时，以 disu+wu,v
为关键字取出最小的二元组，则它对应的节点编号就是我们要找的节点。

注意，一个节点可能有多个入边并多次进入优先队列。但当它第一次被取出时，得到的一定是最短路。为此，需要记录 vis[i] 表示一个节点是否被扩展过。若当前取出节点已经被扩展过，则忽略。也可以判断是否有当前二元组的第二个元等于第一个元（节点编号）的 dis
，若不等说明当前节点被扩展过了。否则复杂度将退化为 m2logm
。

算法的时间复杂度为 O(mlogm)
。

P4779 模板题代码。

#include 
using namespace std;
#define pii pair<int, int>
const int N = 1e5 + 5;
int n, m, s, dis[N];
vector<pii> e[N];
int main() {
  cin >> n >> m >> s;
  for(int i = 1; i <= m; i++) {
    int u, v, w;
    scanf("%d%d%d", &u, &v, &w);
    e[u].push_back(make_pair(v, w));
  }
  memset(dis, 0x3f, sizeof(dis));
  dis[s] = 0;
  priority_queue<pii, vector<pii>, greater<pii>> q; // 优先取权值较小的 pair
  q.push(make_pair(0, s)); // 注意第一关键字要放到前面
  while(!q.empty()) {
    auto t = q.top();
    q.pop();
    int id = t.second; // 不要搞反了，编号是 second
    if(t.first != dis[id]) continue;
    for(auto _ : e[id]) {
      int it = _.first, d = t.first + _.second;
      if(d < dis[it]) q.push(make_pair(dis[it] = d, it));
    }
  }
  for(int i = 1; i <= n; i++) cout << dis[i] << " ";
  return 0;
}

1.3 SPFA 与负环

关于 SPFA，___。

SPFA 本质上是队列优化的 Bellman-Ford。

松弛节点 x
时找到接下来有可能松弛的点，即与 x
相邻且 最短路被更新的点 并压入队列。此外，记录一个点是否在队列中，若是则不压入，可以显著减小常数。

时间复杂度相比 BF 并没有差异，仍为 O(nm)
。在一般图上效率很高，但是可以被特殊数据卡成平方，所以能使用 dijkstra 时不建议 SPFA。

注意，如果使用 SPFA 求解点对点的最短路径（费用流 EK），当队头为目标节点时不能结束算法。因为一个节点进入队列并不等同于它已经取到了最短路。

SPFA 判负环：若一个点 进入队列 超过 n−1
次（注意不是 被松弛，因为一个节点被松弛并不意味着进队），或 最短路边数 大于 n−1
，则整张图存在负环。对于后者，记录 li
表示从源点到 i
的最短路长度，松弛时令 lv←lu+1
并判断是否有 lv 即可。

判入队次数要慢于最短路长度，因此推荐使用后者。

P3385 模板题代码。

#include 
using namespace std;
const int N = 2e3 + 5;
int n, m, dis[N], len[N], vis[N];
vector<pair<int, int>> e[N];
void solve() {
  cin >> n >> m;
  for(int i = 1; i <= n; i++) e[i].clear();
  for(int i = 1; i <= m; i++) {
    int u, v, w;
    cin >> u >> v >> w;
    e[u].push_back(make_pair(v, w));
    if(w >= 0) e[v].push_back({u, w});
  }
  queue<int> q;
  memset(dis, 0x3f, sizeof(dis)); // dis 的初始值需要赋成 0x3f
  memset(vis, 0, sizeof(vis)); // 清空 vis =.=
  q.push(1), len[1] = dis[1] = 0; // 读题，从顶点 1 出发 =.=
  while(!q.empty()) {
    int t = q.front();
    q.pop(), vis[t] = 0;
    for(auto it : e[t]) {
      int d = dis[t] + it.second, to = it.first;
      if(d < dis[to]) {
        dis[to] = d, len[to] = len[t] + 1;
        if(len[to] == n) return puts("YES"), void();
        if(!vis[to]) vis[to] = 1, q.push(to);
      }
    }
  }
  puts("NO");
}
int main() {
  int T;
  cin >> T;
  while(T--) solve();
  return 0;
}

1.4 Johnson

前置知识：Bellman-Ford & Dijkstra。
Johnson 算法用于解决 带有负权边 的 全源最短路经 问题。所谓全源最短路径问题，就是求解图上任意两个点之间的最短路。

Johnson 算法的巧妙之处在于为每个点赋予 势能 hi
。正如物理意义上的势能，从一个点出发，到达另一个点，无论走什么路径，势能的总变化量是一定的。物理实际启发我们将边 (u,v)
的新权值 w′u,v
设置为 wu,v+hu−hv
。

考虑一条路径 S→p1→p2→⋯→T
，其原长为

L(S→T)=wS,p1+wp1,p2+⋯+wpl,T
新的长度为

L′(S→T)=(hS+wS,p1−hp1)+(hp1+wp1,p2−hp2)+⋯+(hpl+wpl,T−hT)
化简后不难看出 L(S→T)=L′(S→T)+hT−hS
。对于固定的 S,T
，原图的路径对应到新图上面，长度增加了 hS−hT
。这与路径经过了哪些节点无关，而只与 S,T
有关。因此，原图上 S→T
的最短路在新图上 仍为最短路。

接下来考虑求解原问题。

由于负权，我们无法使用 dijkstra 求解最短路。多次 SPFA 或 BF 的时间复杂度不优秀。尝试应用上述分析，合理地为每个点赋权值，从而消去图上的所有负权边。

为使 w′(u,v)≥0
，只需 w(u,v)+hu≥hv
。这是什么？三角形不等式！若初始图中无负环，那么我们一定可以不断松弛最终得到这样一个 h
。具体地，初始令所有 h
等于 0
，然后使用 BF 算法进行 n−1
轮松弛。

松弛在 n−1
轮后必然结束，否则意味着原图存在负环，因为上述操作等价于建立虚点 0
并向所有节点连一条边权为 0
的边，并求出 0→i
的最短路 hi
。

操作结束后，我们更新每条边的权值 w′(u,v)=w(u,v)+h(u)−h(v)
。根据一开始的分析，得到的新图与原图任意两点间的最短路径不变，且 没有负边权，可以使用 n
轮 ijkstra 求解任意两点间的最短路。

最后不要忘了 将 u→v
的最短路加上 hv−hu
。

算法的时间复杂度为 O(nmlogm)
。

模板题 P5905 代码。

#include 
using namespace std;
#define pii pair<int, int>
const int N = 3e3 + 5;
int n, m, h[N], dis[N];
vector<pii> e[N];
int main() {
  cin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int u, v, w;
    cin >> u >> v >> w;
    e[u].push_back(make_pair(v, w));
  }
  for(int i = 1; i <= n; i++) {
    bool found = 0;
    for(int j = 1; j <= n; j++)
      for(auto it : e[j])
        if(h[j] + it.second < h[it.first])
          found = 1, h[it.first] = h[j] + it.second;
    if(i == n && found) puts("-1"), exit(0);
  }
  for(int i = 1; i <= n; i++) {
    long long ans = 0;
    for(int j = 1; j <= n; j++) dis[j] = i == j ? 0 : 1e9;
    priority_queue<pii, vector <pii>, greater <pii>> q;
    q.push(make_pair(0, i));
    while(!q.empty()) {
      auto t = q.top();
      q.pop();
      int id = t.second;
      if(t.first != dis[id]) continue;
      for(auto _ : e[id]) {
        int it = _.first, d = t.first + h[id] - h[it] + _.second;
        if(d < dis[it]) q.push(make_pair(dis[it] = d, it));
      }
    }
    for(int j = 1; j <= n; j++) ans += 1ll * j * (dis[j] + (dis[j] < 1e9 ? h[j] - h[i] : 0));
    cout << ans << endl;
  }
  return 0;
}

1.5 Floyd 与传递闭包

和 Johnson 一样，Floyd 也可以解决带有负权边的全源最短路径问题。

Floyd 算法的核心只有四步：枚举 k
，枚举 i
，枚举 j
，用 dis(i,k)+dis(k,j)
更新 dis(i,j)
。

注意枚举顺序，作为中转点的节点必须在最外层枚举。初始令所有有边的点对 (u,v)
之间的 dis(u,v)
等于 w(u,v)
。

正确性证明仍然是归纳法。考虑 u→v
的最短路 u→p1→⋯→pk→v
。令 pi
为 p
当中最后一个被枚举到的点，若 dis(u,pi)
和 dis(pi,v)
已经取到最短路，那么 dis(u,v)
自然能正确地被更新为最短路。

根据初始化操作，边界情况 u→v
的最短路只有一条边时 dis(u,v)
取到最短路 w(u,v)
成立。由数学归纳法，假设成立，算法正确性得证。

算法的时间复杂度为 O(n3)
。不仅好写，而且在稠密图上运行效率高于 Johnson，因此 Floyd 也是数据规模较小时最短路算法的不二之选。

此外，Floyd 还可以求传递闭包（笔者一直以为传递闭包是个动词，没想到是名词）。有向图 G
的传递闭包定义为 n
阶布尔矩阵 T
，满足 Ti,j
当 i
可达 j
时等于 1
，否则为 0
。只需将内层操作改为 Ti,j←Ti,j∨(Ti,k∧Tk,j)
即可。

bitset 可以将传递闭包的复杂度优化至 n3w
。对于稀疏图，缩点后传递闭包可以做到 nmw
。
什么？这么简单的东西你还要代码？

1.6 例题

I. P5304 [GXOI/GZOI2019] 旅行者

一道有趣的题目。

O(mlogmlogk)
做法的核心思想是 二进制分组 后跑最短路。两个不同的数二进制必定至少有一位不同，正确性得以保证。在洛谷要开 O2 才能过。

随机分组也可以，做 k
次的正确性是 1−(34)k
。类似题目如 CF1314 D。

O(mlogm)
做法的思想很巧妙。预处理每个特殊城市到点 i
的最短距离 fi
和对应城市 fri
，以及点 i
到所有特殊城市的最短距离 gi
和对应城市 toi
。对于每条边 u→v
，若 fru≠tov
，则用 fu+wu,v+gv
更新答案。正确性证明见 srf 的题解。

II. P1462 通往奥格瑞玛的道路

答案满足可二分性，二分 + dijkstra 即可。

时间复杂度 nlognlogc
。

. P4568 [JLOI2011] 飞行路线

注意到 k
很小，跑最短路时记录当前用了几条免费边即可,这叫分层图最短路。

时间复杂度 O(mklog(mk))
。

IV. P7916 [CSP-S 2021] 交通规划

k=2
是 “狼抓兔子”，平面图最小割转对偶图最短路。

k>2
的时候也差不多。平面图转对偶图后，最外层会出现 k
个节点。对于一个节点 i
，设其逆时针方向的射线颜色和顺时针方向的射线颜色分别为 Li
和 Ri
，取值为 0
或 1
，表示白或黑。若 Li=Ri
，那么 i
相邻的两个射线处于同一连通块是最优的。因为任何将它们分割开的方案，通过调整使得它们在同一连通块后代价总会减少。

显然，(Li,Ri)
等于 (0,1)
和 (1,0)
的节点个数相同。每个 (0,1)
和每个 (1,0)
匹配，路径经过的所有边两端颜色不同。因此这样的匹配方案总能给出一个划分方案及其代价。

关键性质是任意两点的匹配不会相交，即不会出现 a 且 a
匹配 c
，b
匹配 d
。若相交，则调整法可证不交时不劣。

因此，首先求出所有 (0,1)
和 (1,0)
点之间两两最短路。求匹配最小代价可以类似括号匹配，破环成链后区间 DP，时间复杂度 O(knmlog(nm)+k3)
。

V. CF1163F Indecisive Taxi Fee

经典题。

首先求出 1→n
的最短路 P=p0(=1)−→e1p1−→e2⋯−→eLpL(=n)
。设 t=(u,v)
。

当 t∉P
时，新的最短路要么不变，要么经过这条边。很显然，强制经过某条边 (u,v)
的最短路等于 1
到 u
的最短路，加上 v
到 n
的最短路，再加上 wt
；或者交换 u,v
的地位，两种情况取个最小值。设 1
到 u
的最短路为 pre(u)
，v
到 n
的最短路为 suf(v)
，则答案可写为

min(w§,w(u,v)+min(pre(u)+suf(v),suf(u)+pre(v))
当 t∈P
时，新的最短路要么是 w§−wt+x
，要么是强制不经过 t
的最短路（当 x≤wt
时必然是前者，但是分类讨论太麻烦了，不如两种情况直接取 min
）。现在唯一的问题转化为对每条边 t
，求解 L(t)
表示强制不经过 t
的最短路长度。

考虑求出原图的任意一棵从 1
和从 n
开始的最短路树 T1
和 Tn
。需保证这两棵树上 1
与 n
之间的路径相等，即设 P=T1(1→n)
，那么 P
应当等于 Tn(1→n)
。这可以先求出 T1
以及对应的 P
，再根据 P
求 Tn
。显然，pre(u)
等于 T1
上 u
的深度，suf(v)
等于 Tn
上 v
的深度。

设 pr(u)
表示 T1(1→u)
与 P
的最后一个交点（或者说，pr(u)
等于 T1
上 n
和 u
的 LCA），su(v)
表示 Tn(v→n)
与 P
的第一个交点。换种角度理解，pr(u)
就是从 1
开始到 u
的最短路上，最后一个与从 1
到 n
的最短路径重合的节点，对于 su(v)
同理。

对于一条不属于 P
的边 (u,v)
，我们尝试强制经过这条边（两个方向都要试，以下仅讨论一个方向）。对于从 u→v
而言，根据上述分析，最短路为 T1(1→u)∪(u,v)∪Tn(v→n)
，其长度为 C(u,v)=pre(u)+w(u,v)+suf(v)
（定义 C(e)
表示强制经过 e
的最短路）。

容易发现，C(u,v)
这个数值可以用于更新所有路径 P
上从 pr(u)
到 su(u)
之间所有边 ei
对应的 L(ei)
，因为 C(u,v)
对应的路径没有经过这些边。对于每一条不属于 P
的边，其 C
值会对一段 P
上对应的路径产生贡献。离线扫描线用 multiset 维护即可求出每个 L(ei)
。

因此，对于 t∈P
的情况，答案为 min(w§−wt+x,L(t))
。

等等？是不是有些不严谨？笔者在思考本题时，遇到的一个最大的问题是如何证明对于去掉某条 ei
后，新的最短路 P′
上必然存在一条边 e′j=(p′j−1,p′j)
使得 ei
在 pr(p′j−1)
和 su(p′j)
之间。这个命题等价于 P′
上至少存在一条边 (u,v)
使得 1→u
的路径等于 T1(1→u)
，v→n
的路径等于 Tn(v→n)
，且 ei
不在 pr(u)
和 su(v)
之间 。其证明过于复杂，略去。详见 cf1163f - ycx’s blog。

VI. P3238 [HNOI2014] 道路堵塞

和上题一样的套路。

VII. P3573 [POI2014] RAJ-Rally

和上题一样的套路。

VIII. P2761 软件补丁问题

注意到总的补丁数量很少，所以从初始态能够到达的态一定不会太多。状压 + SPFA 即可。

2. 差分约束

前置知识：Bellman-Ford 和 SPFA。

2.1 算法介绍

差分约束问题为给出若干形如 xa−xb≤c
或 xa−xb≥c
的不等式，求任意一组 x
的解。

我们发现，只要 xa,xb
同在不等号某一侧时符号不同，那么所有限制均可以写为 xi+c≥xj
。

三角形不等式 再一次出现。我们从 i→j
连一条长度为 c
的边，然后再从超级源点 0
向每个点连长度为 0
的边防止图不连通（或者一开始令所有 dis=0
并将所有点入队），跑最短路，每个点的最短路长度就是一组解。

因为一般这个 c
有负值（全是非负的话所有数相等不就行了嘛），所以用 Bellman-Ford 或 SPFA 求解最短路。显然，若出现负环则无解。

时间复杂度 O(nm)
。模板题 P5960 代码如下。

#include 
using namespace std;
const int N = 5e3 + 5;
int n, m, vis[N], dis[N], len[N];
vector<pair<int, int>> e[N];
int main() {
  cin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int u, v, w;
    cin >> u >> v >> w, e[v].push_back(make_pair(u, w));
  }
  queue<int> q;
  for(int i = 1; i <= n; i++) q.push(i), vis[i] = 1;
  while(!q.empty()) {
    int t = q.front();
    q.pop(), vis[t] = 0;
    for(auto it : e[t]) {
      int to = it.first, d = dis[t] + it.second;
      if(d < dis[to]) {
        dis[to] = d, len[to] = len[t] + 1;
        if(len[to] == n) puts("NO"), exit(0);
        if(!vis[to]) q.push(to), vis[to] = 1;
      }
    }
  }
  for(int i = 1; i <= n; i++) cout << dis[i] << " ";
  return 0;
}

2.2 解的字典序极值

一般而言差分约束系统的解没有 “字典序” 这个概念，因为我们只对变量之间的差值进行约束，而变量本身的值可以随着某个变量取值的固定而固定，所以解的字典序可以趋于无穷大或无穷小。

字典序的极值建立于变量有界的基础上。不妨设希望求出当限制 xi≤0
时，整个差分约束系统的字典序的最大值。注意到 xi≤0
可以看成三角形不等式 (x0=0)+0≥xi
，所以我们建立虚点 0
，将其初始 dis
赋为 0
，并向其它所有变量连权值为 0
的边（这等价于一开始令所有点入队且 dis=0
）。

求解差分约束系统时我们使用了三角形不等式，将其转化为最短路问题。这给予它很好的性质：通过 SPFA 求得的一组解，恰为字典序最大解。

首先明确一点，对于一条从 u→v
的边权为 w(u,v)
的边，它的含义为限制 xu+w(u,v)≥xv
。

考虑 0
到每个节点的最短路树。对于树上每条边均满足 xi+w(i,j)=xj
。若 xi+w(i,j)>xj
，那么整张图还可以继续松弛，若 xi+w(i,j) ，说明 j
的最短路不是由 i
继承而来，因此 (i,j)
必然不会作为树边出现。

这说明树上的 xi+w(i,j)≥xj
的限制已经取满，取到了等号（xj
不能再大了，再大就破坏了限制），每个变量都取到了其理论上界，自然就得到了字典序最大解。

对于字典序最小解，我们限制 xi≥0
。因此所有节点向 0
连边 w(i,0)=0
。字典序最小即字典序最大时的相反数。因此，考虑将所有变量取反，那么限制也要全部取反，体现为将图中所有边（包括所有新建的边 i→0
）的 方向（而不是边权）取反。然后求字典序最大解，再取相反数即可。

2.3 例题

I. P5590 赛车游戏

好题。

转换思路，与其设置边权使路径长度相等，不如设置路径长度去拟合边权的限制。

设 di
为 1→i
的最短路，只需保证对于所有边 (u,v)
有 wu,v=dv−du
即可使任意一条简单路径长相等。于是 1≤dv−du≤9
，转化为 du+9≥dv
与 dv−1≥du
，差分约束求解即可。注意不在 1→n
的任意一条路径上的边没有用，这些边不应计入限制，随便标权值。

II. P7515 [省选联考 2021 A 卷] 矩阵游戏

神题。

构造题可以考虑调整法。

固定第一行第一列全都为 0
，可以仅根据 b
的限制推出剩下来整个矩阵 ai,j
。注意到对矩阵第 i
行的每个数进行 −ri,+ri,−ri,+ri,⋯
操作后，仍然满足 b
的限制，列同理。因此我们设将 ai,j
加上 (−1)jri+(−1)icj
，那么有 0≤ai,j+(−1)jri+(−1)icj≤106
。不过这样当 i,j
奇偶性相同时 ri,cj
前的符号相同，出现 和约束，这是无法处理的。

我们希望对于每一行，任意两个相邻的位置的 ri
的系数相反。对于每一列同理。因此考虑 黑白染色，得到系数 (−1)i+j+1ri+(−1)i+jcj
。不难发现 ri
与 cj
前符号一定不同且满足限制，可以使用差分约束求解，时间复杂度 O(Tnm(n+m))
。

题目有些卡常，注意常数。SPFA 判最短路长度而不是入队次数会跑得快一些。

III. P4926 [1007] 倍杀测量者

化乘法为加法不难想到取对数，考虑对没有女装的限制建出差分约束图，若出现负环则一定有人女装。对于固定分数的人 i
，让 0,i
之间互相连边权分别为 logxi
和 −logxi
的边即可。

套一个二分，时间复杂度 O(nslogV)
。

IV. [AGC056C] 01 Balanced

考虑将 0
看做 1
，1
看做 −1
，那么问题的限制是差分约束的形式。

对于限制 L−1,R
，互相连长度为 0
的边。

对于相邻的两个位置 i−1
和 i
，题目要求 |vi−vi−1|=1
。看似没有办法描述。不过当限制变为 |vi−vi−1|≤1
时，可以在 i
和 i−1
之间互相连长度为 1
的边，并且最大化 v
的字典序（差分约束本身自带字典序极值性质）。

我们惊讶地发现，在保证字典序最大的情况下，不可能出现 vi=vi−1
的情况。模拟最短路的过程，可以证明每个 vi
的奇偶性是固定的，并且相邻两个 v
的奇偶性一定不同：0
边连接的两个点的下标奇偶性相同（题目保证了这一点），1
边则奇偶性不同。

整个过程可以想象成，将一些位置初始加入集合 S
，表示它们的 v
值为 0
。每次考虑增加当前的 v
值 cur
，并将 S
的极长连续段向左向右扩展，新扩展的位置的 v
值就等于 cur
。这是因为，考虑 vl−1=vr+1=c
且 [l,r]
的 v
值还没有确定。我们希望最大化 v
的字典序，自然 vl=c+1
，为此，vr
也必须等于 c+1
，这样才能让 [l,r]
这一段的字典序最大，否则从 l
开始的上升段会变短。感性理解一下，我们希望将上升段尽量往前放，而当两端 v
值已经固定相等时，一个上升段必须对应一个下降段，所以为了把所有上升段堆到最前面，我们不得不在最后放一个下降段。

这题思想还是挺高妙的，虽然是差分约束但是形式很新颖，需要猜一些性质（或者说，不要被固有思维所限制）才能得到最终解法。

边权只有 0/1
，考虑 01 BFS，时间复杂度 O(n+m)
。

若为了避免出现 |vi−vi−1|=1
的限制而单纯求前缀和得到 v
，我们会建出带有负权边的差分约束网络。用 SPFA 求解会 TLE。

代码。

V. P3530 [POI2012] FES-Festival

很好，限制非常差分约束。建出图来，先跑一遍负环判无解。但如何满足不同的 t
值数量最大呢？差分约束显然无法解决这样的问题。然后就不会了（大雾）。

首先强连通分量缩点（具体见 5.2 小节），不同 SCC 之间独立，因为我们可以将两个 SCC 之间的距离拉得任意远。而一个 SCC 内部的答案就是任意两点最短路径的最大值 +1
：使最短路距离增加的只有一类边，而一类边的 边权只有 1
，因此若 u→v
的最短路径为 w
，那么从 u→v
的路径上所有点必然取遍了 tu∼tv
这 w+1
个值。

因为图是稠密图，因此使用 floyd 算法求解任意两点之间的最短路。答案即每个 SCC 的答案之和。

时间复杂度三方。

3. 最小生成树

3.1 Kruskal

非常经典的最小生成树算法，基础中的基础。

贪心地将所有边按照边权从小到大排序并依次枚举每一条边，如果当前边两端点不连通则加入该边。连通性用并查集维护。时间复杂度 O(mlogm)
。

正确性考虑反证法，如果存在一条边 (u,v)
使得 (u,v)∉T
且在加入 (u,v)
后 T
上形成的环当中 w(u,v)
不是最大权值，那么断掉权值最大的边可以得到一棵更小的生成树 T′
。但这与贪心策略矛盾，因为 (u,v)
一定在被断掉的这条边之前被枚举到并加入 T
。

kruskal 重构树见 简单树论 第一章，简单概括一下就是通过在并查集合并时新建虚点从而维护合并关系。

3.2 Prim

稍微了解一下。

维护 V,E
，每次找到 ∉E
且一端 ∈V
且另一端 ∉V
的权值最小的边 (u,v)
，并将 v
加入 V
，(u,v)
加入 E
。初始 V
可以包含任意一个节点。

另一种理解方式是维护每个节点的权值 cv
表示从 v
出发的所有边 (v,u)
当中，使得 u∈V
的最小权值。每次取出权值最小的点加入 V
，将最小生成树边权加上 cv
，并利用 v
的所有出边更新剩下来不在 V
当中所有点的权值。

“取出权值最小的点” 这一过程可以类似 dijkstra 算法，通过优先队列实现。因此，算法的时间复杂度为 O(mlogm)
。

3.3 Boruvka

boruvka 求解最小生成树的方法较为神奇。

考虑若干个点，对于每个点而言，如果想要使得它有边相连，那么与它相邻当中的边权最小的边必然入选。这一点通过反证法可以证明。

因此，对于每个点，求出与它相连的边权最小的边。将所有这些边加入最小生成树当中。除去至多 n2
条重边，每条边会使连通块个数 −1
，因此一次这样的过程可以使连得通块个数严格减少一半。这样，对剩余连通块继续上述过程至多 log2n
轮即可求得 MST。注意，在选择边权最小的边时，不能选择两端已经在同一连通块的边。

算法的时间复杂度为 O(mlogn)
。

Boruvka 在解决某类最小生成树问题上非常有用。它形如给定一张 n
个点的完全图，两点之间的信息可以通过某种计算得出。n
一般在 105
级别。

3.4 例题

I. P4180 [BJWC2010] 严格次小生成树
首先 kruskal 求出最小生成树，然后枚举所有边 (u,v)
，用它替换最小生成树上 u,v
之间权值最大或 严格 第二大的边即可。需要严格第二大是因为最大值可能和 wu,v
相等。时间复杂度线性对数。

代码。

*II. CF888G Xor-MST
Boruvka 的有趣应用。

根据异或和最小值不难想到对 ai
建出 01 Trie。对于 01 Trie 上某个状态 p
的子树所包含的所有节点 Vp
，显然它们内部之间已经连通，因为 Vp
跨过该状态向其它状态 q
所表示的节点 Vq
连边的代价大于在 Vp
内部连边的代价。这是因为跨过连边时，根据异或的性质，代价在 p
对应位或其高位有值，但内部连边时 p
对应位及其高位没有值。

因此，考虑计算答案。若 p
的左右儿子均有节点，那么需要在 Vlsp
和 Vrsp
之间连一条边使得 Vp
连通。枚举 Vlsp
当中所有权值 v
并求出 rsp
的子树中与 v
异或和最小的权值 u
（01 Trie 基本操作），那么 minu⊕v
即为连边代价。

由于一个节点最多作为 lsp
被枚举 logV
次，所以即使不启发式合并，时间复杂度也是严格 nlog2V
。使用启发式之后可以将一个 logV
变成 logn
，其实没啥用。

4. 无向图连通性

以下两章内容均与 tarjan 算法有关。Tarjan 老爷子真是神。

无向图和有向图的连通性是图论重要的一部分。

4.1 相关定义

无向图连通性的相关术语有 割点 和 割边（桥）。

两者的定义十分类似，分别是删去后 使连通分量个数增加 的节点或边，且它们都是 无向图 上的定义。显然，一个孤立点或一张仅有一条边构成的无向图唯二的端点都不是割点，但后者唯一的边是割边。

注意百度百科上将割边定义在无向连通图上。这是不严谨的。非连通图的割边为它的每个连通分量的割边的并。

与割点相对应的概念是 点双连通图，定义为 不存在割点 的 无向连通 图。根据割点的定义，孤立点和由一条边连接的点对均视作点双连通图。一张图的极大点双连通子图称为 点双连通分量（V-BCC）。

与割边相对应的概念是 边双连通图，定义为 不存在割边 的 无向连通 图。根据割边的定义，孤立点是边双连通图，但由一条边连接的点对不是边双连通的。一张图的极大边双连通子图称为 边双连通分量（E-BCC）。

由于 “不存在割边” 意味着对于任意两个不同节点 u
和 v
，它们之间不存在必经边。因此，删去任意一条 u→v
的路径后，u,v
仍然连通。这说明任意一条边属于 至少一个简单环（这里，简单环定义为不经过重复的 边 的环）。同理，若每条边至少属于一个简单环，容易证明该图边双连通。我们得到了一张无向连通图是边双连通图的等价判定：任意一条边属于至少一个简单环。

缩点 是 OI 界常见算法，简单地说就是将某种类型的连通分量根据等价性或独立性缩成一个点，原来连接两个不同连通分量的边变成了连接它们缩点后形成的两个点。根据连通分量的类型不同，缩点可分为无向图上的边双连通分量缩点，点双连通分量缩点，以及将在第五章介绍的有向图上的强连通分量（SCC）缩点。

边双和点双缩点后均得到一棵树，而 SCC 缩点后得到一张有向无环图。

4.2 割点的 Tarjan 算法

接下来介绍 tarjan 求割点的方法。

笔者默认读者已经了解 dfs 树与 dfs 序，不再赘述。做一个说明：dfs 序表示对一棵树进行深度优先搜索得到的 节点序列，而 时间戳 dfn 表示每个节点在 dfs 序中的位置。这两个概念需要加以区分。

笔者希望提出一种新的理解 tarjan 算法的方式。网上众多博客讲解该算法的时候，low 数组仿佛凭空出现，抽象的定义让很多初学者摸不着头脑，从提出问题到解决问题这样一条逻辑链的不完整性让我们无法感受到究竟是怎样的灵感促使了这一算法的诞生。

定义节点 x
的子树表示该节点在 dfs 树上的子树，包含节点本身，记作 T(x)
。

4.2.1 非根节点的割点判定法则

以下讨论基于 x
不为当前连通分量的 dfs 树的根节点。

对于 T(x)
，若其中存在节点 y∈T(x)
满足 y
不经过 x
能到达的所有点都被困在 T(x)
内，则 x
是割点，因为删掉 x
后 y
和 T(x)
外的节点（由于 x
不是根，所以 T(x)
外的节点存在）不连通，连通分量个数增加；反之每个 y
都与 T(x)
外部连通，所以整个连通分量仍然连通。

怎么表示 “不经过 x
能到达的所有点被困在 T(x)
内” 呢？

考虑在 dfs 序对应的 时间戳 上做手脚。注意到 T(x)
内所有点的时间戳 dy(y∈T(x))
都不小于 dx
，所以设计状态 fx
表示 x
仅经过一条非树边 所能到达的节点的时间戳的最小值（注意 f
并不是 low 数组）。

为什么 “仅经过一条非树边”：一个割点可能存在于多个点双，对于处在一个 “8” 字形结构最底部的节点 y
，它可以通过一条非树边上翻到结构中间的节点 x
，然后再走一条非树边上翻到结构顶部的节点 u
，这样在求 x
是否是割点时就不合法了，因为 fy
被 从 y
出发只有经过 x
才能到达的点 u
更新，不符合 “不经过 x
” 的假设。只经过一条非树边保证我们求到的 fy
是 y
不需要经过中间点而能够直接到达的节点的时间戳最小值。

题外话，这其实也说明了为什么对于 u
已经访问过且在栈中的邻居 v
，我们用 dfn[v] 而非 low[v] 更新 low[u]。

考虑 x
在 dfs 树上的所有儿子 y1,y2,⋯,yc
，按访问顺序排列。不存在 yi≠yj
使得它们的子树之间有连边，否则在 dfs 的过程中，设 i ，访问 yi
的子树时就可以直接访问到 yj
的子树，所以 yj
在访问 yi
时被访问，与 yj
是 x
在 dfs 树上的儿子矛盾。这说明 x
各个儿子之间的 独立性。换句话说，对于无向图，任何非树边连接的两个点在 dfs 树上一定为祖先后代关系。这是无向图上 tarjan 算法正确性的重要保证。读者需要充分理解这一性质，下文将重复出现。

由于 T(yi)
内部连通，所以删去 x
时 T(yi)
内部每个节点与 T(x)
外的连通性相同。也就是说，要么 T(yi)
所有节点均与 T(x)
外连通，要么均不连通。这说明 x
某个儿子的子树 T(yi)
内部节点的 等价性。

因此，对于 x
的每个儿子 yi
，若 T(yi)
内部 存在 一个点使得它不经过 x
就到达 T(x)
外的节点，那么删掉 x
后 T(yi)
和 T(x)
外连通。我们希望 存在 yi
使得它 不满足 这样一个条件。

先考虑用已知的信息描述 “T(yi)
内部存在点 p
使得它不经过 x
就可以到达 T(x)
外的节点”。若存在 p∈T(yi)
使得存在一条 不经过 x
的路径 p→p1→p2→⋯→pc→q
，满足 q
为路径上第一个 T(x)
外的节点（根据独立性，p
和 pi
均在 T(yi)
内），当且仅当 pc
能够通过一条非树边跳出 T(x)
。

这意味着若存在 p∈T(yi)
使得它不经过 x
可以到达 T(x)
外的节点，那么考虑它 第一次 到达 T(x)
外某个节点 q
的不经过 x
的路径，最后一步使得它从 T(yi)
内跳到了 T(x)
外。因为 q
在 x
之前被访问过（否则 q
在访问 yi
时成为 T(yi)
的一个节点），所以 dq 。这意味着必然存在对应的 pc∈T(yi)
使得 fpc 。

反之，若存在 p∈T(yi)
使得 fp ，那么 T(yi)
内存在一个点使得它不经过 x
可以到达 T(x)
外的节点。p
就是一个这样的节点。

这样，我们就证明了判定 x
是割点的法则：

当且仅当 存在一条 树边 x→y
，使得 y
子树内 不存在 节点 u
使得 fu 时，x
是割点。

这等价于对于所有 u∈T(y)
均有 fu≥dx
，即 minu∈T(y)fu≥dx
。

为此，只需再记录一个数组 gx
表示 x
的子树内所有节点 u∈T(x)
的 fu
的最小值，即可在线性时间内判断每个节点是否是割点。

fu
等于 u
在 dfs 树上所有 返祖边 (u,v)
对应的 dv
的最小值与 du
取 min
。

注意 v
不是 u
在 dfs 树上的父亲，因为此时 (u,v)
为 树边。如果忽略这一点，那么在求解割点时 不会 影响结果（判定是 minfu≥dx
，有等号），但求解割边时会使判断错误（判定是 minfu>dx
，无等号）。求解割边时会再次提到这一点。
即 fu=min(du,minv∈anc(u)∧(u,v)∈Edv)
，而 gu=minv∈T(x)fv
，根据树形动态规划，

gu=min(fu,minv∈son(u)gv)
综上，我们推得

gu=min(du,minv∈anc(u)∧(u,v)∈Edv,minv∈son(u)gv)
gu
恰好代表了 u
的 low 数组。

三个由逗号分隔的式子分别对应了：

将 low[u] 初始化为 dfn[u]。
对于 u
在 dfs 树上的祖先 v
，用 dfn[v] 更新 low[u]。因为是无向边，所以对于任意 (u,v)∈E
，只要 v
在此之前已经被访问过了，那么 v
在 dfs 树上一定是 u
的祖先（考虑反证法，若不成祖先后代关系，对 lca(u,v)
应用子树独立性即可推出矛盾）。
对于没有被访问过的 u
的邻点 v
，搜索 v
后回溯。这意味着在 dfs 树上 v
是 u
的子节点。因此用 low[v] 更新 low[u]。
这就是著名的 Tarjan 算法。

4.2.2 根节点

别忘了还有 x
为根节点的情况。

此时，若 x
在 dfs 树上有超过一个儿子，那么根据子树独立性，去掉 x
后各儿子子树不连通使得连通块个数增加，所以 x
为割点。反之容易证明 x
不是割点。

综上，使用 tarjan 算法求解有向图 G
上所有割点的时间复杂度为 O(n+m)
。模板题 P3388 代码如下。

笔者再次强调，以下代码仅在求解割点时正确。求解割边需要进行额外的特判，原因在上文已经分析过。

#include 
using namespace std;
const int N = 1e5 + 5;
int n, m, root, dn, dfn[N], low[N], cnt, buc[N];
vector<int> e[N];
void dfs(int id) {
  dfn[id] = low[id] = ++dn;
  int son = 0;
  for(int it : e[id]) {
    if(!dfn[it]) {
      son++, dfs(it), low[id] = min(low[id], low[it]);
      if(low[it] >= dfn[id] && id != root) cnt += !buc[id], buc[id] = 1;
    }
    else low[id] = min(low[id], dfn[it]);
  }
  if(son >= 2 && id == root) cnt += !buc[id], buc[id] = 1;
}
int main() {
  cin >> n >> m;
  for(int i = 1, u, v; i <= m; i++) cin >> u >> v, e[u].push_back(v), e[v].push_back(u);
  for(int i = 1; i <= n; i++) if(!dfn[i]) root = i, dfs(i);
  cout << cnt << endl;
  for(int i = 1; i <= n; i++) if(buc[i]) cout << i << " ";
  return 0;
}

4.3 割边

4.3.1 Tarjan 法

Tarjan 算法求割边的思路和求解割点的思路差不多。

尝试探究一条边是割边的充要条件。

首先，如果一条边是非树边，那么割掉它显然不影响连通性，因为树边使得整张图连通。因此，e=(u,v)
是割边的 必要条件 是 e
为树边。

不妨设 v
是 u
的子节点。割掉 e
后若整张图不连通，那么一定是 T(v)
和 T(v)
以外的部分不连通。这说明 T(v)
内部所有节点必须跨过 e
才能到达 T(v)
外，即 e
是沟通 T(v)
内外的 桥。

考虑如何快速判断这种情况。根据求解割点的经验，不难发现 e
为割边等价于 gv>du
，即 low[v] > dfn[u]。相较于割点判定法则，没有等号的原因是此时删去的是边而非节点，所以只要子树能绕过 e
到达 T(v)
以外的部分，包括 u
本身，那么 e
就不是割边。根据子树独立性，这意味着子树通过一条非树边能够到达 u
或其祖先。再根据时间戳的性质（祖先的时间戳小于后代的时间戳），有该判定法则。

求解割边时有个小细节，就是判断返祖边。

一个简陋的想法是 dfs 时记录父亲，若当前边 (u,v)
指向当前节点的父亲（v=fa(u)
），那么跳过这条边。这样有个问题，就是出现 重边 时错误，因为会将树边的重边也判为树边。

解决方法是额外记录边的编号。对于 vector 存图而言，我们在 push_back 当前边指向的节点时，还要将当前边的编号一并压进去。对于链式前向星而言，技巧是 成对变换：初始令 cnt=1
，这样一来，每条边及其反边在链式前向星中存储的编号分别为 2
和 3
，4
和 5
，以此类推。这样，给当前边编号异或 1
即可得到反边编号。

综上，dfs 时记录当前节点 u
，以及从 fa(u)
dfs 下来时经过的边 fe
的编号 idfe
，那么对于 u
的所有出边 e=(u,v)
，只需判断 ide
是否等于 idfe
（vector）或者 idfe⊕1
（链式前向星）即可判断 e
是否为树边，从而决定是否要忽略掉当前边。

算法的时间复杂度为 O(n+m)
。

4.3.2 树上差分法

给出另一种求解割边的方法。

根据子树的独立性，所有非树边 ne
连接的两个端点 (u,v)
一定具有祖先后代关系。这说明在 dfs 树 T
上 u,v
之间是一条竖直的链。

因此，求出原图 G
的任意一棵生成树 T
，对于不在 T
上的边 (u,v)
，将 u,v
之间所有边标记为非树边即可。可以通过树上差分实现。

算法的时间复杂度为 O(n+m)
。

4.4 边双连通分量

求解边双连通分量是非常容易的。

容易证明，对于一张无向连通图 G
，若 e
为其割边，那么对于 G
的任意子图 G′=(E′,V)⊆G
，若 e∈E′
，则必然有 e
为 G′
的割边。

删去 G
的所有割边，可以得到若干连通块。由于所有割边均被删去，所以这些连通块必然是边双连通图。因此，它们就是原图的边双。

得到边双连通分量后记录每个点所在边双编号，容易对 G
进行边双缩点。

接下来介绍利用 tarjan 实现边双连通分量缩点的方法，类似方法可应用在点双缩点上。

先通过 tarjan 算法找到所有割边，再 dfs 找出所有边双连通分量是可行的，但是太麻烦了。我们希望一遍 dfs 就可以做到求解割边 + 找出所有边双连通分量。为此，我们需要对 tarjan 算法进行一些改进。

具体地，维护一个 栈 S
，表示已经访问过的，还没有形成完整边双 的所有节点。每次 dfs 进入一个节点时，先将其压入栈内。这一步骤出现在各种连通分量的缩点算法中。

设当前节点为 u
，v
为当前遍历到的 u
在 dfs 树上的子节点。若 (u,v)
被判定为割边，即 low[v] > dfn[u]，那么我们断言，从栈顶到 v
的所有节点（的点导出子图，下文忽略）形成了一个边双。将这些节点弹出。

考虑证明上述结论。不妨设 原图 割掉 (u,v)
后形成的连通块分别为 u∈U
和 v∈V
。由于判定 (u,v)
为割边是在离开节点 v
回到节点 u
时进行的，所以当前栈中节点 v
往上一直到栈顶均属于 V
：越靠栈顶越晚被访问，而 V
中节点全都在 v
之后被访问，且 U∩S
中节点一定在 v
之前被访问（时刻记住 (u,v)
是割边）。

对于 V
内部所有割边，我们在 dfs 到它们时就已经处理掉了它们形成的边双。因此，V∩S
内部一定 不存在割边，恰好为一个边双。反证法，若 V∩S
可以被分成两个边双 V1
和 V2
，考虑 V1
和 V2
之间唯一一条割边 (x∈V1,y∈V2)
（如果割边不唯一，则与割边定义矛盾）。由于 x,y∈T(v)
，所以 x,y
这条割边一定会在从 v
回溯到 u
之前被处理掉。不妨设 dfs 树上 x
是 y
的祖先，我们在离开 y
回溯到 x
时，会将 x,y
判定为割边，从而将 V2
弹出 S
，与 V2⊆S
矛盾。结论得证。

整个算法可以看成不断从原图上断开一条 “偏僻” 的割边，剥下一层连通分量的过程。“偏僻” 定性描述就是剥下的连通分量不存在割边（已经断开的割边不算），那么这个连通分量自然就是一个边双。对应到缩完点后形成的树上，就是每次通过一条割边剥下一个叶子节点（每个节点都是一个边双）。

上述思想在点双缩点和 SCC 缩点时也会运用到，读者需要仔细体会。

算法的时间复杂度是优秀的 O(n+m)
。代码见例题 III.

4.5 点双连通分量

见 高级图论 第三章圆方树，点双相关性质同样在该部分介绍。

4.6 例题

I. P3469 [POI2008] BLO-Blockade

一道 tarjan 求割点的练手好题。

由于题目求的是有序对，因此不妨设封锁节点 u
后形成的连通块大小分别为 s1,s2,⋯,sk
。不难求得答案为 ∑si(n−si)
。

不要忘记 u
本身形成了一个大小为 1
的连通块，以及除去所有判定 u
是割点的节点 v
形成的连通块后还有一个大小为 sk=n−1−∑i=1k−1si
的连通块。

时间复杂度 O(n)

II. SP15577 STC10 - Blockade

双倍经验题。

III. P2860 [USACO06JAN] Redundant Paths G

题目相当于求添加最少的边数使得整张图变成一个边双，即不存在割边。

考虑边双缩点，得到的树 T
上所有边都是原图上的割边。根据求割边的结论，如果在 (u,v)
之间加一条边，设 U
为 u
所在边双在缩点后的树上对应的节点，V
同理，那么相当于将 U,V
之间简单路径上的所有边在原图上变成非割边。

因此，我们希望用最少的路径覆盖 T
的每一条边。对此有经典结论（或者直接感性理解），答案即 T
的叶子个数除以 2
上取整。

证明这是答案下界非常容易，因为每一条链至多消灭掉两个叶子到它唯一相邻的点的边。当只有两个节点的时候特殊讨论一下，这是平凡的。接下来给出一个达到该下界的构造方法。

称两个节点匹配表示在最终方案中，存在一条连接它们的链。

首先，当叶子个数为奇数时，将一个叶子和度数 ≥3
的节点匹配后可以转化为叶子数量为偶数的情况。如果不存在度数 ≥3
的节点，则 T
为一条链，与叶子个数为奇数矛盾。

考虑先将所有叶子任意两两配对，再调整。如果在当前方案中，存在一条边 (u,v)
没有被覆盖，考察断掉 (u,v)
后 u,v
分别所在的连通块 U,V
。

U
或 V
不可能只有一个叶子（这里的叶子是相对于原树而言的，即在原树 T
上是叶子，而不是 U
本身的叶子），因为若非，则该唯一的叶子和另外某个叶子匹配时必然经过 (u,v)
，与 (u,v)
没有被覆盖矛盾。

同理可以证明 U
或 V
不可能有奇数个叶子。

根据上述结论，当前方案必然是 U
的所有偶数个叶子两两匹配，V
的所有偶数个叶子两两匹配。

不妨设 U
某两个配对的叶子为 u1,u2
，它们在以 u
为根时的 LCA 为 ud
，对于 V
同理，定义 v1,v2
和 vd
。

当前的方案是 u1→ud→u2
以及 v1→vd→v2
上的所有边被覆盖，但通过调整，令 u1
和 v1
，u2
和 v2
匹配，则 ui→ud→u→v→vd→vi
上的所有边被覆盖。原来被覆盖的边仍被覆盖，同时 (u,v)
也被覆盖了。

因此，若对于当前方案，某条边没有覆盖，通过上述调整一定能使得原来被覆盖的边仍被覆盖，且该边也被覆盖，同时不改变原来 #leaf2
的链的条数。答案上界得证。

时间复杂度 O(n+m)
。

#include 
using namespace std;
const int N = 5e3 + 5;
int n, m, dn, deg[N], dfn[N], low[N];
int cn, col[N], stc[N], top;
vector<pair<int, int>> e[N];
void form(int id) {
  cn++;
  for(int x = 0; x != id; ) col[x = stc[top--]] = cn;
}
void tarjan(int id, int eid) {
  stc[++top] = id, dfn[id] = low[id] = ++dn;
  for(auto _ : e[id]) {
    if(_.second == eid) continue;
    int it = _.first;
    if(!dfn[it]) {
      tarjan(it, _.second);
      low[id] = min(low[id], low[it]);
      if(low[it] > dfn[id]) form(it);
    }
    else low[id] = min(low[id], dfn[it]);
  }
  if(!eid) form(id);
}
int main() {
  cin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int u, v;
    cin >> u >> v;
    e[u].push_back(make_pair(v, i));
    e[v].push_back(make_pair(u, i));
  }
  tarjan(1, 0);
  if(cn == 1) puts("0"), exit(0); // 这句判断其实不要也可以
  for(int i = 1; i <= n; i++)
    for(auto _ : e[i]) {
      int it = _.first;
      if(i < it && col[i] != col[it]) deg[col[i]]++, deg[col[it]]++;
    }
  int leaf = 0;
  for(int i = 1; i <= cn; i++) leaf += deg[i] == 1;
  cout << (leaf + 1 >> 1) << endl;
  return cerr << "Time: " << clock() << endl, 0;
}

IV. CF51F Caterpillar

题目要求不能存在环，我们自然地想到将所有边双缩成一个点。缩点后整张图会变成一棵森林，先处理每一棵树，再用连通块数量 −1
次操作将它们连起来。

考虑确定主链后如何用最少的操作使得一棵树变成毛毛虫。

对于除了主链以外的节点，考虑它是否作为最终挂在主链旁边的叶子。将主链看成根，具有祖先后代关系的点对不能同时被选中作为叶子，因为此时后代和主链之间隔了一个祖先，说明它到主链的距离 ≥2
，与题意不符。

因此相当于选择最多的节点使得这些节点之间没有祖先后代关系。我们的决策是选择所有叶子，因为若一个非叶子被选，我们一定可以取消选择它，并选择它的所有儿子，这样一定更优。不断调整即可得到该结论。

因此，最终保留的节点为所有主链上的节点和我们选中作为叶子的节点。这意味着对于某条路径 P
而言，它作为主链时对应的最少操作次数为 n−|P|−L
，其中 n
是树的大小，L
是主链外叶子节点的数量。

容易发现，当 P
的两端不是叶子时总可以调整使得 P
的两端是叶子且 n−|P|−L
不变或变小：向任意一个可以延伸的方向延伸，每次 |P|
增加 1
，但 L
要么不变（当延伸的点是非叶子），要么只减少 1
（当延伸的点是叶子）。

因此，设原图的叶子数量为 K
，则操作次数为 n−K+2−|P|
。n−K+2
是定值，我们希望 |P|
最大，自然是选取树的直径，同时恰好满足了 P
的两端是叶子的要求。

时间复杂度 O(n+m)
。代码。

5. 有向图连通性

5.1 强连通分量

强连通分量全称 Strong Connected Component，缩写 SCC。以下是一些定义和基本性质：

在有向图 G
中，若两个点 u,v (u≠v)
能够相互到达，则称这两个点是 强连通的，它们之间具有 强连通性。
在有向图 G
中，若任意两个节点都是强连通的，则称 G
是一张 强连通图。
有向图 G
的极大强连通子图被称为 G
的 强连通分量。
很显然，强连通性具有 传递性。
强连通分量在求解与连通性有关的题目时很有用，因为在只关心连通性时，同一强连通分量内的所有点是等价的。

5.2 SCC 缩点的 tarjan 算法

有了运用 tarjan 算法求解割点和割边，点双和边双缩点的先例，我们可以自然地将这些方法进行调整后用于求解强连通分量的缩点问题。

5.2.1 有向图 dfs 树的性质

我们考察有向图 dfs 树 Td
的形态，从而得到判定 SCC 的准则。

除了树边以外，Td
还有前向边，返祖边和横叉边。前向边和返祖边由无向图 dfs 树 Tu
的返祖边的两种定向方式得到，而横叉边是 Td
某个节点的两棵子树之间的连边。Tu
没有横叉边，因为 Tu
的子树具有独立性。

为什么 Td
会出现横叉边？因为一个 后访问到 的 SCC 可以向 之前访问 的 SCC 连边。例如 G=({1,2,3},{1→2,1→3,3→2})
，如果我们在 dfs 时先访问到了节点 2
，那么在访问节点 3
时就会找到从 3
到 2
的横叉边。

接下来讨论有向边 u→v
时，设 d=lca(u,v)
，d→u
的第一个节点为 u′
，v′
同理。设 fai
表示 i
在 Td
上的父亲。

尽管子树独立性变弱了，但我们还是能够发现一些性质：

对于前向边 u→v
，u
本身就能通过树边到达 v
，删去后自然没有任何影响。它甚至不影响连通性。
对于返祖边 u→v
，它会使 Td
上 v
到 u
的路径上所有点形成 SCC。多个返祖边相结合可以形成更大更复杂的 SCC。
对于横叉边 u→v
，u
的时间戳必然大于 v
的时间戳。否则，因 u→v
为横叉边，所以 d≠u
且 d≠v
。因为 u→v
，所以访问 T(u′)
时可以访问到 v
，所以 v∈T(u′)
，所以 d=u′
，矛盾。
综合上述三点，可知返祖边和横叉边均使得时间戳减小，只有树边使得时间戳增大。前向边不影响强连通性，所以 忽略所有前向边。

为了探究横叉边对强连通性的影响，考虑横叉边 u→v
，则 dfnv 。因此，对于 dfnv 的点对 (u,v)
，我们希望知道 v
可达 u
的充要条件。

若 dfnv ，则 v
可达 u
当且仅当 v
可达 d
。

充分性：显然。

必要性：考虑路径上的某一步 x→y
满足 dfnx ，显然这一步存在。因为 dfnx ，所以 x→y
是树边。当 y=u
时显然 u∈T(x)
；否则 y≠u
，则 u
在访问 x
之后，y
之前被访问，结合 x→y
是树边与 dfs 过程，u∈T(x)
。因此若 dfnv 且 v
可达 u
，则 v
可达 fau
。对树上路径 u→u′
所有节点依次应用该结论，则 v
可达 d
。

因此，对于横叉边 u→v
，其对强连通性产生影响当且仅当 v
可达 d
。

根据上述结论，有向图 tarjan 算法的 low 数组应定义为子树内所有节点 u
的 返祖边 u→v
，以及 v
可达 d
的 横叉边 u→v
的所有 v
的最小时间戳。有且仅有这些边影响强连通性。

5.2.2 算法流程

若 u,v
同时为 SCC 的最浅节点，易证 d
属于该 SCC，矛盾。因此每个 SCC 在 Td
上只有一个最浅节点。我们希望在每个最浅节点处统计其对应的 SCC。考虑定性描述「形成一个 SCC」的情形。

对于节点 u
，如果它不是某个 SCC 的最浅节点，由 SCC 的定义，它经过若干横叉边和返祖边一定可以到达更浅的，时间戳更小的祖先。相反，如果它是，那么它的整棵子树都不能跳出 x
到达更浅的祖先。根据这一点，我们得到判断 u
是某个 SCC 的最浅节点的充要条件：low[u] >= dfn[u]，其等价表述为 dfn[u] == low[u]。

类似边双缩点，我们时刻维护一个栈 S
，表示已经访问过但还没有确定形成 SCC 的节点。每次找到最浅节点 u
时，就将栈顶一直到 u
的所有节点弹出（由于 u
是该 SCC 第一个被访问到的节点，所以它在栈中位置最深），表示它们形成了一个 SCC。

算法的正确性依赖于弹出的所有节点的强连通性，以及对应 SCC 的极大性。证明方法和边双缩点的正确性证明差不多，这里简要说明一下。

强连通性：设弹出的点集为 V
，若 V
的点导出子图包含两个 SCC G1
和 G2
，设对应点集为 V1
，V2
，且 V1
的最浅节点为 u
，V2
的最浅节点为 v
，那么在 dfs 的过程中回溯到 v
时，由于将 v
判定成 G2
的最浅节点，同时 V2
是在 V1
之后访问的，所以不断弹栈直到弹出 v
的过程中，弹出的点集 V′
一定包含 V2
。与 V2⊆V
矛盾。

极大性：如果存在 v
与 u
强连通但 v∉V
，根据 u
的最浅性，v
一定在此之前被弹出。考虑弹出时对应最浅节点 v′
，则 dfn[v’] == low[v’]，即 v′
的子树内不存在能到达 u
的对强连通性产生影响的边，因此 u,v′
不属于同一 SCC。根据强连通性的传递性，u,v
不强连通，矛盾。

最后考虑如何求 low。对于树边 u→v
，自然用 low[v] 更新 low[u]，关键在于判断其它边的类型。

对于前向边 u→v
，用 dfn[v] 更新 low[u] 没有任何影响，因为 dfn[v] <= low[u]。
对于返祖边 u→v
，用 dfn[v] 更新 low[u]。
对于横叉边 u→v
，若 v
不可达 d
，则 v
在从 v′
回溯至 d
时必然已经被弹出，否则必然没有被弹出，即 v
可达 d
等价于 v
当前已经被弹出栈。正确性不做证明，感性理解：若 v
不可达 d
，那么 v,d
不强连通，因此若 v′
回溯至 d
时 v
未被弹出，则 v
和 d
一定会被一起弹出（从 x
回溯时只会弹出 T(x)
内的点），矛盾；同理，若 v
可达 d
，则 v,d
强连通，此时若 v
被弹出，由于 d
没有被弹出，所以 v,d
不强连通，矛盾（称之为感性理解的原因是存在 low 的正确性与弹出强连通分量正确性之间的循环论证，需要讨论更多细节才能严谨归纳）。因此，若 v
仍在栈内，则用 dfn[v] 更新 low[u]。
由于返祖边 u→v
使得 u,v
强连通，所以此时 v
一定没有被弹出，即 v
在栈中。

综上，可以得到如下做法：对于树边 u→v
，用 low[v] 更新 low[u]；对于非树边 u→v
，若 v
在栈中，则用 dfn[v] 更新 low[u]。

5.2.3 P3387【模板】缩点

因为可以多次经过同一个点，所以一旦进入某个 SCC，就一定可以走遍其中所有点，获得其中所有点权值之和的贡献。但是离开后就没法再回来了。

因此，将所有 SCC 缩点后得到 DAG，每个 SCC 缩点后的权值等于它所包含的所有点的权值之和，问题即找到最长的一条路径使得路径上所有 SCC 的权值之和最大。拓扑排序 DP 即可，时间复杂度 O(n+m)
。

由上我们可以发现 SCC 缩点经常和拓扑排序搭配在一起，因为缩点后的结果是一张有向无环图。

E-BCC 和 V-BCC 缩点后均可以得到一棵树，后者经过处理后就是圆方树。

#include 
using namespace std;
const int N = 1e4 + 5;
int n, m, cn, col[N];
int a[N], val[N], f[N], deg[N];
int top, stc[N], vis[N], dn, dfn[N], low[N];
vector<int> e[N], g[N];
void tarjan(int id) {
  vis[id] = 1, dfn[id] = low[id] = ++dn, stc[++top] = id;
  for(int it : e[id]) {
    if(!dfn[it]) tarjan(it), low[id] = min(low[id], low[it]);
    else if(vis[it]) low[id] = min(low[id], dfn[it]);
  }
  if(dfn[id] == low[id]) {
    col[id] = ++cn;
    while(stc[top] != id) col[stc[top]] = cn, vis[stc[top--]] = 0;
    vis[id] = 0, top--;
  }
}
int main() {
  cin >> n >> m;
  for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
  for(int i = 1; i <= m; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    e[u].push_back(v);
  }
  for(int i = 1; i <= n; i++) if(!dfn[i]) tarjan(i);
  for(int i = 1; i <= n; i++) {
    val[col[i]] += a[i];
    for(int it : e[i])
      if(col[i] != col[it]) {
        g[col[i]].push_back(col[it]);
        deg[col[it]]++;
      }
  }
  queue<int> q;
  for(int i = 1; i <= cn; i++) if(!deg[i]) q.push(i);
  while(!q.empty()) {
    int t = q.front();
    q.pop(), f[t] += val[t];
    for(int it : g[t]) {
      f[it] = max(f[it], f[t]);
      if(!--deg[it]) q.push(it);
    }
  }
  int ans = 0;
  for(int i = 1; i <= cn; i++) ans = max(ans, f[i]);
  cout << ans << endl;
  return 0;
}

5.3 例题

I. AT3945 [ARC092D] Two Faced Edges

强连通性相关首先考虑缩点建出 DAG。

对于连接 SCC (S1,S2)
之间的边，反向后使得 SCC 数量减少当且仅当 S1
在 DAG 上能够不经过该边到达 S2
。可以 O(nm)
求出任意两点之间的路径数对 2
取 min
判断。或者直接求路径数取模，出错的概率较小。

但是 SCC 内部的边就不好办了。如果反向 u→v
，我们断言如果 u
还能到达 v
那么连通性不变。

首先，对于所有 SCC 内部的点对 (x,y)
，从 x
到 y
要么必经 u→v
这条边，要么非必经。对于后者，反向 u→v
不影响 x,y
的连通性。对于前者，若 u
仍能到达 v
则 x
仍能到达 y
，否则反向边 v→u
不会产生任何影响。因为必经 u→v
所以 x
没有其它路径到达 v
，反向后 x,v
不连通自然引出 v→u
无用。

综上，我们得到了判断 SCC 内部边 u→v
反向后强连通性不变的充要条件：去掉 u→v
后 u
仍能到达 v
。这相当于对于一个点的每条出边 u→v1,v2,⋯,vi
都需求出 u
在不经过 u→vj
的情况下能到达哪些点。

考虑这是一个前缀 v1∼vj−1
和后缀 vj+1∼vi
的形式，因此正反各扫一遍，在扫每条出边时记录时刻每个点的可达性，并且在扫当前出边 u→v
时若 v
已经可达则将 u→v
标记为去掉后仍可达。由于依次加入所有出边时 SCC 内每个点只会被遍历一次，故总时间复杂度为 O(nm)
。

注意我们考虑的是保留从 u
出发的一段前缀或后缀的边时从 u
出发每个点的可达情况，因此当再次 dfs 到 u
时需及时返回，否则会遍历到从 u
出发的不属于当前前缀或后缀的边。
更进一步地，发现对于连接 SCC 之间的边 u→v
，我们也希望判断去掉该边后 u
能否到达 v
。这和 SCC 内部的边所需要求解的东西是一致的，因此可以将所有边等价考虑。只不过对于不同 SCC 之间的边，若 u⇝̸v
则反转 u→v
不会改变 SCC 个数，反之则改变。这和 SCC 内部的边恰好相反。这样就不需要显式地建出 DAG 了。

对整张图进行 O(nm)
的深搜会 T 飞掉，我们需要更加高效的算法。考虑每次找到 u
的所有出边中没有被访问的第一个点，可以使用 bitset 的 _Find_first() 实现。

具体而言，设 vis 表示各个节点是否被访问，e[u] 表示 u
的所有出点，则 (~vis & e[u])._Find_first() 即为所求。时

间复杂度 O(n3w)

启示：序列去掉一个位置的信息可由前缀和后缀合并得到。

II. P3436 [POI2006] PRO-Professor Szu

首先，容易发现若一个大小大于 1
的 SCC 或自环（下称为不合法结构）能够到达教学楼，则该不合法结构内部每个点到教学楼的路径数量都是无穷大。因此 SCC 缩点 + 建反图 拓扑排序，不合法结构不能入队。拓扑排序同时记录路径数 fi
表示从 i
到 n+1
的路径数量。因为不能取模，所以要对 36501
取 min
。

但题目没有保证每个点都能到教学楼（题面有误），所以需要先将反图上入度为 0
的非教学楼点入队跑一遍拓扑排序。注意此时不合法结构可以入队，因为它们没有到达教学楼的路径。

最后，若出现没有入队的点，说明这个点能够到达一个不合法结构，因此路径数同样为无穷大。此外，若 fi>36500
也不符合题意。时间复杂度线性。

如果 n+1
所在 SCC 是不合法结构，那么不能入队。
使用 vector 存图会 MLE，原题空间限制 64MB。
代码。

*III. P7737 [NOI2021] 庆典
对于一个 SCC ，将其缩成一个点不影响答案。而题目给定的性质说明图的连通性可以用一棵树刻画，具体来说，拓扑排序，保留每个点最后一条入边。得到一棵外向树。

对于给定的 2(k+1)
个城市端点，若 i
是 j
的祖先，且 s
能到达 i
，j
能到达 t
，说明 i→j
这条链上所有城市都有可能经过，树剖求链并即可。

时间复杂度 O(nlognloglogn)
。loglogn
是排序的复杂度。

IV. CF555E Case of Computer Network

对于一个边双，我们总可以给其内部的边安排一个定向方式，使得其任何一个点都可以到达另外所有点。即边双一定可以定向为 SCC。

证明：首先给出引理，对于一个强连通的点集 S
，设有向路径 P=u→p1→⋯→v
，若 u,v∈S
，则将所有 pi
添加进 S
集合后，S
仍然强连通。这一点容易证明。

根据引理，对于一个边双 G=(V,E)
，我们首先找到其中任意一个环 P
，将其定向成有向环。设初始的强连通集为 P
的点集。接下来，不断选取两端均属于 S
的一条所有边均没有被定向的链 C
，将其定向成有向链并将链上所有点加入 S
。

C
必然存在。考虑边 (u,v)
满足 u∈S
且 v∉S
。当 S≠V
时这样的边必然存在，否则 G
不连通。从 u
出发走到 v
，最终必然会回到 S
。因为 G
边双连通所以除去 (u,v)
这条边，v
必然能回到 u
，自然一定能回到 S
。第一次回到 S
时已经走过的路径就是一个合法的 C
。

由于 G
大小有限，所以上述过程最终一定结束，此时 S=V
，即 V
强连通。将还没有被定向的边随意定向，结论得证。

因此，我们先对原图边双缩点得到一棵树，如果 s,t
不连通自然无解，否则，s
所在点双 G(s)
必须可达 t
所在点双 G(t)
，因此 G(s)
到 G(t)
的简单路径上所有边的定向已经确定。如果存在一条边的定向矛盾则无解，可以通过 LCA + 树上差分实现对一条链的标记。开两个差分数组分别记录当前点到它父亲的连边是否被钦定为向上或向下，若同时有值则无解。

时间复杂度为 O(m+(n+q)logn)
，瓶颈在于求 LCA。使用四毛子可以做到线性。代码。

6. 欧拉图

欧拉，永远滴神！

6.1 定义与判定

欧拉路径：通过 连通图 中所有边恰好一次的路径称为欧拉路径。
欧拉回路：通过 连通图 中所有边恰好一次的 回路 称为欧拉回路。回路，即路径起点和终点相同。
欧拉图：具有欧拉 回路 的有向图或无向图称为欧拉图。
半欧拉图：具有欧拉 通路 但 不具有欧拉回路 的有向图或无向图称为半欧拉图。
做题时基本用不到上述定义（大雾）。

不严谨地说，欧拉图能够从任意一点作为起点一笔画完整张图然后回到该点，而半欧拉图只能从某两个点 S,T
开始才能画完整张图，其中 S,T
分别作为起点和终点。

欧拉图的判定：一张无向图 G
是欧拉图，当且仅当 G
是连通图且每个顶点的 度数都是偶数。一张有向图 G
是欧拉图，当且仅当 G
是 SCC 且每个顶点的入度和出度相等。

考虑证明上述结论。

无论是对于无向图还是有向图而言，必要性都是显然的。考虑最终欧拉回路的形态，每次进入一个点，都要从该点走出去，所以出边和入边必须两两抵消。对于起始点，它一开始走出去的边和最后走回它的边同样抵消了，所以有向图存在欧拉回路必须满足每个点出度和入度相等。同理可证无向图每个点的度数必须为偶数。

充分性通过构造法证明。考虑无向图，首先找到图上任何一个回路 P
（不需要是欧拉回路）。因为除掉所有孤立点，每个点的度数都 ≥2
，所以回路必然存在。然后从图上删去 P
的所有边，并删去所有孤立点。形成的所有子图仍然满足每个点的度数均为偶数，因为 P
中每个点的度数为 2
。由于每个子图均与 P
有交点，所以只需要将子图的欧拉回路接到 P
上即可得到原图的欧拉回路。因此我们对子图进行同样的操作。边的个数有穷，所以整个过程必然结束，继而得到原图的欧拉回路。同理可证有向图欧拉回路判定条件的充分性。

半欧拉图的判定：一张无向图 G
是半欧拉图，当且仅当 G
存在两个奇度数顶点。一张有向图 G
是半欧拉图，当且仅当 G
弱连通，恰存在一个顶点使得出度减入度等于 1
，恰存在一个顶点使得入度减出度等于 1
，且剩余所有顶点出入度相等。弱连通定义为将所有有向边替换为无向边后，整张图连通。

6.2 求欧拉路径：Hierholzer 算法

Hierholzer 算法的核心是不断往当前回路的某个点中插入环，这和欧拉回路存在的判定条件的充分性证明如出一辙，或者说完全等价。

先考虑有向图吧，因为有向图不需要考虑重边的问题。

6.2.1 朴素方法

根据流程，我们有一个朴素的实现方法：首先 dfs 找到经过某个点的任意一个环 P
（不需要是简单环），将 P
上的所有点标记为已删去。然后依次加入 P
上的每个节点 p1,p2,⋯,p|P|,p1
。加入 pi
之前，我们先递归找到 pi
所在子图（删去了一些边，分裂成若干子图）的欧拉回路，然后插入当前路径。因此这是一个递归形式的算法。

每次枚举到一个点都要遍历它的所有出边以找到第一个没有被删去的边，复杂度为 O(m2)
。

若用双向链表维护每个点剩余的所有出边，则每条边只会被遍历一次，时间复杂度 O(n+m)
。

进一步地，我们发现每次删去的环边一定是每个节点所有没有被删去的出边中开头的若干个。也就是说，如果给 u
的所有出边 (u,vi)
钦定一个遍历顺序 (u,v1),⋯,(u,vout(u))
，那么找环时被删去的一定是开头的若干条边 (u,v1),(u,v2),⋯,(u,vk)
。因为我们不会因找不到环而反悔掉走某一条边的操作。

不断无脑深搜，最终一定能找到环。

证明该结论。不妨设从 u
开始找环，每次走当前节点第一条没有被删去的出边并删去。走到节点 v≠u
时，设这是第 i
次进入 v
，那么我们只会离开 v
共 i−1
次（每次离开必然对应一次进入，而在第 i
次进入之前，只有 i−1
次进入）。故此时只删掉了 v
的 i−1
条出边，而 v
有不少于 i
条出边：第 i
次进入 v
意味着 in(v)≥i
，而 in(v)=out(v)
所以 out(v)≥i
。这说明我们必然能从 v
走出去到别的节点。

因此，最终必然只可能在 u
处走不到其它节点。但这意味着此时已经找到了一个环。

根据上述结论，我们不需要维护双向链表了。存图用的链式前向星也可以满足要求，因为每次只会删去开头的出边。这样改进后，链表头就和网络最大流 Dinic 算法的当前弧非常相似，都是 记录第一个有用的边 以省去一条条跳无用边的时间。

该结论同时也证明了找到一个环的复杂度关于环上边数线性，所以总复杂度即 O(n+m)
。

注意，需要使用双向链表维护将一个环插入当前回路的过程，否则复杂度会退化成 O(n(n+m))
（如果一旦走到目标节点而非目标节点不可以在往外走时就认为找到环，复杂度会退化成 O(m(n+m))
）。因为这样处理一个环的复杂度变成了所有未处理的边的个数之和。

6.2.2 巧妙方法

上述做法的时间复杂度已经足够优秀，但实现起来稍微有些复杂。我们希望算法能够更简单。

我们可以用自己的语言描述复杂的方法干了些什么，再思考有哪些地方可以简化。

从整体上考察，我们无非就是实现了这样的步骤：从一个起点开始找到一个环，然后以环上的每个起点开始找到一个环 …… 不断递归下去。

然后思考究竟是哪里麻烦了。我们会发现，为了依次从环上的每个起点开始找环，需要先 显式 地将这个环找到，排出来，再依次处理上面的所有节点。所以我们需要一个 dfs 函数找环，另一个递归式函数解决欧拉回路问题。

这样太蠢了，因为无论以怎样的顺序安排环上节点的找环顺序，都不会影响欧拉回路的正确性。我们只是找环并插入啊，换个顺序又不会让问题变得无解。

因此，考虑在 dfs 找环的回溯过程中直接对环上的每个节点找环。换句话说，将原来找环的顺序倒过来，这样就没有必要先显式地找到当前环了，而是在回溯的过程中，一边对当前点找环，一边往回路中插入当前环。

综上，我们得到了求解欧拉回路的最常用算法 —— Hierholzer 算法的具体步骤：遍历当前节点 u
的所有出边 (u,v)
，若 (u,v)
未走过，那么向节点 v
深搜。遍历完所有出边后，将 u
加入路径。最终得到的就是一条反着的欧拉路径。倒过来即可。

如果要求字典序最小，只需在一开始对每个点的所有出边从小到大排序。这样一来，欧拉回路上从左往右看，每个点的后继都取到了理论最小值。

6.2.3 无向图和欧拉通路
以上，我们通过两小节的篇幅提出并优化了有向图欧拉回路的求解方法。

对于无向图的欧拉回路，可以类似有向图欧拉回路一样做，唯一的注意点是需要对边判重。使用求桥边时的成对变换技巧，用 2k
和 2k+1
存储一条边的两个方向，并开桶记录。不能只判返祖边，因为可能有重边。

对于无向图和有向图的欧拉通路，注意必须从奇点或唯一的出度大于入度的点开始 dfs。其它地方和欧拉回路没有区别。

模板题 P7771 【模板】欧拉路径 代码如下。

#include 
using namespace std;
const int N = 2e5 + 5;
int n, m, lar, top, stc[N], in[N], hd[N];
vector<int> e[N];
void dfs(int id) {
  for(int &i = hd[id]; i < e[id].size(); ) dfs(e[id][i++]);
  stc[++top] = id;
}
int main() {
  cin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    e[u].push_back(v), in[v]++;
  }
  for(int i = 1; i <= n; i++) {
    sort(e[i].begin(), e[i].end());
    if(abs((int) e[i].size() - in[i]) > 1) puts("No"), exit(0);
    if(e[i].size() > in[i])
      if(lar) puts("No"), exit(0);
      else lar = i;
  }
  dfs(lar ? lar : 1);
  if(top != m + 1) puts("No");
  else {
    reverse(stc + 1, stc + top + 1);
    for(int i = 1; i <= top; i++) cout << stc[i] << " ";
  }
  return 0;
}

6.3. 例题

I. P2731 [USACO3.3] 骑马修栅栏 Riding the Fences

无向图最小字典序欧拉路径板题。注意有重边，所以只能记录边的编号而非两个顶点以判重。

II. P1127 词链

从每个字符串第一个字符向最后一个字符连边，跑有向图欧拉回路即可。注意对邻接链表排序要按照每条边存储的字符串的字典序排序，而非指向节点的编号大小。

III. P1341 无序字母对

板题。

IV. P3443 [POI2006] LIS-The Postman

每条路径片段的限制形如在片段中出现的相邻两条边必须先后走，因为一条边有向边仅出现一次。

所有限制形成一条边先后走的关系的链，类似 CSP2019 T4 树上的数，将这条链缩成从起点到终点的一条边，跑欧拉回路。最后输出这条边时要再展开成链，因此要记录每条链上的节点顺序。

若限制关系出现环或分叉则无解，这可以通过并查集或链表维护。时间复杂度线性对数。

细节还是挺多的，代码。

V. P3520 [POI2011] SMI-Garbage

设 f(i)
表示以 i
为一端的需要经过的边的数量。对于一条回路，所有点度数均为偶数，因此一次操作后 f(i)
的奇偶性不变。故若存在 i
使得 f(i)
是奇数，则无解。否则，注意到有解是需要经过的边形成的图的每个连通块均存在欧拉回路的充要条件，对这张图跑一遍欧拉回路。由于要求不能经过相同的点，而路径上相同的点之间也一定是回路，所以借助栈把相同的点之间的回路弹出。时间复杂度 O(n+m)
。

对于不需要经过的边，可以直接忽略，这是因为是否有解与这些边无关：如果 f
均为偶数，我们必然能构造出一种不经过需要修改的边，反之无解。

VI. P3511 [POI2010] MOS-Bridges
若存在 2∤degi
则无解。

二分答案，若存在一条边的两个方向均走不了，则当前答案无解，否则一些边的方向已经确定，其余边有两种方向可选择。

考虑有向图存在欧拉回路的充要条件，所有点的出度和入度相等，据此已经可以算出每个点最终的出度。注意到若 (u,v)
定向为 u→v
则 u
的出度增加 1
，反之 v
的出度增加 1
，这自然地给予我们网络流模型：将每条边抽象成点，S→e
容量 1
，若 l≤mid
则 e→u
容量 1
，若 p≤mid
则 e→v
容量 1
，i→T
容量 degi2
，用最大流检查是否存在给所有边定向且满足限制的方案。若存在则当前答案有解，否则无解。

求出最终答案后根据边的定向方案还原有向图，跑欧拉回路即可。时间复杂度 O(mm−−√logV)

结语

恭喜，初级图论全部完成！期待进一步发展。