[ABC193F]Zebraness

题目

传送门 to AtCoder

题目描述
一个 $n\times n$ 的网格图，一些格子是黑色，一些格子是白色，还有一些无色。你要把无色的格子都染色，使得 $\mathrm{Z}\mathrm{e}\mathrm{b}\mathrm{r}\mathrm{a}\mathrm{n}\mathrm{e}\mathrm{s}\mathrm{s}$ 最大。$\mathrm{Z}\mathrm{e}\mathrm{b}\mathrm{r}\mathrm{a}\mathrm{n}\mathrm{e}\mathrm{s}\mathrm{s}=$ 相邻的异色格子有多少对。相邻指，有一条公共边。

数据范围与提示
$n\le 100$，无其他限制。

思路

怎么 $ABC$ 都需要写网络流了……

由于 $\mathtt{d}\mathtt{p}$ 无法下手，又很难找到美妙的性质（事实上有一些吧。比如，我们可以构造一个 “黑色连通块” 大小最大为 $2$，“白色连通块” 要么是链、要么是环的最优方案。但是我没办法用它解决问题），我们就应该考虑将其 转化为图论。

事实上，这个就是一个选择问题，每个点在最小割中属于 $S,T$ 其中之一，代表 $W$ 和 $B$ 。不过，同时选择 $B$ 则失去 $1$ 的得分，这样不方便建边，因为这样不是一条割边。我们把 $(i,j)(i+j\mathrm{m}\mathrm{o}\mathrm{d}2=1)$ 的 格子的颜色都翻转 就行了！

然后跑 $\mathtt{d}\mathtt{i}\mathtt{n}\mathtt{i}\mathtt{c}$，由于边的容量都很小，可以近似于单位图或二分图，大致是 $\mathcal{O}(n^3)$ 的。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long int_;
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void writeint(int_ x){
	if(x > 9) writeint(x/10);
	putchar((x-x/10*10)^48);
}

const int MaxN = 105;
const int infty = (1<<30)-1;

struct Edge{
	int to, nxt, val;
	Edge(){}
	Edge(int T,int N,int V){
		to = T, nxt = N, val = V;
	}
};
Edge e[MaxN*MaxN*30];
int head[MaxN*MaxN], cntEdge;
void addEdge(int a,int b,int c){
	e[cntEdge] = Edge(b,head[a],c);
	head[a] = cntEdge ++;
	e[cntEdge] = Edge(a,head[b],0);
	head[b] = cntEdge ++;
}

int dis[MaxN*MaxN], q[MaxN*MaxN];
bool bfs(int S,int T){
	rep(i,S+1,T) dis[i] = -1;
	dis[S] = 0; *q = S;
	int *fro = q, *bac = q;
	for(; fro<=bac; ++fro)
	for(int i=head[*fro]; ~i; i=e[i].nxt)
		if(e[i].val && dis[e[i].to] == -1){
			dis[e[i].to] = dis[*fro]+1;
			*(++ bac) = e[i].to;
		}
	return dis[T] != -1;
}
int cur[MaxN*MaxN];
int dfs(int x,int inFlow,const int &T){
	if(x == T) return inFlow; int sum = 0;
	for(int &i=cur[x]; ~i; i=e[i].nxt)
		if(e[i].val && dis[e[i].to] == dis[x]+1){
			int d = dfs(e[i].to,min(e[i].val,inFlow-sum),T);
			e[i].val -= d, e[i^1].val += d;
			if((sum += d) == inFlow) break;
		}
	if(sum != inFlow) dis[x] = -1; return sum;
}
int dinic(int S,int T){
	int ans = 0;
	while(bfs(S,T)){
		memcpy(cur,head,(T+1)<<2);
		ans += dfs(S,infty,T);
	}
	return ans;
}

char maze[MaxN][MaxN];
int main(){
	memset(head,-1,sizeof(head));
	int n = readint();
	rep(i,1,n) scanf("%s",maze[i]+1);
	rep(i,1,n) rep(j,1,n) if((i+j)&1)
		if(maze[i][j] != '?')
			maze[i][j] = 'B'+'W'-maze[i][j];
	int S = 0, T = n*n+1;
	# define __id ((i-1)*n+j)
	rep(i,1,n) rep(j,1,n)
		if(maze[i][j] == 'B') // S
			addEdge(__id,T,4);
		else if(maze[i][j] == 'W') // T
			addEdge(S,__id,4);
	rep(i,1,n) rep(j,1,n-1){
		addEdge(__id,__id+1,1); // B & W
		addEdge(__id+1,__id,1); // W & B
	}
	rep(i,1,n-1) rep(j,1,n){
		addEdge(__id,__id+n,1); // B & W
		addEdge(__id+n,__id,1); // W & B
	}
	printf("%d\n",2*(n-1)*n-dinic(S,T));
	return 0;
}

后记

$\mathsf{S}\mathsf{h}\mathsf{a}\mathsf{m}\mathsf{e}\mathsf{r}$ 说，她有一个更暴力的做法，放在云剪切板上的。用来解决 “颜色相同则提供贡献” 的情况。

其实问题很简单，我们的 $+\infty$ 边的作用是，一旦某个点是 $S$ 集合，那么对面那个点也是。缺陷在于，它只用来检测 “存在” 而不是数量。这里看上去好像需要 “两个” 黑色？不，是 全部 为黑色。而我们的 $\forall$ 和 $\exists$ 本质上就是相同的：全部是黑色，转化为没有一个白色，转化为 只要有白色就失去贡献。

那么这就是简单的问题了。相邻的两个点之间建立一个虚点，二者都向它连 $+\infty$ 边，然后它再向 $T$ 连一条边，容量是二者同时选择白色获得的贡献。只要有一个黑色（放在 $S$ 部内），就会失去这条边。

同时选择黑色的贡献同理。因为 $+\infty$ 的反向边也有传递 $T$ 的能力。

当然，这种做法的边数量会多一点，可以看到，翻转颜色是多么神奇的操作！（如果有兴趣的话，把这个图中的冗余边去掉，大概也和颜色翻转后的结果类似……）