洛谷3355 骑士共存问题

题目链接：骑士共存问题

本题的建图依然是十分清晰，主要是要考虑到直接求放多少个马不是很方便求，于是从问题的反面入手，考虑在棋盘全满的情况下最少拿走多少个马使得当前棋盘的局面合法

由于格子存在相互攻击的可能性（即两个格子的马可以相互攻击而不是单独一个攻击另一个），因此将图完全建立出来会耗费不少时间。

所以我们考虑按照格子行列之和的奇偶性来建图

首先建立源点(s)和汇点(v)

然后由源点向所有的红格子连边，容量为1（每个格子最多只有一匹马）；

​ 由红格子向各自可以攻击的黄格子连边，容量为INF；

​ 由黄格子向汇点连边，容量为1。

然后跑网络流即可

不要忘记相减QAQ

注：如果加了当前弧优化的话就不会出现按偶数为原点建边时超时的情况了

#include<iostream>
#include<string>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<vector>
#include<queue>
#include<map>
using namespace std;
#define maxd 1e9+7
struct network_flows{
    struct node{
        int from,to,nxt,flow;
    }sq[4000100];
    int all,dep[100100],head[100100],cur[100100],n,m,s,t;
    bool vis[100100];

   void init(int n)
    {
        this->s=n*n+1;this->t=n*n+2;
        this->n=n*n+2;this->all=1;
        memset(head,0,sizeof(head));
    }

    void add(int u,int v,int w)
    {
        all++;sq[all].from=u;sq[all].to=v;sq[all].nxt=head[u];sq[all].flow=w;head[u]=all;
        all++;sq[all].from=v;sq[all].to=u;sq[all].nxt=head[v];sq[all].flow=0;head[v]=all;
    }

    bool bfs()
    {
        queue<int> q;int i;
        memset(vis,0,sizeof(vis));
        vis[s]=1;q.push(s);dep[s]=0;
        while (!q.empty())
        {
            int u=q.front();q.pop();
            for (i=head[u];i;i=sq[i].nxt)
            {
                int v=sq[i].to;
                if ((!vis[v]) && (sq[i].flow))
                {
                    vis[v]=1;dep[v]=dep[u]+1;q.push(v);
                }
            }
        }
        if (!vis[t]) return 0;
        for (i=1;i<=n;i++) cur[i]=head[i];
        return 1;
    }

    int dfs(int now,int to,int lim)
    {
        if ((!lim) || (now==to)) return lim;
        int i,sum=0;
        for (i=cur[now];i;i=sq[i].nxt)
        {
            int v=sq[i].to;cur[now]=i;
            if (dep[now]+1==dep[v])
            {
                int f=dfs(v,to,min(lim,sq[i].flow));
                if (f)
                {
                    lim-=f;sum+=f;
                    sq[i].flow-=f;
                    sq[i^1].flow+=f;
                    if (!lim) break;
                }
            }
        }
        return sum;
    }

    int work()
    {
        int ans=0;
        while (bfs()) ans+=dfs(s,t,maxd);
        return ans;
    }
}dinic;
struct node{
    int x,y;
}block[40010];
const int dx[]={-1,1,2,2,1,-1,-2,-2},
          dy[]={2,2,1,-1,-2,-2,-1,1};
int n,m,s,t;
bool used[201][201];

int read()
{
    int x=0,f=1;char ch=getchar();
    while ((ch<'0') || (ch>'9')) {if (ch=='-') f=-1;ch=getchar();}
    while ((ch>='0') && (ch<='9')) {x=x*10+(ch-'0');ch=getchar();}
    return x*f;
}

int change(int x,int y)
{
    return (x-1)*n+y;
}

void init()
{
    n=read();m=read();int i,j,k;
    dinic.init(n);
    s=n*n+1;t=n*n+2;
    memset(used,1,sizeof(used));
    for (i=1;i<=m;i++) 
        {block[i].x=read();block[i].y=read();used[block[i].x][block[i].y]=0;}
    for (i=1;i<=n;i++)
    {
        for (j=1;j<=n;j++)
        {
            if (!used[i][j]) continue;
            if ((i+j)%2==1) dinic.add(change(i,j),t,1);
            else 
            {
                dinic.add(s,change(i,j),1);
                for (k=0;k<8;k++)
                {
                    int nx=i+dx[k],ny=j+dy[k];
                    if ((nx>=1) && (nx<=n) && (ny>=1) && (ny<=n) && (used[nx][ny]))
                        dinic.add(change(i,j),change(nx,ny),maxd);
                }
            }
        }
    }
}

void work()
{
    int ans=dinic.work();
    printf("%d",n*n-m-ans);
}

int main()
{
    init();
    work();
    return 0;
}

练习题：https://www.luogu.org/problemnew/show/P5030