【YBT2022寒假Day5 C】孤立点集（Dilworth定理）（网络流）

孤立点集

题目链接：YBT2022寒假Day5 C

题目大意

给你一个 DAG，问你至多能选出多少个点使得这些点不能到达对方。
然后要输出其中一种方案，并输出每个点是否有可能在所有方案中出现。

思路

首先你要知道一个定理叫做Dilworth定理：
对于任意有限偏序集，最大反链长等于最小链划分。
链就指的是这个偏序集的一个偏序关系。
然后反链是一堆元素无法比较的。

那在这题中，我们可以定义偏序关系为：\(x\leqslant y\) 当且仅当 \(x\) 能到 \(y\)。（当然要先 Floyed 处理出）
那如果无法到达，就是无法比较，那我们要求的就是最大反链长，也即是最小链覆盖。

那最小链覆盖在这里就是点数 - 二分图最大匹配，因为这里是一个二分图匹配问题。（拆点）

然后接着就是后面的问题：如果找到一组解和判断是否可能在解中。
我们先考虑第三个：如果它在解中，那能到它的点和它能到的点都不可以选了。
那你考虑屏蔽了这些点之后再跑一遍网络流，如果流量真的恰好少了 \(1\)，那就说明它可能在方案中。

那其实根据这个我们也不难想出构造方案了，就枚举点试试能不能选，如果可以选就把它，它能到，能到它的点全部屏蔽掉，不恢复，然后继续搞就可以了。

代码

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

using namespace std;

int n, m, x, y, ans;
bool a[101][101];
struct node {
	int x, to, nxt, op;
}e[2000001];
int le[501], KK, lee[501], tot, S, T, dis[501];
queue <int> q;

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

bool bfs() {
	for (int i = 1; i <= tot; i++) lee[i] = le[i], dis[i] = 0;
	while (!q.empty()) q.pop();
	q.push(S); dis[S] = 1;
	while (!q.empty()) {
		int now = q.front(); q.pop();
		for (int i = le[now]; i; i = e[i].nxt)
			if (e[i].x && !dis[e[i].to]) {
				dis[e[i].to] = dis[now] + 1;
				if (e[i].to == T) return 1;
				q.push(e[i].to);
			}
	}
	return 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 (e[i].x && dis[now] + 1 == dis[e[i].to]) {
			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;
			}
		}
	return go;
}

int dinic() {
	int re = 0;
	while (bfs())
		re += dfs(S, INF);
	return re;
}

bool kill[501];

int main() {
//	freopen("isolated.in", "r", stdin);
//	freopen("isolated.out", "w", stdout);
	
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &x, &y); a[x][y] = 1;
	}
	
	for (int k = 1; k <= n; k++)
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= n; j++)
				if (a[i][k] && a[k][j]) a[i][j] = 1;
	
	tot = 2 * n; S = ++tot; T = ++tot;
	for (int i = 1; i <= n; i++) add(S, i, 1), add(n + i, T, 1);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= n; j++)
			if (a[i][j]) add(i, n + j, 1);
	
	ans = n - dinic();
	printf("%d\n", ans);
	
	int now = ans, tmpp = 0;
	for (int x = 1; x <= n; x++) {
		if (kill[x]) {
			printf("0"); continue;
		}
		KK = 0; memset(le, 0, sizeof(le));
		for (int i = 1; i <= n; i++)
			if (i != x && !a[i][x] && !a[x][i] && !kill[i])
				for (int j = 1; j <= n; j++)
					if (j != x && !a[j][x] && !a[x][j] && !kill[j])
						if (a[i][j]) add(i, n + j, 1);
		int tmp = 0;
		for (int i = 1; i <= n; i++)
			if (i != x && !a[i][x] && !a[x][i] && !kill[i]) add(S, i, 1), add(n + i, T, 1);
			else if (!kill[i] && (i == x || a[i][x] || a[x][i])) tmp++;
		int nw = dinic();
		if (now - 1 == n - tmpp - tmp - nw) {
			printf("1");
			now = n - tmpp - tmp - nw; kill[x] = 1; tmpp += tmp;
			for (int i = 1; i <= n; i++)
				if (a[i][x] || a[x][i]) kill[i] = 1;
		}
		else printf("0");
	}
	printf("\n");
	
	for (int x = 1; x <= n; x++) {
		KK = 0; memset(le, 0, sizeof(le));
		for (int i = 1; i <= n; i++)
			if (i != x && !a[i][x] && !a[x][i])
				for (int j = 1; j <= n; j++)
					if (j != x && !a[j][x] && !a[x][j])
						if (a[i][j]) add(i, n + j, 1);
		int tmp = 0;
		for (int i = 1; i <= n; i++)
			if (i != x && !a[i][x] && !a[x][i]) add(S, i, 1), add(n + i, T, 1);
				else tmp++;
		if (ans - 1 == n - dinic() - tmp) {
			printf("1");
		}
		else printf("0");
	}
	
	return 0;
}