OI+ACM 笔记：F - 图论

F - 图论杂项

图论基础

参考：

https://oi-wiki.org/graph/concept/

https://yhx-12243.github.io/OI-transit/memos/14.html

图的储存

邻接表的封装：

template <const int N, const int M>
struct adj {
	int tot, head[N], ver[M], edge[M], Next[M];
	void add_edge(int u, int v, int w) {
		ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot;
	} 
};

邻接表的储存成对变换：在具有双向边的图中，把正反方向的边分别储存在邻接表的位置 $n, n + 1$ （ $n$ 为偶数），就可以通过 $\mathrm{xor} \ 1$ 的操作获得当前边的反向边的储存位置。具体实现时，初始化要令 tot = 1。

图的遍历

BFS

Breadth First Search。

DFS

Depth First Search。

拓扑排序

拓扑序：一张有向无环图中的一个节点序列 $A$ ，满足对于图中的每条边 $(x, y)$ ， $x$ 在 $A$ 中都出现在 $y$ 之前。

维护一个入度为 $0$ 的点集 $S$ 。每次扩展时，从 $S$ 中取出任意一点 $u$ 加入拓扑序，然后枚举 $u$ 的所有出边，若某个出点 $v$ 在删除了 $(u, v)$ 这条边之后入度变为 $0$ ，则将 $v$ 加入点集 $S$ 。
由拓扑排序的算法得到的拓扑序按照层次分层，但同一层次的节点未必需要在拓扑序中相邻。
若要求字典序最小的拓扑序，将队列换成优先队列即可。

int tot, head[N], ver[M], Next[M], deg[N];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;    deg[v] ++;
}

int seqlen, seq[N];

void topsort() {
	std::queue<int> q;

	for (int i = 1; i <= n; i ++)
		if (deg[i] == 0) q.push(i);

	while (q.size()) {
		int u = q.front(); q.pop();

		seq[++ seqlen] = u;

		for (int i = head[u]; i; i = Next[i]) {
			int v = ver[i];
			if (-- deg[v] == 0) q.push(v);
		}
	}
}

欧拉路、欧拉回路

欧拉路：恰好不重不漏的经过每条边一次（可以重复经过图中的节点）的通路。

欧拉回路：恰好不重不漏的经过每条边一次（可以重复经过图中的节点）的回路。

欧拉图：存在欧拉回路的无向图。

欧拉图的判定：

一张无向图为欧拉图，当且仅当无向图连通，并且每个点的度数都是偶数。
一张有向图为欧拉图，当且仅当非零度点强联通，每个点的入度与出度相等。

欧拉路的存在性判定：一张图中存在欧拉路，当且仅当无向图连通，并且途中恰好有两个节点的度数为奇数，其他节点的度数都是偶数。这两个度数为奇数的节点就是欧拉路的起点 $S$ 和终点 $T$ 。

三元环计数、四元环计数

无向图三元环计数：

将所有点以度数为第一关键字（小到大）编号为第二关键字（小到大）排序，将所有边按排名从小到大定向，形成一张 DAG。
此时所有三元环的边向情况，只有 $x \to y$ 、 $y \to z$ 、 $x \to z$ 这一种情况。
枚举点 $x$ ，第一轮枚举 $x$ 在新图中的出边，将所到达的点 $z$ 打上标记；第二轮枚举 $x$ 在新图中的出边，对于所到达的点 $y$ ，再枚举 $y$ 在新图中的出边到达的点 $z$ ，如果 $z$ 上有标记，则 $x, y, z$ 构成三元环。

std::vector<int> e[N];

int id[N], rk[N];
std::vector<int> out[N];

bool vis[N];

int main() {
	for (int i = 1, u, v; i <= m; i ++)
		e[u].push_back(v), e[v].push_back(u);

	for (int i = 1; i <= n; i ++) id[i] = i;
	std::sort(id + 1, id + 1 + n);

	for (int i = 1; i <= n; i ++) rk[id[i]] = i;

	for (int u = 1; u <= n; u ++)
		for (int v : e[u]) if (rk[u] < rk[v]) out[u].push_back(v);

	int ans = 0;
	for (int x = 1; x <= n; x ++) {
		for (int z : out[x]) vis[z] = 1;

		for (int y : out[x])
			for (int z : out[y])
				if (vis[z]) ans ++;

		for (int z : out[x]) vis[z] = 0;
	}
}

无向图三元环计数，时间复杂度： $\mathcal{O}(m\sqrt{m})$ 。

无向图三元环计数，时间复杂度分析：

记 $\mathrm{deg}_u$ 为原图中点 $u$ 的度， $\mathrm{out}_u$ 为新图中点 $u$ 的出度。可证 $\mathrm{out}_u$ 为 $\mathcal{O}(\sqrt{m})$ 级别。
- 若 $\mathrm{deg}_u \leq \sqrt{m}$ ，则 $\mathrm{out}_u \leq \sqrt{m}$ 。
- 若 $\mathrm{deg}_u > \sqrt{m}$ ，则 $u$ 在新图中指向的点的度数大于 $\sqrt{m}$ ，故 $\mathrm{out}_u \leq \sqrt{m}$ 。
上述流程的复杂度，相当于对定向后每条边 $(u, v)$ 的 $v$ 的 $\mathrm{out}_v$ 求和。每条边的贡献为 $\mathcal{O}(\sqrt{m})$ 级别，故上述流程的复杂度为 $\mathcal{O}(m\sqrt{m})$ 。

无向图三元环计数的推论：无向图的三元环个数为 $\mathcal{O}(m\sqrt{m})$ 级别。

有向图三元环计数：转化为无向图三元环计数，找到三元环时判断方向即可。

竞赛图三元环计数：记点 $i$ 的出度为 $\mathrm{out}_i$ ，则三元环个数为

(\binom{n}{3}) - \sum_{i = 1}^{n} (\binom{{o u t}_{i}}{2})

$\dbinom{n}{3} - \sum\limits_{i = 1}^n \dbinom{\mathrm{out}_i}{2}$

无向图四元环计数：

将所有点以度数为第一关键字（小到大）编号为第二关键字（小到大）排序，将所有边按排名从小到大定向，形成一张 DAG。
此时所有四元环的边向情况，只有两条形如 $(x, y)$ 、 $y \to z$ 的路径拼起来的情况：
- $x \to y_1$ 、 $y_1 \to z$ 、 $x \to y_2$ 、 $y_2 \to z$ 。
- $x \gets y_1$ 、 $y_1 \to z$ 、 $x \to y_2$ 、 $y_2 \to z$ 。
- $x \gets y_1$ 、 $y_1 \to z$ 、 $x \gets y_2$ 、 $y_2 \to z$ 。
枚举点 $x$ ，再枚举 $x$ 在原图中的出边，对于所到达的点 $y$ ，再枚举 $y$ 在新图中的出边到达的点 $z$ （为避免第三种边向情况重复计数，此处枚举到的 $z$ 应满足 $\mathrm{rk}_x < \mathrm{rk}_z$ ），则先前枚举的所有形如 $(x, y)$ 、 $y \to z$ 的路径都与当前枚举的路径构成四元环。

std::vector<int> e[N];

int id[N], rk[N];
std::vector<int> out[N];

int cnt[N];

int main() {
	for (int i = 1, u, v; i <= m; i ++)
		e[u].push_back(v), e[v].push_back(u);

	for (int i = 1; i <= n; i ++) id[i] = i;
	std::sort(id + 1, id + 1 + n);

	for (int i = 1; i <= n; i ++) rk[id[i]] = i;

	for (int u = 1; u <= n; u ++)
		for (int v : e[u]) if (rk[u] < rk[v]) out[u].push_back(v);

	int ans = 0;
	for (int x = 1; x <= n; x ++) {
		for (int y : e[x])
			for (int z : out[y])
				if (rk[x] < rk[z]) ans += cnt[z] ++;

		for (int y : e[x])
			for (int z : out[y])
				if (rk[x] < rk[z]) cnt[z] = 0;
	}
}

