Algorithem Notes 5.2 图论

网络流

• 设源点为 $s$，汇点为 $t$，每条边 $e$ 的流量上限为 $c(e)$，流量为 $f(e)$。
• 割 指对于某一顶点集合 $P\subset V$，从 $P$ 出发指向 $P$ 外部的那些原图中的边的集合，记作割 $(P,V/P)$。这些边的容量被称为割的容量。若 $s\in P,t\in V/P$，则称此时的割为 $s-t$ 割。
• 对于任意的 $s-t$ 流 $F$ 和任意的 $s-t$ 割 $(P,V/P)$ 割，由每个点的流量平衡条件得：
  $$F的流量=P出边总流量-P入边总流量\le 割的容量$$
• 对于在残量网络中不断增广得到的流 $F$，设其对应的残量网络中从 $s$ 出发可到达的顶点集为 $S$，则对于 $S$ 指向 $V/S$ 的边 $e$ 有 $f(e)=c(e)$，而对 $V/S$ 指向 $S$ 的边有 $f(e)=0$，则：
  $$F的流量=S出边总流量-S入边总流量=S出边总流量=割的容量$$
• 因而 $F$ 为最大流，同时 $(S,V/S)$ 为最小割，即最大流等于最小割。

Dinic 算法

• 主要思想即每次寻找最短的增广路，构造分层图，并沿着它多路增广。
• 每次多路增广完成后最短增广路长度至少增加 1，构造分层图次数为 $\mathcal{O}(n)$，在同一分层图中，每条增广路都会被至少一条边限制流量（我们称之为瓶颈），显然任意两条增广路的瓶颈均不相同，因而增广路总数为 $\mathcal{O}(m)$，加上当前弧优化，我们就能避免对无用边多次检查，寻找单条增广路的时间复杂度为 $\mathcal{O}(n)$，总时间复杂度 $\mathcal{O}(n^{2}m)$。
• 这只是一个粗略的上界，实际的复杂度分析要结合具体的图模型，例如若最大流上限较小（设为 $F$），时间复杂度 $\mathcal{O}(F(n+m))$。

template <class T>
inline T Min(T x, T y) {return x < y ? x : y;}

const int N = 1e4 + 5;
const int M = 2e5 + 5;
const ll Maxn = 1e15;
int nxt[M], to[M], adj[N], que[N], cur[N], lev[N]; ll cap[M];
int n, m, src, des, qr, T = 1;

inline void linkArc(int x, int y, ll w)
{
	nxt[++T] = adj[x]; adj[x] = T; to[T] = y; cap[T] = w;
	nxt[++T] = adj[y]; adj[y] = T; to[T] = x; cap[T] = 0;	
}

inline bool Bfs()
{
	for (int x = 1; x <= n; ++x)	
		cur[x] = adj[x], lev[x] = -1;
	// 初始化具体的范围视建图而定，这里点的范围为 [1,n]
	que[qr = 1] = src;
	lev[src] = 0;
	for (int i = 1; i <= qr; ++i)
	{
		int x = que[i], y;
		for (int e = adj[x]; e; e = nxt[e])
			if (cap[e] > 0 && lev[y = to[e]] == -1)
			{
				lev[y] = lev[x] + 1;
				que[++qr] = y;
				if (y == des)
					return true;
			}
	}
	return false;
} 

inline ll Dinic(int x, ll flow)
{
	if (x == des)
		return flow;
	int y, delta; ll res = 0;	
	for (int &e = cur[x]; e; e = nxt[e]) 
		if (cap[e] > 0 && lev[y = to[e]] > lev[x])
		{
			delta = Dinic(y, Min(flow - res, (ll)cap[e]));
			if (delta)
			{
				cap[e] -= delta;
				cap[e ^ 1] += delta;
				res += delta;
				if (res == flow)
					break ; 
				//此时 break 保证下次 cur[x] 仍有机会增广 
			}
		} 
	if (res != flow)
		lev[x] = -1;
	return res; 
}

inline ll maxFlow()
{   //求完最大流后与 src 属于同一点集的点满足 lev[x] != -1
	ll res = 0;
	while (Bfs())
		res += Dinic(src, Maxn);
	return res;
}

• 单位网络 在该网络中，所有边的流量均为 1，除源汇点以外的所有点，都满足入边或者出边最多只有一条。
• 结论 对于包含二分图最大匹配在内的单位网络，$\text{Dinic}$ 算法求解最大流的时间复杂度为 $\mathcal{O}(m\sqrt{n})$。

证明 对于单位网络，每条边最多被考虑一次，一轮增广的时间复杂度为 $\mathcal{O}(m)$。

假设我们已经完成了前 $\sqrt{n}$ 轮增广，还需找到 $d$ 条增广路才能找到最大流，每条增广路的长度至少为 $\sqrt{n}$。这些增广路不会在源点和汇点以外的点相交，因而至少经过了 $d\sqrt{n}$ 个点，$d\le \sqrt{n}$，则至多还需增广 $\sqrt{n}$ 轮，总时间复杂度 $\mathcal{O}(m\sqrt{n})$。

经典模型

• 二者选其一的最小割 有 $n$ 个物品和两个集合 $A,B$，若第 $i$ 个物品没有放入 $A$ 集合花费 $a_i$，没有放入 $B$ 集合花费 $b_i$，还有若干个限制条件，若 $u_i$ 和 $v_i$ 不在一个集合则花费 $w_i$。
  • 源点 $s$ 向第 $i$ 个点连一条容量为 $a_i$ 的边，第 $i$ 个点向汇点 $t$ 连一条容量为 $b_i$ 的边，在 $u_i$ 和 $v_i$ 之间连容量为 $w_i$ 的双向边，最小割即最小花费。
• 最大权闭合子图 给定一张有向图，每个点都有一个权值（可为负），选择一个权值和最大的子图，使得子图中每个点的后继都在子图中。
  • 若点权为正，则 $s$ 向该点连一条容量为点权的边。
  • 若点权为负，则该点向 $t$ 连一条容量为点权的相反数的边。
  • 原图上所有边的容量设为 $+\infty$。
  • 则答案为正点权之和减去最小割。
• 分糖果问题 $n$ 个糖果 $m$ 个小孩，小孩 $i$ 对糖果 $j$ 有偏爱度 $a_{i,j}=1/2$，设 $c_{i,j}=0/1$ 表示小孩 $i$ 是否分得了糖果 $j$，小孩 $i$ 觉得高兴当且仅当 $\sum _{j=1}^n{c}_{i,j}{a}_{i,j}\ge b_i$，判断是否存在方案使所有小孩都高兴。
  • 偏爱度 $a_{i,j}=1/2$ 不好建图，转换思路先分配所有 $a_{i,j}=2$ 的糖果。
  • $s$ 向所有糖果连一条容量为 1 的边，小孩 $i$ 向 $t$ 连一条容量为 $\lfloor \frac{b_i}{2}\rfloor$ 的边。
  • 对于所有满足 $a_{i,j}=2$ 的边，令糖果 $j$ 向小孩 $i$ 连一条容量为 1 的边。
  • 求得最大流 $ans$，则存在方案当且仅当 $ans+n\ge \sum _{j=1}^m{b}_i$。
