洛谷 P3355 骑士共存问题

题面

题意

给出一张边长为n,有几个障碍点的棋盘,问最多可以放几个骑士使他们不互相攻击.

做法

我们可以反过来考虑,先将棋盘放满骑士,计算至少去掉几个骑士.
经过观察,我们可以发现,相同颜色的格子上的棋子无法相互攻击,因此可以让超级源点连想每一个红点,每一个黄点连向超级汇点,流量均为一,表示将棋盘放满,再将红格子向可以攻击到的格子连一条边,流量为INF,如果有流量通过某个点,就说明这个点不放棋子,因此计算这张图的最小割也就是最大流就能算出至少要拿掉几个棋子,用总棋子数减掉这个值即可.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define zh(x,y) ((x-1)*n+y)
#define N 50010
#define INF 0x3f3f3f3f
using namespace std;

int bb=1,n,m,first[N],dir[8][2]= {1,2,-1,2,2,1,-2,1,-1,-2,1,-2,-2,-1,2,-1},s,t,ans,deep[N],cur[N];
bool mm[210][210];
struct Bn
{
    int to,next,quan;
} bn[N*20];
queue<int>que;

inline void add(int u,int v,int w)
{
    bb++;
    bn[bb].to=v;
    bn[bb].quan=w;
    bn[bb].next=first[u];
    first[u]=bb;
}

inline void ad(int u,int v,int w)
{
    add(u,v,w);
    add(v,u,0);
}

inline bool bfs()
{
    int p,q;
    for(; !que.empty(); que.pop());
    memset(deep,0,sizeof(deep));
    que.push(s);
    deep[s]=1;
    for(; !que.empty()&&!deep[t];)
    {
        q=que.front();
        que.pop();
        for(p=first[q]; p!=-1; p=bn[p].next)
        {
            if(deep[bn[p].to]||!bn[p].quan) continue;
            deep[bn[p].to]=deep[q]+1;
            que.push(bn[p].to);
        }
    }
    return deep[t];
}

int dfs(int now,int mn)
{
    if(now==t)
        return mn;
    int res;
    for(int &p=cur[now]; p!=-1; p=bn[p].next)
    {
        if(deep[bn[p].to]!=deep[now]+1||!bn[p].quan) continue;
        res=dfs(bn[p].to,min(mn,bn[p].quan));
        if(res)
        {
            bn[p].quan-=res;
            bn[p^1].quan+=res;
            return res;
        }
    }
    return 0;
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,k,p,q;
//  for(i=0;i<8;i++) cout<<dir[i][0]<<" "<<dir[i][1]<<endl;
    cin>>n>>m;
    t=n*n+1;
    for(i=1; i<=m; i++)
    {
        scanf("%d%d",&p,&q);
        mm[p][q]=1;
    }
    for(i=1; i<=n; i++)
    {
        for(j=1; j<=n; j++)
        {
            if(mm[i][j]) continue;
            if((i+j)%2)
            {
                ad(s,zh(i,j),1);
                for(k=0; k<8; k++)
                {
                    p=i+dir[k][0];
                    q=j+dir[k][1];
                    if(p<1||p>n||q<1||q>n||mm[p][q]) continue;
                    ad(zh(i,j),zh(p,q),INF);
                }
            }
            else
            {
                ad(zh(i,j),t,1);
            }
        }
    }
    for(; bfs();)
    {
        for(i=s; i<=t; i++) cur[i]=first[i];
        for(q=dfs(s,INF); q; ans+=q,q=dfs(s,INF));
    }
    cout<<n*n-m-ans;
}