题目：
题目描述
Blinker 最近喜欢上一个奇怪的游戏。
这个游戏在一个 N*M 的棋盘上玩，每个格子有一个数。每次 Blinker 会选择两个相邻的格子，并使这两个数都加上 1。
现在 Blinker 想知道最少多少次能使棋盘上的数都变成同一个数，如果永远不能变成同一个数则输出 -1。
输入格式
输入的第一行是一个整数 T，表示输入数据有T 轮游戏组成。
每轮游戏的第一行有两个整数 N 和 M ， 分别代表棋盘的行数和列数。
接下来有 N 行，每行 M 个数。
输出格式
对于每个游戏输出最少能使游戏结束的次数，如果永远不能变成同一个数则输出 -1。
样例数据 1
输入 [复制]
2
2 2
1 2
2 3
3 3
1 2 3
2 3 4
4 3 2
输出
2
-1
备注
【数据范围】
对于 30% 的数据，保证 T<=10，1<=N,M<=8
对于 100% 的数据，保证 T<= 10，1<=N,M<=40，所有数为正整数且小于 1000000000
题解：
这里引用http://www.cnblogs.com/DaD3zZ-Beyonder/p/5765882.html：
一道比较有趣的题目
先对题目进行分析：
首先我们考虑对棋盘黑白染色，那么我们发现：“每次相邻两个+1”，显然是一黑一白+1
那么我们先统计出WhiteNum，BlackNum（黑白点的数目），WhiteSum，BlackSum（黑白点初始权值和）（接下来可能用Wn,Ws,Bn,Bs代替）
那么对于一次增加，显然是WhiteSum+1,BlackSum+1
考虑对最后的情况进行讨论：
那么很显然，当WhiteNum==BlackNum时（即总点数为偶数）
如果WhiteSum！=BlackSum，显然无解
如果WhiteSum==BlackSum时，我们发现，对于X如果成立，那么X+1一定成立，显然满足二分的性质，那么二分这个值，进行判定
当WhiteNum!=BlackNum时（即总点数为奇数）
发现显然，若有解，则解唯一，那么直接验证正确性即可
至于解怎么求？
设最后所有数变为X，易得X*Wn-Ws=X*Bn-Bs,整理下可得：X=(Ws-Bs)/(Wn-Bn)，用网络流验证即可
那么考虑建图：
S-->白点，约束为X-val[i][j]
黑点-->T，约束为X-val[i][j]
相邻的白点-->黑点，约束为INF
判断是否满流即可
最后说下个人心得：
这道题的重点其实不是网络流，而是黑白染色这一想法，由相邻格子染色其实可以考虑到这一点，以后做到相似的题要注意这一想法····然后就是后面的分类讨论···也是由黑白染色后考虑答案的性质得出的·····这是一道很好的题，染色+二分+网络流；
代码
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<cctype>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int N=2010;
const int M=1001000;
const long long inf=1e+18;
int Ri()
{
char c;
int f=0;
for(c=getchar();c<‘0‘||c>‘9‘;c=getchar());
for(;c<=‘9‘&&c>=‘0‘;c=getchar())
f=(f<<3)+(f<<1)+c-‘0‘;
return f;
}
long long Rl()
{
char c;
long long f=0;
for(c=getchar();c<‘0‘||c>‘9‘;c=getchar());
for(;c<=‘9‘&&c>=‘0‘;c=getchar())
f=f*10+c-‘0‘;
return f;
}
int T,n,m,tot,first[N],cur[N],lev[N],next[M],go[M],Wn,Bn,src,des;
int color[N][N],num[N][N];
long long map[N][N],rest[M],Ws,Bs,ans,sum;
inline void comb(int a,int b,long long c)
{
next[++tot]=first[a],first[a]=tot,go[tot]=b,rest[tot]=c;
next[++tot]=first[b],first[b]=tot,go[tot]=a,rest[tot]=0;
}
inline bool bfs()
{
for(int i=src;i<=des;i++) cur[i]=first[i],lev[i]=-1;
static int que[N],tail,u,v;
que[tail=1]=src;
lev[src]=0;
for(int head=1;head<=tail;head++)
{
u=que[head];
for(int e=first[u];e;e=next[e])
{
if(lev[v=go[e]]==-1&&rest[e])
{
lev[v]=lev[u]+1;
que[++tail]=v;
if(v==des) return true;
}
}
}
return false;
}
inline long long dinic(int u,long long flow)
{
if(u==des)
return flow;
long long res=0,delta;
int v;
for(int &e=cur[u];e;e=next[e])
{
if(lev[v=go[e]]>lev[u]&&rest[e])
{
delta=dinic(v,min(flow-res,rest[e]));
if(delta)
{
rest[e]-=delta;
rest[e^1]+=delta;
res+=delta;
if(res==flow) break;
}
}
}
if(flow!=res) lev[u]=-1;
return res;
}
inline long long maxflow()
{
long long temp=0;
while(bfs())
temp+=dinic(src,inf);
return temp;
}
inline bool jud(int x,int y)
{
return x>=1&&x<=n&&y>=1&&y<=m;
}
inline bool check(long long lim)
{
tot=1;
memset(first,0,sizeof(first));
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
if(
!color[i][j])
comb(src,num[i][j],lim-map[i][j]);
else
comb(num[i][j],des,lim-map[i][j]);
}
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(!color[i][j])
{
if(jud(i-1,j))
comb(num[i][j],num[i-1][j],inf);
if(jud(i+1,j))
comb(num[i][j],num[i+1][j],inf);
if(jud(i,j-1))
comb(num[i][j],num[i][j-1],inf);
if(jud(i,j+1))
comb(num[i][j],num[i][j+1],inf);
}
long long temp=maxflow();
if(temp==((long long)Wn*lim-Ws))
return true;
else return false;
}
inline void solve()
{
Wn=Ws=Bn=Bs=0;
src=0;
des=n*m+1;
int cnt=0;
long long left=0,right=1e+18;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
{
num[i][j]=++cnt;
color[i][j]=(i+j)%2;
if(!color[i][j])
Wn++,Ws+=map[i][j];
else
Bn++,Bs+=map[i][j];
left=max(left,map[i][j]);
}
if(Wn==Bn)
{
if(Ws!=Bs)
{
cout<<"-1"<<endl;
return;
}
else
{
while(left<=right)
{
long long mid=(left+right)/2;
if(check(mid)) ans=mid,right=mid-1;
else left=mid+1;
}
cout<<ans*Wn-Ws<<endl;
}
}
else
{
ans=(long long)(Ws-Bs)/(Wn-Bn);
if(ans<left)
{
cout<<"-1"<<endl;
return;
}
if(check(ans))
{
cout<<ans*Wn-Ws<<endl;
return;
}
else cout<<"-1"<<endl;
}
}
int main()
{
// freopen("a.in","r",stdin);
T=Ri();
while(T--)
{
n=Ri(),m=Ri();
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
map[i][j]=Rl();
solve();
}
return 0;
}