无向图四元环计数，时间复杂度： $\mathcal{O}(m\sqrt{m})$ 。

无向图四元环计数，时间复杂度分析：同无向图三元环计数。

Prufer 序列

Prufer 序列：一个包含 $n-2$ 个取值范围在 $[1, n]$ 中的正整数的序列。可以理解为带标号的完全图生成树与数列的双射。

Prufer 序列构造：每次选择一个编号最小的叶结点并删掉它，并且在序列中记录下它连接到的那个结点。重复 $n-2$ 次后，只剩下两个节点后停止。

Prufer 序列性质：

在构造完 Prufer 序列后原树中会剩下两个结点，其中一个一定是编号最大的点 $n$ 。
每个节点在 Prufer 序列中的出现次数是其度数减 $1$ ，叶节点不出现。

树转 Prufer 序列：

$\mathcal{O}(n \log n)$ 构造：堆优化。
$\mathcal{O}(n)$ 构造：注意到叶节点个数是单点不增的。考虑维护一个指针 $p$ ，初始时 $p$ 指向编号最小的叶节点。同时维护每个节点的度数，考虑重复如下过程：
1. 删除节点 $p$ ，并检查是否产生新的叶节点。
2. 如果产生新的叶节点 $x$ ，比较 $x, p$ 的大小关系，若 $x > p$ ，则不做其他操作；若 $x < p$ ，则立刻删除 $x$ ，然后检查是否产生新的叶节点 ...（重复步骤 2），直到未产生新节点或新节点的编号 $>p$ 。
3. 让 $p$ 自增，直到遇到一个未被删除的叶节点为止。

int tot, head[N], ver[N * 2], Next[N * 2], deg[N];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;    deg[v] ++;
}

int Fa[N];

void dfs(int u) {
	for (int i = head[u]; i; i = Next[i]) {
		int v = ver[i];
		if (Fa[v]) continue;
		Fa[v] = u;
		dfs(v);
	}
}

int prufer[N];

int main() {
	Fa[n] = -1, dfs(n);

	int leaf = 0, p = 0;
	for (int i = 1; i <= n; i ++)
		if (deg[i] == 1) { leaf = p = i; break; }
	for (int i = 1; i <= n - 2; i ++) {
		int x = Fa[leaf];

		prufer[i] = x;

		if (-- deg[x] == 1 && x < p) {
			leaf = x;
		} else {
			p ++;
			while (deg[p] != 1) p ++;
			leaf = p;
		}
	}

	for (int i = 1; i <= n - 2; i ++)
		printf("%d ", prufer[i]);
	puts("");
}

Prufer 序列转树：通过 Prufer 序列反推每个节点的度数。依次枚举 Prufer 序列的每一个点，每次选择一个度数为 $1$ 且编号最小的节点，与当前枚举到的 Prufer 序列的点连边，并且令这两个点的度数减 $1$ 。重复 $n-2$ 次后，只剩下两个度数为 $1$ 的节点，将这两个点连边。

$\mathcal{O}(n \log n)$ 构造：堆优化。
$\mathcal{O}(n)$ 构造：同 "树转 Prufer 序列"。

int n;
int prufer[N];

int deg[N]; 

std::pair<int, int> e[N];

int main() {
	for (int i = 1; i <= n; i ++) deg[i] = 1;
	for (int i = 1; i <= n - 2; i ++) deg[prufer[i]] ++;

	int leaf = 0, p = 0;
	for (int i = 1; i <= n; i ++)
		if (deg[i] == 1) { leaf = p = i; break; }
	for (int i = 1; i <= n - 2; i ++) {
		int x = prufer[i];

		e[i] = std::make_pair(leaf, x);

		if (-- deg[x] == 1 && x < p) {
			leaf = x;
		} else {
			p ++;
			while (deg[p] != 1) p ++;
			leaf = p;
		}
	}

	e[n - 1] = std::make_pair(leaf, n);
}

Cayley 公式（有标号完全图生成树计数）：有标号完全图有 $n^{n-2}$ 棵生成树。

回到顶部

F - 图论最小生成树

Kruskal

$\mathcal{O}(n + m \log m)$ 。

struct edg {
	int u, v, w;
	bool operator < (const edg &rhs) const {
		return w < rhs.w;
	}
} e[M];

int fa[N];
int get(int x) {
	return fa[x] == x ? x : fa[x] = get(fa[x]);
}

void kruskal() {
	std::sort(e + 1, e + 1 + m);
 
	for (int i = 1; i <= n; i ++) fa[i] = i;
	for (int i = 1; i <= m; i ++) {
		int u = e[i].u, v = e[i].v, w = e[i].w;
		int p = get(u), q = get(v);

		if (p == q) continue;

		// Calculate the information of the (u, v, w)

		fa[p] = q;
	}
}

Kruskal 重构树

Kruskal 重构树：按 Kruskal 的流程，每加入一条边 $(u, v, w)$ ，就新建一个点 $x$ ，同时将 $x$ 的点权设为 $w$ ，将 $u, v$ 所在的树的根节点分别设为点 $x$ 的左儿子与右儿子。在进行 $n - 1$ 轮合并后，得到了一棵恰有 $n$ 个叶子的二叉树，同时每个非叶子节点恰好有两个儿子，这棵树即为 kruskal 重构树。

struct edg {
	int u, v, w;
	bool operator < (const edg &rhs) const {
		return w < rhs.w;
	}
} e[M];

namespace KRT {
	const int SIZE = N * 2;

	int nClock;
	struct node {
		int lc, rc;
		int val;
	} t[SIZE];

	int fa[SIZE];
	int get(int x) {
		return fa[x] == x ? x : fa[x] = get(fa[x]);
	}

	void build() {
		std::sort(e + 1, e + 1 + m);

		nClock = n;
		for (int i = 1; i <= n; i ++) fa[i] = i;
		for (int i = 1; i <= m; i ++) {
			int u = e[i].u, v = e[i].v, w = e[i].w;
			int p = get(u), q = get(v);

			if (p == q) continue;

			int x = ++ nClock;
			t[x].val = w, t[x].lc = p, t[x].rc = q;

			fa[p] = fa[q] = fa[x] = x;
		}
	}
}

Kruskal 重构树的简单性质：

kruskal 最小重构树是大根堆，kruskal 最大重构树是小根堆。
kruskal 最小重构树中，两叶子节点之间 LCA 的权值，对应原图中两点之间所有简单路径上最大边权的最小值。
kruskal 最小重构树中，对于叶子节点 $x$ 到根的路径上权值 $\leq \mathrm{val}$ 的最浅节点，其子树内的所有节点，即为从 $x$ 开始只经过边权 $\leq \mathrm{val}$ 的边所能到达的节点（满足两点之间所有简单路径上最大边权的最小值 $\leq \mathrm{val}$ ）。

Prim

$\mathcal{O}(n^2)$ 。

const int inf = 0x3f3f3f3f;

int a[N][N];

int d[N];
bool exist[N];

void prim() {
	for (int i = 1; i <= n; i ++) d[i] = inf;
    d[1] = 0;

	for (int i = 1; i <= n; i ++) exist[i] = 0;

	for (int i = 1; i <= n; i ++) {
		int u = 0;
		for (int x = 1; x <= n; x ++)
			if (!exist[x] && (u == 0 || d[x] < d[u])) u = x;

		exist[u] = 1;

		for (int v = 1; v <= n; v ++)
			if (!exist[v]) d[v] = std::min(d[v], a[u][v]); 
	}
}

Brouvka

初始时，每一个点都是一个连通块。每一轮，遍历所有点和边，连接一个连通块中和其他连通块相连的最小边。
$\mathcal{O}((n + m) \log n)$ 。

const int inf = 0x3f3f3f3f;

struct edg {
	int u, v, w;
} e[M];

int fa[N];
int get(int x) {
	return fa[x] == x ? x : fa[x] = get(fa[x]);
}

int great_val[N], great_id[N];

