BZOJ 2756 [SCOI2012]奇怪的游戏 二分+网络流

Description

Blinker最近喜欢上一个奇怪的游戏。
这个游戏在一个 N*M 的棋盘上玩，每个格子有一个数。每次 Blinker 会选择两个相邻
的格子，并使这两个数都加上 1。
现在 Blinker 想知道最少多少次能使棋盘上的数都变成同一个数，如果永远不能变成同
一个数则输出-1。

Input

输入的第一行是一个整数T，表示输入数据有T轮游戏组成。
每轮游戏的第一行有两个整数N和M， 分别代表棋盘的行数和列数。
接下来有N行，每行 M个数。 

Output

  对于每个游戏输出最少能使游戏结束的次数，如果永远不能变成同一个数则输出-1。

Sample Input

2
2 2
1 2
2 3
3 3
1 2 3
2 3 4
4 3 2

Sample Output

2
-1

HINT

【数据范围】

    对于30%的数据，保证  T<=10，1<=N,M<=8

对于100%的数据，保证  T<=10，1<=N,M<=40，所有数为正整数且小于1000000000 

 

传送门

吐槽一句……RE了这么久……最后是inf太小了……

（吐血）

首先这题的话，由于是相邻的同时加一，相邻的，

所以我们可以对其进行黑白染色。意思就是：

白黑白黑白……

黑白黑白黑……

…………

然后就分出了2个集合：黑和白。我们把白看做0，把黑看做1.

用num[0..1]表示黑或者白的个数，sum[0..1]表示黑格或者白格的数字和。

假设最后，所有格子的值都成了X。 那么我们有：

X*num[0]-sum[0]=X*num[1]-sum[1]

为什么呢？很好想，每次相邻的都加一，两个集合的sum都加一。

所以最后，两个集合所增长的值是一样的。

我们化简这个式子，得到

X=(sum[0]-sum[1])/(num[0]-num[1])

如果说num[0]≠num[1]，那么我们可以直接计算出来X了。

只要判断X是否为整数，即可直接得出最后答案。

如果X是整数，那么我们需要网络流来检验。具体之后说。

不是整数？直接-1.

注意这个X是最后统一的值，答案应当是把X代入X*num[0]-sum[0]

如果num[0]=num[1]呢？这会很麻烦，因为X是任意的值都有可能性的。

我们可以挖掘到X的一个性质：二分性。这是很显然的不多说。

那么我们可以从最大值开始不停向上二分X、

对于当前X用网络流来检验是否合法，然后取得最小答案。

重点：网络流如何来check？

首先当然是把二维转成一维来看。

我们建边（source,u,X-a[u]），其中u是白色点集的一个点，a[u]是它的初始值。

以及（v,sink,X-a[v]），v是黑色点集的一个点。

和(u,v,inf)，uv如上，inf=正无穷，其中u，v满足相邻。

这样的话我们观察到以下几个点：

1、X>=max(a[i])

2、X-a[i]的意义是需要增加的次数。

3、如果source流出的总流量=sink接收的总流量，说明可以成功平衡，X合法。

所以直接上就ok了。

注意一下-1的判断。除了以上几个，还有一个：

当sum[0]不等于sum[1]且num[0]等于num[1]时也无解。

这个是从hzwer dalao的blog的评论里面得到的。

isap跑得还真行……

对了数组稍稍开大一点……