• 动态流问题 宽为 $w$ 的河上有 $n$ 块石头，第 $i$ 块坐标 $(x_i,y_i)$，同一时刻最大承受人数为 $c_i$，现有 $m$ 个游客想要渡河，每人每次最远跳 $d$ 米 ，单次耗时 1 秒，求全部渡河的最少时间（ $n,m\le 50$）。
  • 答案取值范围较小可暴力枚举，将每一时刻的石头都视作一点，在石头上跳跃可视作从第 $t$ 时刻的石头 $i$ 跳向第 $t+1$ 时刻的石头 $j$，每次将时刻加一，建出新的点和边后跑最大流，直至总流量大于等于 $m$。

费用流

• 在最大流的前提下使该网络总花费最小。

SSP 算法

• 每次寻找单位费用最小的增广路进行增广，直至图中不存在增广路为止。

• 设流量为 $i$ 的时候最小费用为 $f_i$，假设初始网络上没有负圈，$f_0=0$。

• 假设用 $\text{SSP}$ 算法求出的 $f_i$ 是最小费用，我们在 $f_i$ 的基础上，找到一条最短的增广路，从而求出 $f_{i+1}$，此时 $f_{i+1}-f_i$ 就是这条最短增广路的长度。

• 假设存在更小的 $f_{i+1}$，设其为 $f_{i+1}^{\prime }$，则 $f_{i+1}^{\prime }-f_i$ 一定对应一个经过至少一个负圈的增广路。若残量网络中存在至少一个负圈，则可在不增加 $s$ 流出的流量的情况下使费用减小，与 $f_i$ 是最小费用矛盾。

• 综上，$\text{SSP}$ 算法可以正确求出无负圈网络的最小费用最大流，设最大流为 $F$，总时间复杂度 $\mathcal{O}(Fnm)$。

• 因为随着流量的增大，最短路一定不降，因而费用关于流量的函数是一个凸函数。

template <class T>
inline T Min(T x, T y) {return x < y ? x : y;}

const int N = 5e3 + 5;
const int M = 1e5 + 5;
const int Maxn = 1e9;
int nxt[M], to[M], cap[M], que[M], cst[M], adj[N], dis[N];
bool vis[N]; int n, m, src, des, ans, T = 1, qr;

inline void linkArc(int x, int y, int w, int z)
{
	nxt[++T] = adj[x]; adj[x] = T; to[T] = y; cap[T] = w; cst[T] = z;
	nxt[++T] = adj[y]; adj[y] = T; to[T] = x; cap[T] = 0; cst[T] = -z;	
}

inline bool SPFA()
{
	for (int x = 1; x <= n; ++x)
		dis[x] = Maxn, vis[x] = false;
	// 初始化具体的范围视建图而定，这里点的范围为 [1,n]
	dis[que[qr = 1] = src] = 0;
	for (int i = 1, x, y; i <= qr; ++i)
	{
		vis[x = que[i]] = false;
		for (int e = adj[x]; e; e = nxt[e])
			if (cap[e] > 0 && dis[y = to[e]] > dis[x] + cst[e])
			{
				dis[y] = dis[x] + cst[e];
				if (!vis[y])
					vis[que[++qr] = y] = true;
			}
	}
	return dis[des] < Maxn;
}

inline int Dinic(int x, int flow)
{
	if (x == des)
	{
		ans += flow * dis[des];
		return flow;
	}
	vis[x] = true;
	int y, delta, res = 0;
	for (int e = adj[x]; e; e = nxt[e])
		if (!vis[y = to[e]] && cap[e] > 0 && dis[y] == dis[x] + cst[e])
		// vis 数组防止 dfs 在总费用为 0 的环上死循环 
		{
			delta = Dinic(y, Min(flow - res, cap[e]));
			if (delta)
			{
				cap[e] -= delta;
				cap[e ^ 1] += delta;
				res += delta;
				if (res == flow)
					break ;	
			} 
		}
	return res;
}

inline int MCMF()
{
	ans = 0;
	int res = 0;
	while (SPFA())
		res += Dinic(src, Maxn);
	return res;
}

经典模型

• 餐巾计划问题 一家餐厅在接下来的 $T$ 天内需用餐巾，第 $i$ 天需要 $r_i$ 块干净餐巾，餐厅可任意购买单价为 $p$ 的干净餐巾，或者将脏餐巾送往快洗部（单块餐巾需洗 $m$ 天，花费 $f$）或慢洗部（单块餐巾需洗 $n$ 天，花费 $s$），求这 $T$ 天内的最小花费。
  • 主要的难点在于需将干净餐巾和脏餐巾区分开，第 $i$ 天分设点 $i,i^{\prime }$，流向这两点的流量分别表示第 $i$ 天的干净餐巾和脏餐巾。
  • $s$ 向 $i$ 连一条容量为 $+\infty$ 、费用为 $p$ 的边，$i$ 向 $t$ 连一条容量为 $r_i$、费用为 0 的边。
  • $s$ 向 $i^{\prime }$ 连一条容量为 $r_i$、费用为 0 的边，$i^{\prime }$ 向 $i+m$ 连一条容量为 $+\infty$，费用为 $f$ 的边，向 $i+n$ 连一条容量为 $+\infty$，费用为 $s$ 的边，向 $(i+1{)}^{\prime }$ 连一条容量为 $+\infty$，费用为 $0$ 的边。
  • 显然该建图能使到 $t$ 的边满流，则最小费用即为所求。
• 费用流转二分图最大匹配 若除去费用的建图为二分图且费用不为 0 的边均在二分图一侧，可将有费用的边从小到大排序，按照这一顺序跑匈牙利算法，容易证明最大匹配即对应最小费用，可将时间复杂度降至 $\mathcal{O}(nm)$。

上下界网络流

• 以下 $(x,y,l,r)$ 代指 $x$ 向 $y$ 容量上限为 $l$ 下限为 $r$ 的边，$(x,y,w)$ 代指 $x$ 向 $y$，连容量为 $w$ 的边。

无源汇上下界可行流

• 对原图中每条边 $(x,y,l,r)$，假设每条边已有初始流量 $l$，在新图中连边 $(x,y,r-l)$。

