【ybtoj高效进阶 21254】摆放鞋子（二分图匹配）（网络流）

摆放鞋子

题目链接：ybtoj高效进阶 21254

题目大意

给你一个网格，然后每个点可能是两个类型的其中一种，四个方向的一种，然后你可以无限次操作，每次选两个相邻的点，一个顺时针转 90 度，一个逆时针转 90 度。

然后两个相邻的点能匹配要他们是不同类型的，而且它们的方向要满足四个条件的其中一个。
（四个条件其实就是要按着摆鞋子的方法摆，总之就是左脚右脚要放好）

然后问你能有的最大匹配。

思路

补充一下四个条件：

首先我们要发现它这个转是可以传递下去的，然后如果你把右下左上分别标成 (0,1,2,3)，你会发现整个图所有点方向的值的和对 (4) 的取模结果是不变的。

你考虑从这个地方入手，首先不管这个条件直接用类型匹配，这个二分图匹配。
然后如果匹配没有满，那你剩下的那个随便挑方向，一定会可以使得最后的值是满足的。
但是如果匹配满了，你就要特殊判断一下（二分图的匹配结果拿出来用），如果值是满足的就直接用，否则就要放掉一个匹配来使得条件满足。

然后就好啦。

代码

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

using namespace std;

int n, m, a[105][105], st, ans, S, T;
char c[105][105], w[105][105];
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

bool ck(int x, int y) {
	if (x < 1 || x > n) return 0;
	if (y < 1 || y > m) return 0;
	return 1;
}

struct node {
	int x, to, nxt, op;
}e[600001];
int le[10005], KK, lee[10005];

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;
}

int get_bh(int x, int y) {
	return (x - 1) * m + y;
} 

int dis[10005];
queue <int> q;

bool bfs() {//网络流
	while (!q.empty()) q.pop();
	memset(dis, 0, sizeof(dis));
	for (int i = 1; i <= T; i++) lee[i] = le[i];
	
	dis[S] = 1;
	q.push(S);
	while (!q.empty()) {
		int now = q.front();
		q.pop();
		
		for (int i = le[now]; i; i = e[i].nxt)
			if (!dis[e[i].to] && e[i].x) {
				dis[e[i].to] = dis[now] + 1;
				q.push(e[i].to);
			}
	}
	
	return dis[T];
}

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[e[i].to] == dis[now] + 1) {
			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;
			}
		}
	
	if (go < sum) dis[now] = -1;
	return go;
}

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

int main() {
//	freopen("shoe.in", "r", stdin);
//	freopen("shoe.out", "w", stdout);
	
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++) {
			c[i][j] = getchar();
			while (c[i][j] != 'L' && c[i][j] != 'R') c[i][j] = getchar();
		}
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++) {
			w[i][j] = getchar();
			while (w[i][j] != 'L' && w[i][j] != 'R' && w[i][j] != 'U' && w[i][j] != 'D') w[i][j] = getchar();
			if (w[i][j] == 'R') a[i][j] = 0;
			if (w[i][j] == 'L') a[i][j] = 2;
			if (w[i][j] == 'D') a[i][j] = 1;
			if (w[i][j] == 'U') a[i][j] = 3;
			st = (st + a[i][j]) % 4;
		}
	
	S = n * m + 1; T = S + 1;
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			if (c[i][j] == 'L') {
				add(S, get_bh(i, j), 1);
				for (int k = 0; k < 4; k++) {
					int xx = i + dx[k], yy = j + dy[k];
					if (ck(xx, yy) && c[xx][yy] == 'R') {
						add(get_bh(i, j), get_bh(xx, yy), 1);
					}
				}
			}
			else add(get_bh(i, j), T, 1);
	
	ans = dinic();
	
	if (ans * 2 < n * m) {//转移没有满，可以剩下的随便动使得满足条件
		printf("%d", ans);
	}
	else {
		int ck = 0;
		for (int i = 1; i <= n; i++)
			for (int j = 1; j <= m; j++)
				if (c[i][j] == 'L') {
					int x = get_bh(i, j);
					for (int k = le[x]; k; k = e[k].nxt)
						if (!e[k].x && k & 1 && e[k].to != S) {
							if (i == (e[k].to - 1) / m + 1)
								ck = (ck + 2) % 4;
						}
				}
		if (ck == st) printf("%d", ans);//当前已经满足了条件
			else printf("%d", ans - 1);//不能就只能解开一对来满足条件
	}
	
	return 0;
}