bzoj2756

看到相邻格子都+1的操作一下就想到黑白染色了
相邻格子都+1说明不管怎么弄，黑格子的总和和白格子总和的差总是定值
这里首先要注意，最后不一定变成的是所有元素中的最大值，可能比它大
比如 1 2 2 
     2 1 0  这里最后可以全变成3
所以做题的时候下结论一定要小心，我们不妨设最后都变成了x，c1,c2表示黑白格子个数，s1,s2分别表示原来黑白格子元素和
则x*c1-s1=x*c2-s2
则(c1-c2)*x=s1-s2
如果棋盘格子数为奇数，则，最后一定变成(s1-s2)/(c1-c2)，我们只要验证这个即可
否则，当s1≠s2则无解
等于的话就有许多解，随着x的增大显然操作次数增多，所以我们二分x判定
如何判定呢？
我们将s连黑点，白点连t，流量是x-初始值
对相邻黑白点连inf的边，表示这两个格子可以共同+1
最后我们只要判断是否满流即可

const inf=int64(1) shl 36;
      dx:array[1..4] of longint=(0,0,-1,1);
      dy:array[1..4] of longint=(1,-1,0,0);

type node=record
       next,po:longint;
       flow:int64;
     end;

var e:array[0..400010] of node;
    p,cur,pre,numh,h:array[0..1640] of longint;
    d:array[0..1640] of int64;
    num:array[0..40,0..40] of longint;
    a:array[0..40,0..40] of int64;
    test,t,i,n,m,j,k,len:longint;
    ans,mx,s1,s2,l,r,mid:int64;

function min(a,b:int64):int64;
  begin
    if a>b then exit(b) else exit(a);
  end;

procedure add(x,y:longint;f:int64);
  begin
    inc(len);
    e[len].po:=y;
    e[len].flow:=f;
    e[len].next:=p[x];
    p[x]:=len;
  end;

procedure build(x,y:longint;f:int64);
  begin
    add(x,y,f);
    add(y,x,0);
  end;

function sap:int64;
  var u,i,j,tmp,q:longint;
      neck:int64;

  begin
    fillchar(h,sizeof(h),0);
    fillchar(numh,sizeof(numh),0);
    for i:=0 to t do
      cur[i]:=p[i];
    neck:=inf;
    numh[0]:=t+1;
    u:=0;
    sap:=0;
    while h[0]<t+1 do
    begin
      d[u]:=neck;
      i:=cur[u];
      while i<>-1 do
      begin
        j:=e[i].po;
        if (e[i].flow>0) and (h[u]=h[j]+1) then
        begin
          neck:=min(neck,e[i].flow);
          cur[u]:=i;
          pre[j]:=u;
          u:=j;
          if u=t then
          begin
            sap:=sap+neck;
            while u<>0 do
            begin
              u:=pre[u];
              j:=cur[u];
              dec(e[j].flow,neck);
              inc(e[j xor 1].flow,neck);
            end;
            neck:=inf;
          end;
          break;
        end;
        i:=e[i].next;
      end;
      if i=-1 then
      begin
        dec(numh[h[u]]);
        if numh[h[u]]=0 then exit;
        q:=-1;
        tmp:=t;
        i:=p[u];
        while i<>-1 do
        begin
          j:=e[i].po;
          if (e[i].flow>0) and (h[j]<tmp) then
          begin
            tmp:=h[j];
            q:=i;
          end;
          i:=e[i].next;
        end;
        cur[u]:=q;
        h[u]:=tmp+1;
        inc(numh[h[u]]);
        if u<>0 then
        begin
          u:=pre[u];
          neck:=d[u];
        end;
      end;
    end;
  end;

function check(w:int64):boolean;
  var i,j,x,y:longint;
      s:int64;
  begin
    len:=-1;
    s:=0;
    fillchar(p,sizeof(p),255);
    for i:=1 to n do
      for j:=1 to m do
        if (i+j) mod 2=1 then build(num[i,j],t,w-a[i,j])
        else begin
          build(0,num[i,j],w-a[i,j]);
          for k:=1 to 4 do
          begin
            x:=i+dx[k];
            y:=j+dy[k];
            if num[x,y]>0 then build(num[i,j],num[x,y],inf);
          end;
          s:=s+w-a[i,j];
        end;

    if sap<>s then exit(false)
    else begin
      ans:=s;
      exit(true);
    end;
  end;

begin
  readln(test);
  while test>0 do
  begin
    dec(test);
    readln(n,m);
    fillchar(num,sizeof(num),0);
    s1:=0;
    s2:=0;
    k:=0;
    mx:=0;
    for i:=1 to n do
      for j:=1 to m do
      begin
        read(a[i,j]);
        inc(k);
        num[i,j]:=k;
        if (i+j) mod 2=0 then s1:=s1+a[i,j]
        else s2:=s2+a[i,j];
        if a[i,j]>mx then mx:=a[i,j];
      end;
    t:=n*m+1;
    ans:=-1;
    if n*m mod 2=1 then
    begin
      if (mx<=s1-s2) and check(s1-s2) then writeln(ans)
      else writeln(-1);
    end
    else begin
      if s1<>s2 then writeln(-1)
      else begin
        l:=mx;
        r:=int64(1) shl 33;
        while l<=r do
        begin
          mid:=(l+r) shr 1;
          if check(mid) then r:=mid-1
          else l:=mid+1;
        end;
        writeln(ans);
      end;
    end;
  end;
end.