网络流 24 题汇总（LOJ 上只有 22 题？？？）

太裸的我就不放代码了。。。（黑体字序号的题表示值得注意）

1、搭配飞行员 [LOJ#6000]

二分图最大匹配。

2、太空飞行计划 [LOJ#6001]

最小割常规套路、输出方案。（注：这题换行符要用 \r）

3、最小路径覆盖 [LOJ#6002]

网上大多数题解都是二分图相关的，但这题有一个更直观的做法。

我们限制每个点的流量上下界都为 \(1\)，从源点向每个点的“入点”连容量为 \(1\) 的边，从每个点的“出点”向汇点连容量为 \(1\) 的边，然后跑最小流。

最后输出方案暴力 dfs 即可。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define dwn(i, s, t) for(int i = (s); i >= (t); i--)

const int BufferSize = 1 << 16;
char buffer[BufferSize], *Head, *Tail;
inline char Getchar() {
	if(Head == Tail) {
		int l = fread(buffer, 1, BufferSize, stdin);
		Tail = (Head = buffer) + l;
	}
	return *Head++;
}
int read() {
	int x = 0, f = 1; char c = Getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = Getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = Getchar(); }
	return x * f;
}

#define maxn 410
#define maxm 136010
#define oo 2147483647

int at[maxn];
int CntP;
struct Point {
	int id;
	Point(): id(0) {}
	int p() { return id ? id : id = ++CntP; }
} In[maxn], Out[maxn], S, T, SS, TT;

struct Edge {
	int from, to, flow;
	Edge() {}
	Edge(int _1, int _2, int _3): from(_1), to(_2), flow(_3) {}
};
struct Dinic {
	int n, m, s, t, head[maxn], nxt[maxm];
	Edge es[maxm];
	int Q[maxn], hd, tl, vis[maxn];
	int cur[maxn];
	bool CanPass, etag[maxm];
	int cntp, path[maxn];

	void init() {
		m = 0; memset(head, -1, sizeof(head));
		return ;
	}
	void setn(int _) {
		n = _;
		return ;
	}

	void AddEdge(int a, int b, int c) {
		es[m] = Edge(a, b, c); nxt[m] = head[a]; head[a] = m++;
		es[m] = Edge(b, a, 0); nxt[m] = head[b]; head[b] = m++;
		return ;
	}

	bool BFS() {
		memset(vis, 0, sizeof(vis));
		vis[t] = 1;
		hd = tl = 0; Q[++tl] = t;
		while(hd < tl) {
			int u = Q[++hd];
			for(int i = head[u]; i != -1; i = nxt[i]) {
				Edge& e = es[i^1];
				if(!CanPass && etag[i]) continue;
				if(!vis[e.from] && e.flow) {
					vis[e.from] = vis[u] + 1;
					Q[++tl] = e.from;
				}
			}
		}
		return vis[s] > 1;
	}

	int DFS(int u, int a) {
		if(u == t || !a) return a;
		int flow = 0, f;
		for(int& i = cur[u]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(!CanPass && etag[i]) continue;
			if(vis[e.to] == vis[u] - 1 && (f = DFS(e.to, min(a, e.flow)))) {
				flow += f; a -= f;
				e.flow -= f; es[i^1].flow += f;
				if(!a) return flow;
			}
		}
		return flow;
	}

	int MaxFlow(int _s, int _t, bool canpass) {
		s = _s; t = _t; CanPass = canpass;
		int flow = 0;
		while(BFS()) {
			rep(i, 1, n) cur[i] = head[i];
			flow += DFS(s, oo);
		}
		return flow;
	}

	void getpath(int u) {
		path[++cntp] = at[u];
		for(int i = head[u]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(e.flow < oo && at[e.to]) getpath(Out[at[e.to]].p());
		}
		return ;
	}
	void print(int s) {
		int cnt = 0;
		for(int i = head[s]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(!e.flow && e.to != t) {
				cnt++;
				cntp = 0; getpath(Out[at[e.to]].p());
				rep(i, 1, cntp) printf("%d%c", path[i], i < cntp ? ' ' : '\n');
			}
		}
		printf("%d\n", cnt);
		return ;
	}
} sol;

int main() {
	int n = read(), m = read();
	sol.init();
	rep(i, 1, n)
		sol.AddEdge(SS.p(), Out[i].p(), 1), sol.AddEdge(In[i].p(), TT.p(), 1),
		sol.AddEdge(S.p(), In[i].p(), 1), sol.AddEdge(Out[i].p(), T.p(), 1),
		at[In[i].p()] = at[Out[i].p()] = i;
	sol.etag[sol.m] = sol.etag[sol.m^1] = 1;
	sol.AddEdge(T.p(), S.p(), oo);
	rep(i, 1, m) {
		int a = read(), b = read();
		sol.AddEdge(Out[a].p(), In[b].p(), oo);
	}
	sol.setn(CntP);

	sol.MaxFlow(SS.p(), TT.p(), 1);
	sol.MaxFlow(T.p(), S.p(), 0);
	sol.print(S.p());

	return 0;
}

4、魔术球 [LOJ#6003]

二分答案（答案不超过 \(2000\)），然后和上一题基本一样。（注：这题不能用 fread()）

5、圆桌聚餐 [LOJ#6004]

二分图匹配、输出方案。

6、最长递增子序列 [LOJ#6005]

先 dp 出 \(f_i\) 表示以第 \(i\) 个数结尾的最长不降子序列长度，然后对于 \(∀(i, j)\) 满足 \(i < j, f_i + 1 = f_j, A_i \le A_j\)，在第 \(i\) 个数和第 \(j\) 个数之间连边，然后点限制流量为 \(1\)（第三问把第一个和第 \(n\) 个节点的流量限制改成无穷），跑最大流。

7、试题库 [LOJ#6006]

同第 \(5\) 题。注意这题有可能有某个类型须要 \(0\) 道题。

8、方格取数 [LOJ#6007]

将棋盘黑白染色后跑最小割。

9、餐巾计划 [LOJ#6008]

有下界的最小费用可行流，详见这里（网上许多做法似乎没这个直观，当然他们是做了优化）。

10、数字梯形 [LOJ#6010]

最小费用最大流裸题。

11、运输问题 [LOJ#6011]

最小费用最大流裸题。

12、分配问题 [LOJ#6012]

同上。

13、负载平衡 [LOJ#6013]

小于平均值的仓库向汇点连容量为平均值减仓库存量的边，源点向大于平均值的仓库连容量为库存减平均值的边（费用均为 \(0\)），然后相邻仓库连容量无穷费用为 \(1\) 的双向边。最后跑最小费用最大流。

14、最长 k 可重区间集 [LOJ#6014]

这个题有点厉害啊，想了半天。。。

还是有一个直接的思路。把坐标离散化后，最后的收益相当于每段小区间的长度乘它被覆盖的次数的总和。对于一个给出的开区间，我们可以用“环”的性质保证它出了 \(1\)，最后能够回来 \(1\)。就是说我们将所有点从左到右依次连边（容量为 \(k\)，费用为负的区间长度，这里的区间长度就是它和下一个点的距离），然后对于一个区间 \((l, r)\)，连一条从点 \(r\) 到点 \(l\)，容量为 \(1\)，费用为 \(0\) 的边，最后跑最小费用可行流。（注意这个图是有负环的，我们可以先强行流满所有的负边，然后用类似有下界可行流的办法进行调整）

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;
#define rep(i, s, t) for(int i = (s); i <= (t); i++)
#define dwn(i, s, t) for(int i = (s); i >= (t); i--)

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
	return x * f;
}

#define maxn 1510
#define maxm 3014
#define oo 2147483647

struct Edge {
	int from, to, flow, cost;
	Edge() {}
	Edge(int _1, int _2, int _3, int _4): from(_1), to(_2), flow(_3), cost(_4) {}
};
struct ZKW {
	int n, m, s, t, cost, ans, head[maxn], nxt[maxm];
	Edge es[maxm];
	bool inq[maxn];
	int d[maxn], Q[maxn*10], hd, tl;
	bool vis[maxn];

	void init() {
		m = 0; memset(head, -1, sizeof(head));
		return ;
	}
	void setn(int _) {
		n = _;
		return ;
	}

	void AddEdge(int a, int b, int c, int d) {
		es[m] = Edge(a, b, c, d); nxt[m] = head[a]; head[a] = m++;
		es[m] = Edge(b, a, 0, -d); nxt[m] = head[b]; head[b] = m++;
		return ;
	}

	bool BFS() {
		rep(i, 1, n) d[i] = oo;
		d[t] = 0;
		hd = tl = 0; Q[++tl] = t; inq[t] = 1;
		while(hd < tl) {
			int u = Q[++hd]; inq[u] = 0;
			for(int i = head[u]; i != -1; i = nxt[i]) {
				Edge& e = es[i^1];
				if(d[e.from] > d[u] + e.cost && e.flow) {
					d[e.from] = d[u] + e.cost;
					if(!inq[e.from]) inq[e.from] = 1, Q[++tl] = e.from;
				}
			}
		}
		if(d[s] == oo) return 0;
		cost = d[s];
		return 1;
	}

	int DFS(int u, int a) {
		if(u == t || !a) return ans += cost * a, a;
		if(vis[u]) return 0;
		vis[u] = 1;
		int flow = 0, f;
		for(int i = head[u]; i != -1; i = nxt[i]) {
			Edge& e = es[i];
			if(d[e.to] == d[u] - e.cost && (f = DFS(e.to, min(a, e.flow)))) {
				flow += f; a -= f;
				e.flow -= f; es[i^1].flow += f;
				if(!a) return flow;
			}
		}
		return flow;
	}

	int MaxFlow(int _s, int _t) {
		s = _s; t = _t;
		int flow = 0, f;
		while(BFS())
			do {
				memset(vis, 0, sizeof(vis));
				f = DFS(s, oo);
				flow += f;
			} while(f);
		return flow;
	}
} sol;

#define pii pair <int, int>
#define x first
#define y second
#define mp(x, y) make_pair(x, y)

pair <int, int> line[maxn];
int num[maxn], cntn;

int main() {
	int n = read(), k = read();
	rep(i, 1, n) {
		int l = read(), r = read();
		if(l > r) swap(l, r);
		line[i] = mp(l, r);
		num[++cntn] = l; num[++cntn] = r;
	}
	sort(num + 1, num + cntn + 1);
	cntn = unique(num + 1, num + cntn + 1) - num - 1;
	rep(i, 1, n)
		line[i].x = lower_bound(num + 1, num + cntn + 1, line[i].x) - num,
		line[i].y = lower_bound(num + 1, num + cntn + 1, line[i].y) - num;

	int S = cntn + n + 1, T = S + 1, sum = (num[cntn] - num[1]) * k;
	sol.init(); sol.setn(T);
	sol.AddEdge(S, cntn, k, 0); sol.AddEdge(1, T, k, 0);
	rep(i, 2, cntn) sol.AddEdge(i, i - 1, k, num[i] - num[i-1]);
	rep(i, 1, n) sol.AddEdge(line[i].y, line[i].x, 1, 0);
	sol.MaxFlow(S, T);
	printf("%d\n", sum - sol.ans);

	return 0;
}

15、星际转移 [LOJ#6015]

这题其实应该给出一个条件：天数不会超过 \(30\)。那就枚举答案然后分层建图网络流检验。

16、孤岛营救问题 [LOJ#6121]

这题网络流怎么做？！

bfs 做法显然。令状态 \((x, y, s)\) 表示身处 \((x, y)\) 格子，当前有的钥匙集合为 \(s\)，然后就搜就行了。

17、航空路线问题 [LOJ#6122]

\(2\) 到 \(n - 1\) 号城市限流为 \(1\)，\(1\) 和 \(n\) 号城市限流为 \(2\)，所有城市费用为 \(-1\)，跑最小费用最大流，若最大流为 \(2\) 则有界，沿着流输出。

18、汽车加油行驶问题 [LOJ#6223]

这题也许是告诉我们费用流可以用来跑最短路吧。。。

令状态 \((x, y, k)\) 表示在坐标 \((x, y)\) 处，当前有 \(k\) 的油量。跑最短路即可。

19、深海机器人问题 [LOJ#6224]

最小费用最大流裸题。

20、火星探险问题 [LOJ#6225]

最小费用最大流裸题 + 输出方案。

21、骑士共存问题 [LOJ#6226]

同样是棋盘染色 + 最小割。

22、最长k可重线段集问题 [LOJ#6227]

这题和第 \(14\) 题很像，做法也一样，但是区间的权值变化了，不难处理。