hdu 3046 最小割

每个栅栏其实就是一条边，修一些栅栏，使得狼不能抓到羊，其实就是求一个割，使得羊全在S中，狼全在T中。

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#define maxn 40010
#define oo 0x3f3f3f3f
#define clr(arr,n) memset(&arr,0,sizeof(arr[0])*(n+1))
using namespace std;

struct Edge {
    int u, v, f;
    Edge( int u, int v, int f ):u(u),v(v),f(f){}
};
struct Dinic {
    int n, src, dst;
    vector<Edge> edge;
    vector<int> g[maxn];
    int dep[maxn], cur[maxn];
    
    void init( int n, int src, int dst ) {
        this->n = n;
        this->src = src;
        this->dst = dst;
        for( int u=1; u<=n; u++ )
            g[u].clear();
        edge.clear();
    }
    void add_edge( int u, int v, int f ) {
        g[u].push_back( edge.size() );
        edge.push_back( Edge(u,v,f) );
        g[v].push_back( edge.size() );
        edge.push_back( Edge(v,u,0) );
    }
    bool bfs() {
        queue<int> qu;
        clr( dep, n );
        qu.push(src);
        dep[src] = 1;
        while( !qu.empty() ) {
            int u=qu.front();
            qu.pop();
            for( int t=0; t<g[u].size(); t++ ) {
                Edge &e=edge[g[u][t]];
                if( e.f && !dep[e.v] ) {
                    dep[e.v] = dep[e.u]+1;
                    qu.push( e.v );
                }
            }
        }
        return dep[dst];
    }
    int dfs( int u, int a ) {
        if( u==dst || a==0 ) return a;
        int remain=a, past=0, na;
        for( int &t=cur[u]; t<g[u].size(); t++ ) {
            Edge &e = edge[g[u][t]];
            Edge &ve = edge[g[u][t]^1];
            if( e.f && dep[e.v]==dep[e.u]+1 && (na=dfs(e.v,min(e.f,remain))) ) {
                remain -= na;
                past += na;
                e.f -= na;
                ve.f += na;
                if( remain==0 ) break;
            }
        }
        return past;
    }
    int maxflow() {
        int flow = 0;
        while(bfs()) {
            clr( cur, n );
            flow += dfs(src,oo);
        }
        return flow;
    }
};

int n, m;
int idx[210][210], id_clock;
int map[210][210];
int dx[2] = { +1, 0 };
int dy[2] = { 0, +1 };
Dinic D;

int main() {
    for( int cas=1; ; cas++ ) {
        if( scanf( "%d%d", &n, &m )!=2 ) return 0;
        id_clock = 0;
        for( int i=1; i<=n; i++ ) 
            for( int j=1; j<=m; j++ ) {
                scanf( "%d", &map[i][j] );
                idx[i][j] = ++id_clock;
            }
        D.init( id_clock+2, id_clock+1, id_clock+2 );
        for( int i=1; i<=n; i++ )
            for( int j=1; j<=m; j++ ) 
                for( int d=0; d<2; d++ ) {
                    int ni = i+dx[d];
                    int nj = j+dy[d];
                    if( 1<=ni&&ni<=n && 1<=nj&&nj<=m ) {
                        int u = idx[i][j];
                        int v = idx[ni][nj];
                        D.add_edge( u, v, 1 );
                        D.add_edge( v, u, 1 );
                    }
                }
        for( int i=1; i<=n; i++ )
            for( int j=1; j<=m; j++ ) {
                if( map[i][j]==1 ) 
                    D.add_edge( D.src, idx[i][j], oo );
                if( map[i][j]==2 )
                    D.add_edge( idx[i][j], D.dst, oo );
            }
        printf( "Case %d:
%d
", cas, D.maxflow() );
    }
}