• 对于图中每个点 $x$，记点 $x$ 的初始流入流量减去初始流出流量为 ${\Delta }_x$，新建超级源汇点 $S^{\prime }$ 和 $T^{\prime }$：

  • 若 ${\Delta }_x>0$，连边 $(S^{\prime },x,{\Delta }_x)$。
  • 若 ${\Delta }_x<0$，连边 $(x,T^{\prime },-{\Delta }_x)$。

• 对新图跑最大流算法，若 $S^{\prime }$ 的出边全部满流则存在可行流，可行流中每条边的流量等于初始流量加上当前流量。

	cin >> n >> m;
	src = n + 1, des = n + 2;
	for (int i = 1, x, y, l, r; i <= m; ++i)
	{
		cin >> x >> y >> l >> r;
		linkArc(x, y, r - l);
		ide[i] = T; lim[i] = l;
		delt[x] -= l, delt[y] += l; 
	}
	ll tot = 0;
	for (int i = 1; i <= n; ++i)
		if (delt[i] > 0)
			linkArc(src, i, delt[i]), tot += delt[i];
		else if (delt[i] < 0)
			linkArc(i, des, -delt[i]);
	if (maxFlow() == tot) //注意结点初始化的范围为n+2
	{
		cout << "YES\n";
		for (int i = 1; i <= m; ++i)
			cout << cap[ide[i]] + lim[i] << '\n';
	}
	else cout << "NO\n";

有源汇上下界可行流

• 在无源汇上下界可行流的基础上，在原有的源汇点 $S$ 和 $T$ 间增加连边 $(T,S,\infty )$，跑最大流后该边反向弧的流量即为可行流的流量。

	cin >> n >> m >> src >> des; 
	for (int i = 1, x, y, l, r; i <= m; ++i)
	{
		cin >> x >> y >> l >> r;
		linkArc(x, y, r - l);
		delt[x] -= l, delt[y] += l; 
	}
	linkArc(des, src, Maxn);
	int key = T;
	src = n + 1, des = n + 2;
	ll tot = 0;
	for (int i = 1; i <= n; ++i)
		if (delt[i] > 0)
			linkArc(src, i, delt[i]), tot += delt[i];
		else if (delt[i] < 0)
			linkArc(i, des, -delt[i]);
	if (maxFlow() == tot) //注意结点初始化的范围为 n+2
		cout << cap[key] << '\n';
	else
		cout << "please go home to sleep\n";

有源汇上下界最大流

• 在有源汇上下界可行流的基础上，直接跑原图 $S$ 到 $T$ 的最大流，此时 $(T,S,\infty )$ 的反向弧流量会被退回，因此所求即为有源汇上下界最大流。

	cin >> n >> m >> src >> des; 
	for (int i = 1, x, y, l, r; i <= m; ++i)
	{
		cin >> x >> y >> l >> r;
		linkArc(x, y, r - l);
		delt[x] -= l, delt[y] += l; 
	}
	linkArc(des, src, Maxn);
	int _src = src, _des = des;
	src = n + 1, des = n + 2;
	ll tot = 0;
	for (int i = 1; i <= n; ++i)
		if (delt[i] > 0)
			linkArc(src, i, delt[i]), tot += delt[i];
		else if (delt[i] < 0)
			linkArc(i, des, -delt[i]);
	if (maxFlow() == tot) //注意结点初始化的范围为 n+2
	{
		src = _src, des = _des;
		cout << maxFlow() << '\n';
	}
	else
		cout << "please go home to sleep\n";

有源汇上下界最小流

• 在有源汇上下界可行流的基础上，删去 $(T,S,\infty )$，之后跑 $T$ 到 $S$ 的最大流，此时可行流减去最大流的流量即为有源汇上下界最小流。

	cin >> n >> m >> src >> des; 
	for (int i = 1, x, y, l, r; i <= m; ++i)
	{
		cin >> x >> y >> l >> r;
		linkArc(x, y, r - l);
		delt[x] -= l, delt[y] += l; 
	}
	int _src = src, _des = des;
	src = n + 1, des = n + 2;
	ll tot = 0;
	for (int i = 1; i <= n; ++i)
		if (delt[i] > 0)
			linkArc(src, i, delt[i]), tot += delt[i];
		else if (delt[i] < 0)
			linkArc(i, des, -delt[i]);
	linkArc(_des, _src, Maxn);
	if (maxFlow() == tot)
	{
		ll allow = cap[T];
		src = _des, des = _src;
		cap[T] = cap[T - 1] = 0;
		cout << allow - maxFlow() << '\n';
	}
	else
		cout << "please go home to sleep\n";

最小费用可行流

• 在可行流的边中增加费用即可，注意要加上初始流量的费用。

最小割树

• 即 Gomory-Hu Tree，用于求无向图中任意两点间的最小割。
• 设当前的点集为 $V$，从 $V$ 取出两点 $s$ 和 $t$，求 原图 中 $s$ 到 $t$ 的最小割 $w$，在新图中连边 $(s,t,w)$，最小割将 $V$ 分为两个点集 $V_1,V_2$，递归下去直至每个点集仅包含一点，新图构成了一棵树，若采用的是 Dinic 算法，时间复杂度 $\mathcal{O}(n^{3}m)$。
• 结论 原图中任意两点间的最小割等于树上两点间的路径最小值。

证明 先考虑证明三个点的情况，即存在两条边 $(a,b,w_1)$ 和 $(b,c,w_2)$，需证明 $a$ 和 $c$ 间的最小割 w=min⁡{w1,w2}w = \min\{w_1,w_2\}w=min{w1​,w2​}。

$w$ 将原图分为两个点集，仅可能存在两种情况之一，故得证。

• $a,b$ 属于同一点集，最小割为 $w_2$。
• $b,c$ 属于同一点集 ，最小割为 $w_1$。

对于一条路径，不断选择一端的三点，用 (a,c,min⁡{w1,w2})(a,c,\min\{w_1,w_2\})(a,c,min{w1​,w2​}) 替换 $(a,b,w_1)$ 和 $(b,c,w_2)$ 即可。

inline void solve(int l, int r)
{   // curp[i] 初始为 i 
	if (l == r)
		return ;
	src = curp[l], des = curp[l + 1];
	for (int i = 2; i <= T; i += 2)
	{
		int w = cap[i] + cap[i ^ 1] >> 1;
		cap[i] = cap[i ^ 1] = w;
	}
	int w = maxFlow();
	e[src].emplace_back(des, w);
	e[des].emplace_back(src, w);
	
	vector<int> _cur;
	for (int i = l; i <= r; ++i)
	{
		int x = curp[i];
		if (lev[x] != -1)
			_cur.emplace_back(x);
	}
	int mid = l + _cur.size() - 1;
	for (int i = l; i <= r; ++i)
	{
		int x = curp[i];
		if (lev[x] == -1)
			_cur.emplace_back(x);
	}
	for (int i = l; i <= r; ++i)
		curp[i] = _cur[i - l];						
	solve(l, mid);
	solve(mid + 1, r);	
}

