TYVJ1035 棋盘覆盖

链接：http://www.joyoi.cn/problem/tyvj-1035

题意：

      N*M的棋盘，某些格子进制放棋子，

最多能在棋盘上放置多少块1*2的骨牌，

骨牌不能出界，相互不能重叠。

思路：

      一个骨牌占两个格子，将棋盘黑白染色，二分图最大匹配关键，

找0要素和1要素：这里1要素是每个格子只能被一块骨牌覆盖，0要

素不同色的格子不能被同一块骨牌所覆盖。所以根据不同颜色划分

为2个部分，可以被同一块骨牌覆盖的两点之间连线，由此可以形

成一张二分图，然后其最大匹配数即最多能放置的骨牌数。

AC代码：

WA点：

         左部节点集、右部节点集弄混，原因是黑白节点的判断标准弄错

（不能按照格子序号的奇偶性，应该是行数+列数的奇偶性）。

#define ll long long
using namespace std;
const int N=10010;
const int M=10010*4;
int Next[M];
int ver[M];
int head[N];
int tot;
void add(int x,int y)
{
    ver[++tot]=y;
    Next[tot]=head[x];
    head[x]=tot;
}
bool visit[N];
int match[N];
bool dfs(int x)
{
    for(int i=head[x];i;i=Next[i])
    {
        int y=ver[i];
        if(!visit[y])
        {
            visit[y]=1;
            if(!match[y]||dfs(match[y]))//对立点没有被使用，或者占用它的左节点可以
            {
                match[y]=x;
                return 1;
            }
        }
    }
    return 0;
}
bool mark[N];
bool judge(int x,int y,int n)
{
    if(x>=1&&x<=n&&y>=1&&y<=n)return 1;
    else  return 0;
}
int main()
{
    int n,m;
    while(cin>>n>>m)
    {
        memset(head,0,sizeof(head));
        memset(Next,0,sizeof(Next));
        memset(ver,0,sizeof(ver));
        tot=0;
        memset(match,0,sizeof(match));
        memset(mark,0,sizeof(mark));
        for(int i=1;i<=m;++i)
        {
            int x,y;
            cin>>x>>y;
            mark[n*(x-1)+y]=1;
        }
        for(int i=1;i<=n;++i)
            for(int j=1;j<=n;++j)
            {
                int v=(i-1)*n+j;
                if((i+j)%2==1||mark[v])continue;
                if(judge(i-1,j,n)&&!mark[v-n])add(v,(i-2)*n+j),add((i-2)*n+j,v);
                if(judge(i+1,j,n)&&!mark[v+n])add(v,i*n+j),add(i*n+j,v);
                if(judge(i,j+1,n)&&!mark[v+1])add(v,(i-1)*n+j+1),add((i-1)*n+j+1,v);
                if(judge(i,j-1,n)&&!mark[v-1])add(v,(i-1)*n+j-1),add((i-1)*n+j-1,v);

            }
        int ans=0;
        for(int i=1;i<=n;i++)//遍历每一个左部节点，看能不能找到其在右边的对应匹配节点
            for(int j=1;j<=n;++j)
                if((i+j)%2==0)
                {
                    int v=(i-1)*n+j;
                    memset(visit,0,sizeof(visit));
       //visit只是一个临时标记，只在单一节点为起点的搜索中起作用，搜一个节点更新一次；
                    if(dfs(v))ans++;
                }
        cout<<ans<<endl;
    }
    return 0;
}

 

The end；