【YBT2023寒假Day11 B】催眠大师（费用流）

催眠大师

题目链接：YBT2023寒假Day11 B

题目大意

有一个 n*n 的棋盘，有一些位置有障碍。
然后定义棋盘上两个位置能相互攻击当且仅当在同一行或同一列，且之间的所有位置都没有障碍。
多次询问每次给你 k 求在棋盘中选 k 个没有障碍的位置放棋子，最小能互相攻击的对数。

思路

你可以发现障碍把每一行和每一列分别都拆成了若干个段，里面的点就互相可以攻击。
那就是这些段每个的个数 $d$ 的 $\left(\genfrac{}{}{0ex}{}{d}{2}\right)$ 之和。

看到 $n$ 很小，但是如果我们直接 $O(n^2)$ 网络流也不行。
但是因为是棋盘，一个经典的方法就是行列分别建点，然后之间的边标记图中的点。
不过你注意到一行或者一列个数的不是线性的。

不过我们思考网络流每次跑费用最小的地方，那在能互相攻击到的位置上，你每选一个点，增加的费用是每次递增，增加 $1$ 的。
那我们可以改成建两排点分别是行里面互相能到的点和列里面互相能到的点。
然后原本行列连边就改成在它属于的互相能到的点连边。

然后每个行列互相能到的点到分别源点汇点就连多条边，每条的流量是 $1$，费用是递增的 $1\sim x$。
然后跑费用流就好了。

代码

#include<queue>
#include<cstdio>
#include<iostream>
#define INF 0x3f3f3f3f3f3f3f3f

using namespace std;

const int N = 55;
int n, a[N][N], ans[N * N], coll[N][N], colr[N][N], sz[N * N * 2];
int S, T, le[N * N * 2], KK, tot, Tot;
struct node {
	int x, val, to, nxt, op;
}e[N * N * N * N];
char c;

int deg[N * N * 2], dis[N * N * 2], lee[N * N * 2];
bool in[N * N * 2];
queue <int> Q;

void add(int x, int y, int z, int val) {
	e[++KK] = (node){z, val, y, le[x], KK + 1}; le[x] = KK;
	e[++KK] = (node){0, -val, x, le[y], KK - 1}; le[y] = KK;
}

bool SPFA() {
	while (!Q.empty()) Q.pop();
	for (int i = 0; i <= tot; i++) deg[i] = 0, dis[i] = INF, lee[i] = le[i];
	Q.push(S); deg[S] = 1; dis[S] = 0; in[S] = 1;
	while (!Q.empty()) {
		int now = Q.front(); Q.pop();
		for (int i = le[now]; i; i = e[i].nxt)
			if (dis[e[i].to] > dis[now] + e[i].val && e[i].x) {
				dis[e[i].to] = dis[now] + e[i].val;
				deg[e[i].to] = deg[now] + 1;
				if (!in[e[i].to]) {
					in[e[i].to] = 1; Q.push(e[i].to);
				}
			}
		in[now] = 0;
	}
	return dis[T] != dis[0];
}

int dfs(int now, int sum) {
	if (now == T) return sum;
	int go = 0;
	for (int &i = lee[now]; i; i = e[i].nxt)
		if (dis[e[i].to] == dis[now] + e[i].val && deg[e[i].to] == deg[now] + 1 && e[i].x) {
			int this_go = dfs(e[i].to, min(sum - go, e[i].x));
			if (this_go) {
				e[i].x -= this_go;
				e[e[i].op].x += this_go;
				go += this_go; if (go == sum) return go;
			}
		}
	deg[now] = -1;
	return go;
}

int main() {
	freopen("table.in", "r", stdin);
	freopen("table.out", "w", stdout);
	
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) {
			c = getchar(); while (c != '.' && c != '#') c = getchar();
			if (c == '.') a[i][j] = 1;
				else a[i][j] = 0;
		}
	
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) {
			if (!a[i][j]) continue;
			if (!a[i - 1][j]) coll[i][j] = ++Tot;
				else coll[i][j] = coll[i - 1][j];
			sz[coll[i][j]]++;
			if (!a[i][j - 1]) colr[i][j] = ++Tot;
				else colr[i][j] = colr[i][j - 1];
			sz[colr[i][j]]++;
		}
	
	S = Tot + 1; T = S + 1; tot = T;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++) {
			if (!a[i][j]) continue;
			add(coll[i][j], colr[i][j], 1, 0);
			if (coll[i][j] != coll[i - 1][j])
				for (int k = 1; k <= sz[coll[i][j]]; k++) add(S, coll[i][j], 1, k - 1);
			if (colr[i][j] != colr[i][j - 1])
				for (int k = 1; k <= sz[colr[i][j]]; k++) add(colr[i][j], T, 1, k - 1);
		}
	
	int num = 0;
	while (SPFA()) {
		int x = dfs(S, INF);
		for (int i = 1; i <= x; i++) num++, ans[num] = ans[num - 1] + dis[T];
	}
	
	int q; scanf("%d", &q);
	while (q--) {
		int x; scanf("%d", &x); printf("%d\n", ans[x]);
	}
	
	return 0;
}