无向图最小割

• Stoer-Wagner 算法可在 $\mathcal{O}(n^3)$ 时间内求解无向图最小割。
• 具体流程为，每次 $\mathcal{O}(n^2)$ 找到一对点 $s,t$ 的最小割（见函数 calcMinCut 和以下描述），之后将 $s,t$ 及其之间的边缩为一点，直至图中仅剩一点时，过程中求得的最小割即为答案。
• 定义 $d(x,y)$ 为邻接矩阵，权值函数 $w(A,x)={\sum }_{y\in A}d(x,y)$，每次将 $w(A,x)$ 最大且不属于 $A$ 的 $x$ 加入 $A$，直至 $A=V$。
• 结论 设 $A_x$ 表示所有在 $x$ 之前加入的点的点集，$s,t$ 为最后加入 $A$ 的两个结点，则 $w(A_t,t)$ 为 $s,t$ 的最小割。

证明 即证明对于任意 $s-t$ 割 $C$，总有 $w(A_t,t)\le w(C)$，其中 $w(C)={\sum }_{(x,y)\in C}d(x,y)$。

定义一个点 $x$ 被 激活 当且仅当 $A_x$ 中最后一个点与 $x$ 分属 $C$ 的两侧，且 $C_x$ 为 $C$ 在 Ax∪{x}A_x \cup \{x\}Ax​∪{x} 下的诱导割，现在归纳证明，对于一个被激活的点 $x$，恒有：
$$w(A_x,x)\le w(C_x)$$

• 对于第一个被激活的点，显然有 $w(A_x,x)=w(C_x)$。
• 否则，设当前被激活的点为 $x$，上一个被激活的点为 $y$，则

$$\begin{array}{rl}w(A_x,x)& =w(A_y,x)+w(A_x-A_y,x)\\ & \le w(A_y,y)+w(A_x-A_y,x)\\ & \le w(C_y)+w(A_x-A_y,x)\\ & \le w(C_x)\end{array}$$

由 $w(A_t,t)$ 的定义，$t$ 一定被激活，代入 $t$ 即得到 $w(A_t,t)\le w(C_t)=w(C)$，证毕。

• 该结论也意味着对于一个无向图，总存在一条边 $(s,t)$ 使得 $t$ 的所有邻边是 $s,t$ 的最小割，并且可在类似 Dijkstra 的时间复杂度内找到。

#include <bits/stdc++.h>

template <class T>
inline void CkMin(T &x, T y) {x > y ? x = y : 0;}

using std::ios;
using std::cin;
using std::cout;

const int N = 60;
const int Maxn = 1e9;
int n, m, src, des;
int dis[N][N], w[N], ord[N];
bool del[N], vis[N];

inline int calcMinCut(int x) 
{
	for (int i = 1; i <= n; ++i)
		w[i] = 0, vis[i] = false;
	for (int i = 1; i <= n - x + 1; ++i) 
	{
		int id = 0;
		for (int j = 1; j <= n; ++j)
			if (!del[j] && !vis[j] && (!id || w[j] > w[id])) 
				id = j;
		vis[id] = true, ord[i] = id;
		for (int j = 1; j <= n; ++j) 
			if (!del[j] && !vis[j]) 
				w[j] += dis[id][j];
	}
	src = ord[n - x], des = ord[n - x + 1];
	return w[des];
}

inline void Contraction()
{
	del[des] = true;
	for (int j = 1; j <= n; ++j) 
	{
		dis[src][j] += dis[des][j];
		dis[j][src] += dis[j][des];
	}
}

inline int StoerWagner() 
{
	int res = Maxn;
	for (int i = 1; i < n; ++i) 
	{
		CkMin(res, calcMinCut(i));
		Contraction();
	}
	return res;
}

int main() 
{
	srand(time(0)); 
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	
	cin >> n >> m;
	int x, y, z;
	while (m--)
	{
		cin >> x >> y >> z;
		dis[x][y] += z;
		dis[y][x] += z;
	}
	cout << StoerWagner() << '\n';
	return 0;
}

二分图最大匹配

• 记图 $G=(V,E)$。
  • 匹配 $G$ 中两两没有公共端点的边集合 $M\subseteq E$。
  • 边覆盖 $G$ 中的任意顶点都至少是 $F$ 中某条边的边集合 $F\subseteq E$。
  • 独立集 $G$ 中两两互不相连的顶点集 $S\subseteq V$。
  • 点覆盖 $G$ 中任意边都有至少一个端点属于 $P$ 的顶点集合 $P\subseteq V$。
• 结论1 对于不存在孤立点的图，$|最大匹配|+|最小边覆盖|=|V|$。

证明 设最大匹配数为 $x$，则其覆盖的点数为 $2x$，剩余点两两之间没有边。则最少需要增加 $|V|-2x$ 条边才能将所有点覆盖，则最小边覆盖数为 $x+|V|-2x=|V|-x$。

• 结论2 $|最大独立集|+|最小点覆盖|=|V|$。

证明 只需证明独立集和点覆盖一一对应且互为关于 $V$ 的补集即可。取一个点覆盖关于 $V$ 的补集，若其不是一个独立集，则存在两点有公共边，不难发现这与点覆盖的定义矛盾。

• 结论3 在二分图中，$|最大匹配|=|最小点覆盖|$。

证明 设最大匹配数为 $x$，即让匹配中的每条边都和其一个端点关联。$x$ 个点是足够的，否则若存在一条边未被覆盖，加入这条边能得到一个更大的匹配。$x$ 个点是必需的，因为匹配的 $x$ 条边两两无公共点。

