「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
Output
51
資料範圍與提示
對於所有資料 1≤N×M≤10^5，佇列中僅包含 1、2、3、* 四種字元。
solution
平均值為
2
2
2，不難想到
1
,
3
1,3
1,3必須是一對一對繫結的
而且
2
2
2一定是單獨成一個矩陣的（最優）
所以只考慮
1
,
3
1,3
1,3湊成一對，明顯的二分圖匹配問題
將相鄰的
1
,
3
1,3
1,3連邊，然後跑二分圖最大匹配，匈牙利的
n
3
n^3
n3是受不了的
於是乎就請到了我們的老朋友——網路流跑二分圖最大匹配
將
s
s
s與
1
1
1連流量為
1
1
1的邊，相鄰的
1
−
3
1-3
1−3連流量為
1
1
1的邊，
3
3
3與
t
t
t連流量為
1
1
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;
}