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<<];
 LL T,n,m,s,e=,Depth[N],num[],sum[],maxn,cnt;
 LL head[N],num_edge,a[N][N],col[N][N],id[N][N];
 LL dx[]={,,-,,},dy[]={,,,,-};
 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==) return low;
     LL f=,Min=;
     for (int i=head[x]; i; i=edge[i].next)
         if (edge[i].flow && Depth[edge[i].to]==Depth[x]+ && (Min=Dfs(edge[i].to,min(low,edge[i].flow))))
         {
             edge[i].flow-=Min;
             edge[((i-)^)+].flow+=Min;
             f+=Min; low-=Min;
             if (!low) break;
         }
     if (!f) Depth[x]=-;
     return f;
 }

 bool Bfs(LL s,LL e)
 {
     memset(Depth,,sizeof(Depth));
     Depth[s]=; 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]+;
                 q.push(edge[i].to);
             }
     }
     return (Depth[e]!=);
 }

 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!=) return false;
     for (int i=head[e]; i; i=edge[i].next)
         if (edge[((i-)^)+].flow!=) return false;
     return true;
 }

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

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