• 结论4 在有向无环图中，$|最小点不相交路径覆盖|+|最大匹配|=|V|$。这里的最大匹配指的是，将原图每个点拆成入点和出点两点，对于有向边 $x\to y$，将 $x$ 的入点向 $y$ 的出点连边，在该二分图上求得的最大匹配。

  • 若需求 $|最小点可相交路径覆盖|$，可以每个点为起点 BFS 求出传递闭包，传递闭包上建图即可，传递闭包中图的边数可能达到 $\mathcal{O}(|V{|}^2)$，时间复杂度 $\mathcal{O}(|V||E|+|V{|}^{2.5})$，空间复杂度 $\mathcal{O}(|V{|}^2)$，输出方案记录每个入点的匹配点即可，时间复杂度 $(|V|)$。
  • 若 $|E|$ 较小，也可以不求传递闭包，将有向边的容量设为 $+\infty$，并将所有的出点向对应的入点连一条容量为 $+\infty$ 的边，即可实现传递闭包的效果，直接跑网络流即可，因为最大流上限为 $|V|$，时间复杂度 $\mathcal{O}(|V|(|V|+|E|))$，空间复杂度 $\mathcal{O}(|V|+|E|)$，实际上严格优于前述做法。该做法的输出方案较为麻烦，具体来说，我们根据所有匹配边建出一张图，若一个点的出边比入边多则它可以作为一条链的起点，暴力往下跳即可，实现时将本质相同的边压缩成一条可将空间复杂度降至 $\mathcal{O}(|V|+|E|)$，时间复杂度 $\mathcal{O}(|V{|}^2)$，参考代码如下：

  	// C 为二分图一侧的点数，src = 2 * C + 1
  	// 注意孤立点以及删去一条链可能会产生新的起点的情况
  	for (int x = 1; x <= C; ++x)
  		for (int e = adj[x]; e; e = nxt[e])
  			if (to[e] > C && to[e] < src && to[e] - C != x && cap[e ^ 1] > 0)
  			{
  				re[x].emplace_back(std::make_pair(to[e] - C, cap[e ^ 1])); 
  				++lre[x];
  				sre[x] += cap[e ^ 1];
  				ind[to[e] - C] += cap[e ^ 1]; 
  			}
  	tis = 0;
  	for (int t = 1; t <= C; ++t)
  	{
  		for (int x = 1; x <= C; ++x)
  			while (sre[x] > ind[x])
  			{
  				++tis;
  				int u = x;
  				ans[u] = tis;
  				while (sre[u])
  				{
  					pir &v = re[u][lre[u] - 1];
  					int vid = v.first;
  					if (--v.second == 0)
  						re[u].pop_back(), --lre[u];
  					--sre[u];
  					u = vid;
  					ans[u] = tis;
  					--ind[u];
  				}
  			}
  	}
  

证明 只需证明二分图中匹配与原图中的路径覆盖一一对应且总和为 $|V|$。对于每个没有匹配边的出点，我们都能构造一条路径，若其对应的入点存在匹配边，则将该匹配边加入该路径同时继续考虑该匹配边的出点直至其对应的入点不存在匹配边。得到的所有路径恰能覆盖所有点，且没有匹配边的出点和入点恰好能两两配对分别构成所有路径的起点和终点。

• Dilworth定理 对于任意有限偏序集，其最大反链中的元素个数必等于最小链划分中链的个数。
  • 有限偏序集的最小链划分即其哈斯图对应的有向无环图的 $|最小点可相交路径覆盖|$，用上述方法求解即可。

证明 设 $m$ 为最大反链的元素个数，$|X|=n$，只要证明偏序集 $X$ 可被划分成 $m$ 个链即可。

考虑用归纳法证明，当结点数 $n=1$ 时显然成立 $n=1$ 时显然成立，下面证明 $n>1$ 时的情形，设该有限偏序集中所有极小点构成的集合为 $L$，所有极大点构成的集合为 $G$，分两种情况讨论：

1. 若存在最大反链 $A$，使得 $A\ne L$ 且 $A\ne G$。构造：
   A+={x∣x∈X∧∃a∈A,a≤x}A−={x∣x∈X∧∃a∈A,x≤a} A^+=\{x|x\in X \wedge \exist a\in A,a\le x\} \\ A^-=\{x|x\in X \wedge \exist a\in A,x \le a\} \\ A+={x∣x∈X∧∃a∈A,a≤x}A−={x∣x∈X∧∃a∈A,x≤a}
   则容易得到 $|A^{+}|<|X|$、$|A^{-}|<|X|$ 且 $A^{+}\cup A^{-}=X,A^{+}\cap A^{-}=A$，由归纳假设可将 $A^{+}$ 和 $A^{-}$ 的 $m$ 链划分拼接起来即可得到 $X$ 的 $m$ 链划分。

2. 若只存在反链 $A=L$ 或 $A=G$，取极小元 $x$ 和极大元 $y$ 满足 $x\le y$（$x,y$ 可相等），则由归纳假设 X−{x,y}X -\{x,y\}X−{x,y} 最大反链的元素个数为 $m-1$，存在 $m-1$ 链划分，增加链 $x\le y$ 可得到 $X$ 的 $m$ 链划分。

• Dilworth定理的对偶形式 最长链中元素个数必等于最小反链划分中反链的个数。

证明 设最长链的长度为 $m$，最小反链划分的数目为 $M$。

1. 由于在任意一个反链中选取超过一个元素都违反链的定义，容易得到 $m\le M$。
2. 考虑每次删去当前偏序集中的所有极小点，恰好删除 $m$ 次能够将所有点删除，设第 $i$ 次删点构成的极小点集合为 $A_i$，则 $A_1,A_2,\dots ,A_m$ 构成一个反链划分，故有 $M\le m$。

综上所述，$m=M$，原命题得证。

匈牙利算法

• 从每个点出发尝试找到一条增广路，时间复杂度 $\mathcal{O}(nm)$。

inline bool Hungary(int x)
{
	int y;
	for (arc *e = adj[x]; e; e = e->nxt)
		if (!mateR[y = e->to])
			return mateR[y] = x, true;
	for (arc *e = adj[x]; e; e = e->nxt)
	{
		if (vis[y = e->to] == tis)
			continue ;
		vis[y] = tis;
		if (Hungary(mateR[y]))
			return mateR[y] = x, true;
	}
	return false;
}

inline int maxMatch()
{
	int cnt = 0;
	for (int i = 1; i <= n; ++i)
	{
		++tis;
		if (Hungary(i))
			++cnt;
	} 
	return cnt;
}

二分图最大权匹配

Kuhn-Munkres算法

• 该算法用于 $\mathcal{O}(n^3)$ 求二分图的最大权完美匹配，若二分图左右部的点数不相同，需将点数补至相同，并将所有不存在的边的权设为 0。
• 若题目对是否是完备匹配有要求，需将不存在的边设为 $-\infty$（具体值需保证一旦选这种边就比所有不选这种边的方案更劣），此时也能处理原图边权有负数的情况。
• 可行顶标 对于二分图 $<X,E,Y>$，对于 $x\in X$ 分配权值 $\text{labx}(x)$，对于 $y\in Y$ 分配权值 $\text{laby}(y)$，对于所有边 $(x,y)\in E$ 满足 $w(x,y)\le \text{labx}(x)+\text{laby}(y)$。
• 相等子图 在一组可行顶标下原图的生成子图，包含所有点但只满足包含 $\text{labx}(x)+\text{laby}(y)=w(x,y)$ 的边 $(x,y)$。
• 定理 对于某组可行顶标，若其相等子图内存在完美匹配，该匹配为原图的最大权完美匹配。

