[NOIP模擬賽]黑白棋

題目描述
給你一個n*n的網格。每個格子只會是這三種之一：x(黑塊),o(白塊),.(空格)。當前網格上沒有任意兩個白塊相鄰，任意白塊上下左右必有一個空格。

現在你要向空格上放黑塊，對於任意一個白塊上下左右如果全是黑塊，那麼這個白塊就會變成空格。求空格最大能達到多少個？

輸入格式

第1行：1個整數n（n ≤ 50），表示網格的大小接下來n行，每行n個字符，描述網格

輸出格式

第1行：1個整數，表示最多能得到多少個空格

輸入樣例
3
o.o
.o.

o.o

輸出樣例

5

樣例說明
最優解是把黑塊放在(1,2)，(2,1)，(2,3)，(3,2)。網格會將變成如下:
.x.
x.x
.x.

可以看出，有5個空格

題解：最大流。

題目的難點在於選擇將哪些白棋周圍的空位放上黑棋，因爲一個白棋變空格對答案貢獻1，但消耗的空格數可能更多，得不償失。

因此答案就是白棋數+空格數-得不償失的白棋數。

將白棋與其周圍的空格連邊，跑最大流，就得到了得不償失的白棋數。因爲要花費更多的空格使它們變成空格。

#include<cstdio>
#include<algorithm>
using namespace std;

const int INF=0x3f3f3f3f;
const int T=55;
const int N=2505;
const int M=1e6;

int n, p, sum;
int to[4][2]={ { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };

int fir[N], ecnt=1;
struct node{ int e, cap, next; } edge[M];
void Link( int s, int e, int cap ) {
	edge[++ecnt].e=e; edge[ecnt].next=fir[s]; fir[s]=ecnt;
	edge[ecnt].cap=cap;
	edge[++ecnt].e=s; edge[ecnt].next=fir[e]; fir[e]=ecnt;
}

int Pos( int i, int j ) { return (i-1)*n+j; }

char map[T][T];
void Build() {
	scanf( "%d", &n ); sum=n*n;
	for( int i=1; i<=n; i++ ) scanf( "%s", map[i]+1 );
	for( int i=1; i<=n; i++ )
		for( int j=1; j<=n; j++ ) {
			if( map[i][j]=='x' ) sum--;
			else if( map[i][j]=='o' ) {
				p=Pos( i, j )+1; Link( 1, p, 1 );
				for( int k=0; k<4; k++ ) {
					int x=i+to[k][0], y=j+to[k][1];
					if( map[x][y]=='.' ) Link( p, Pos( x, y )+1, INF );
				}
			}
			else if( map[i][j]=='.' ) Link( Pos( i, j )+1, n*n+2, 1 );
		}
	n=n*n+2;
}

int pos[N], cnt[N];
int maxFlow( int s, int max_aug ) { 
    if( s==n ) return max_aug; 
    int rest_aug=max_aug, minpos=n-1, delta; 
    for( int i=fir[s]; i && rest_aug>0; i=edge[i].next )
		if( edge[i].cap>0 ) { 
			if( pos[s]==pos[ edge[i].e ]+1 ) { 
				delta=maxFlow( edge[i].e, min( rest_aug, edge[i].cap ) ); 
				rest_aug-=delta; 
				edge[i].cap-=delta; 
				edge[i^1].cap+=delta; 
				if( pos[1]>=n ) return max_aug-rest_aug; 
			} 
			minpos=min( minpos, pos[ edge[i].e ] ); 
		} 
    if( max_aug==rest_aug ) {
        cnt[ pos[s] ]--;
        if( !cnt[ pos[s] ] ) pos[1]=n; 
        cnt[ pos[s]=minpos+1 ]++; 
    } 
    return max_aug-rest_aug; 
}

int main() {
	Build();
	while( pos[1]<n ) sum-=maxFlow( 1, INF );
	printf( "%d\n", sum );
	return 0;
}