BZOJ 2756 SCOI2012 奇怪的游戏

2756: [SCOI2012]奇怪的游戏

Time Limit: 40 Sec Memory Limit: 128 MB

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

分析：
首先我们考虑对棋盘黑白染色，那么我们发现：“每次相邻两个+1”，显然是一黑一白 +1
那么我们先统计出WhiteNum，BlackNum（黑白点的数目），WhiteSum，BlackSum（黑白点初始权值和）
那么对于一次增加，显然是WhiteSum+1,BlackSum+1
考虑对最后的情况进行讨论：
那么很显然，当WhiteNum==BlackNum时（即总点数为偶数）
如果WhiteSum！=BlackSum，显然无解
如果WhiteSum==BlackSum时，我们发现，对于X如果成立，那么X+1一定成立，显然满足二分的性质，那么二分这个值，进行判定
当WhiteNum!=BlackNum时（即总点数为奇数）
发现显然，若有解，则解唯一，那么直接验证正确性即可
至于解怎么求？
那么假设我们知道最后值为X，那么显然可以得到X∗WhiteNum−WhiteSum=X∗BlackNum−BlackSum
移项后显然可以化减出，eeeee，公式有点难写，自己化去吧

那么考虑建图：
S–>白点，约束为X-val[i][j]
黑点–>T，约束为X-val[i][j]
相邻的白点–>黑点，约束为INF
判断是否满流即可

#include<iostream>
#include<cstring>
#include<queue>
#include<cstdio>
#include<cmath>
#include<algorithm>
using namespace std;
inline int read(int &x){
    x=0;int f=1;char c=getchar();
    while(c>'9'||c<'0'){ if(c=='-') f=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ x=(x<<1)+(x<<3)+(c-'0'); c=getchar(); } x*=f;
}
#define MAXM 1001000
#define LL long long
#define MAXN 2010
int Cas,m,n,mat[50][50];
struct Edge{ int to,next;LL val; }e[MAXM];
int head[MAXN],tot=1;
inline void Add_Edge(int u,int v,LL w){
    e[++tot].to=v;e[tot].val=w;
    e[tot].next=head[u];head[u]=tot;
}
inline void Insert_Edge(int u,int v,LL w){ Add_Edge(u,v,w);Add_Edge(v,u,0); }
int dep[MAXN],cur[MAXN],S,T;
queue<int> q;
bool BFS(){
    while(!q.empty()) q.pop();
    memset(dep,-1,sizeof dep );
    q.push(S);dep[S]=0;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head[u];i;i=e[i].next){
            int v=e[i].to;
            if(e[i].val&&dep[v]==-1){ dep[v]=dep[u]+1;q.push(v); }
        }
    }
    return dep[T]!=-1;
}
#define INF 1LL<<60
inline bool ok(int x,int y){ return (x>=1&&x<=n&&y>=1&&y<=m); }
inline void init(){ tot=1;memset(head,0,sizeof head ); }
int col[50][50],id[50][50];
LL Sum_b,Sum_w,Num_w,Num_b,ID;
LL DFS(int u,LL flow){
    if(u==T) return flow;
    LL ret=0;
    for(int i=cur[u];i;i=e[i].next){
        int v=e[i].to;
        if(e[i].val&&dep[v]==dep[u]+1){
            LL w=DFS(v,min(flow-ret,e[i].val));
            e[i].val-=w;e[i^1].val+=w;ret+=w;
            if(e[i].val) cur[u]=i;
            if(ret==flow) return ret;
        }
    }
    if(!ret) dep[u]=-1;
    return ret;
}
LL Dinic(){
    LL ret=0;
    while(BFS()){
        for(int i=S;i<=T;i++) cur[i]=head[i];
        ret+=DFS(S,INF);
    }
    return ret; 
}
bool Check(LL x){
    LL Tot=0; init();
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if(col[i][j]){
                Insert_Edge(S,id[i][j],x-mat[i][j]);Tot+=(x-mat[i][j]);
                if(ok(i-1,j)) Insert_Edge(id[i][j],id[i-1][j],INF);
                if(ok(i,j-1)) Insert_Edge(id[i][j],id[i][j-1],INF);
                if(ok(i,j+1)) Insert_Edge(id[i][j],id[i][j+1],INF);
                if(ok(i+1,j)) Insert_Edge(id[i][j],id[i+1][j],INF);
            }
            else Insert_Edge(id[i][j],T,x-mat[i][j]);
        }
    LL ans=Dinic();
    return Tot==ans;
}
void Build(){
    S=0; T=n*m+1; Sum_b = Sum_w = Num_b = Num_w = 0; ID=0; int maxx=0;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            col[i][j]=(i+j)&1,id[i][j]= ++ID,maxx=max(maxx,mat[i][j]);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if(col[i][j]) Sum_w += mat[i][j],Num_w++;
            else Sum_b += mat[i][j],Num_b++;
        }
    if(Num_w==Num_b&&Sum_b!=Sum_w){ puts("-1");return; }
    if(Num_w==Num_b){
        LL l=maxx,r=(1LL<<50);
        while(l<=r){
            LL Mid=(l+r)>>1;
            if(Check(Mid)) r=Mid-1;
            else l=Mid+1;
        }
        printf("%lld\n",l*Num_w-Sum_w);
    } else {
        LL x=(Sum_b-Sum_w)/(Num_b-Num_w);
        if(x<maxx) {puts("-1");return;}
        if(Check(x)) printf("%lld\n",x*Num_w-Sum_w);
        else puts("-1");
    }
}
int main(){
    read(Cas);
    while(Cas--){
        read(n); read(m);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++) read(mat[i][j]);
        Build();
    }
    return 0;
}