HDU 3046 Pleasant sheep and big big wolf

网络流最大流最小割。

题目的意思就是说如何建立最小的栅栏，使得狼和羊之间没有一条路，狼和羊都在格子内。可以这么考虑，每个格子和它周围的四个格子（如果有的话）连边，而每条边就代表着一个栅栏，我们就是想要选择最小的栅栏，使得狼与羊之间没有路，也就是没有流量。将点分成三类构图，狼，羊，一般点。从s到狼连边，容量为inf，表明最小割不会割这条边，同理，从羊到t连边，容量为inf。而每条格子之间的边，容量为1，利用最大流等于最小割，就能解决问题。

#include "cstdio"
#include "vector"
#include "queue"
#include "cstring"
using namespace std;
struct edge{int to,cap,rev;};
#define max_v 44444
#define inf 11111111
vector <edge> g[max_v];
int level[max_v];
int iter[max_v];
void add_edge(int from,int to,int cap){
	g[from].push_back((edge){to,cap,(int)g[to].size()});
	g[to].push_back((edge){from,0,(int)g[from].size()-1});
}
void bfs(int s){
	memset(level,-1,sizeof(level));
	queue<int> que;
	level[s]=0;
	que.push(s);
	while(!que.empty()){
	    int v=que.front(); que.pop();
	    for(int i=0;i<g[v].size();i++){
	        edge &e=g[v][i];
	        if(e.cap>0&&level[e.to]<0){
	            level[e.to]=level[v]+1;
	            que.push(e.to);
	        }
	    }
	}
}
int dfs(int v,int t,int f){
	if(v==t)  return f;
	for(int &i=iter[v];i<g[v].size();i++){
	    edge &e=g[v][i];
	    if(e.cap>0&&level[v]<level[e.to]){
	        int d=dfs(e.to,t,min(f,e.cap));
	        if(d>0){
	            e.cap-=d;
	            g[e.to][e.rev].cap+=d;
	            return d;
	        }
	    }
	}
	return 0;
}
int max_flow(int s,int t){
	int flow=0;
	for(;;){
	    bfs(s);
	    if(level[t]<0)  return flow;
	    memset(iter,0,sizeof(iter));
	    int f;
	    while((f=dfs(s,t,inf))>0){ flow+=f;}
	}
}
int n,m;
int map[222][222];
int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};
int judge(int x,int y){
    if(x>=1&&x<=n&&y>=1&&y<=m)  return 1;
    return 0;
}
int main(){
    int kase=1;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(g,0,sizeof(g));
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)  scanf("%d",&map[i][j]);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                int x,y;
                for(int k=0;k<4;k++){
                        x=i+dx[k],y=j+dy[k];
                        if(judge(x,y)){
                            add_edge(m*(i-1)+j,(x-1)*m+y,1);
                        }
                    }
                if(map[i][j]==1)  add_edge(m*(i-1)+j,n*m+1,inf);
                if(map[i][j]==2)  add_edge(0,m*(i-1)+j,inf);
            }
        }
        printf("Case %d:\n%d\n",kase++,max_flow(0,n*m+1));
    }
    return 0;
}