BZOJ 2756 [SCOI2012]奇怪的游戏

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

Solution
个人觉得这道网络流是最近刷到比较难的，它的建模很有借鉴意义。

先把格子黑白染色(因为每次染相邻两个格子这样就可以连边了)
首先我们按格子数量分奇偶讨论。
先设几个变量：
设最后都变成了$x$，白格上数的和为$sum1$，黑格为$sum2$
当格子是奇数个$(n*m~\equiv1~(mod~2)):$
$~~~~~~~$白格数量为$cnt1$,黑格为$cnt1+1$
$~~~~~~~$$cnt1*x-sum1=(cnt1+1)*x-sum2$
$~~~~~~~$解得$x~=~sum2-sum1$
$~~~~~~~$然后用网络流check一下
当格子个数是偶数$(n~\equiv~1~(mod)~2~|~|~m~\equiv~1~（mod）~2)$
$~~~~~~~$二分$x$
$~~~~~~~$二分的正确性:设当前$x1$满足，有$x2>x1$，则$(n*m*(x2-x1)~\equiv~0~(mod)~2)$
$~~~~~~~$即$x2$是满足的。
关于怎么用网络流check
$~~~~~~~$对于黑色格子，$src$向其连一条边，容量为$A[i][j]-x$
$~~~~~~~$对于白色格子，向$sink$连一条边，容量为$A[i][j]-x$
$~~~~~~~$然后每个黑色格子向四周的白格连一条边，容量为INF
$~~~~~~~$check的时候观察流入是否等于流出。

这个建模说出来很简单，但是实际上个人觉得并不明显。
借鉴意义在于那个染色并且连边，格子的题好像很多都有这么干过。

code

/**************************************************************
    Problem: 2756
    User: bblss123
    Language: C++
    Result: Accepted
    Time:12972 ms
    Memory:1940 kb
****************************************************************/

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
const int M=2005;
const int N=1e4+5;
const ll INF=1ll<<50;
struct Edge{
    int to;ll cap;int nxt;
}edge[N<<2];
int A[45][45];
int _,n,m,head[M],work[M],tot_edge,src,sink,dist[M];
inline void Max(int &a,int b){if(a<b)a=b;}
inline void add_edge(int from,int to,ll c){
    edge[tot_edge]=(Edge){to,c,head[from]};
    head[from]=tot_edge++;
    edge[tot_edge]=(Edge){from,0,head[to]};
    head[to]=tot_edge++;
}
queue<int>que;
bool bfs(){
    for(int i=0;i<=sink;++i)
        dist[i]=-1;
    dist[src]=0;
    que.push(src);
    for(;!que.empty();){
        int v=que.front();que.pop();
        for(int i=head[v];~i;i=edge[i].nxt){
            int to=edge[i].to;
            if(dist[to]==-1&&edge[i].cap){
                dist[to]=dist[v]+1;
                que.push(to);
            }
        }
    }
    return dist[sink]!=-1;
}
bool mark[M],clr[45][45];
ll dfs(int v,ll f){
    if(v==sink)return f;
    mark[v]=1;
    for(int &i=work[v];~i;i=edge[i].nxt){
        int to=edge[i].to;
        if(edge[i].cap&&dist[to]==dist[v]+1&&!mark[to]){
            ll d=dfs(to,min(f,edge[i].cap));
            if(d){
                edge[i].cap-=d;
                edge[i^1].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
inline ll Dinic(){
    ll res=0;
    for(;bfs();){
        for(int i=0;i<=sink;++i)
            work[i]=head[i];
        for(;;){
            for(int i=0;i<=sink;++i)
                mark[i]=0;
            ll f=dfs(src,INF);
            if(!f)break;
            res+=f;
        }
    }
    return res;
}
inline int hash(int i,int j){return (i-1)*m+j;}
int rx[]={1,0,-1,0};
int ry[]={0,1,0,-1};
inline bool Legal(int &x,int &y){return x>=1&&x<=n&&y>=1&&y<=m;}
inline bool check(ll s){
    memset(head,-1,sizeof(head));
    tot_edge=0;
    //Init
    src=0,sink=n*m+1;
    ll res=0,w=0;
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j){
            if(clr[i][j]){
                add_edge(src,hash(i,j),s-A[i][j]);
                for(int k=0;k<4;++k){
                    int tx=i+rx[k],ty=j+ry[k];
                    if(Legal(tx,ty))add_edge(hash(i,j),hash(tx,ty),INF);
                }
                res+=(ll)s-A[i][j];
            }
            else{
                add_edge(hash(i,j),sink,s-A[i][j]);
                w+=s-A[i][j];
            }
        }
    ll flow=Dinic();
    return flow==res&&flow==w;
}
inline void gao(){
    scanf("%d %d",&n,&m);
    int Mx=0;
    ll tot=0;
    for(int i=1;i<=m;++i)
        clr[1][i]=clr[1][i-1]^1;
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j){
            scanf("%d",&A[i][j]);
            Max(Mx,A[i][j]);
            tot+=A[i][j];
            if(i^1)clr[i][j]=clr[i-1][j]^1;
        }
    if(n*m%2==0){
        ll l=Mx,r=INF,ans=-1;
        for(ll mid;l<=r;){
            mid=l+r>>1ll;
            if(check(mid))ans=mid,r=mid-1;
            else l=mid+1;
        }
        if(~ans)ans=1ll*ans*n*m-tot>>1LL;
        printf("%lld\n",ans);
    }
    else{
        ll sum[2]={0};
        for(int i=1;i<=n;++i)
            for(int j=1;j<=m;++j)
                sum[clr[i][j]]+=A[i][j];
        ll x=sum[1]-sum[0];
        ll ans=x*n*m-tot>>1;
        if(x<Mx)puts("-1");
        else printf("%lld\n",check(x)?ans:-1);
    }
}
int main(){for(scanf("%d",&_);_--;)gao();}