poj--2391--Ombrophobic Bovines(floyd+二分+最大流拆点)

Ombrophobic Bovines

Time Limit: 1000MS

Memory Limit: 65536KB

64bit IO Format: %I64d & %I64u

Submit
Status

Description

FJ's cows really hate getting wet so much that the mere thought of getting caught in the rain makes them shake in their hooves. They have decided to put a rain siren on the farm to let them know when rain is approaching. They intend
to create a rain evacuation plan so that all the cows can get to shelter before the rain begins. Weather forecasting is not always correct, though. In order to minimize false alarms, they want to sound the siren as late as possible while still giving enough
time for all the cows to get to some shelter.



The farm has F (1 <= F <= 200) fields on which the cows graze. A set of P (1 <= P <= 1500) paths connects them. The paths are wide, so that any number of cows can traverse a path in either direction.




Some of the farm's fields have rain shelters under which the cows can shield themselves. These shelters are of limited size, so a single shelter might not be able to hold all the cows. Fields are small compared to the paths and require no time for cows to traverse.




Compute the minimum amount of time before rain starts that the siren must be sounded so that every cow can get to some shelter.

Input

* Line 1: Two space-separated integers: F and P



* Lines 2..F+1: Two space-separated integers that describe a field. The first integer (range: 0..1000) is the number of cows in that field. The second integer (range: 0..1000) is the number of cows the shelter in that field can hold. Line i+1 describes field
i.



* Lines F+2..F+P+1: Three space-separated integers that describe a path. The first and second integers (both range 1..F) tell the fields connected by the path. The third integer (range: 1..1,000,000,000) is how long any cow takes to traverse it.

Output

* Line 1: The minimum amount of time required for all cows to get under a shelter, presuming they plan their routes optimally. If it not possible for the all the cows to get under a shelter, output "-1".

Sample Input

3 4
7 2
0 4
2 6
1 2 40
3 2 70
2 3 90
1 3 120

Sample Output

110

Hint

OUTPUT DETAILS:



In 110 time units, two cows from field 1 can get under the shelter in that field, four cows from field 1 can get under the shelter in field 2, and one cow can get to field 3 and join the cows from that field under the shelter in field 3. Although there are
other plans that will get all the cows under a shelter, none will do it in fewer than 110 time units.

Source

USACO 2005 March Gold



【题目大意】

给定一个无向图，点 i 处有 Ai 头牛，点 i 处的牛棚能容纳 Bi 头牛，求一个最短时

间 T 使得在 T 时间内所有的牛都能进到某一牛棚里去。（1 <= N <= 200, 1 <= M <=

1500, 0 <= Ai <= 1000, 0 <= Bi <= 1000, 1 <= Dij <= 1,000,000,000）

【建模方法】

将每个点 i 拆成两个点 i’, i’’，连边(s, i’, Ai), (i’’, t, Bi)。二分最短时间 T，若 d[i][j]<=T

（d[i][j]表示点 i, j 之间的最短距离）则加边(i’, j’’, ∞)。每次根据最大流调整二分

的上下界即可。

其中每条无向边表示两条方向相反的有向边，容量均为∞。

当二分到 T = 70 的时候，显然我们只加入了(2, 3)和(3, 4)两条无向边，因为只有

这两对点间的最短距离小于等于 70。但是从图中也可以看出，由于没有拆点，

点 2 也可以通过这两条边到达点 4，而实际上这是不允许的。也就是说我们所加

的限制条件没有起到作用。由此可见，只有拆点才是正确的做法。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<algorithm>
using namespace std;
#define MAXN 1000
#define MAXM 200000+10
#define INF 10000000+100
#define LL long long
struct node
{
	int u,v,cap,flow,next;
}edge[MAXM];
int head[MAXN],top;
int cur[MAXN],dis[MAXN];
int m,n;
int cow[MAXN],vis[MAXN],cap[MAXN];
LL map[MAXN][MAXN];
int sum;
void init()
{
	top=0;
	memset(head,-1,sizeof(head));
}
void floyd()
{
	for(int k=1;k<=n;k++)
	{
		for(int i=1;i<=n;i++)
		{
			if(map[i][k]==INF) continue;
			for(int j=1;j<=n;j++)
			{
				map[i][j]=min(map[i][j],map[i][k]+map[k][j]);
			}
		}
	}
}
void input()
{
	sum=0;
	for(int i=1;i<=n;i++)
	scanf("%d%d",&cow[i],&cap[i]),sum+=cow[i];
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			if(i==j) map[i][j]=0;
			else map[i][j]=1e16;
		}
	}
	int a,b;
	LL c;
	while(m--)
	{
		scanf("%d%d%lld",&a,&b,&c);
		if(map[a][b]>c)
		map[a][b]=map[b][a]=c;
	}
	floyd();
}
void add(int a,int b,int c)
{
	node E1={a,b,c,0,head[a]};
	edge[top]=E1;
	head[a]=top++;
	node E2={b,a,0,0,head[b]};
	edge[top]=E2;
	head[b]=top++;
}
void getmap(LL mid)
{
	for(int i=1;i<=n;i++)
	add(0,i,cow[i]);
	for(int i=n+1;i<=2*n;i++)
	add(i,2*n+1,cap[i-n]);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			if(map[i][j]<=mid)
			{
				add(i,j+n,INF);
				if(i!=j)
				add(j,i+n,INF);
			}
		}
	}
}
bool bfs(int s,int e)
{
	queue<int>q;
	memset(vis,0,sizeof(vis));
	memset(dis,-1,sizeof(dis));
	while(!q.empty()) q.pop();
	q.push(s);
	dis[s]=0;
	vis[s]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		for(int i=head[u];i!=-1;i=edge[i].next)
		{
			node E=edge[i];
			if(E.cap>E.flow&&!vis[E.v])
			{
				vis[E.v]=1;
				dis[E.v]=dis[E.u]+1;
				if(E.v==e) return true;
				q.push(E.v);
			}
		}
	}
	return false;
}
int dfs(int x,int a,int e)
{
	if(x==e||a==0)
	return a;
	int flow=0,f;
	for(int &i=cur[x];i!=-1;i=edge[i].next)
	{
		node &E=edge[i];
		if(dis[x]+1==dis[E.v]&&(f=dfs(E.v,min(E.cap-E.flow,a),e))>0)
		{
			E.flow+=f;
			edge[i^1].flow-=f;
			a-=f;
			flow+=f;
			if(a==0) break;
		}
	}
	return flow;
}
int MAXflow(int s,int e)
{
	int flow=0;
	while(bfs(s,e))
	{
		memcpy(cur,head,sizeof(head));
		flow+=dfs(s,INF,e);
	}
	return flow;
}
void slove()
{
	LL left=0,right=1e16,mid,ans=1e16;
	while(right>=left)
	{
		mid=(left+right)/2;
		init();
		getmap(mid);
		if(MAXflow(0,2*n+1)==sum)
		{
			ans=mid;
			right=mid-1;
		}
		else left=mid+1;
	}
	if(ans==1e16)
	printf("-1\n");
	else
	printf("%lld\n",ans);
}
int main()
{
	while(scanf("%d%d",&n,&m)!=EOF)
	{
		input();
		slove();
	}
	return 0;
}