hdu3046 pleasant sheep and big big wolf 最小割

/*
    题目描述：在一张n*m的地图上有0（空地）、1（吸氧羊）、2（灰太狼），现在通过在格与格之间放置单位长度的篱笆使得羊与狼不接触，
    问最少放置多少篱笆


    方法：由隔断的概念想到图上割的概念（类似Uva1515），那么，要怎么隔断呢？在放篱笆的时候，1与1之间，2与2之间放篱笆显然是无意义的，
    但除此之外的格与格之间放篱笆都有可能是合理的。
            我们将图想象成3列，第一列是狼，第二列是空地，第三列是羊，所以，将狼连向相邻的空地与相邻的羊，将空地连向相邻的空地与相邻的
    羊；上述所有边的容量为1；
            将源节点连向所有的狼，容量为inf，意味着不能割断，所有羊连向汇节点，容量为inf，意味着不能割断，在上述图中用最大流算法求最小割。


    为什么能这样做呢？可以这样来理解问题：对于任何一只羊，不允许他走到任何一只狼。建图后认为每切一条边花费为1，那么怎么切能让所有狼
    和羊都不连通呢？  这么想就可以得到上面的做法。
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int inf = 1000000000;
const int maxn = 200 + 5;
const int maxs = 40000 + 5;
int n,m,source,sink;
int mp[maxn][maxn];
struct Edge
{
    int from,to,cap,flow;
};
struct Dicnic
{
    int n,m,s,t;
    int d[maxs],cur[maxs],vis[maxs];
    vector<int>G[maxs];
    vector<Edge>edges;




    void AddEdge(int from,int to,int cap)
    {
        Edge e1 = {from,to,cap,0};
        Edge e2 = {to,from,0,0};
        edges.push_back(e1);
        edges.push_back(e2);
        int m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }




    void init(int n)
    {
        this -> n = n;
        for(int i = 0;i<=n;i++){
            G[i].clear();
        }
        edges.clear();
    }




    bool BFS()
    {
        mem(vis,0);
        queue<int>Q;
        Q.push(s);
        vis[s] = 1;
        d[s] = 0;
        while(!Q.empty()){
            int x = Q.front();      Q.pop();
            for(int i=0;i<G[x].size();i++){
                Edge &e = edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }




    int DFS(int x ,int a)
    {
        if(x==t||a==0)      return a;
        int flow = 0 , f;
        for(int &i = cur[x];i<G[x].size();i++){
            Edge &e = edges[G[x][i]];
            if(d[e.to]==d[x]+1&&(f = DFS(e.to,min(a,e.cap-e.flow)))>0){
                e.flow += f;
                edges[G[x][i]^1].flow -= f;
                flow += f;
                a -= f;
                if(a==0)        break;
            }
        }
        return flow;
    }




    int MaxFlow(int s,int t)
    {
        this -> s = s;      this ->t  = t;
        int flow = 0;
        while(BFS()){
            mem(cur,0);
            flow += DFS(s,inf);
        }
        return flow;
    }
};
Dicnic g;
int drx[] = {0,1,0,-1};
int dry[] = {1,0,-1,0};
bool valid(int x,int y)
{
    if(x<1||x>n||y<1||y>m)
        return false;
    else
        return true;
}
int id(int x,int y)
{
    return (x-1)*m + y;
}
int main()
{
    int kase = 0;
    while(scanf("%d %d",&n,&m)!=EOF){
        g.init(n*m + 1);
        for(int i=1;i<=n;i++){
            for(int j = 1;j<=m;j++){
                scanf("%d",&mp[i][j]);
            }
        }
        int source = 0 , sink = n * m + 1;
        for(int i=1;i<=n;i++){
            for(int j = 1;j<=m;j++){
                if(mp[i][j]==2){
                    g.AddEdge(source,id(i,j),inf);              //源点流向羊
                    for(int k = 0;k<4;k++){
                        int nx = i + drx[k];
                        int ny = j + dry[k];
                        if(valid(nx,ny)&&mp[nx][ny]!=2){
                            g.AddEdge(id(i,j),id(nx,ny),1);   //狼连向空地和羊
                        }
                    }
                }
                else if(mp[i][j]==1){
                    g.AddEdge(id(i,j),sink,inf);            //羊连向汇点
                }
                else{
                    for(int k = 0;k<4;k++){
                        int nx = i + drx[k];
                        int ny = j + dry[k];
                        if(valid(nx,ny)&&mp[nx][ny]!=2){
                            g.AddEdge(id(i,j),id(nx,ny),1);   //空地连向空地和羊
                        }
                    }
                }
            }
        }
        int ans = g.MaxFlow(source,sink);
        printf("Case %d:\n%d\n",++kase,ans);
     }
    return 0;
}