证明 设可行顶标下相等子图中的完美匹配为 $M^{\prime }$，对于原二分图任意一组完美匹配 $M$，其边权和
$$\text{val}(M)=\sum _{(x,y)\in M}w(x,y)\le \sum _{x\in X}\text{labx}(x)+\sum _{y\in Y}\text{laby}(y)=\text{val}(M^{\prime })$$
故若 $M^{\prime }$ 存在，$M^{\prime }$ 即为最大权完美匹配。

• 下面的算法过程将证明一定能够通过调整顶标，使得相等子图内存在完美匹配。
• 初始可行顶标 labx(x)=max⁡y∈Y{w(x,y)},laby(y)=0\text{labx}(x) = \max\limits_{y\in Y}\{w(x,y)\}, \text{laby}(y) = 0labx(x)=y∈Ymax​{w(x,y)},laby(y)=0，在相等子图内找一个未匹配的点，尝试寻找增广路，若能找到直接增广，否则将形成一棵交错树。
• 交错树是由从一个未匹配点出发沿着 非匹配边-匹配边 交替的所有路径构成的树，将树中顶点与 $X$ 的交集记为 $S$，与 $Y$ 的交集记为 $T$，令 $S^{\prime }=X-S,T^{\prime }=Y-T$（$S/S^{\prime },T/T^{\prime }$ 程序中分别用 $\text{visx}(x)$ 和 $\text{visy}(y)$ 标示），如下图所示。
  
• 在相等子图中：
  • $S-T^{\prime }$ 的边不存在，若其为匹配边违反交错树的定义，若其为非匹配边则会形成增广路或者使交错树扩大。
  • $S^{\prime }-T$ 的边一定是非匹配边，否则将使交错树扩大。
• 将 $S$ 中的顶标 $-a$，将 $T$ 中的顶标 $+a$，可以发现：
  • $S-T$ 和 $S^{\prime }-T^{\prime }$ 在相等子图中的边均无变化。
  • $S-T^{\prime }$ 的边对应顶标和减少，可能作为非匹配边加入相等子图，由上述性质，增加的边将形成增广路或使交错树扩大。
  • $S^{\prime }-T$ 的边对应顶标和增加，不可能加入相等子图。
• 设 slacky(y)=min⁡x∈S{labx(x)+laby(y)−w(x,y)}\text{slacky}(y) = \min\limits_{x\in S}\{\text{labx}(x) + \text{laby}(y) - w(x,y)\}slacky(y)=x∈Smin​{labx(x)+laby(y)−w(x,y)}（当且仅当 $y\in T^{\prime }$ 该值才有意义），则令 a=min⁡y∈T′{slacky(y)}a = \min\limits_{y\in T'}\{\text{slacky}(y)\}a=y∈T′min​{slacky(y)}，每次修改顶标时，必定会有至少一条产生增广路或使交错树扩大的非匹配边加入相等子图。
  • 在遍历交错树的过程中，记 $\text{pre}(y)=x(x\in X,y\in Y)$ 表示交错树上 $x,y$ 通过非匹配边相连，若产生了增广路，根据 $\text{pre}$ 更新匹配边即可完成增广。
  • 若使交错树扩大， 更新 $\text{slacky}$，在交错树增加的结点中重复上述过程直至完成增广，由于左右部点数相同，这一过程一定能够结束。
• 遍历交错树的部分通过 $\text{BFS}$ 实现。总共需要完成 $n$ 次增广，每次增广中 $\text{BFS}$ 的总时间复杂度为 $\mathcal{O}(n^2)$，更新顶标的次数为 $\mathcal{O}(n)$（每次更新都会使 $T$ 扩大），每次更新后维护 $\text{slacky}$ 并确定 $a$ 的时间复杂度也为 $\mathcal{O}(n)$，故总的时间复杂度为 $\mathcal{O}(n^3)$。

typedef long long ll;
const int N = 405;
const int Maxn = 2e9;
int que[N], w[N][N], slacky[N];
int labx[N], laby[N], matex[N], matey[N], pre[N];
bool visx[N], visy[N];
int nl, nr, qr, n, m; ll ans;

inline bool Augment(int y)
{
	if (matey[y])
	{
		que[++qr] = matey[y];
		visx[matey[y]] = visy[y] = true;
		return false;
	}
	else 
	{
		while (y)
		{
			int x = pre[y];
			matey[y] = x;
			std::swap(matex[x], y);
		}
		return true;
	}
}

inline void bfsHungary(int src)
{
	for (int i = 1; i <= n; ++i)
	{		
		pre[i] = 0;
		visx[i] = visy[i] = false;
		slacky[i] = Maxn;
	}
	visx[que[qr = 1] = src] = true;
	while (1)
	{
		for (int i = 1, x; i <= qr; ++i)
		{
			x = que[i];
			for (int y = 1; y <= n; ++y)	
				if (!visy[y])
				{
					int delta = labx[x] + laby[y] - w[x][y];
					if (delta > slacky[y])
						continue ;
					pre[y] = x;
					if (delta > 0)
						slacky[y] = delta;
					else if (Augment(y))
						return ;
				}
		}
		int nxt, delta = Maxn;
		for (int y = 1; y <= n; ++y)
			if (!visy[y] && slacky[y] < delta)
				delta = slacky[y], nxt = y;
		for (int i = 1; i <= n; ++i)
		{
			if (visx[i])
				labx[i] -= delta;
			if (visy[i])
				laby[i] += delta;
			else 
				slacky[i] -= delta; 
		}
		qr = 0;
		if (Augment(nxt))
			return ;
	}
}

int main()
{
	read(nl); read(nr); read(m);
	n = Max(nl, nr);
	int x, y, z;
	while (m--)
	{
		read(x); read(y); read(z);
		CkMax(w[x][y], z);
		CkMax(labx[x], z);
	}
	for (int i = 1; i <= n; ++i)
		bfsHungary(i);
	
	for (int i = 1; i <= n; ++i) 
		ans += w[i][matex[i]];
	put(ans), putchar('\n');
	for (int i = 1; i <= nl; ++i)
		put(w[i][matex[i]] ? matex[i] : 0), putchar(' ');
}

二分图稳定匹配

问题描述

• 对于任意的 $x\in X$，存在一个由 $Y$ 内所有结点构成的偏爱列表 $pr{f}_X[x]$，列表中结点排名越靠前对 $x$ 适配度越高，记 $r{k}_X[x][y]$ 表示 $y$ 在 $pr{f}_X[x]$ 中的排名。
• 对于任意的 $y\in Y$，同样定义 $pr{f}_Y[y]$ 和 $r{k}_Y[y][x]$。
• 对于二分图 $<X,Y,E>$，某一匹配是稳定的（Stable Matching)当且仅当（记 $x$ 的匹配结点为 $ma{t}_X[x]$，$y$ 的匹配结点为 $ma{t}_Y[y]$）：
  • 不存在 $x,y$ 满足 $x\ne ma{t}_Y[y]$，且：
    • $r{k}_X[y]<r{k}_X[ma{t}_X[x]]$
    • $r{k}_Y[x]<r{k}_Y[ma{t}_Y[y]]$