#include<bits/stdc++.h>
#define ll long long
using namespace std;
int read(){
    int x=0,f=1;char ch=getchar();
    while (ch<'0' || ch>'9'){if (ch=='-') f=-1;ch=getchar();}
    while (ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int 
	N=95,
	NN=N*N;
const ll 
	inf=(ll)1<<(ll)50;
int n,m,Ecnt,source,sink;
int d[NN],gap[NN],Q[NN],pre[NN],cur[NN];
ll tot,a[N][N],sum[2];
bool col[N][N];
int num[2];
struct Edge{
	int next,to;
	ll C;
}E[NN<<1]; int head[NN];
int Vertex(int x,int y){
	return (x-1)*m+y;
}
void add(int u,int v,ll C){
	E[Ecnt].next=head[u];
	E[Ecnt].to=v;
	E[Ecnt].C=C;
	head[u]=Ecnt++;
}
void BFS(){
	int h=0,t=1;
	memset(d,255,sizeof(d));
	memset(gap,0,sizeof(gap));
	Q[0]=sink,d[sink]=0,gap[0]++;
	while (h<t){
		int u=Q[h++];
		for (int i=head[u];~i;i=E[i].next){
			int j=E[i].to;
			if (~d[j]) continue;
			d[j]=d[u]+1,gap[d[j]]++;
			Q[t++]=j;
		}
	}
}
ll ISAP(){
	BFS();
	memcpy(cur,head,sizeof(cur));
	int u;ll flow=(ll)0;
	u=pre[source]=source;
	while (d[sink]<n*m+3){
		if (u==sink){
			ll f=inf,neck;
			for (int i=source;i!=sink;i=E[cur[i]].to)
				if (f>E[cur[i]].C) f=E[cur[i]].C,neck=i;
			for (int i=source;i!=sink;i=E[cur[i]].to)
				E[cur[i]].C-=f,E[cur[i]^1].C+=f;
			flow+=f,u=neck;
		}
		int j;
		for (j=cur[u];~j;j=E[j].next)
			if (E[j].C && d[E[j].to]+1==d[u]) break;
		
		if (~j) pre[E[j].to]=u,cur[u]=j,u=E[j].to;
			else{
			if (!(--gap[d[u]])) break;
			int mind=n*m+3;
			for (int i=head[u];~i;i=E[i].next)
				if (E[i].C && mind>d[E[i].to])
					mind=d[E[i].to],cur[u]=i;
			d[u]=mind+1,gap[d[u]]++;
			u=pre[u];
		}
	}
	return flow;
}
void build(ll X){
	Ecnt=0,tot=(ll)0;
	memset(head,255,sizeof(head));
	for (int i=1;i<=n;i++)
		for (int j=1;j<=m;j++){
			int t=Vertex(i,j),t1;
			if (!col[i][j]){
				if (i<n) t1=Vertex(i+1,j),add(t,t1,inf),add(t1,t,(ll)0);
				if (j<m) t1=Vertex(i,j+1),add(t,t1,inf),add(t1,t,(ll)0);
				if (i>1) t1=Vertex(i-1,j),add(t,t1,inf),add(t1,t,(ll)0);
				if (j>1) t1=Vertex(i,j-1),add(t,t1,inf),add(t1,t,(ll)0);
				if (X-a[i][j]) add(source,t,X-a[i][j]),add(t,source,(ll)0);
				tot+=X-a[i][j];
			}	else
			if (X-a[i][j]) add(t,sink,X-a[i][j]),add(sink,t,(ll)0);
		}
}
bool ok(ll x){
	build(x);
	ll t=ISAP();
//	cout<<t<<endl;
	return t==tot;
}
void solve(){
	n=read(),m=read();
	source=n*m+1,sink=n*m+2;
	num[0]=num[1]=0;
	sum[0]=sum[1]=(ll)0;
	ll MAX=(ll)0;
	
	for (int i=1;i<=n;i++)
		for (int j=1;j<=m;j++)
			a[i][j]=read(),col[i][j]=(i+j)&1,
			num[col[i][j]]++,sum[col[i][j]]+=a[i][j],
			MAX=max(MAX,a[i][j]);

	if (num[0]!=num[1]){
		ll x=(sum[0]-sum[1])/(ll)(num[0]-num[1]);
		if (x*(ll)(num[0]-num[1])!=sum[0]-sum[1]){puts("-1");return;}
		
		if (x>=MAX && ok(x)) printf("%lld\n",x*(ll)num[0]-sum[0]);
			else puts("-1");
	}	else{
		if (sum[0]!=sum[1]){puts("-1");return;}
		ll L=MAX,R=inf,mid;
		bool flag=0;
		while (L<R){
			mid=(L+R)>>(ll)1;
			if (ok(mid)) flag=1,R=mid;
				else L=mid+1;
		}
		if (!flag) puts("-1");
			else printf("%lld\n",R*(ll)num[0]-sum[0]);
	}
}
int main(){
	int cas=read();
	while (cas--) solve();
	return 0;
}