void boruvka() {
	for (int i = 1; i <= n; i ++) fa[i] = i;

	while (1) {
		for (int i = 1; i <= n; i ++) great_val[i] = inf, great_id[i] = 0;

		bool exist = 0;
		for (int i = 1; i <= m; i ++) {
			int p = get(e[i].u), q = get(e[i].v);
			if (p == q) continue;
			exist = 1;
			if (e[i].w < great_val[p]) great_val[p] = e[i].w, great_id[p] = i;
			if (e[i].w < great_val[q]) great_val[q] = e[i].w, great_id[q] = i;
		}

		if (!exist) break;

		for (int i = 1; i <= n; i ++) {
			if (great_id[i] == 0) continue;
			int id = great_id[i], p = get(e[id].u), q = get(e[id].v);
			if (p == q) continue;
			// Calculate the data of this edge.
			fa[p] = q;
		}
	}
}

const int inf = 0x3f3f3f3f;

int cur_block;

int fa[N];
int get(int x) {
	return fa[x] == x ? x : fa[x] = get(fa[x]);
}

int great_val[N], great_id[N];

void boruvka() {
	cur_block = n;
	for (int i = 1; i <= n; i ++) fa[i] = i;

	while (cur_block ^ 1) {
		for (int i = 1; i <= n; i ++) great_val[i] = inf, great_id[i] = 0;

		for (int i = 1; i <= n; i ++) {
			int p = get(i);
			// update the data of this connected block p with i.
		}

		for (int i = 1; i <= n; i ++) {
			if (great_id[i] == 0) continue;
			int p = get(i), q = get(great_id[i]);
			if (p == q) continue;
			// Calculate the data of this edge.
			fa[p] = q, cur_block --;
		}
	}
}

回到顶部

F - 图论最短路径

Dijkstra

Dijkstra： $\mathcal{O}(n^2)$ 。
Dijkstra + Heap： $\mathcal{O}((n + m) \log m)$ 。

const int inf = 0x3f3f3f3f;

int tot, head[N], ver[M], edge[M], Next[M];
void add_edge(int u, int v, int w) {
	ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot; 
}

int dist[N];
bool vis[N];

void dijkstra() {
	for (int i = 1; i <= n; i ++) dist[i] = inf;
	for (int i = 1; i <= n; i ++) vis[i] = 0;

	std::priority_queue< pair<int, int> > q;
	q.push(make_pair(0, 1)), dist[1] = 0;

	while (q.size()) {
		int u = q.top().second; q.pop();

		if (vis[u]) continue;
		vis[u] = 1;

		for (int i = head[u]; i; i = Next[i]) {
			int v = ver[i], w = edge[i];
			if (dist[u] + w < dist[v]) {
				dist[v] = dist[u] + w;
				q.push(make_pair(-dist[v], v));
			}
		}
	}
}

Bellman-ford & SPFA

SPFA： $\mathcal{O}(nm)$ 。

const int inf = 0x3f3f3f3f;

int tot, head[N], ver[M], edge[M], Next[M];
void add_edge(int u, int v, int w) {
	ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot;
}

int dist[N];
bool vis[N];

void SPFA() {
	for (int i = 1; i <= n; i ++) dist[i] = inf;
	for (int i = 1; i <= n; i ++) vis[i] = 0;

	std::queue<int> q;
	q.push(1), dist[1] = 0;

	while (q.size()) {
		int u = q.front(); q.pop(); vis[u] = 0;

		for (int i = head[u]; i; i = Next[i]) {
			int v = ver[i], w = edge[i];
			if (dist[u] + w < dist[v]) {
				dist[v] = dist[u] + w;
				if (!vis[v]) q.push(v), vis[v] = 1;
			}
		}
	}
}

Bellman-Ford 判负环：若经过 $n$ 轮迭代后，图中仍有能更新的边，则图中有负环。

SPFA 判负环：设 $\mathrm{cnt}_x$ 表示 $1$ 到 $x$ 的最短路包含的边数。在迭代的过程中，若发现 $\mathrm{cnt}_y \geq n$ ，则图中有负环。

Floyd

Floyd： $\mathcal{O}(n^3)$ 。
Floyd 本质上是 dp。定义 $f(k, i, j)$ 表示允许经过 $1$ 到 $k$ 号点作为中间点（除了 $i, j$ 分别为起点终点，经过的其他点只能是 $1 \sim k$ 的点）的情况下，点 $i$ 到点 $j$ 的最短路。通过滚动数组优化掉了阶段维，才得到最常见的 Floyd 写法。如果以任意的顺序枚举 $k$ ，得到的 $f(i, j)$ 即为允许经过枚举过的点作为中间点的情况下，点 $i$ 到点 $j$ 的最短路。

差分约束

差分约束：一种特殊的 $n$ 元一次不等式组，包含 $n$ 个变量 $x_1, x_2, \cdots, x_n$ 以及 $m$ 组限制关系 $x_i - x_j \leq c_k$ 。

$x_i - x_j \leq c_k$ 可以变形为 $x_i \leq x_j + c_k$ ，形似三角形不等式，因此从点 $j$ 向点 $i$ 连一条长度为 $c_k$ 的有向边。
若存在负环则无解，否则最短路即为一组合法解。

同余最短路

同余最短路，问题 1：给出 $a_1, a_2, \cdots, a_n$ 和一个模数 $K$ ，对于每一个 $p \in [0, K)$ 求使得 $(\sum a_i x_i) \bmod K = p$ 的 $\sum a_ix_i$ 最小值。

建 $K$ 个点，编号为 $0 \sim K - 1$ 。
对于每一个 $p \in [0, K)$ 和每一个 $a_i$ ，令 $p$ 向 $(p + a_i) \bmod K$ 连一条长度为 $a_i$ 的边。转化为图论模型。

同余最短路，问题 2：给出 $a_1, a_2, \cdots, a_n$ 和一个上界 $H$ ，求 $\sum a_ix_i$ 的数值在 $[0, H]$ 有多少个解。

回到顶部

F - 图论连通性

无向图 tarjan

时间戳与追溯值

时间戳 $\mathrm{dfn}_x$ ：在深度优先遍历的过程中，节点 $x$ 第一次被访问时的时间顺序。

追溯值 $\mathrm{low}_x$ ：以下节点的时间戳的最小值

$\mathrm{subtree}(x)$ 中的节点。
通过一条非搜索树边，能够到达 $\mathrm{subtree}(x)$ 中的节点的点。

时间戳 $\mathrm{dfn}_x$ 与追溯值 $\mathrm{low}_x$ 的计算方式：对整张图进行深度优先遍历，一开始 $\mathrm{low}_x = \mathrm{dfn}_x$ ，考虑从 $x$ 出发的每条边 $(x, y)$

若 $x$ 是 $y$ 的父亲，则

{low}_{x} = min ({low}_{x}, {low}_{y})

$\text{low}_x = \min(\text{low}_x, \text{low}_y)$

若 $(x, y)$ 为非搜索树边，则

{low}_{x} = min ({low}_{x}, {dfn}_{y})

$\text{low}_x = \min(\text{low}_x, \text{dfn}_y)$

割点

割点：满足删去该点以及连接该点的边后，原图不连通的点。

割点判定法则：在搜索树上，若存在 $x$ 的某个儿子 $y$ 满足

{d f n}_{x} \leq {l o w}_{y}

$\mathrm{dfn}_x \leq \mathrm{low}_y$

则 $x$ 为割点。特别地，若 $x$ 为搜索树的根，则至少要找出两个满足条件的儿子。

int tot, head[N], ver[M * 2], Next[M * 2];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
}

int root, dfsClock, dfn[N], low[N];
bool cut[N];

void tarjan(int u) {
	dfn[u] = low[u] = ++ dfsClock;

	int cp = 0;
	for (int i = head[u]; i; i = Next[i]) {
		int v = ver[i];
		if (!dfn[v]) {
			tarjan(v);
			low[u] = std::min(low[u], low[v]);
			if (dfn[u] <= low[v]) {
				cp ++;
				if (u != root || cp > 1) cut[u] = 1;
			}
		} else {
			low[u] = std::min(low[u], dfn[v]);
		}
	}
}