Gale-Shapley 算法

• 描述该算法的 python 代码如下：

rkx = rky = matx = maty = dict()
for x in prfx.keys():
    for i in range(len(prfx[x])):
        rkx[(x, prfx[x][i])] = i
for y in prfy.keys():
    for i in range(len(prfy[y])):
        rky[(y, prfy[y][i])] = i

for x in prfx.keys():
    prfx[x].reverse()
list = [x for x in prfx.keys()]
while len(list) > 0:
    x = list.pop()
    while len(prfx[x]) > 0:
        y = prfx[x].pop()
        if y not in maty:
            maty[y] = x
            matx[x] = y
            break 
        elif rky[(y, x)] < rky[(y, maty[y])]:
            del matx[maty[y]]
            list.append(maty[y])
            maty[y] = x
            matx[x] = y
            break 

• 关于该算法的正确性：
  • 如果 $|X|=|Y|$，最后总能找到一个匹配，且 $pr{f}_X[x]$ 中的元素不会重复遍历，时间复杂度 $\mathcal{O}(|X||Y|)$。
  • 考虑任何不在现有匹配中的 $(x,y)$：
    • 若 $x$ 从未尝试与 $y$ 匹配，则说明 $r{k}_X[x][ma{t}_X[x]]<r{k}_X[x][y]$。
    • 若 $x$ 尝试过与 $y$ 匹配，则说明 $r{k}_Y[y][ma{t}_Y[y]]<r{k}_Y[y][x]$。
  • 故该匹配是稳定的。
• 定义1 配对 $(x,y)$ 是有效的当且仅当存在一个稳定匹配使之包含 $(x,y)$。
• 定义2 记 $y_x$ 表示在列表 $pr{f}_X[x]$ 中最靠前的 $y$，一个匹配为 $X$-最优匹配当且仅当若 $(x,y_x)$ 是有效的，则该匹配一定包含 $(x,y_x)$。
• 结论 Gale-Shapley 算法产生的匹配 $M$ 一定为 $X$-最优匹配。

证明 记 $y=y_x$，假设 $(x,y)$ 是有效的且 $M$ 不包含 $(x,y)$。

设 $M$ 中与 $y$ 匹配的是 $x^{\prime }$，由算法流程 $r{k}_Y[y][x^{\prime }]<r{k}_Y[y][x]$（要么 $x$ 匹配后被 $x^{\prime }$ 替代，要么 $x^{\prime }$ 先匹配后无法被 $x$ 替代）。

由有效配对的定义，一定存在稳定匹配 $M^{\prime }$ 包含 $(x,y)$。

记 $M^{\prime }$ 中与 $x^{\prime }$ 匹配的是 $y^{\prime }$，能够得到匹配 $M$ 的条件是 $r{k}_X[x^{\prime }][y]<r{k}_X[x^{\prime }][y^{\prime }]$，则由于 $(x^{\prime },y)$ 的存在，$M^{\prime }$ 是不稳定的，与假设矛盾。

图的着色

点着色

• 设图 $G$ 的点色数为 $\chi (G)$，则显然有 $\chi (G)\le \Delta (G)+1$。
• Brooks 定理 若 $G$ 不为完全图或奇环，则 $\chi (G)\le \Delta (G)$。

证明 设 $|V(G)|=n$，考虑数学归纳法。

首先，$n\le 3$ 时，命题显然成立。

根据归纳法，假设对于 $n-1$ 的命题成立。

不妨只考虑 $\Delta (G)$-正则图，因为对于非正则图来说，可以看作在正则图里删去一些边构成的，而这一过程并不会影响结论。

对于任意不是完全图也不是奇圈的正则图 $G$，任取其中一点 $v$，考虑子图 $H=G-v$，由归纳假设知 $\chi (H)\le \Delta (H)\le \Delta (G)$，接下来我们只需证明在 $H$ 中插入 $v$ 不会影响结论即可。

若 $\Delta (H)<\Delta (G)$，无需再做证明，我们只考虑 $\Delta (H)=\Delta (G)$ 的情况。

令 $\Delta =\Delta (G)$，设 $H$ 染的 $C$ 种颜色分别为 $c_1,c_2,\dots ,c_{\Delta }$，$v$ 的 $\Delta$ 个邻接点为 $v_1,v_2,\dots ,v_{\Delta }$。若 $v$ 的邻接点个数不足 $\Delta$ 个或存在任意两点颜色相同，同样无需再做证明。

设所有在 $H$ 中染成 $c_i$ 或 $c_j$ 的点以及它们之间的所有边构成子图 $H_{i,j}$。不妨假设任意 2 个不同的点 $v_i,v_j$ 一定在 $H_{i,j}$ 的同一个连通分量中，否则若在两个连通分量中的话，可以交换其中一个连通分量所有点的颜色，从而使 $v_i,v_j$ 颜色相同，即能有多余的颜色对 $v$ 进行染色，无需再做证明。

这里的交换颜色指的是若图中只有两种颜色 $a,b$，那么把图中原来染成颜色 $a$ 的点全部染成颜色 $b$，把图中原来染成颜色 $b$ 的点全部染成颜色 $a$。

我们设上述连通分量为 $C_{i,j}$，取出 $C_{i,j}$ 中一条路径记作 $P_{i,j}$，则恒有 $C_{i,j}=P_{i,j}$。因为 $v_i$ 在 $H$ 中的度为 $\Delta -1$，所以 $v_i$ 在 $H$ 中的邻接点颜色一定两两不同，否则可以给 $v_i$ 染别的颜色，从而和 $v$ 的其他邻接点颜色重复，所以 $v_i$ 在 $C_{i,j}$ 中邻接点数量为 1。若 $C_{i,j}\ne P_{i,j}$，设在 $C_{i,j}$ 中从 $v_i$ 开始沿着 $P_{i,j}$ 遇到的第一个度数大于 2 的点为 $u$，注意到 $u$ 的邻接点最多只用了 $\Delta -2$ 种颜色，所以 $u$ 可以重新染色，从而使 $v_i,v_j$ 不连通。

