「LibreOJ Round #11」Misaka Network 与测试 (网络流跑二分图匹配)

description

研究者们想要测试 Misaka Network，于是他们把 Misaka Network 中的所有妹妹们召集到了一起。
现在妹妹们排成了 N行 M 列，有的位置没有人。现在研究者们给每一个个体的超能力进行了评定，一共有三个能力等级：Level 1 低能力者、Level 2 异能力者 和 Level 3 超能力者。研究者们每次测试可以选取一个子矩形内的所有个体，为了保证高效，他们不希望这个矩形内存在空的位置。并且，为了保证稳定，他们希望这个矩形内所有个体的能力等级的平均值恰好为 2 。同时，每个个体最多只能参加一次测试，因此，多次测试选取的矩形应当不相交。

研究者们想知道他们最多能进行多少次测试。

输入格式
第一行两个整数N、M
接下来 N行每行 M个字符，每个字符表示了队列中对应位置的个体。
1 表示 Level 1 低能力者，2 表示 Level 2 异能力者，3 表示 Level 3 超能力者，* 表示一个空的位置。

输出格式
一行一个整数，表示最多能够进行多少次测试。
样例 1
Input
2 3
31*
*13
Output
2

样例 2
Input
6 6
23311*
**13**
11*233
13*223
***133
331***
Output
9

样例 3
Input
2 50
21111121332233123311312211231333122233133212221212
21332123132223111331233121122331133311112121331311
Output
51

数据范围与提示
对于所有数据 1≤N×M≤10^5，队列中仅包含 1、2、3、* 四种字符。

solution

平均值为$2$，不难想到$1,3$必须是一对一对绑定的
而且$2$一定是单独成一个矩阵的（最优）
所以只考虑$1,3$凑成一对，明显的二分图匹配问题
将相邻的$1,3$连边，然后跑二分图最大匹配，匈牙利的$n^3$是受不了的
于是乎就请到了我们的老朋友——网络流跑二分图最大匹配

将$s$与$1$连流量为$1$的边，相邻的$1-3$连流量为$1$的边，$3$与$t$连流量为$1$的边

code

#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 100005
#define inf 1e9
struct node {
	int nxt, to, flow;
}edge[maxn << 2];
queue < int > q;
int n, m, cnt;
char str[2][maxn];
int head[maxn], cur[maxn], dep[maxn];

void addedge( int u, int v, int w ) {
	edge[cnt].nxt = head[u];
	edge[cnt].to = v;
	edge[cnt].flow = w;
	head[u] = cnt ++;
	
	edge[cnt].nxt = head[v];
	edge[cnt].to = u;
	edge[cnt].flow = 0;
	head[v] = cnt ++;
}

bool bfs( int s, int t ) {
	memcpy( cur, head, sizeof( head ) );
	memset( dep, 0, sizeof( dep ) );
	q.push( s ), dep[s] = 1;
	while( ! q.empty() ) {
		int u = q.front(); q.pop();
		for( int i = head[u];~ i;i = edge[i].nxt ) {
			int v = edge[i].to;
			if( ! dep[v] && edge[i].flow ) {
				dep[v] = dep[u] + 1;
				q.push( v );
			}
		}
	}
	return dep[t];
}

int dfs( int u, int t, int cap ) {
	if( u == t || ! cap ) return cap;
	int flow = 0;
	for( int i = cur[u];~ i;i = edge[i].nxt ) {
		cur[u] = i;
		int v = edge[i].to;
		if( dep[v] == dep[u] + 1 ) {
			int w = dfs( v, t, min( cap, edge[i].flow ) );
			if( ! w ) continue;
			cap -= w;
			flow += w;
			edge[i].flow -= w;
			edge[i ^ 1].flow += w;
			if( ! cap ) break;
		}
	}
	return flow;
}

int dinic( int s, int t ) {
	int ans = 0;
	while( bfs( s, t ) )
		ans += dfs( s, t, inf );
	return ans;
}

int id( int i, int j ) {
	return ( i - 1 ) * m + j;
}

int main() {
	memset( head, -1, sizeof( head ) );
	scanf( "%d %d", &n, &m );
	int s = 0, t = n * m + 1, tot = 0;
	for( int i = 1;i <= n;i ++ ) {
		int k = i & 1;
		scanf( "%s", str[k] + 1 );
		for( int j = 1;j <= m;j ++ ) {
			int pos = id( i, j );
			switch( str[k][j] ) {
				case '*' : { break; }
				case '1' : {
					addedge( s, pos, 1 );
					if( i != 1 && str[k ^ 1][j] == '3' )
						addedge( pos, pos - m, 1 );
					if( j != 1 && str[k][j - 1] == '3' )
						addedge( pos, pos - 1, 1 );
					if( j != m && str[k][j + 1] == '3' )
						addedge( pos, pos + 1, 1 );
					break;
				}
				case '2' : { tot ++; break; }
				case '3' : {
					addedge( pos, t, 1 );
					if( i != 1 && str[k ^ 1][j] == '1' )
						addedge( pos - m, pos, 1 );
					break;
				}
			}
		}
	}
	printf( "%d\n", tot + dinic( s, t ) );
	return 0;
}