int main() {
	for (int i = 1; i <= n; i ++)
		if (!dfn[i]) root = i, tarjan(i);
}

割边

割边：满足删去该边后，原图不连通的边。

割边判定法则：在搜索树上，若 $x$ 为 $y$ 的父亲，且满足

{d f n}_{x} < {l o w}_{y}

$\mathrm{dfn}_x < \mathrm{low}_y$

则 $(x, y)$ 为割边。

int tot = 1, head[N], ver[M * 2], Next[M * 2];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
}

int dfsClock, dfn[N], low[N];
bool bridge[M * 2];

void tarjan(int u, int in_edge) {
	dfn[u] = low[u] = ++ dfsClock;

	for (int i = head[u]; i; i = Next[i]) {
		int v = ver[i];
		if (!dfn[v]) {
			tarjan(v, i);
			low[u] = std::min(low[u], low[v]);
			if (dfn[u] < low[v]) bridge[i] = bridge[i ^ 1] = 1;
		} else if (i != (in_edge ^ 1)) {
			low[u] = std::min(low[u], dfn[v]);
		}
	}
}

int main() {
	for (int i = 1; i <= n; i ++)
		if (!dfn[i]) tarjan(i, 0);
}

点双连通分量

点双连通：若删去任意一个点（除 $u, v$ 以外）， $u, v$ 仍连通，则称 $u$ 与 $v$ 是点双连通的。

点双连通图：不存在割点的无向连通图。

点双连通分量（v-DCC）：无向图的极大点双连通子图。

v-DCC 的简单性质：

一张无向连通图是 v-DCC，当且仅当任意两个点都包含在至少一个简单环中。
对于一个 v-DCC 的任意两个点，它们之间都有至少两个点不重复的路径。
对于一个 v-DCC 中任意两个点，它们之间简单路径的并集，恰好完全等于这个 v-DCC。
割点至少在两个 v-DCC 中，其他非割点属于且仅属于一个 v-DCC 中。

v-DCC 的缩点（圆方树）：

在圆方树中，原图中每个点对应一个圆点，每个 v-DCC 对应一个方点。
对于每个 v-DCC，令其对应的方点向该 v-DCC 中的每一个圆点连边。每个 v-DCC 构成一个菊花图，多个菊花图通过原图中的割点连接。
对原图做一遍无向图 tarjan。考虑一个 v-DCC 在 DFS 树中的最顶端节点 $u$ ，在点 $u$ 处确定这个 v-DCC。对于一个树边 $(u, v)$ ， $u, v$ 在同一个 v-DCC 中且 $u$ 是这个 v-DCC 中的最顶端节点，当且仅当 $\mathrm{dfn}_u = \mathrm{low}_v$ 。
可以在 DFS 的过程中，维护一个栈，储存还未确定所属 v-DCC（可能有多个）的节点。找到 v-DCC 时，v-DCC 中除了 $u$ 以外的其他点都集中在栈顶端，只需不断弹出栈顶直到弹出 $v$ 为止。 $u$ 和被弹出的所有点，构成一个 v-DCC，都需要向新建的方点连边。

const int SIZE = N * 2;

template <const int N, const int M>
struct adj {
	int tot, head[N], ver[M], Next[M];
	void add_edge(int u, int v) {
		ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
	}
};

adj<N, M * 2> G;
adj<SIZE, SIZE * 2> V;

int dfsClock, dfn[N], low[N];
int stk, top[N];

int v_dcc;

void tarjan(int u) {
	dfn[u] = low[u] = ++ dfsClock;
	stk[++ top] = u;

	for (int i = G.head[u]; i; i = G.Next[i]) {
		int v = G.ver[i];
		if (!dfn[v]) {
			tarjan(v);
			low[u] = std::min(low[u], low[v]);

			if (dfn[u] == low[v]) {
				v_dcc ++;

				int x, p = n + v_dcc;
				do {
					x = stk[top --];
					V.add_edge(x, p), V.add_edge(p, x);
				} while (x != v);

				V.add_edge(u, p), V.add_edge(p, u);
			}
		} else {
			low[u] = std::min(low[u], dfn[v]);
		}
	}
}

int main() {
	for (int i = 1, u, v; i <= m; i ++)
		G.add_edge(u, v), G.add_edge(v, u);

	for (int i = 1; i <= n; i ++)
		if (!dfn[i]) top = 0, tarjan(i);
}

边双连通分量

边双连通：若删去任意一条边， $u, v$ 仍连通，则称 $u$ 与 $v$ 是边双连通的。

边双连通图：不存在割边的无向连通图。

边双连通分量（e-DCC）：无向图的极大边双连通子图。

e-DCC 的简单性质：

一张无向连通图是 e-DCC，当且仅当任意一条边都包含在至少一个简单环中。
对于一个 e-DCC 中的任意两个点，它们之间都有至少两个边不重复的路径。
对于一个 e-DCC 中的任意两个点，它们之间简单路径的并集，恰好完全等于这个 e-DCC。
割边不属于任意 e-DCC，其他非割边属于且仅属于一个 e-DCC。
一张图经过 e-DCC 缩点后会得到树或森林。

e-DCC 的缩点：

对原图做一遍无向图 tarjan。考虑一个 e-DCC 在 DFS 树中的最顶端节点 $u$ ，在点 $u$ 处确定这个 e-DCC。 $u$ 是这个 e-DCC 中的最顶端节点，当且仅当 $\mathrm{dfn}_u = \mathrm{low}_u$ 。
可以在 DFS 的过程中，维护一个栈，储存还未确定所属 e-DCC（可能有多个）的节点。找到 e-DCC 时，e-DCC 中的所有点都集中在栈顶端，只需不断弹出栈顶直到弹出 $u$ 为止。被弹出的所有点，构成一个 e-DCC。
在找出了所有的 e-DCC 后，枚举原图中的所有边 $(u, v)$ ，若 $u$ 与 $v$ 不属于同一个 e-DCC，则在 $u, v$ 所属的 e-DCC 之间连一条边。

template <const int N, const int M>
struct adj {
	int tot = 1, head[N], ver[M * 2], Next[M * 2];
	void add_edge(int u, int v) {
		ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
	}
};

adj<N, M * 2> G;
adj<N, N * 2> V;

int dfsClock, dfn[N], low[N];
int top, stk[N];

int e_dcc, col[N];

void tarjan(int u, int in_edge) {
	dfn[u] = low[u] = ++ dfsClock;
	stk[++ top] = u;

	for (int i = G.head[u]; i; i = G.Next[i]) {
		int v = G.ver[i]; 
		if (!dfn[v]) {
			tarjan(v, i);
			low[u] = std::min(low[u], low[v]); 
		} else if (i != (in_edge ^ 1)) {
			low[u] = std::min(low[u], dfn[v]);
		}
	}

	if (dfn[u] == low[u]) {
		e_dcc ++;

		int x;
		do {
			x = stk[top --];
			col[x] = e_dcc;
		} while (x != u);
	}
}

int main() {
	for (int i = 1, u, v; i <= m; i ++)
		G.add_edge(u, v), G.add_edge(v, u);

	for (int i = 1; i <= n; i ++)
		if (!dfn[i]) tarjan(i, 0);

	for (int i = 2; i < G.tot; i += 2) {
		int u = G.ver[i ^ 1], v = G.ver[i];
		if (col[u] == col[v]) continue;

		V.add_edge(col[u], col[v]), V.add_edge(col[v], col[u]);
	}
}

有向图 tarjan

流图

时间戳 $\mathrm{dfn}_x$ ：在深度优先遍历的过程中，节点 $x$ 第一次被访问时的时间顺序。

流图：给定有向图 $G = (V, E)$ ，若存在 $r \in V$ ，满足从 $r$ 出发能够到达 $V$ 中的所有点，则称 $G$ 是一个流图，其中 $r$ 称为流图的源点。

流图中的有向边 $(x, y)$ 分类：对于流图中的有向边 $(x, y)$ ，必是以下四种之一

