【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=<<;
       dx:array[..]of longint=(-,,,);
       dy:array[..]of longint=(,,-,);
 var head,gap,dis:array[..]of longint;
     vet,next,fan:array[..]of longint;
     len:array[..]of int64;
     num,a:array[..,..]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]:=;
  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-; flow:=;
  while e<> do
  begin
   v:=vet[e];
   if len[e]> then
   begin
    if dis[u]=dis[v]+ 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= then
  begin
   dec(gap[dis[u]]);
   if gap[dis[u]]= then dis[source]:=s;
   dis[u]:=val+;
   inc(gap[dis[u]]);
  end;
  exit(flow);
 end;

 function maxflow:int64;
 var ans:int64;
 begin
  fillchar(gap,sizeof(gap),);
  fillchar(dis,sizeof(dis),);
  gap[]:=s; ans:=;
  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),); tot:=;
  for i:= to n do
   for j:= to m do
    if (i+j) mod = then
    begin
     for l:= to  do
     begin
      x:=i+dx[l]; y:=j+dy[l];
      if (x>)and(x<=n)and(y>)and(y<=m) then add(num[i,j],num[x,y],oo);
     end;
    end;

  for i:= to n do
   for j:= to m do
    if (i+j) mod = 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:= to  do
   if i mod = then fan[i]:=i+
    else fan[i]:=i-;
 // for i:= to  do
  // for j:= to  do num[i,j]:=(i-)*+j;
  for v:= to cas do
  begin
   read(n,m);
   s1:=; s2:=; k1:=; k2:=; mx:=-maxlongint;
   for i:= to n do
    for j:= to m do
    begin
     read(a[i,j]);
     if (i+j) mod = 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-)*m+j;
    end;
   s:=n*m+; source:=n*m+; src:=n*m+;
   if k1<>k2 then
   begin
    k:=(s1-s2) div (k1-k2);
    if k<mx then writeln(-)
     else
     begin
      build(k);
      if isok(k) then writeln(k*k1-s1)
       else writeln(-);
     end;
   end
    else
    begin
     if s1<>s2 then writeln(-)
      else
      begin
       l:=mx; r:=oo; last:=oo;
       while l<=r do
       begin
        mid:=(l+r)>>;
        build(mid);
        if isok(mid) then begin last:=mid; r:=mid-; end
         else l:=mid+;
       end;
       writeln(last*k1-s1);
      end;
    end;

  end;

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