BZOJ 1001 狼抓兔子 （最大流）

这里是传送门

1001: [BeiJing2006]狼抓兔子

Time Limit: 15 Sec   Memory Limit: 162 MB
Submit: 24044   Solved: 6079
[ Submit][ Status][ Discuss]

Description

现在小朋友们最喜欢的"喜羊羊与灰太狼",话说灰太狼抓羊不到，但抓兔子还是比较在行的，

而且现在的兔子还比较笨，它们只有两个窝，现在你做为狼王，面对下面这样一个网格的地形：

 

左上角点为(1,1),右下角点为(N,M)(上图中N=4,M=5).有以下三种类型的道路 

1:(x,y)<==>(x+1,y) 

2:(x,y)<==>(x,y+1) 

3:(x,y)<==>(x+1,y+1) 

道路上的权值表示这条路上最多能够通过的兔子数，道路是无向的. 左上角和右下角为兔子的两个窝，

开始时所有的兔子都聚集在左上角(1,1)的窝里，现在它们要跑到右下解(N,M)的窝中去，狼王开始伏击

这些兔子.当然为了保险起见，如果一条道路上最多通过的兔子数为K，狼王需要安排同样数量的K只狼，

才能完全封锁这条道路，你需要帮助狼王安排一个伏击方案，使得在将兔子一网打尽的前提下，参与的

狼的数量要最小。因为狼还要去找喜羊羊麻烦.

Input

第一行为N,M.表示网格的大小，N,M均小于等于1000.

接下来分三部分

第一部分共N行，每行M-1个数，表示横向道路的权值. 

第二部分共N-1行，每行M个数，表示纵向道路的权值. 

第三部分共N-1行，每行M-1个数，表示斜向道路的权值. 

输入文件保证不超过10M

Output

输出一个整数，表示参与伏击的狼的最小数量.

Sample Input

3 4
5 6 4
4 3 1
7 5 3
5 6 7 8
8 7 6 5
5 5 5
6 6 6

Sample Output

14

好像是很难的问题，但我还是用最大流水到了，让求出割边的最小值，也就是最小割，然后顺理成章的用最大流水到。只是在建图的时候好像稍微有点难度，还有跑dinic的时候，去掉了一句话是16s，加上以后瞬间到了1.8s。这就是神奇的网络流吧，还看到一次不断改变10000次的网络流，想不到网络流还可以这样跑，神奇。

代码实现：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<cstdio>
#define ll long long
#define mset(a,x) memset(a,x,sizeof(a))
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;
const double PI=acos(-1);
const int inf=0x3f3f3f3f;
const double esp=1e-6;
const int maxn=1e6+5;
const int mod=1e9+7;
int dir[4][2]={0,1,1,0,0,-1,-1,0};
struct node{
	int v,w,next;
}edge[maxn*6];

int head[maxn],d[maxn],start,END,cnt,sum,n,m;

void add(int u,int v,int w)
{
	edge[++cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt;
/*    edge[cnt].v= u;
    edge[cnt].w=0;
    edge[cnt].next=head[v];
    head[v]=cnt++;*/
}

int bfs()
{
	int i,j,k;
	mset(d,0);
	d[start]=1;
	queue <int> q;
	q.push(start);
	while(!q.empty())
	{
		int temp=q.front();
		q.pop();
	//	if(temp==END)                   //到达汇点 
	//	return 1;
		
		for(i=head[temp];i!=-1;i=edge[i].next) //搜增广路 
		{
			int temp1=edge[i].v;               //下一可连通点 
			int temp2=edge[i].w;               //当前流量 
			if(temp2&&d[temp1]==0)             //temp1没走到 
			{
				d[temp1]=d[temp]+1;            //点加1 
				if(temp1==END)                 //找到增广路 
				return 1;
				q.push(temp1);                 //入队列 
			}
		}
	}
	return 0;
}

int dfs(int u,int maxflow)
{
	if(u==END)
	return maxflow;
	
	int i,j,ret=0;
	for(i=head[u];i!=-1;i=edge[i].next)
	{
		int temp1=edge[i].v;            //下一个可连通点 
		int temp2=edge[i].w;            //当前点的流量 
		if(temp2&&d[temp1]==d[u]+1)
		{
			int temp=dfs(temp1,min(maxflow-ret,temp2)); //下一点，取最大流跟当前流量小的一个 
			edge[i].w-=temp;                  //正向相减 
			edge[i^1].w+=temp;                //反向弧相加 
			ret+=temp;                        //最大流 
			if(ret==maxflow)                  //下一点最大流等于这一点 
			return ret;
		}
	}
	if(!ret)
	d[u]=-1;
	return ret;
}

int dinic()
{
	int ans=0;
	while(bfs()==1)
	{
		ans+=dfs(start,inf);    //
	}
	return ans;
}

int judge(int x,int y)
{
	return (x-1)*m+y;
}

int main()
{
	int x,y,z,i,t,j;
	while(~scanf("%d%d",&n,&m))
	{
		cnt=1;
		mset(head,-1);
		start=1;END=n*m;
		for(i=1;i<=n;i++)
		{
			for(j=1;j<=m-1;j++)
			{
				scanf("%d",&x);
				add(judge(i,j),judge(i,j+1),x);
				add(judge(i,j+1),judge(i,j),x);
				cout<< judge(i,j)<<"-->"<<judge(i,j+1)<<endl;
			}
		}
		for(i=1;i<=n-1;i++)
		{
			for(j=1;j<=m;j++)
			{
				scanf("%d",&x);
				add(judge(i,j),judge(i+1,j),x);
				add(judge(i+1,j),judge(i,j),x);
				cout<< judge(i,j)<<"-->"<<judge(i,j+1)<<endl;
			}
		}
		for(i=1;i<=n-1;i++)
		{
			for(j=1;j<=m-1;j++)
			{
				scanf("%d",&x);
				add(judge(i,j),judge(i+1,j+1),x);
				add(judge(i+1,j+1),judge(i,j),x);
				cout<< judge(i,j)<<"-->"<<judge(i,j+1)<<endl;
			}
		}
		int ans=dinic();
		cout<<ans<<endl;
	}
	return 0;
}