树枝边。指搜索树中的边，即 $x$ 是 $y$ 的父节点。
前向边。指搜索树中 $x$ 是 $y$ 的祖先节点。
后向边。指搜索树中 $y$ 是 $x$ 的祖先节点。
横叉边。指除了以上三种情况之外的边，一定满足 $\mathrm{dfn}_x > \mathrm{dfn}_y$ 。

强连通分量

强连通：若既存在 $x$ 到 $y$ 的路径，又存在 $y$ 到 $x$ 的路径，则称 $x$ 与 $y$ 是强连通的。

强连通图：任意两点都强连通的有向图。

强连通分量（SCC）：有向图的极大强连通子图。

时间戳 $\mathrm{dfn}_x$ ：在深度优先遍历的过程中，节点 $x$ 第一次被访问时的时间顺序。

追溯值 $\mathrm{low}_x$ ：以下节点的时间戳的最小值

栈中的节点。有向图 tarjan 在深度优先遍历的同时维护了一个栈，当访问到节点 $x$ ，保存从 $x$ 出发的后向边、横叉边形成环的节点：
- 搜索树上 $x$ 的祖先节点，记作 $\mathrm{anc}(x)$ 。
- 已经访问过，并且存在一条路径到达 $\mathrm{anc}(x)$ 的节点。
通过一条从 $\mathrm{subtree}(x)$ 中出发的有向边，以该点为终点。

时间戳 $\mathrm{dfn}_x$ 与追溯值 $\mathrm{low}_x$ 的计算方式：对整张图进行深度优先遍历，一开始 $\mathrm{low}_x = \mathrm{dfn}_x$ ，将 $x$ 入栈，考虑从 $x$ 出发的每条边 $(x, y)$

若 $y$ 没有访问过，则说明 $x$ 为 $y$ 的父亲，则

{l o w}_{x} = min ({l o w}_{x}, {l o w}_{y})

$\mathrm{low}_x = \min(\mathrm{low}_x, \mathrm{low}_y)$

若 $y$ 被访问过，且 $y$ 在栈中，则

{l o w}_{x} = min ({l o w}_{x}, {d f n}_{y})

$\mathrm{low}_x = \min(\mathrm{low}_x, \mathrm{dfn}_y)$

在 $x$ 回溯之前，若 $\mathrm{dfn}_x = \mathrm{low}_x$ ，则不断弹出栈顶直到弹出 $x$ 为止。

SCC 判定法则：在 $x$ 回溯之前，若 $\mathrm{dfn}_x = \mathrm{low}_x$ ，则栈中从 $x$ 到栈顶的所有节点构成一个 SCC。

SCC 的缩点：在找出了所有的 SCC 后，枚举原图中的所有边 $(u, v)$ ，若 $u$ 与 $v$ 不属于同一个 SCC，则在 $u, v$ 所属的 SCC 之间连一条边。

template <const int N, const int M>
struct adj {
	int tot, head[N], ver[M], Next[M];
	void add_edge(int u, int v) {
		ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
	}
}; 

adj<N, M * 2> G, V;

int dfsClock, dfn[N], low[N];
int top, stk[N]; bool inc[N];

int scc, col[N];
std::vector<int> h[N];

void tarjan(int u) {
	dfn[u] = low[u] = ++ dfsClock;
	stk[++ top] = u, inc[u] = 1;

	for (int i = G.head[u]; i; i = G.Next[i]) {
		int v = G.ver[i];
		if (!dfn[v]) {
			tarjan(v);
			low[u] = std::min(low[u], low[v]);
		} else if (inc[v]) {
			low[u] = std::min(low[u], dfn[v]);
		}
	}

	if (dfn[u] == low[u]) {
		scc ++;

		int x;
		do {
			x = stk[top --], inc[x] = 0;
			col[x] = scc, h[scc].push_back(x);
		} while (x != u);
	}
}

int main() {
	for (int i = 1, u, v; i <= m; i ++)
		G.add_edge(u, v);

	for (int i = 1; i <= n; i ++)
		if (!dfn[i]) tarjan(i);

	for (int u = 1; u <= n; u ++)
		for (int i = G.head[u]; i; i = G.Next[i]) {
			int v = G.ver[i];
			if (col[u] == col[v]) continue;

			V.add_edge(col[u], col[v]);
		}
}

tarjan 编号：tarjan 编号，为原图缩点后 DAG 的拓扑序反序。

2-SAT

2-SAT：有 $n$ 个变量，每个变量只有两种可能的取值。给定 $m$ 个条件，每个条件都形如「若 $a_i = p$ 则 $a_j = q$ 」。求是否存在对 $n$ 个变量的合法赋值，使得 $m$ 个条件均得到满足。

2-SAT 的判定：

建立包含 $2n$ 个节点的有向图， $a_i = 0$ 对应节点 $i$ ， $a_i = 1$ 对应节点 $i + n$ 。
建立条件「若 $a_i = p$ 则 $a_j = q$ 」在图中的边，令 $a_i = p$ 所代表的节点向 $a_j = q$ 所代表的节点连一条有向边。
使用有向图 tarjan 算法求出图中所有的强连通分量。若存在一个 $i$ 使得 $a_i = 0$ 与 $a_i = 1$ 所代表的节点存在于同一个强联通分量中，则没有合法的赋值方案，否则肯定可以找到一组合法的赋值方案。

2-SAT 求方案：

在缩点后 DAG " 自底向上 " 的拓扑序中，若 $a_i = 0$ 比 $a_i = 1$ 靠后，则 $a_i = 1$ 则 $a_i = 0$ 。
tarjan 得到的 SCC 编号，即为缩点后 DAG " 自底向上 " 的拓扑序。

回到顶部

F - 图论二分图

二分图：若一张无向图的 $n$ 个节点可以分成 $A, B$ 两个非空无交集合，并且在同一集合内的点之间都没有边相连，那么这张无向图称为一张二分图， $A, B$ 分别称为二分图的左部与右部。

二分图染色

二分图判定定理：一张无向图是二分图，当且仅当图中不存在奇环。

二分图判定定理推论：一张二分图的任意子图为二分图。

二分图路径长度简单性质：

一张二分图中，任意两点间路径经过的边数奇偶性确定。
一张连通非二分图中，任意两点间路径经过的边数可以是奇数也可以是偶数。

二分图染色：对整张图进行深度优先遍历，尝试用黑白两种颜色标记图中的节点，当一个节点被标记后，它的所有相邻节点应被标记与它相反的颜色。若标记过程中产生冲突，则说明图中存在奇环。

int tot, head[N], ver[M * 2], Next[M * 2];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
}

int col[N];

bool dfs(int u, int color) {
	col[u] = color;

	for (int i = head[u]; i; i = Next[i]) {
		int v = ver[i];
		if (col[u] == col[v])
			return 0;
		else if (!col[v] && !dfs(v, 3 - color))
			return 0;
	}

	return 1;
}

二分图匹配

匹配：一组边的集合 $S$ ，满足任意两条边都没有公共端点。属于 $S$ 的边被称为匹配边，否则被称为非匹配边。若存在 $S$ 中的一条边的端点为该点，则称该点为匹配点，否则称该点为非匹配点。

最大匹配：包含边数最多的一组匹配。

增广路：若二分图中，存在一条连接两个非匹配点的路径，使得非匹配边和匹配边在该路径上交替出现，则称该路径是匹配 $S$ 的增广路，也叫交错路。满足

长度 $\mathrm{len}$ 为奇数。
路径上第 $1, 3, 5, \cdots, \mathrm{len}$ 条边为非匹配边，路径上第 $2, 4, 6, \cdots, \mathrm{len} - 1$ 条边为匹配边。

增广路的简单性质：若将增广路上所有边的状态取反，得到的新的边集 $S'$ 仍然是一组匹配，并且匹配边数加一。故二分图的一组匹配 $S$ 是最大匹配，当且仅当图中不存在 $S$ 的增广路。

完美匹配：给定一张二分图，其左、右部分别为 $X, Y$ ，若最大匹配包含 $\min(|X|, |Y|)$ 条匹配边，则称该二分图具有完备匹配。

