题目描述

       在一个 n*n个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘上某些方格设置了障碍，骑士不得进入。对于给定的 n*n 个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑士，使得它们彼此互不攻击。

题解

      这道题问的是最多放置多少个骑士。那么看到“最多”的字眼很容易就想到了最大费用最大流，每个点向整张图可以去到的点连边，再取相反数跑mcmf。

      但是会发现，，会爆空间。而且时间也会超限。

      怎么办呢，我们会想到一个有趣的定理：要的点数+不要的点数=总点数。所以我们如果可以把不要的点找出来就可以啦。

最小割

      最小割很明显符合这个逻辑（把不要的边割掉相当于不要这个点）。

      关于证明我就不多讲，我们还是像方格取数问题一样，把整张图分为两个集合，一个A集合，一个B集合（具体分法看超链接哦。）。意思就是说选A集合的点时，不能选附近骑士能走到的B集合点。（这里运用得很巧妙）。

      那么我们从begin到每个A集合点连一条流量为1的边，表示选这个点有1的价值，每个B集合点到end连一条流量为1的边，表示选这个点有1的价值。

      每个A集合点到附近能到达的B集合点连一条流量为INF的边。

      那么最小割一定是简单割，最小割=最大流。

      要的点数+不要的点数=总点数 =〉要的点数=总点数-不要的点数；

      要使左侧最大，那么右边的减数应当最小 =〉最小割

贴代码

//记得减去最小割再输出

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#define INF 1e6
using namespace std;

int n,m;
int p[40010];
int ans=0;
struct edge{int y,next,c;};
edge s[399999];
int first[40010];
int begin,end;
int len=1;
queue<int> f;
int h[40010];
int map[210][210];

int mmin(int x,int y)
{
	return x<y?x:y;
}

void ins(int x,int y,int c)
{
	len++;
	s[len].y=y;s[len].c=c;s[len].next=first[x];first[x]=len;
	len++;
	s[len].y=x;s[len].c=0;s[len].next=first[y];first[y]=len;
}

bool bfs()
{
	f.push(begin);
	memset(h,0,sizeof(h));
	h[begin]=1;
	while(!f.empty())
	{
		int x=f.front();
		f.pop();
		for(int i=first[x];i!=0;i=s[i].next)
		{
			int y=s[i].y;
			if(h[y]==0 && s[i].c>0)
			{
				h[y]=h[x]+1;
				f.push(y);
			}
		}	
	}
	if(h[end]==0) return false;
	return true;
}

int dfs(int x,int t)
{
	if(x==end) return t;
	int tot=0;
	for(int i=first[x];i!=0;i=s[i].next)
	{
		if(tot==t) return t;
		int y=s[i].y;
		if(h[y]==h[x]+1 && s[i].c>0)
		{
			int now=dfs(y,mmin(s[i].c,t-tot));
			tot+=now;s[i].c-=now;s[i^1].c+=now;
		}
	}
	if(tot==0) h[x]=0;
	return tot;
}

int max_flow()
{
	int flow=0,dx;
	while(bfs())
	{
		dx=dfs(begin,1e9);
		while(dx!=0)
		{
			flow+=dx;
			dx=dfs(begin,1e9);
		}
	}
	return flow;
}

int main()
{
	scanf("%d %d",&n,&m);
	begin=0,end=n*n+1;
	ans=n*n-m;
	for(int i=1;i<=m;i++)
	{
		int x,y;
		scanf("%d %d",&x,&y);
		map[x][y]=1;
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			if(map[i][j]==1) continue;
			int x=(i-1)*n+j;
			if((i%2==1 && j%2==0) || (i%2==0 && j%2==1)) ins(x,end,1);
			else if((i%2==1 && j%2==1) || (i%2==0 && j%2==0))
			{
				ins(begin,x,1);
				if(i-1>0 && j-2>0 && map[i-1][j-2]==0) ins(x,x-n-2,INF);
				if(i-2>0 && j-1>0 && map[i-2][j-1]==0) ins(x,x-2*n-1,INF);
				if(i-1>0 && j+2<=n && map[i-1][j+2]==0) ins(x,x-n+2,INF);
				if(i-2>0 && j+1<=n && map[i-2][j+1]==0) ins(x,x-2*n+1,INF);
				if(i+1<=n && j-2>0 && map[i+1][j-2]==0) ins(x,x+n-2,INF);
				if(i+2<=n && j-1>0 && map[i+2][j-1]==0) ins(x,x+2*n-1,INF);
				if(i+1<=n && j+2<=n && map[i+1][j+2]==0) ins(x,x+n+2,INF);
				if(i+2<=n && j+1<=n && map[i+2][j+1]==0) ins(x,x+2*n+1,INF);
			}
		}
	printf("%d",ans-max_flow());
}