沿用这一技术，我们可以证明对于 3 个不同的点 $v_i,v_j,v_k$，V(Ci,j)∩V(Cj,k)={vj}V(C_{i,j})\cap V(C_{j,k}) = \{v_j\}V(Ci,j​)∩V(Cj,k​)={vj​}。假设存在 $w\in V(C_{i,j})\cap V(C_{j,k})$，若 $w\ne v_j$，则 $w$ 必被染色为 $c_j$，且恰有两个被染色为 $c_i$ 的邻接点和两个被染色为 $c_j$ 的邻接点，注意到 $w$ 的邻接点最多只用了 $\Delta -2$ 种颜色，所以 $w$ 同样可以重新染色。

若 $v$ 的邻接点两两相邻，则必有 $\Delta =n$，即 $G$ 为完全图。否则不妨设 $v_1,v_2$ 不相邻，在 $C_{1,2}$ 取 $v_1$ 的邻接点 $w$，交换 $C_{1,3}$ 中的颜色，则 $w\in V(C_{1,2})\cap V(C_{2,3})$，与上述结论矛盾。

至此命题证明完毕。

斯坦纳树

• 以以下题面为例，主要把握其思想：
  • 给定连通图 $G$ 中的 $n$ 个点与 $k$ 个关键点，求能包含 $k$ 个关键点的生成树的最小边权，$k\ll n$。
• 设 $f_{x,S}$ 表示以 $x$ 为根且包含关键点集合 $S$ 的生成树的最小边权，在外层从小到大枚举 $S$，转移分为两类：
  • fx,S=min⁡{fx,S,fx,S−T+fx,T}f_{x,S} = \min\{f_{x,S}, f_{x,S-T}+f_{x,T}\}fx,S​=min{fx,S​,fx,S−T​+fx,T​}
  • 松弛，可通过 Dijkstra 或 SPFA 实现，fx,S=min⁡{fx,S,fy,S+w(x,y)}f_{x,S} = \min\{f_{x,S},f_{y,S} + w(x,y)\}fx,S​=min{fx,S​,fy,S​+w(x,y)}
• 总时间复杂度 $\mathcal{O}(2^k(n+m)\log (n+m)+3^{k}n)$。

竞赛图

• 定义 将 $n$ 个点的无向完全图任意定向即可得到竞赛图。
• 性质1 竞赛图缩点后呈链状，即求出竞赛图缩点后的拓扑序后，任意两个强连通分量之间的连边一定都是从拓扑序小的连向拓扑序大的。

证明 对强连通分量个数归纳，若新增的强连通分量拓扑序最大，则所有连向其的边同向。

• 性质2 竞赛图中每个强连通分量中存在哈密顿回路。

证明 对点数 $n(n\ge 3)$ 归纳，若新增的点连向原有 $n$ 个点的所有边均同向，则这 $n+1$ 个点不构成强连通分量，否则总可以找到 $n$ 个点中的两个点，使得它们在哈密顿回路上相邻且连向新增点的方向相反。

• 性质3 竞赛图中存在一条哈密顿路径。

证明 因为属于不同强连通分量间的点均有连边，由 性质2 取每个强连通分量中的哈密顿回路相连即可。

• 性质4 对于点数为 $n$ 的强连通竞赛图，$\forall 3\le l\le n$，其一定存在长度为 $l$ 的简单环。

证明 考虑对点数 $n$ 归纳，由 性质1，删除第 $n$ 个点后原图变为若干个强连通分量的链状图，由归纳条件，每个强连通分量均可以构造出不超过点数的简单环，且第 $n$ 个点一定有指向拓扑序最小的强连通分量的边，拓扑序最大的强连通分量一定有指向 $n$ 的边，不难得到构造长度不超过 $n$ 的简单环的方案。

• 性质5 在竞赛图中若点 $u$ 的出度大于等于点 $v$ 的出度，则 $u$ 一定可以到达 $v$。

证明 考虑证明其逆否命题，由 性质1，仅需证明 $u$ 所在强连通分量拓扑序大于 $v$ 所在强连通分量拓扑序的情况，此时显然 $v$ 的出度大于 $u$ 的出度。

• 兰道定理 将竞赛图的出度序列排序后得到 $s_1,s_2,\dots ,s_n$，该序列合法当且仅当 $\forall 2\le k\le n,\sum _{i=1}^k{s}_i\ge \left(\genfrac{}{}{0ex}{}{k}{2}\right)$ 且 $\sum _{i=1}^n{s}_i=\left(\genfrac{}{}{0ex}{}{n}{2}\right)$。

证明 其必要性显然，因为任取点数为 $k$ 的导出子图都满足该条件。考虑证明其充分性，构造一个所有边均是大点连向小点的竞赛图，则其 $s_i^{\prime }=i-1$，上述不等式可变形为 $\sum _{i=1}^k{s}_i\ge \sum _{i=1}^k{s}_i^{\prime }$，现在尝试通过不断调整该图，使得每个不等式均能取等号，每次操作如下：

• 找到第一个 $x$ 使得 $s_x>s_x^{\prime }$。
• 在 $x$ 后找到第一个 $z$ 使得 $s_z<s_z^{\prime }$
• 因而有 $s_z^{\prime }>s_z\ge s_x>s_x^{\prime }$，即 $s_z^{\prime }-s_x^{\prime }\ge 2$，此时必存在点 $y$，使得边 $z\to y$ 和 $y\to x$ 存在，将这两条边反向，则 $s_z^{\prime }$ 减少 1，$s_x^{\prime }$ 增加 1，$s_y^{\prime }$ 不变，原不等式仍成立。

强连通竞赛图计数

• 设 $f_n$ 表示 $n$ 个点的强连通竞赛图个数，考虑通过容斥原理计算 $f_n$，枚举拓扑序最靠前的强连通分量的大小，则剩余点连向该强连通分量的边的方向固定，而剩余点内部的连边是任意的，则对于 $n\ge 1$，有：
  $$\begin{array}{r}{f}_n=2^{\left(\genfrac{}{}{0ex}{}{n}{2}\right)}-\sum _{i=1}^{n-1}\left(\genfrac{}{}{0ex}{}{n}{i}\right)f_i{2}^{\left(\genfrac{}{}{0ex}{}{n-i}{2}\right)}\\ \frac{2^{\left(\genfrac{}{}{0ex}{}{n}{2}\right)}}{n!}=\sum _{i=1}^n\frac{f_i}{i!}\frac{2^{\left(\genfrac{}{}{0ex}{}{n-i}{2}\right)}}{(n-i)!}\end{array}$$
• 设 $F(x)=\sum _{n\ge 1}\frac{f_n}{n!}{x}^n$，$G(x)=\sum _{n\ge 0}\frac{2^{\left(\genfrac{}{}{0ex}{}{n}{2}\right)}}{n!}{x}^n$，则上式可表达为：
  $$\begin{array}{r}G=FG+1\\ F=1-\frac{1}{G}\end{array}$$
• 通过多项式求逆计算出 $F$ 即可。