多重匹配：给定一张二分图，其左、右部节点数分别为 $n_l, n_r$ 。从中选出尽量多的边，使第 $i(1 \leq i \leq n_l)$ 个左部节点至多与 $kl_i$ 条选出的边相连，第 $j(1 \leq j \leq n_r)$ 个右部节点至多与 $kr_i$ 条选出的边相连。

二分图最大匹配：匈牙利算法

匈牙利算法：初始时，所有边都是非匹配边。匈牙利算法不断寻找增广路，依次给每个左部节点 $x$ 寻找一个匹配的右部节点 $y$ ，需要满足以下两个条件之一

$y$ 是非匹配点。则 $x \to y$ 构成一条长度为 $1$ 的增广路。
$y$ 与左部点 $x'$ 匹配，但从 $x'$ 出发能找到另一个右部点 $y'$ 与 $x'$ 匹配。则 $x \to y \to x' \to y'$ 构成一条增广路。

匈牙利算法原理：一个节点成为匹配点后，至多因为找到增广路而更换匹配对象，但是绝对不会再变回非匹配点。本质上是贪心。

匈牙利算法，时间复杂度： $\mathcal{O}(nm)$ 。

int tot, head[N], ver[M * 2], Next[M * 2];
void add_edge(int u, int v) {
	ver[++ tot] = v;    Next[tot] = head[u];    head[u] = tot;
}

bool vis[N];
int match[N];

bool dfs(int u) {
	for (int i = head[u]; i; i = Next[i]) {
		int v = ver[i];
		if (vis[v]) continue;
		vis[v] = 1;
		if (!match[v] || dfs(match[v])) {
			match[v] = u;
			return 1;
		}
	}

	return 0;
}

int main() {
	int ans = 0;
	for (int i = 1; i <= nl; i ++) {
		memset(vis, 0, sizeof(vis));
		if (dfs(i)) ans ++;
	}
}

匈牙利算法求字典序最小的最大匹配：考虑匈牙利算法的流程，是一个左部节点不断地挤掉右部节点已匹配的左部节点的过程。可以考虑按编号从大到小加入左部节点，将左部节点的所有出边从小到大排序，保证优先考虑较小的右部节点，即可求得字典序最小的最大匹配。

二分图最大匹配：最大流模型

最大流模型：将源点向左部所有点连一条容量为 $1$ 的边，将右部所有点向汇点连一条容量为 $1$ 的边。将左部向右部的连边容量设为 $1$ 。此时该网络的最大流即为最大匹配。

最大流模型，时间复杂度：使用 Dinic 算法求最大流，时间复杂度为 $\mathcal{O}(m\sqrt{n})$ 。

二分图最大带权匹配：KM 算法

待填。

二分图最大带权匹配：费用流模型

费用流模型：将源点向左部所有点连一条容量为 $1$ 费用为 $0$ 的边，将右部所有点向汇点连一条容量为 $1$ 费用为 $0$ 的边。将左部向右部的连边容量设为 $1$ 并保持费用不变。此时该网络的最大费用最大流即为最大匹配。

二分图最大多重匹配：最大流模型

最大流模型：将源点向左部的节点 $i(1 \leq i \leq n_l)$ 连一条容量为 $kl_i$ 的边，将右部的节点 $j(1 \leq j \leq n_r)$ 向汇点连一条容量为 $kr_i$ 的边。将左部向右部的连边容量设为 $1$ 。此时该网络的最大流即为最大多重匹配。

二分图常用模型

点覆盖：一组点的集合 $S$ ，满足任意一条边都至少有一个端点属于该点集。

边覆盖：一组边的集合 $S$ ，满足任意一个点都至少有一条邻边属于该边集。

独立集：一组点的集合 $S$ ，满足该点集中的点两两没有边。

团：一组点的集合 $S$ ，满足该点集中的点两两有边。

二分图中的最小点覆盖（König 定理）：在二分图中，最小点覆盖等于最大匹配。

König 定理证明：对于同一个二分图的任意一个匹配，由于匹配中的边的端点不相交，则匹配中的任意一条边至少有一个端点要在点覆盖中，即任意匹配 $\leq$ 任意点覆盖。现在考虑对最大匹配构造一个点覆盖

对二分图求一个最大匹配。
从左部每个非匹配点出发，再执行一次 DFS 寻找增广路的过程（一定会失败，以匹配边结束），标记路上经过的所有点。
取左部未被标记点，右部标记点，就得到了一组点覆盖。

上述构造，对点覆盖所包含点数等于最大匹配所包含边数的讨论：

左部非匹配点一定都被标记。因为他们是出发点。
右部非匹配点一定都没被标记。否则就找到了增广路。
一对匹配点要么都被标记，要么都没被标记。因为在找增广路的过程中，左部匹配点只能通过右部到达。

由于在上述构造中，我们取了左部未标记点，右部标记点。根据对点的讨论可以发现，恰好是每条匹配边取了一个点，所以选出的点数等于最大匹配所包含的边数。

上述构造，对点覆盖合法性的讨论：

匹配边一定被覆盖。因为恰好有一个端点被取走。
连接两个非匹配点的边一定不存在。否则就有长度为 $1$ 的增广路了。
连接左部非匹配点 $i$ 与右部匹配点 $j$ 的边。 $j$ 一定被访问，因为 $i$ 是出发点，而我们取了所有右部标记点，因此这样的边也被覆盖。
连接左部匹配点 $i$ 与右部非匹配点 $j$ 的边。 $i$ 一定没有被访问，否则再走到 $j$ 就找到了增广路，而我们取了所有左部未被标记点，因此这样的边也被覆盖。

二分图中的最大独立集：在二分图中，最大独立集与最小点覆盖互补。

二分图中的最小边覆盖：在二分图中，若不存在独立点，则最小边覆盖等于最大独立集。

无向图中的最大团：在无向图中，原图的最大团等于其补图的最大独立集。

有向无环图中的最小不相交路径覆盖：在有向无环图 $G = (V, E)$ 中，原图 $G$ 的最小不相交路径覆盖等于 $|V|$ 减去其拆点二分图 $G_0$ 的最大匹配。

构造拆点二分图 $G_0$ ，其左、右部节点数均为 $|V|$ ，若 $(x, y) \in E$ ，则在左部点 $x$ 与右部点 $y$ 之间连边。

Hall 定理

Hall 定理：一张二分图存在完备匹配，当且仅当对于 $1 \leq k \leq |X|$ ，均满足从 $X$ 中选出 $k$ 个不同点，连向 $Y$ 的点集大小 $\geq k$ 。

Trick

树上最大独立集

先选上所有叶子，然后从叶子向上考察每个点能否进入独立集，能选则选。

回到顶部

F - 图论网络流

网络基础

网络流图：

源点：有且仅有一个点 $s$ ，它的入度为 $0$ ，称这个点为源点。
汇点：有且仅有一个点 $t$ ，它的出度为 $0$ ，称这个点为汇点。
容量：每一条有向边，均有流量的上限，即容量。

容量函数 $c$ ： $V \times V \to \R$ 的函数，满足

\forall (u, v) \in E, c (u, v) \geq 0 \forall (u, v) \notin E, c (u, v) = 0

$\forall (u, v) \in E, c(u, v) \geq 0 \\ \forall (u, v) \notin E, c(u, v) = 0$

流量函数 $f$ ： $V \times V \to \R$ 的函数，满足以下条件

容量限制： $\forall (u, v), f(u, v) \leq c(u, v)$ 。
斜对称性： $\forall (u, v), f(u, v) = -f(v, u)$ 。
流守恒性：从源点流出的流量等于汇点流出的流量，即

\forall x \in V ∖ {s, t}, \sum_{(u, x) \in E} f (u, x) = \sum_{(x, v) \in E} f (x, v)

$\forall x \in V \backslash \{s, t\}, \sum\limits_{(u, x) \in E} f(u, x) = \sum\limits_{(x, v) \in E} f(x, v)$

或

\forall x \in V ∖ {s, t}, \sum_{(x, y)} f (x, y) = 0

