[网络流24题] 骑士共存问题（最小点覆盖）

骑士共存问题

1、对这张n*n的图进行黑白染色，将黑色的点放在一个集合，白色的点放在一个集合。容易发现，能相互攻击到的点一定在不同一个集合。这显然满足二分图。

2、对能相互攻击到的点连边，最多能放置多少个等价最少要取走多少个，才能使这些边不存在，这是最小点覆盖问题，在二分图中最小点覆盖等于最大匹配。
所以答案就是总点数减去不能放置的点再减去最小点覆盖

3、这里如果用匈牙利算法直接做的话，匈牙利需要进行dfs N次，每次最多跑满一张图也就是所有的边，复杂度是O(NM) 其中N是点数，M是边数。

对于此题的数据范围，当输入的n=200，m=0时候，
就有4e4个点，有一半的点能连8条边，4e4 * 2e4 * 8=6.4e9 显然会TLE
所以这里我们用Dinic算法跑最大流即可。
最大流跑二分图的复杂度是O(M × sqrt(N))

#pragma GCC optimize(3)
#include<bits/stdc++.h>
using namespace std;
const int N=210*210;
struct E{
    int to,next,v;
}e[10*N];
int mp[210][210],in[210][210];
int dx[]={1,1,2,2,-1,-1,-2,-2},dy[]={2,-2,1,-1,2,-2,1,-1};
int h[N],tot;
int n,m,k;
int ans;
int deep[N],cur[N];
void add(int a,int b,int v){
    e[tot]={b,h[a],v},h[a]=tot++;
    e[tot]={a,h[b],0},h[b]=tot++;
}
int bfs(int s,int t){
      memset(deep,0,sizeof deep);
      queue<int> que;
      deep[s]=1;
      que.push(s);
      while(!que.empty()){
          int x=que.front();
          que.pop();
          for(int i=h[x];~i;i=e[i].next){
              int to=e[i].to,v=e[i].v;
              if(v && !deep[to]){
                  deep[to]=deep[x]+1;
                  que.push(to);
              }
          }
      }
      return deep[t];
}
int dfs(int s,int t,int flow){
    if(s==t) return flow;
    int sum=0;
    for(int &i=cur[s];~i;i=e[i].next){
        int to=e[i].to,v=e[i].v;
        if(v && deep[to]==deep[s]+1){
            int Next=dfs(to,t,min(flow,v));
            e[i].v-=Next,e[i^1].v+=Next;
            flow-=Next,sum+=Next;
        }
    }
    if(!sum) deep[s]=-2;
    return sum;
}
void Dinic(int s,int t){
    int INF=1e9;
    ans=0;
    while(bfs(s,t)) {
        for(int i=0;i<=n*n+1;i++) cur[i]=h[i];
        ans+=dfs(s,t,INF);
    }
}
int main(){
    
    memset(h,-1,sizeof h);
    tot=0;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
		int x,y;
		scanf("%d%d",&x,&y);
		mp[x][y]=1;
	}  
	int num=0;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++) in[i][j]=++num;
	}
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			if(mp[i][j]) continue;
			if((i+j)&1){//左部的点
				add(0,in[i][j],1);///源点连向左部的点
				for(int k=0;k<8;k++){
					int x=i+dx[k],y=j+dy[k];
					if(x<1 || x>n || y<1 || y>n || mp[x][y]) continue;
					add(in[i][j],in[x][y],1);///左部的点连到右部的点
					
				}
			}
			else add(in[i][j],n*n+1,1);///右部的点连向汇点
		}
	}
    Dinic(0,n*n+1);
    printf("%d\n",n*n-m-ans);///答案就是所有的点减去不可放置的点在减去最大匹配
		
    return 0;
}