BZOJ2756:[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

Solution

emmm这个题真的有毒啊……INF改成8e8才过……最慢的点跑2s……幸亏BZOJ算总时间
首先看到这个数据范围十有八九网络流没跑了……
先将格子黑白染色，考虑一通操作成功后每个格子的数都是v，若：
1、n*m是奇数。设黑白格子个数为num[0/1],和为sum[0/1]，那么$num0*x-sum0=num1*x-sum1$，因为每次操作肯定会给一个黑点和一个白点加。
2、n*m是偶数。如果最终答案是v满足的话，那么显然最终答案是v+1肯定也是可以满足的。这个就可以二分了。
现在的问题转换为判断是否可行。
s-black，容量为v-a[i][j]
white-e，容量为v-a[i][j]
black-white， 容量为INF。
怎么理解呢？把INF边看成给两端的数各自加一，而INF边连着的两端的边又限制了INF边的使用次数。

Code 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#define N (2001)
#define INF (8000000000LL)
#define LL long long
using namespace std;

struct Edge{LL to,next,flow;}edge[N<<4];
LL T,n,m,s,e=1999,Depth[N],num[2],sum[2],maxn,cnt;
LL head[N],num_edge,a[N][N],col[N][N],id[N][N];
LL dx[6]={0,1,-1,0,0},dy[6]={0,0,0,1,-1};
queue<LL>q;

void add(LL u,LL v,LL l)
{
    edge[++num_edge].to=v;
    edge[num_edge].next=head[u];
    edge[num_edge].flow=l;
    head[u]=num_edge;
}

LL Dfs(LL x,LL low)
{
    if (x==e || low==0) return low;
    LL f=0,Min=0;
    for (int i=head[x]; i; i=edge[i].next)
        if (edge[i].flow && Depth[edge[i].to]==Depth[x]+1 && (Min=Dfs(edge[i].to,min(low,edge[i].flow))))
        {
            edge[i].flow-=Min;
            edge[((i-1)^1)+1].flow+=Min;
            f+=Min; low-=Min;
            if (!low) break;
        }
    if (!f) Depth[x]=-1;
    return f;
}

bool Bfs(LL s,LL e)
{
    memset(Depth,0,sizeof(Depth));
    Depth[s]=1; q.push(s);
    while (!q.empty())
    {
        LL x=q.front(); q.pop();
        for (int i=head[x]; i; i=edge[i].next)
            if (!Depth[edge[i].to] && edge[i].flow)
            {
                Depth[edge[i].to]=Depth[x]+1;
                q.push(edge[i].to);
            }
    }
    return (Depth[e]!=0);
}

bool Dinic(LL s,LL e)
{
    while (Bfs(s,e)) Dfs(s,INF);
    for (int i=head[s]; i; i=edge[i].next)
        if (edge[i].flow!=0) return false;
    for (int i=head[e]; i; i=edge[i].next)
        if (edge[((i-1)^1)+1].flow!=0) return false;
    return true;
}

bool check(LL v)
{
    memset(head,0,sizeof(head)); num_edge=0;
    memset(edge,0,sizeof(edge));
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
        {
            if (col[i][j]) add(s,id[i][j],v-a[i][j]),add(id[i][j],s,0);
            else add(id[i][j],e,v-a[i][j]),add(e,id[i][j],0);
            if (!col[i][j]) continue;
            for (int k=1; k<=4; ++k)
            {
                LL x=i+dx[k], y=j+dy[k];
                if (x<1 || x>n || y<1 || y>m) continue;
                add(id[i][j],id[x][y],INF),add(id[x][y],id[i][j],0);
            }
        }
    return Dinic(s,e);
}

int main()
{
    scanf("%lld",&T);
    while (T--)
    {
        scanf("%lld%lld",&n,&m);
        sum[0]=sum[1]=maxn=cnt=0;
        if (n*m%2) num[1]=n*m/2+1,num[0]=n*m/2;
        else num[1]=num[0]=n*m/2;
        for (int i=1; i<=n; ++i)
            for (int j=1; j<=m; ++j)
            {
                scanf("%lld",&a[i][j]);
                id[i][j]=++cnt;
                maxn=max(maxn,a[i][j]);
                if (i%2==j%2) col[i][j]=1;
                sum[col[i][j]]+=a[i][j];
            }
        if (n*m%2)
        {
            LL v=(sum[1]-sum[0])/(num[1]-num[0]);
            if (check(v)) printf("%lld
",(v*n*m-sum[0]-sum[1])/2);
            else printf("-1
");
        }
        else
        {
            LL l=maxn, r=INF, ans=-1;
            while (l<=r)
            {
                LL mid=(l+r)/2;
                if (check(mid)) r=mid-1,ans=mid;
                else l=mid+1;
            }
            if (ans==-1) printf("-1
");
            else printf("%lld
",(ans*n*m-sum[0]-sum[1])/2);
        }
    }
}