题目：狼和羊的故事

Posted 2021-03-23 loney-s

题目

传送门

思路

比较明显的最小割的题

将S向所有的狼连一条INF的边

再将所有羊向E连一条INF的边

之后再将所有的格点向周围的四个格点连一条容量为1的边

之后跑最大流就行了

我们不属于任何一方的格子怎么办

也无所谓，

因为路径始终是存在的，我们始终要将路径断掉

至于怎么断，怎样断才优秀，那就是dinic的事情了

代码

#include<iostream>
#include<cstring>
#include<climits>
#include<queue>
using namespace std;
int n,m;
struct network_edge_dinic
{
    #define maxn 80005
    int s,t;
    int cnt;
    int cur[maxn];
    int head[maxn];
    int to[maxn<<1];
    int val[maxn<<1];
    int nxt[maxn<<1];
    int d[maxn];
    #undef maxn
    void init()
    {
        cnt=1;
    }
    void add_edge(int u,int v,int w)
    {
        to[++cnt]=v;
        val[cnt]=w;
        nxt[cnt]=head[u];
        head[u]=cnt;
        to[++cnt]=u;
        val[cnt]=0;
        nxt[cnt]=head[v];
        head[v]=cnt;
    }
    int dfs(int u,int f)
    {
        if(u==t)
            return f;
        int minn=0,summ=0;
        for(int& i=cur[u];i;i=nxt[i])
        {
            int v=to[i];
            if(d[v]==d[u]+1&&val[i]>0)
            {
                minn=dfs(v,min(f,val[i]));
                f-=minn;
                val[i]-=minn;
                val[i^1]+=minn;
                summ+=minn;
                if(!f)
                    break;
            }  
        }
        if(!summ)
            d[u]=-1;
        return summ;
    }
    bool bfs()
    {
        memset(d,-1,sizeof(d));
        queue<int> q;
        q.push(s);
        d[s]=0;
        while(!q.empty())
        {
            int u=q.front();
            q.pop();
            for(int i=head[u];i;i=nxt[i])
            {
                int v=to[i];
                if(d[v]==-1&&val[i]>0)
                {
                    d[v]=d[u]+1;
                    q.push(v);
                }
            }
        }
        if(d[t]!=-1)
            return 1;
        return 0;
    }
    int dinic(int S,int T)
    {
        s=S;
        t=T;
        int ans=0;
        while(bfs())
        {
            for(int i=1;i<=n*m+2;i++)
                cur[i]=head[i];
            ans+=dfs(s,1e9);
        }
        return ans;
    }
}g;
int dx[5]={0,1,-1,0,0};
int dy[5]={0,0,0,1,-1};
int gethash(int x,int y)
{
    return (x-1)*m+y;
}
bool inside(int a,int b)
{
    if(1<=a&&a<=n&&1<=b&&b<=m)
        return 1;
    return 0;
}
int main()
{
    g.init();
    cin>>n>>m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            for(int k=1;k<=4;k++)
            {
                int tx=i+dx[k];
                int ty=j+dy[k];
                if(inside(tx,ty))
                    g.add_edge(gethash(i,j),gethash(tx,ty),1);
            }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            int x;
            cin>>x;
            if(x==1)
                g.add_edge(gethash(i,j),n*m+2,INT_MAX/2);
            if(x==2)
                g.add_edge(n*m+1,gethash(i,j),INT_MAX/2);
        }
    }
    cout<<g.dinic(n*m+1,n*m+2);
    return 0;
}