$\forall x \in V \backslash \{s, t\}, \sum\limits_{(x, y)} f(x, y) = 0$

饱和弧 / 非饱和弧：在一个可行流中，若一条边的流量等于容量，则称这条边为饱和弧。否则称这条边为非饱和弧。

零弧：在一个可行流中，若一条边的流量为 $0$ ，则称这条边为零弧。

前向弧 / 后向弧：在一个可行流中，对于一条 $s \to t$ 的路径，与路径方向相同的边称为前向弧。否则称为后向弧。

剩余容量函数 $c_f$ ： $c_f(u, v) = c(u, v) - f(u, v)$ 。

残量网络 $G_f$ ： $G_f = (V_f = V, E_f = \{(u, v), c_f(u, v) > 0\})$ 。

整张网络的流量 $|f|$ ： $|f| = \sum_v f(s, v)$ 。

最大流

增广路：残量网络上 $s \to t$ 的路径，前向弧都是非饱和弧，后向弧都是非零弧。

EK

EK：

每次在当前流 $f$ 的残量网络 $G_f$ 上，用 BFS 找到一个最短增广路 $(x_1 = s, x_2, \cdots, x_{k - 1}, x_k = t)$ ，将增广路描述成一个流函数 $f_0$ ：
- 对于 $1 \leq i < k$ ：
$f_0(x_i, x_{i + 1}) = + \min_{1 \leq j < k} \{c_f(x_j, x_{j + 1})\} \\f_0(x_{i + 1}, x_{i}) = - \min_{1 \leq j < k} \{c_f(x_j, x_{j + 1})\}$
- 而其余函数值为 $0$ 。
得到一个流量更大的流函数 $f' = f + f_0$ 。
不断重复此过程，直到当前流 $f$ 的残量网络 $G_f$ 上不存在增广路。

EK 时间复杂度： $\mathcal{O}(nm^2)$ 。

EK 时间复杂度证明：

每次寻找的增广路长度是不降的。
- 更强结论： $\forall v \in V, d'(s, v) \geq d(s, v)$ 。
增广次数： $\mathcal{O}(nm)$ 。
- 每次增广时， $c_f(u, v)$ 最小的边记作关键边。一条边成为关键边的次数至多为 $\frac{n - 1}{2}$ 。

const int inf = 0x3f3f3f3f;

namespace nw {
	const int Nx = ..., Mx = ...;

	int S, T;

	int tot = 1, head[Nx], ver[Mx * 2], edge[Mx * 2], Next[Mx * 2];
	void add_edge(int u, int v, int w) {
		ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot;
	}
	void add_network(int u, int v, int w) {
		add_edge(u, v, w), add_edge(v, u, 0);
	}

	int pre[Nx], mf[Nx];
	bool vis[Nx];

	bool bfs() {
		for (int i = S; i <= T; i ++) vis[i] = 0;
	
		std::queue<int> q; while (q.size()) q.pop();
		q.push(S), vis[S] = 1, mf[S] = inf;
	
		while (q.size()) {
			int u = q.front(); q.pop();
	
			for (int i = head[u]; i; i = Next[i]) {
				int v = ver[i], w = edge[i];
				if (w > 0 && !vis[v]) {
					vis[v] = 1, pre[v] = i, mf[v] = std::min(mf[u], w);
					q.push(v);
	
					if (v == T) return 1;
				}
			}
		}
	
		return 0;
	}

	int EK() {
		int max_flow = 0;
		while (bfs()) {
			max_flow += mf[T];
			for (int x = T; x != S; x = ver[pre[x] ^ 1])
				edge[pre[x]] -= mf[T], edge[pre[x] ^ 1] += mf[T];
		}
	
		return max_flow;
	}
}

Dinic

Dinic：本质和 EK 相同，但优化了寻找增广路的过程。

分层图优化：Dinic 算法首先对图进行一次 BFS，然后在 BFS 生成的分层图中进行多次 DFS。这样就切断了原图中许多不必要的连接，可以进行多路增广，减少了调用增广函数的次数。
不完全 BFS 优化：在 BFS 到汇点 $t$ 之后就可以停止了，因为后面的路径一定更长。
当前弧优化：每次 DFS 完，找到容量最小的一条边。在这条边之前的路径容量 $\geq$ 这条边的容量，可能会引出其他的增广路。这样的话，在找到第一条增广路后，回溯到容量最小边的起点时，可以避免继续枚举已经流满的容量最小边。
点优化：在同一次 DFS 中，如果一个点引发不出任何的增广路，可以将该点在层次图中抹去。

Dinic 时间复杂度： $\mathcal{O}(n^2m)$ 。

Dinic 时间复杂度证明：

在一张分层图上，执行 DFS 的次数最多为 $\mathcal{O}(m)$ 。
建立分层图的次数不超过 $n - 1$ 。
- 每轮增广后，残量网络的 $d(s, t)$ 严格单调递增。

const int inf = 0x3f3f3f3f;

namespace nw {
	const int Nx = ..., Mx = ...;

    int S, T;

	int tot = 1, head[Nx], ver[Mx * 2], edge[Mx * 2], Next[Mx * 2];
	void add_edge(int u, int v, int w) {
		ver[++ tot] = v;    edge[tot] = w;    Next[tot] = head[u];    head[u] = tot;
	}
	void add_network(int u, int v, int w) {
		add_edge(u, v, w), add_edge(v, u, 0);
	}

	int lev[Nx];
	int cur[Nx];

	bool bfs() {
        for (int i = S; i <= T; i ++) cur[i] = head[i];
		for (int i = S; i <= T; i ++) lev[i] = 0;

		std::queue<int> q; while (q.size()) q.pop();
		q.push(S), lev[S] = 1;

		while (q.size()) {
			int u = q.front(); q.pop();

			for (int i = head[u]; i; i = Next[i]) {
				int v = ver[i], w = edge[i];
				if (w > 0 && !lev[v]) {
					lev[v] = lev[u] + 1;
					q.push(v);

					if (v == T) return 1;
				}
			}
		}

		return 0;
	}

	int dfs(int u, int flow) {
		if (u == T) return flow;

		int res = 0;
		for (int &i = cur[u]; i; i = Next[i]) {
			int v = ver[i], w = edge[i];
			if (w > 0 && lev[u] < lev[v]) {
				int delta = dfs(v, std::min(w, flow - res));
				if (delta) {
					edge[i] -= delta, edge[i ^ 1] += delta;
					res += delta;
	
					if (res == flow) break;
				}
			}
		}

		if (res < flow) lev[u] = 0;
		return res;
	}

	int dinic() {
		int max_flow = 0;
		while (bfs()) max_flow += dfs(S, inf);

		return max_flow;
	}
}

常用模型

限制点的流量：可以考虑将点拆成「入点」与「出点」，从入点向出点连一条有容量的边。

最小割

割：在图 $G = (V, E)$ 上，对于某个点集 $P \subseteq V$ ，割 $(P, V \backslash P)$ 定义为

(P \times (V ∖ P)) ⋂ E

$(P \times (V \backslash P)) \bigcap E$

割的容量：割包含的边的容量之和，即

c (P, V ∖ P) = \sum_{u \in P} \sum_{v \in V ∖ P} c (u, v)

$c(P, V \backslash P) = \sum\limits_{u \in P}\sum\limits_{v \in V \backslash P} c(u, v)$

$s \to t$ 割：满足 $s \in P$ 且 $t \in V \backslash P$ 的割。

最大流与最小割：在一张网络中，最大流等于最小割。

最大流与最小割证明：对于同一个网络的任意一个流 $f$ 和任意一个 $s \to t$ 割 $(S, T)$ ，均有

| f | = \sum_{u \in S} \sum_{v \in T} f (u, v) \leq \sum_{u \in S} \sum_{v \in T} c (u, v) = c (S, T)

$|f| = \sum\limits_{u \in S}\sum\limits_{v \in T} f(u, v) \leq \sum\limits_{u \in S} \sum\limits_{v \in T} c(u, v) = c(S, T)$

