【Codevs1922】骑士共存问题（最小割，二分图最大独立集转最大匹配）

题意：

在一个n*n个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘
上某些方格设置了障碍，骑士不得进入。

对于给定的n*n个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑士，使得它们彼此互不攻击。

n<=200,m<=n^2

思路：经典的二分图最大独立集，采用黑白点染色的思想。

如果按照相邻点黑白不同染色，可以发现每次跳到的点必定与现在所在点不同色，二分图最大匹配即可。

每切断一条黑白点之间的边就是少放了一个骑士，用最小割算出最少要切断几条边，总数减去有障碍的再减切断的边数就是最大匹配数，最大独立集又可以转化为最大匹配数。

这里用最小割来解决，因为不能允许任何黑白点之间的任何一条边有流量，符合最小割的思想。

 const dx:array[..]of longint=(-,-,-,-,,,,);
       dy:array[..]of longint=(-,,-,,-,,-,);
 var head,vet,next,len,fan,gap,dis:array[..]of longint;
     b,num,a:array[..,..]of longint;
     n,m,i,tot,x,y,k,j,source,src,s:longint;

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

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

 function dfs(u,aug:longint):longint;
 var e,v,val,flow,t:longint;
 begin
  if u=src then exit(aug);
  flow:=; val:=s-;
  e:=head[u];
  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:longint;
 var ans:longint;
 begin
  fillchar(gap,sizeof(gap),);
  fillchar(dis,sizeof(dis),);
  gap[]:=s; ans:=;
  while dis[source]<s do ans:=ans+dfs(source,maxlongint);
  exit(ans);
 end;

 begin
  assign(input,'codevs1922.in'); reset(input);
  assign(output,'codevs1922.out'); rewrite(output);
  read(n,m);
  for i:= to n do
   for j:= to n do
   begin
    inc(s); a[i,j]:=(i+j+) mod ; num[i,j]:=s;
   end;
  for i:= to m do
  begin
   read(x,y);
   b[x,y]:=;
  end;
  s:=n*n+;
  for i:= to n do
   for j:= to n do
    if (a[i,j]=)and(b[i,j]=) then
    begin
     for k:= to  do
     begin
      x:=i+dx[k]; y:=j+dy[k];
      if (x>)and(x<=n)and(y>)and(y<=n)and(b[x,y]=) then
      begin
       fan[tot+]:=tot+;
       fan[tot+]:=tot+;
       add(num[i,j],num[x,y],);
       add(num[x,y],num[i,j],);
      end;
     end;
    end;
  source:=; src:=;
  for i:= to n do
   for j:= to n do
    if a[i,j]= then
     begin
      fan[tot+]:=tot+;
      fan[tot+]:=tot+;
      add(source,num[i,j],);
      add(num[i,j],source,);
     end
      else if b[i,j]= then
      begin
       fan[tot+]:=tot+;
       fan[tot+]:=tot+;
       add(num[i,j],src,);
       add(src,num[i,j],);
      end;
  writeln(n*n-m-maxflow);
  close(input);
  close(output);
 end.