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

【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;
}