【BZOJ2756】奇怪的游戏（二分，最小割）

题意：

Blinker最近喜欢上一个奇怪的游戏。
这个游戏在一个 N*M 的棋盘上玩，每个格子有一个数。每次 Blinker 会选择两个相邻
的格子，并使这两个数都加上 1。
现在 Blinker 想知道最少多少次能使棋盘上的数都变成同一个数，如果永远不能变成同
一个数则输出-1。

n,m<=40 a[i,j]<=10^9

思路：假设我们已经询问最终是否都能变成数字D怎么做？

注意到黑白点染色后每次加的点必定是1黑点1白点

设黑格子有k1个，和为s1，白格子有k2个，和为s2

显然k1*d-s1=k2*d-s2

d=(s1-s2)/(k1-k2)

当k1<>k2时D可以直接被计算出，用网络流验证即可，注意当D<max(a[i,j])时显然不可能完成

当k1=k2时注意到每次加必定黑+1，白+1，如果s1<>s2就不可能完成

又因为此时n*m为偶数，任意的D如果符合要求，任意的D'>D必定符合要求

因为总个数为偶数时必定可以设计出方案使所有数都+1

所以可以二分答案，找到最小的能被取到的D，同样用网络流验证

网络流验证：

S——>黑点 流量为D-a[i,j]

白点——>T 流量为D-a[i,j]

黑点——>相邻的白点 流量为oo

看最小割是否等于需要被加上的总和即可，因为每个黑点只向相邻的白点连边所以一个最小割就对应了一个操作的方案

另外二分上界只需要2^50，太大会炸

num数组一定要动态开，直接设完全部会导致标号不连续调了一天全是泪

const oo=1<<50;
      dx:array[1..4]of longint=(-1,1,0,0);
      dy:array[1..4]of longint=(0,0,-1,1);
var head,gap,dis:array[0..2000]of longint;
    vet,next,fan:array[1..200000]of longint;
    len:array[1..200000]of int64;
    num,a:array[1..40,1..40]of longint;
    n,m,i,j,tot,k1,k2,s,source,src,cas,v,mx:longint;
    l,r,mid,last,s1,s2,k:int64;

procedure add(a,b:longint;c:int64);
begin
 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 len[tot]:=c;
 head[a]:=tot;

 inc(tot);
 next[tot]:=head[b];
 vet[tot]:=a;
 len[tot]:=0;
 head[b]:=tot;
end;

function min(x,y:int64):int64;
begin
 if x<y then exit(x);
 exit(y);
end;

function dfs(u:longint;aug:int64):int64;
var e,v,val:longint;
    flow,t:int64;
begin
 if u=src then exit(aug);
 e:=head[u]; val:=s-1; flow:=0;
 while e<>0 do
 begin
  v:=vet[e];
  if len[e]>0 then
  begin
   if dis[u]=dis[v]+1 then
   begin
    t:=dfs(v,min(len[e],aug-flow));
    len[e]:=len[e]-t;
    len[fan[e]]:=len[fan[e]]+t;
    flow:=flow+t;
    if dis[source]>=s then exit(flow);
    if aug=flow then break;
   end;
   val:=min(val,dis[v]);
  end;
  e:=next[e];
 end;
 if flow=0 then
 begin
  dec(gap[dis[u]]);
  if gap[dis[u]]=0 then dis[source]:=s;
  dis[u]:=val+1;
  inc(gap[dis[u]]);
 end;
 exit(flow);
end;

function maxflow:int64;
var ans:int64;
begin
 fillchar(gap,sizeof(gap),0);
 fillchar(dis,sizeof(dis),0);
 gap[0]:=s; ans:=0;
 while dis[source]<s do ans:=ans+dfs(source,oo);
 exit(ans);
end;

function max(x,y:longint):longint;
begin
 if x>y then exit(x);
 exit(y);
end;

function isok(k:int64):boolean;
begin
 if k*k1-s1=maxflow then exit(true);
 exit(false);
end;

procedure build(k:int64);
var i,j,l,x,y:longint;
begin
 fillchar(head,sizeof(head),0); tot:=0;
 for i:=1 to n do
  for j:=1 to m do
   if (i+j) mod 2=0 then
   begin
    for l:=1 to 4 do
    begin
     x:=i+dx[l]; y:=j+dy[l];
     if (x>0)and(x<=n)and(y>0)and(y<=m) then add(num[i,j],num[x,y],oo);
    end;
   end;

 for i:=1 to n do
  for j:=1 to m do
   if (i+j) mod 2=0 then add(source,num[i,j],k-a[i,j])
    else add(num[i,j],src,k-a[i,j]);
end;

begin
 assign(input,'bzoj2756.in'); reset(input);
 assign(output,'bzoj2756.out'); rewrite(output);
 read(cas);
 for i:=1 to 200000 do
  if i mod 2=1 then fan[i]:=i+1
   else fan[i]:=i-1;
// for i:=1 to 40 do
 // for j:=1 to 40 do num[i,j]:=(i-1)*40+j;
 for v:=1 to cas do
 begin
  read(n,m);
  s1:=0; s2:=0; k1:=0; k2:=0; mx:=-maxlongint;
  for i:=1 to n do
   for j:=1 to m do
   begin
    read(a[i,j]);
    if (i+j) mod 2=0 then begin inc(k1); s1:=s1+a[i,j]; end
     else begin inc(k2); s2:=s2+a[i,j]; end;
    mx:=max(mx,a[i,j]); num[i,j]:=(i-1)*m+j;
   end;
  s:=n*m+2; source:=n*m+1; src:=n*m+2;
  if k1<>k2 then
  begin
   k:=(s1-s2) div (k1-k2);
   if k<mx then writeln(-1)
    else
    begin
     build(k);
     if isok(k) then writeln(k*k1-s1)
      else writeln(-1);
    end;
  end
   else
   begin
    if s1<>s2 then writeln(-1)
     else
     begin
      l:=mx; r:=oo; last:=oo;
      while l<=r do
      begin
       mid:=(l+r)>>1;
       build(mid);
       if isok(mid) then begin last:=mid; r:=mid-1; end
        else l:=mid+1;
      end;
      writeln(last*k1-s1);
     end;
   end;


 end;

 close(input);
 close(output);
end.