vijos p1729 Knights

描述

在一个N*N的正方形棋盘上，放置了一些骑士。我们将棋盘的行用1开始的N个自然数标记，将列用'A'开始的N个大写英文字母标记。举个例子来说，一个标准的8*8的国际象棋棋盘的行标记为1..8，列标记为A..H，D3、H1分别表示棋盘上第3行第4列和第1行第8列的格子。

骑士是这样一类棋子。若一个骑士放置在格子(x, y)。那么格子(x-2, y-1), (x-2, y+1), (x-1, y-2), (x-1, y+2), (x+1, y-2), (x+1, y+2), (x+2, y-1), (x+2, y+1)如果在棋盘内的话，就都处于这个骑士的攻击范围内。

如果若干个骑士在棋盘上的一种放置方法能使得没有一个骑士处在其它骑士的攻击范围内，那么称为和谐的方案。现在给定一个棋盘，上面已经放置了M个骑士。你的任务是拿走尽可能少的骑士，使得剩余的骑士构成一个和谐的方案。

格式

输入格式

第一行，两个正整数N，M，分别表示棋盘的大小，和骑士的数目。

以下M行，每行一个字符串，描述一个骑士的坐标。

输出格式

输出一行，一个整数，表示至少拿走多少个骑士。

样例1

样例输入1[复制]

6 9

A1

A5

B3

C5

C1

D2

D4

E6

F5

样例输出1[复制]

限制

每个测试点1s

提示

30%的数据满足，1 <= N <= 4.
100%的数据满足，1 <= N <= 26，骑士的坐标格式均合法，任意两个骑士的位置都不同。

来源

Topcoder

————————————我是分割线————————————————————

二分图问题。

看到这道题我们先会想到贪心，就是那个骑士被踩的最多，就先拿哪个。

但是，提交后就只过了5个点，其实这种贪心策略是不对的

特殊情况

当图G是以最大度数为偶数的点对称的奇阶图时，这种策略就是不对的....

那么要怎么做呢..

我们可以将各个骑士看成点，然后将互相攻击的骑士连边，那么求拿走多少也就是求这个图最小点的覆盖

求一般图的最小点的覆盖时无法在多项式时间里解决的.....

那要怎么办呢

我们知道二分图的最大匹配就是最小点的覆盖，那我们看看这个图是不是二分图。

这个图就是二分图

证明：

将棋盘黑白二染色，即将A1染成黑色，然后与A1相邻的格子染成白色，然后与白色格子相邻的再染成黑色，依次类推。那么可以发现，两个发生冲突的骑士所在的格子一定是一黑一白。那么，将白色格子的骑士对应的点设为无向图的X部，黑色对应到Y部，那么边就只存在于两部分的点之间。得证。

所以将x部的点向y部的点连边，得到一张二分图，那么求这个二分图的最大匹配就是结果。

 /*

     Problem:

     OJ:

     User:S.B.S.

     Time:

     Memory:

     Length:

 */

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<cmath>

 #include<algorithm>

 #include<queue>

 #include<cstdlib>

 #include<iomanip>

 #include<cassert>

 #include<climits>

 #include<functional>

 #include<bitset>

 #include<vector>

 #include<list>

 #include<map>

 #define maxn 100001

 #define F(i,j,k) for(int i=j;i<=k;i++)

 #define M(a,b) memset(a,b,sizeof(a))

 #define FF(i,j,k) for(int i=j;i>=k;i--)

 #define inf 0x3f3f3f3f

 #define maxm 1001

 #define mod 998244353

 //#define LOCAL

 using namespace std;

 int read(){

     int x=,f=;char ch=getchar();

     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}

     while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}

     return x*f;

 }

 const int dx[]={-,-,-,-,,,,};

 const int dy[]={-,-,,,,,-,-};

 int n,m;

 struct EDGE

 {

     int from;

     int to;

     int next;

 }e[maxn];

 struct NODE

 {

     int x;

     int y;

 }a[maxn];

 int head[maxn];

 int tot;

 int vis[maxm][maxm],ins[maxn];

 int py[maxn];

 int ans;

 inline void addedge(int u,int v)

 {

     tot++;

     e[tot].from=u;

     e[tot].to=v;

     e[tot].next=head[u];

     head[u]=tot;

 }

 inline bool path(int x)

 {

     int y;

     for(int i=head[x];i;i=e[i].next)

     {

         if(!ins[y=e[i].to]){

             ins[y]=;

             if(!py[y]||path(py[y])){

                 py[y]=x;

                 return true;

             }

         }

     }

     return false;

 }

 int main()

 {

 //    std::ios::sync_with_stdio(false);//cout<<setiosflags(ios::fixed)<<setprecision(1)<<y;

     #ifdef LOCAL

     freopen("data.in","r",stdin);

     freopen("data.out","w",stdout);

     #endif

     cin>>n>>m;

     char s[];

     F(i,,m){

         gets(s+);

         a[i].x=s[]-'A'+;

         int len=strlen(s+);

         F(j,,len){

             a[i].y*=;

             a[i].y+=s[j]-'';

         }

         vis[a[i].x][a[i].y]=i;

     }

     F(i,,m){

         F(k,,){

             int fx=dx[k]+a[i].x,fy=dy[k]+a[i].y;

             if(fx<||fy<||fx>n||fy>n||!vis[fx][fy]) continue;

             addedge(i,vis[fx][fy]);

         }

     }

     F(i,,m){

         if((a[i].x+a[i].y)&){

             M(ins,);

             if(path(i)) ans++;

         }

     }

     cout<<ans<<endl;

     return ;

 }