【BZOJ2756】奇怪的游戏（二分，网络流）

题面

BZOJ

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

题解

我竟然调了$1h+....$

我们假设知道了要把他们都变成$x$
如何检验$x$是否可行？

很明显，棋盘黑白染色之后，永远都是一个黑点和一个白点一起加一
所以黑点加的次数和白点加的次数一定相同

同样的，我们知道一个黑点要加多少次
现在的问题不过变成了黑点加的若干次如何分配给白点
因为只能加给邻边，黑白染色之后向相邻的格子连容量为$inf$的边就行了
最后只需要检查是否满流即可。

当黑白格子数量相同的时候，显然答案可以二分
假设我们都可以加到一个最小的$x$
那么，一个黑格子唯一确定一个白格子
所有格子就可以都加一，因此也可以得到任何一个大于$x$的数
所以二分+判定即可

当黑白格子数量不同
此时可行的$x$应该唯一确定
我们求出白格子的和$S1$，黑格子的和$S2$
不妨设白格子数量为$c1$，黑格子数量为$c2$,且$c1>c2$
因为每一次都是一个黑格加一，一个白格加一
所以$x=\frac{S1-S2}{C1-C2}$
证明？算了，随便写一下

$$xc1-S1=xc2-S2$$
移过去除一下检查是否可行即可。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define INF (1ll<<50)
#define MAX 2000
inline int read()
{
    RG int x=0,t=1;RG char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return x*t;
}
struct Line{int v,next;ll w;}e[MAX<<4];
int h[MAX],cnt;
inline void Add(int u,int v,ll w)
{
    e[cnt]=(Line){v,h[u],w};h[u]=cnt++;
    e[cnt]=(Line){u,h[v],0};h[v]=cnt++;
}
void init(){memset(h,0,sizeof(h));cnt=2;}
int level[MAX],S,T;
bool bfs()
{
    memset(level,0,sizeof(level));level[S]=1;
    queue<int> Q;Q.push(S);
    while(!Q.empty())
    {
        int u=Q.front();Q.pop();
        for(int i=h[u];i;i=e[i].next)
            if(e[i].w&&!level[e[i].v])
                level[e[i].v]=level[u]+1,Q.push(e[i].v);
    }
    return level[T];
}
ll dfs(int u,ll flow)
{
    if(u==T||!flow)return flow;
    ll ret=0;
    for(int i=h[u];i;i=e[i].next)
        if(e[i].w&&level[e[i].v]==level[u]+1)
        {
            ll d=dfs(e[i].v,min(flow,e[i].w));
            ret+=d;flow-=d;
            e[i].w-=d;e[i^1].w+=d;
        }
    if(!ret)level[u]=0;
    return ret;
}
ll Dinic()
{
    ll ret=0;
    while(bfs())ret+=dfs(S,INF);
    return ret;
}
int n,m,a[45][45],bh[45][45];
int d[4][2]={-1,0,0,-1,1,0,0,1};
ll sum1,sum2;
bool check(ll x)
{
    init();ll tot=0;
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            if((i+j)&1)
            {
                tot+=x-a[i][j];Add(S,bh[i][j],x-a[i][j]);
                for(int k=0;k<4;++k)
                {
                    int xx=i+d[k][0],yy=j+d[k][1];
                    if(!(xx&&yy&&xx<=n&&yy<=m))continue;
                    Add(bh[i][j],bh[xx][yy],INF);
                }
            }
            else Add(bh[i][j],T,x-a[i][j]);
    return Dinic()==tot;
}
int main()
{
    int TT=read();
    while(TT--)
    {
        n=read();m=read();sum1=sum2=0;
        int tot=0,mx=0,whi=0,blk=0;
        for(int i=1;i<=n;++i)
            for(int j=1;j<=m;++j)
                mx=max(a[i][j]=read(),mx),bh[i][j]=++tot;
        for(int i=1;i<=n;++i)
            for(int j=1;j<=m;++j)
                if((i+j)&1)sum1+=a[i][j],++whi;
                else sum2+=a[i][j],++blk;
        S=0;T=tot+1;
        if(whi!=blk)
        {
            ll x=(sum1-sum2)/(whi-blk);
            if(x>=mx&&check(x))printf("%lld\n",x*whi-sum1);
            else puts("-1");continue;
        }
        if(sum1!=sum2){puts("-1");continue;}
        ll l=mx,r=1ll<<35;
        while(l<=r)
        {
            ll mid=(l+r)>>1ll;
            if(check(mid))r=mid-1;
            else l=mid+1;
        }
        printf("%lld\n",l*whi-sum1);
    }
    return 0;
}