SCOI 2012 奇怪的游戏

题目：http://61.187.179.132/JudgeOnline/problem.php?id=2756

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 

 

题解：

　　给格子黑白染色后我们会发现，每次必定是把一个黑格子和一个白格子的值加1，那么就可以把两边给分开了。

 

　　设白格子有num1个，数值和为sum1，黑格子有num2 个，数值和为sum2，设所有数最后都变成了x，那么有x*num1-sum1=x*num2-sum2，解之可得x=(sum1-sum2)/(num1-num2)，当num1=num2即有偶数个格子时，此方程无意义，所以先说num1!=num2的情况。

 

　　num1!=num2时，解出一个x，由于始终是把两个格子的值加1，所以若有解，x不可能小于所有值中的最大值且x必须是个整数，那么这样就只需检验当x满足上述两个条件时，是否可行即可了。

 

　　num1=num2时，如果说都变成x可以实现，那么都变成x+1也能实现（做法是黑白格子两两配对后加1），所以可以二分最后变成的那个数即可（所操作的次数与x的大小是正相关的）。

 

　　那么现在只需要检验当能否所有数都变成x，自然而然地就想到网络流了。总源向每个白格子连边，每个黑格子向总汇连边，流量为x减去该格子本来的权值，然后相邻的黑白格子连流量为无限大的边，求个最大流max_flow，并且提前算出若该方案可行需要多少步step，如果max_flow=step，则说明这是一个可行解，否则为不可行。

 

　　网络流建议写非递归的，递归的跑起来有点慢（虽说应该不会有太大影响的，但我的递归的T了），然后左右界稍微卡好一点，不然也容易T。

 

　　考试的时候已经把方法都想出来了，可是不知道又哪里写错了，再次崩掉。唉，还得努力攒RP啊……………………

 

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
 
using namespace std;
 
const int maxw=41;
const int maxn=1800;
const int maxm=100000;
const long long INF=123456789876ll;
 
int n,m,en,d[maxn],s,e,stack[maxn];
 
long long map[maxw][maxw];
 
queue<int> que;
 
struct edge
{
    int e;
    long long f;
    edge *next,*op;
}*v[maxn],ed[maxm],*p[maxn],*fe[maxn];
 
void add_edge(int s,int e,long long f)
{
    en++;
    ed[en].next=v[s];v[s]=ed+en;v[s]->e=e;v[s]->f=f;
    en++;
    ed[en].next=v[e];v[e]=ed+en;v[e]->e=s;v[e]->f=0;
    v[s]->op=v[e];v[e]->op=v[s];
}
 
int get(int x,int y)
{
    return (x-1)*m+y;
}
 
void get_add(int x,int y)
{
    if (x>1) add_edge(get(x,y),get(x-1,y),INF);
    if (x<n) add_edge(get(x,y),get(x+1,y),INF);
    if (y>1) add_edge(get(x,y),get(x,y-1),INF);
    if (y<m) add_edge(get(x,y),get(x,y+1),INF);
}
 
bool bfs()
{
    memset(d,-1,sizeof(d));
    d[s]=0;
    que.push(s);
    while (que.size())
    {
        int now=que.front();
        que.pop();
        for (edge *e=v[now];e;e=e->next)
            if (e->f && d[e->e]==-1)
            {
                d[e->e]=d[now]+1;
                que.push(e->e);
            }
    }
 
    return d[e]!=-1;
}
 
long long dfs(int now,long long cur_flow)
{
    if (now==e) return cur_flow;
    long long rest=cur_flow;
    for (edge *e=v[now];e;e=e->next)
        if (e->f && d[e->e]==d[now]+1)
        {
            long long new_flow=dfs(e->e,min(rest,e->f));
            e->f-=new_flow;
            e->op->f+=new_flow;
            rest-=new_flow;
        }
    return cur_flow-rest;
}
 
long long agument()
{
    int now,next,stop;
    long long delta,ans=0;
    for (int a=s;a<=e;a++)
        p[a]=v[a];
    stack[stop=1]=s;
    int t=e;
    while (stop>0)
    {
        now=stack[stop];
        if (now!=t)
        {
            for (;p[now];p[now]=p[now]->next)
                if ((p[now]->f) && (d[now]+1==d[next=p[now]->e])) break;
            if (p[now])
            {
                stack[++stop]=next;
                fe[stop]=p[now];
            }
            else
            {
                stop--;
                d[now]=-1;
            }
        }
        else
        {
            delta=INF;
            for (int a=stop;a>=2;a--)
                if (fe[a]->f<delta) delta=fe[a]->f;
            ans+=delta;
            for (int a=stop;a>=2;a--)
            {
                fe[a]->f-=delta;
                fe[a]->op->f+=delta;
                if (fe[a]->f==0) stop=a-1;
            }
        }
    }
    return ans;
}
 
long long dinic()
{
    long long ans=0;
    while (bfs())
        ans+=agument();
    return ans;
}
 
bool check(long long x)
{
    en=0;
    memset(v,0,sizeof(v));
    s=0;
    e=n*m+1;
    long long flow=0;
    for (int a=1;a<=n;a++)
        for (int b=1;b<=m;b++)
        {
            if ((a+b)%2==0)
            {
                add_edge(s,get(a,b),x-map[a][b]);
                get_add(a,b);
            }
            else add_edge(get(a,b),e,x-map[a][b]);
            flow+=x-map[a][b];
        }
    long long ans=dinic();
    if (ans*2!=flow) return false;
    else return true;
}
 
long long gettime(long long x)
{
    long long ans=0;
    for (int a=1;a<=n;a++)
        for (int b=1;b<=m;b++)
            ans+=x-map[a][b];
    return ans>>1;
}
 
int main()
{
    freopen("game.in","r",stdin);
    freopen("game.out","w",stdout);
 
    int t;
    scanf("%d",&t);
    for (int z=1;z<=t;z++)
    {
        scanf("%d%d",&n,&m);
        int num1=0,num2=0;
        long long sum1=0,sum2=0;
        long long max_v=0;
        for (int a=1;a<=n;a++)
            for (int b=1;b<=m;b++)
            {
                scanf("%lld",&map[a][b]);
                if ((a+b)%2==0)
                {
                    num1++;
                    sum1+=map[a][b];
                }
                else
                {
                    num2++;
                    sum2+=map[a][b];
                }
                max_v=max(max_v,map[a][b]);
            }
        if (num1!=num2)
        {
            if ((sum1-sum2) % (num1-num2)!=0)
            {
                printf("-1\n");
                continue;
            }
            else
            {
                long long x=(sum1-sum2)/(num1-num2);
                if (x<max_v)
                {
                    printf("-1\n");
                    continue;
                }
                if (check(x)) printf("%lld\n",gettime(x));
                else printf("-1\n");
            }
        }
        else
        {
            long long l=max_v-1,r=INF;
            while (l+1!=r)
            {
                long long m=(l+r)>>1;
                if (check(m)) r=m;
                else l=m;
            }
            if (check(r)) printf("%lld\n",gettime(r));
            else printf("-1\n");
        }
    }
 
    return 0;
}