BZOJ 2756: [SCOI2012]奇怪的游戏 二分+最大流

title

BZOJ 2756
LUOGU 5038
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

analysis

看到题目没想法？又是棋盘问题？先进行黑白染色，没错的。
这样子最起码有个思路：

1. 设黑色格子的个数为 \(num1\)，数值和为 \(sum1\)；
2. 设白色格子的个数为 \(num0\)，数值和为 \(sum0\)；

那我们就想了，最后棋盘的数值都要变成一个数： \(x\) ，因为操作次数相同，那么就会有\[num1*x-sum1=num0*x-sum0\]

\[x=\frac{(sum1–sum0)}{(num1–num0)}\]

所以分两种情况：

1. \(num1=\not num0\)：可以解出 x 再用网络流 \(check\) 即可；
2. \(num1=num0\)：可以发现，对于一个合法的 \(x\) ，\(x\leq k\) 都是一个合法的解，具有单调性。因为 \(num1=num0\to (num1+num0)\%2==0\) 可以构造一层的满覆盖，所以可以二分 \(x\)，然后用网络流 \(check\) 即可。

网络流的建图得单独说一下了：

1. \(源点s\) 向 \(黑点a\) 连容量为 \(x-v[a]\) 的边；
2. \(白点a\) 向 \(汇点t\) 连容量为 \(x-v[a]\) 的边；
3. \(黑点a\) 连他的四通图，容量为 \(INF\)。

code

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
const ll maxn=2e3+10,maxm=2e4+10,inf=1ll<<50;//inf不可过大

char buf[1<<15],*fs,*ft;
inline char getc() { return (ft==fs&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),ft==fs))?0:*fs++; }
template<typename T>inline void read(T &x)
{
    x=0;
    T f=1, ch=getchar();
    while (!isdigit(ch) && ch^'-') ch=getchar();
    if (ch=='-') f=-1, ch=getchar();
    while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
    x*=f;
}

template<typename T>inline void write(T x)
{
    if (!x) { putchar('0'); return ; }
    if (x<0) putchar('-'), x=-x;
    T num=0, ch[20];
    while (x) ch[++num]=x%10+48, x/=10;
    while (num) putchar(ch[num--]);
}

int ver[maxm],Next[maxm],head[maxn],len=1;
ll edge[maxm];
inline void add(int x,int y,ll z)
{
    ver[++len]=y,edge[len]=z,Next[len]=head[x],head[x]=len;
    ver[++len]=x,edge[len]=0,Next[len]=head[y],head[y]=len;
}

int s,t;
int dist[maxn];
inline bool bfs()
{
    queue<int>q;
    memset(dist,0,sizeof(dist));
    q.push(s);dist[s]=1;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        for (int i=head[x]; i; i=Next[i])
        {
            int y=ver[i];
            if (edge[i] && !dist[y])
            {
                dist[y]=dist[x]+1;
                if (y==t) return 1;
                q.push(y);
            }
        }
    }
    return 0;
}

inline ll get(int x,ll low)
{
    if (x==t) return low;
    ll tmp=low;
    for (int i=head[x]; i; i=Next[i])
    {
        int y=ver[i];
        if (edge[i] && dist[y]==dist[x]+1)
        {
            ll a=get(y,min(tmp,edge[i]));
            if (!a) dist[y]=0;
            edge[i]-=a;
            edge[i^1]+=a;
            if (!(tmp-=a)) break;
        }
    }
    return low-tmp;
}

inline ll Dinic()
{
    ll ans=0;
    while (bfs()) ans+=get(s,inf);
    return ans;
}

int n,m;
inline int hash(int i,int j)
{
    return (i-1)*m+j;
}

ll sum1,sum0;//sum1 黑点权值和 sum0 白点权值和
int num1,num0,a[45][45];//num1 黑点个数 num0 白点个数
inline bool check(ll x)
{
    memset(head,0,sizeof(head));
    len=1;//数组不清空，爆零两行泪
    ll sum=0; s=0,t=n*m+1;
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j)
            if ((i+j)&1)
            {
                add(s,hash(i,j),x-a[i][j]);sum+=x-a[i][j];
                for (int k=0; k<4; ++k)
                {
                    int x=i+dx[k],y=j+dy[k];
                    if (x<1 || y<1 || x>n || y>m) continue;
                    add(hash(i,j),hash(x,y),inf);
                }
            }
            else add(hash(i,j),t,x-a[i][j]);
    if (Dinic()==sum) return 1;
    return 0;
}

int main()
{
    int T;read(T);
    while (T--)
    {
        num1=sum1=num0=sum0=0;
        read(n);read(m);
        int mx=0;
        for (int i=1; i<=n; ++i)
            for (int j=1; j<=m; ++j)
            {
                read(a[i][j]),mx=max(mx,a[i][j]);
                if ((i+j)&1) sum1+=a[i][j],++num1;//黑点
                else sum0+=a[i][j],++num0;//白点
            }
        if (num1^num0)
        {
            ll x=(sum0-sum1)/(num0-num1);
            if (x>=mx) if (check(x)) { write(x*(ll)num1-sum1),puts(""); continue; }
            puts("-1");
        }
        else
        {
            if (sum1^sum0) { puts("-1"); continue; }
            ll l=mx,r=inf;
            while (l<=r)
            {
                ll mid=(l+r)>>1;
                if (check(mid)) r=mid-1;
                else l=mid+1;
            }
            write(l*(ll)num1-sum1),puts("");
        }
    }
    return 0;
}