即任意流 $\leq$ 任意割。考虑 EK 算法求得的流 $f$ ，记流 $f$ 对应的残量网络中从 $s$ 出发可达的所有点组成的点集为 $S$ ，不可达的所有点组成的点集为 $T$ ，由于找不到流 $f$ 的增广路，故 $(S, T)$ 是一个 $s \to t$ 割，且由残量网络的定义可得 $|f| = c(S, T)$ 。故最大流等于最小割。

最小割的可行边（并）与必经边（交）：

可行边：一条边 $(u, v, w)$ 是最小割可行边，当且仅当这条边满流，且 $G_f$ 不存在 $u \to v$ 的路径（ $u, v$ 不在同一个强连通分量内）。
必经边：一条边 $(u, v, w)$ 是最小割必经边，当且仅当这条边满流，且 $G_f$ 上存在 $s \to u$ 和 $v \to t$ 的路径（ $u$ 和 $s$ 在同一个强连通分量内， $v$ 和 $t$ 在同一个强连通分量内）。

常用模型

二选一模型：有 $n$ 个任务，每个任务可以在机器 $A$ 或机器 $B$ 上完成，花费分别为 $a_i$ 和 $b_i$ 。有 $m$ 对二元关系 $(x_i, y_i)$ ，若第 $x_i$ 个任务与第 $y_i$ 个任务不在同一个机器上完成，则增加 $v_i$ 的花费。求最小总花费。

模型构造：
- 建源点 $s$ 与汇点 $t$ ，每个任务都建一个点，标号 $1 \sim n$ 。
- $S$ 向第 $i$ 个任务连一条容量为 $a_i$ 的边，第 $i$ 个任务向 $T$ 连一条容量为 $b_i$ 的边。
- 对于每个二元关系 $(x_i, y_i)$ ，在第 $x_i$ 个任务与第 $y_i$ 个任务间连一条容量为 $v_i$ 的双向边。
模型分析：
- 第 $i$ 个任务在机器 $A$ 上完成，就要割去边权为 $a_i$ 的边。第 $i$ 个任务在机器 $B$ 上完成，就要割去边权为 $b_i$ 的边。
- 对于每个二元关系 $(x_i, y_i)$ ，若 $x_i, y_i$ 没有被分配到同一个机器，就要割去边权为 $v_i$ 的边。

闭合子图：一个有向图 $G = (V, E)$ 的闭合子图，是该有向图的一个子图，且该子图内点集的所有出边都指向该点集。

最大权闭合子图：点权和最大的闭合子图。

最大权闭合子图模型：有 $n$ 个事件，事件发生会带来收益 $w_i$ ， $w_i$ 可正可负，一个事件发生的前提是指定的若干事件必须发生。求最优的确定所有事件是否发生的方案，使得收益最大。

模型构造：
- 建源点 $s$ 与汇点 $t$ ，对每个事件都建一个点，标号 $1 \sim n$ 。
- 若 $w_i > 0$ ，则令 $S$ 向 $i$ 连一条容量为 $w_i$ 的边；若 $w_i < 0$ ，则令 $i$ 向 $T$ 连一条容量为 $-w_i$ 的边。
- 对于原图中的边，容量设为 $+\infty$ 。
模型分析：最大权闭合子图 $=$ 正点权和 $-$ 最小割。
- 在一个割中割去的边，负权点表示选择，正权点表示不选。
- 可以证明，在一个割中，已割去的负权点与未割去的正权点组成的子图 $W$ 与原图的闭合子图对应。如果 $W$ 不是闭合子图，出边可能指向已割去的正权点或未割去的负权点。若为前者，则 $W$ 内的流越过了这个割；若为后者，则 $W$ 内的流可以流向汇点。

费用流

EK & Dinic：每次需要扩展一条费用最小的增广路。

const int inf = 0x3f3f3f3f;

namespace nw {
	const int Nx = ..., Mx = ...;

	int S, T;

	int tot = 1, head[Nx], ver[Mx * 2], Next[Mx * 2]; int edge[Mx * 2], cost[Mx * 2];
	void add_edge(int u, int v, int w, int c) {
		ver[++ tot] = v;    edge[tot] = w;    cost[tot] = c;    Next[tot] = head[u];    head[u] = tot;
	}
	void add_network(int u, int v, int w, int c) {
		add_edge(u, v, w, +c), add_edge(v, u, 0, -c);
	}

	int max_flow, min_cost;

	int dist[Nx];
	bool exist[Nx];

	int cur[Nx];
	bool vis[Nx];

	bool spfa() {
		for (int i = S; i <= T; i ++) cur[i] = head[i], vis[i] = 0;
		for (int i = S; i <= T; i ++) dist[i] = inf;

		std::queue<int> q;
		q.push(S), dist[S] = 0;

		while (q.size()) {
			int u = q.front(); q.pop(); exist[u] = 0;

			for (int i = head[u]; i; i = Next[i]) {
				int v = ver[i], w = edge[i], c = cost[i];
				if (w > 0 && dist[u] + c < dist[v]) {
					dist[v] = dist[u] + c;
					if (!exist[v]) {
						exist[v] = 1;
						q.push(v);
					}
				}
			}
		}

		return dist[T] < inf;
	}

	int dfs(int u, int flow) {
		if (u == T) {
			min_cost += flow * dist[T];
			return flow;
		}

		vis[u] = 1;

		int res = 0;
		for (int &i = cur[u]; i; i = Next[i]) {
			int v = ver[i], w = edge[i], c = cost[i];
			if (w > 0 && !vis[v] && dist[u] + c == dist[v]) {
				int delta = dfs(v, std::min(w, flow - res));
				if (delta) {
					edge[i] -= delta, edge[i ^ 1] += delta;
					res += delta;
	
					if (res == flow) break;
				}
			}
		}

		if (res == flow) vis[u] = 0;
		return res;
	}

	void dinic() {
		max_flow = 0, min_cost = 0;
		while (spfa()) max_flow += dfs(S, inf);
	}
}

posted @ 2022-12-19 10:23 Calculatelove 阅读(243) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· OI+ACM 笔记：D - 数据结构

· OI+ACM 笔记：A - 基础算法

· 网络流，二分图与图的匹配

· 图论知识点摘要

· 图论学习笔记（三）：二分图、网络流

阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· Manus爆火，是硬核还是营销？
· 终于写完轮子一部分：tcp代理了，记录一下
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通

公告

来自福建的算法竞赛选手，现大一。
OI 时期，就读于福建省长乐第一中学。
ACM 时期，就读于福州大学。
QQ：1872207996。

昵称： Calculatelove
园龄： 6年5个月
粉丝： 21
关注： 24

+加关注

2025年3月

日

一

二

三

四

五

六

C.L.

Love all my perfect imperfections.

OI+ACM 笔记：F - 图论

F - 图论 杂项

图论基础

图的储存

图的遍历

BFS

DFS

拓扑排序

欧拉路、欧拉回路

三元环计数、四元环计数

Prufer 序列

F - 图论 最小生成树

Kruskal

Kruskal 重构树

Prim

Brouvka

F - 图论 最短路径

Dijkstra

Bellman-ford & SPFA

Floyd

差分约束

同余最短路

F - 图论 连通性

无向图 tarjan

时间戳与追溯值

割点

割边

点双连通分量

边双连通分量

有向图 tarjan

流图

强连通分量

2-SAT

F - 图论 二分图

二分图染色

二分图匹配

二分图最大匹配：匈牙利算法

二分图最大匹配：最大流模型

二分图最大带权匹配：KM 算法

二分图最大带权匹配：费用流模型

二分图最大多重匹配：最大流模型

二分图常用模型

Hall 定理

Trick

树上最大独立集

F - 图论 网络流

网络基础

最大流

EK

Dinic

常用模型

最小割

常用模型

费用流

公告

搜索

常用链接

随笔分类 (46)

随笔档案 (47)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

F - 图论杂项

F - 图论最小生成树

F - 图论最短路径

F - 图论连通性

F - 图论二分图

F - 图论网络流