模拟题 ： 棋盘游戏

【题目描述】

Alice 和 Bob 在玩一个游戏，给出一张 n × m 的棋盘，上面有一些点是障碍，游戏的开始，Alice 选定棋盘
上任意一个不是障碍的格子，并且将一枚棋子放在其中，然后 Bob 先手，两人轮流操作棋子，每次操作必
须将棋子从当前位置移动到一个相邻的无障碍且未经过的格子（即每个格子不允许经过两次），不能操作的
人输，如果两人都按照最优策略操作，请问初始时 Alice 将棋子放在哪些格子上有必胜策略？

输入格式
第一行，两个正整数 n、m。
接下来输入一个 n × m 的字符矩阵，n 行 m 列， . 表示空的格子， # 表示有障碍的格子。
输出格式
第一行，一个正整数 ans，为 Alice 有必胜策略的格子的个数。
接下来 ans 行，每行一个坐标 (x, y) 表示第 x 行第 y 列是一个 Alice 有必胜策略的初始位置，以矩阵的左上角 (1, 1)，右下角为 (n, m)。
数据范围与提示
对于20% 的数据，n, m ≤ 4；
对于60% 的数据，n, m ≤ 10；
对于100% 的数据，1 ≤ n, m ≤ 100。

【思路】

首先可以注意到这一定是个二分图。然后就自然想到二分图染色建边。
一个一个连通块分开考虑，如果存在完备匹配，$Bob$每次沿着匹配边走即可，一定无解。
那么如果一个点不在匹配中,$Alice$先走这个点，下一步不管如何$Bob$一定会走到一个匹配点，然后$Alice$每次沿着匹配边走就可以了。最后一定会走到一个匹配节点结束，$Alice$必胜。

【代码】

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <queue>
#include <cstring>
#define N 10005
#define M 40005
#define INF 0x7fffffff
using namespace std;
typedef long long ll;
typedef pair<int,int> pa;

ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
    return x*f;
} 

int n,m,cnt,ind,ans;
bool mark[N],Flag[N];
int mat[N],used[N],id[105][105];
int b[M],p[N],nextedge[M];
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};

class Node{
    public:
        int x,y;
    Node(){}
    Node(int xx,int yy){
        x=xx,y=yy;
    }
}e[N];

void Add(int x,int y)
{
    cnt++;
    b[cnt]=y;
    nextedge[cnt]=p[x];
    p[x]=cnt;
}

void Anode(int x,int y){
    Add(x,y);Add(y,x);
}

void Input_Init()
{
    n=read(),m=read();
    for(int i=1;i<=n;i++)
    {
        char ch[105];
        scanf("%s",ch+1);
        for(int j=1;j<=m;j++) if(ch[j]=='.') {
            id[i][j]=++ind;
            e[ind]=(Node){i,j};
        }
    }
}

void Build_Graph()
{
    for(int i=1;i<=n;i++)
    for(int j=1;j<=m;j++) if(id[i][j]&&((i+j)&1))
    {
        for(int k=0;k<4;k++)
        {
            int xx=i+dx[k],yy=j+dy[k];
            if(!xx||!yy||xx>n||yy>m||!id[xx][yy]) continue;
            Anode(id[i][j],id[xx][yy]);
        }
    }
}

bool Dfs(int x,int now)
{
    for(int i=p[x];i;i=nextedge[i])
    {
        int v=b[i];
        if(used[v]!=now)
        {
            used[v]=now;
            if(!mat[v]||Dfs(mat[v],now))
            {
                mat[v]=x;
                return 1;
            }
        }
    }
    return 0;
}

void Update(int x)
{
    for(int i=p[x];i;i=nextedge[i])
    {
        int v=b[i];
        if(mat[v]&&!Flag[mat[v]]) 
        {
            Flag[mat[v]]=1;
            Update(mat[v]);
        }
    }
}

void Hungary()
{
    for(int i=1;i<=ind;i++) 
        if((e[i].x+e[i].y)&1)
            Dfs(i,i);
    for(int i=1;i<=ind;i++) if(mat[i]) mat[mat[i]]=i;
    for(int i=1;i<=ind;i++) if(!mat[i])
    {
        Flag[i]=1;
        Update(i);
    }
    for(int i=1;i<=ind;i++)
        if(Flag[i]) ans++;
    printf("%d\n",ans);
    for(int i=1;i<=ind;i++) if(Flag[i])
        printf("%d %d\n",e[i].x,e[i].y);
}

int main()
{
    Input_Init();
    Build_Graph();
    Hungary();
    return 0;
}