poj 2391 Ombrophobic Bovines（二分+最大流）

http://poj.org/problem?id=2391

题目大意：

农场里面N块地，分别有Ai头奶牛；

地上搭有遮雨棚，棚内可以容纳Bi头奶牛；

农场的N块地之间有P条路径，给出从u到v的路径需要花费时间time[u][v]；

问所有奶牛都到遮雨棚中的最小时间是多少。

思路：

1、把每块地拆成两个点i和i‘ ；

2、建立一个源点s和一个汇点t；

3、连边(s, i’, Ai)和(i’’, t, Bi)；

4、通过二分搜索时间上下界，如果界限内最大流和牛奶总数相等，时间即符合要求。

#include<iostream>
using namespace std;

const __int64 inf=100000000000000;
const int MAX=405;

int s,t;
int N,P;
__int64 sum_cow;
__int64 cap[MAX][MAX];
__int64 time[MAX][MAX];
int cow[MAX];
int shelter[MAX];
int pre[MAX];
int queue[MAX];


bool bfs()
{
	int head=0;
	int tail=0;
	int x;
	
	memset(pre,-1,sizeof(pre));
	queue[tail++]=s;
	pre[s]=0;
	
	while(head<tail)
	{
		x=queue[head++];
		for(int i=0;i<=t;i++)
		{
			if(cap[x][i]>0 && pre[i]<0)
			{
				pre[i]=pre[x]+1;
				queue[tail++]=i;
				if(i==t)
				{
					head=tail;
					break;
				}
			}
		}
	}
	return pre[t]<0;
}

int maxflow()
{
	int i,j;
	int x;
	int head;
	
	__int64 max_flow=0;
	__int64 min_flow;
	
	while(true)
	{
		if(bfs())
			break;
		
		head=0;
		x=s;
		
		while(true)
		{
			if(x==t)
			{
				queue[head++]=t;
				for(min_flow=inf,i=0;i<head-1;i++)
				{
					if(min_flow>cap[ queue[i] ][ queue[i+1] ])
					{
						min_flow=cap[ queue[i] ][ queue[i+1] ];
						x=i;
					}
				}
				
				for(i=0;i<head-1;i++)
				{
					cap[ queue[i] ][ queue[i+1] ] -= min_flow;
					cap[ queue[i+1] ][ queue[i] ] += min_flow;
				}
				
				head=x;
				
				max_flow+=min_flow;
			}
			for(j=0;j<=t;j++)
			{
				if(cap[x][j]>0 && pre[j]==pre[x]+1)
					break;
			}
			if(j<=t)
			{
				queue[head++]=x;
				x=j;
			}
			else
			{
				if(head==0)
					break;
				
				pre[x]=-1;
				x=queue[--head];
			}
		}
	}
	return max_flow;
}	

int main(int i,int j,int k)
{
	while(~scanf("%d %d",&N,&P))
	{
		/*Initial*/
		
		sum_cow=0;
		int n=2*N+2;
		for(i=0;i<=N;i++)
		{
			for(j=0;j<=N;j++)
			{
				if(i==j)
					time[i][j]=0;
				else
					time[i][j]=inf;
			}
		}
		
		/*Input*/
		for(i=1;i<=N;i++)
		{
			scanf("%d %d",&cow[i],&shelter[i]);
			sum_cow += cow[i];
		}
		
		int u,v;
		__int64 w;
		for(i=1;i<=P;i++)
		{
			scanf("%d %d %I64d",&u,&v,&w);
			if(time[u][v]>w)
				time[u][v]=time[v][u]=w;
		}		
		
		/*Floyd Algorithm*/
		
		for(k=1;k<=N;k++)
		{
			for(i=1;i<=N;i++)
			{
				for(j=1;j<=N;j++)
				{
					if(time[i][j]>time[i][k]+time[k][j])
						time[i][j]=time[i][k]+time[k][j];
				}
			}
		}
		
		/*binary search*/
		
		__int64 left=0;
		__int64 right=inf;
		__int64 ans=-1;
		s=0;
		t=2*N+1;
		
		while(left<right)
		{
			__int64 mid=(left+right)/2;
			
			/*Structure Graph*/
			for(i=0;i<=n;i++)
			{
				for(j=0;j<=n;j++)
					cap[i][j]=0;
			}
			
			for(i=1;i<=N;i++)
			{
				cap[s][i]=cow[i];
				cap[N+i][t]=shelter[i];
				cap[i][N+i]=inf;
			}
			
			for(i=1;i<=N;i++)
			{
				for(j=1;j<=N;j++)
				{
					if(i!=j && mid>=time[i][j])
						cap[i][N+j]=inf;
				}
			}
			
			if(maxflow()==sum_cow)
			{
				right=mid;
				ans=mid;
			}
			else
				left=mid+1;
		}
		printf("%I64d\n",ans);
	}
	return 0;
}