poj2391 Ombrophobic Bovines

Ombrophobic Bovines

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 20459		Accepted: 4403

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

题目大意：n块地，每块地有初始的牛的数量和最多能容纳的牛的数量，每两块地之间有距离，求地容纳下所有牛的最短时间.

分析：显然要用网络流来做,流就相当于牛的路线. 但是流只能记录最后有多少头牛能够被容纳，最短时间怎么求呢？ 

　　　可以发现：流就相当于是一个判定答案的标准. 将最优性问题转化为判定性问题，二分即可.

　　　先做一次floyd即可求出任意两点间的最短距离，每次把长度小于二分的mid的边给连上.

　　　做这道题的时候我犯了很多sb错误. 一开始把S,T定义在了外面，直接赋值为了T = 2 * n + 1,因为n没有被初始化，所以T变成了1......  边数计算错了，导致RE.   数组开大导致TLE

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;
const ll maxn = 160010,inf = 10000000000000000;

ll n,m,a[410],b[410],head[410],to[maxn],nextt[maxn],tot = 2,w[maxn];
ll dist[410][410],ans = -1,sum,maxx,d[410],S,T;

void add(ll x,ll y,ll z)
{
    w[tot] = z;
    to[tot] = y;
    nextt[tot] = head[x];
    head[x] = tot++;

    w[tot] = 0;
    to[tot] = x;
    nextt[tot] = head[y];
    head[y] = tot++;
}

bool bfs()
{
    queue <ll> q;
    q.push(S);
    memset(d,-1,sizeof(d));
    d[S] = 0;
    while (!q.empty())
    {
        ll u = q.front();
        q.pop();
        if (u == T)
            return true;
        for (ll i = head[u];i;i = nextt[i])
        {
            ll v = to[i];
            if (w[i] && d[v] == -1)
            {
                d[v] = d[u] + 1;
                q.push(v);
            }
        }
    }
    return false;
}

ll dfs(ll u,ll flow)
{
    if (u == T)
        return flow;
    ll res = 0;
    for (ll i = head[u];i;i = nextt[i])
    {
        ll v = to[i];
        if (w[i] && d[v] == d[u] + 1)
        {
            ll temp = dfs(v,min(flow - res,w[i]));
            w[i] -= temp;
            w[i ^ 1] += temp;
            res += temp;
            if (res == flow)
                return res;
        }
    }
    if (res == 0)
        d[u] = -1;
    return res;
}

bool check(ll x)
{
    tot = 2;
    memset(head,0,sizeof(head));
    for (ll i = 1; i <= n; i++)
    {
        add(S,i,a[i]);
        add(i + n,T,b[i]);
    }
    for (ll i = 1; i <= n; i++)
        for (ll j = 1; j <= n; j++)
            if (dist[i][j] <= x)
                add(i,j + n,inf);
    ll cnt = 0;
    while (bfs())
        cnt += dfs(S,inf);
    if (cnt == sum)
        return true;
    return false;
}

void solve()
{
    for (ll i = 1; i <= n; i++)
        for (ll j = 1; j <= n; j++)
            if (dist[i][j] != inf)
                maxx = max(maxx,dist[i][j]);
    ll l = 1,r = maxx;
    while (l <= r)
    {
        ll mid = (l + r) >> 1;
        if (check(mid))
        {
            ans = mid;
            r = mid - 1;
        }
        else
            l = mid + 1;
    }
}

int main()
{
    scanf("%lld%lld",&n,&m);
    S = 2 * n + 1;
    T = 2 * n + 2;
    for (ll i = 1; i <= n; i++)
    {
        scanf("%lld%lld",&a[i],&b[i]);
        sum += a[i];
    }
    for (ll i = 1; i <= n; i++)
        for (ll j = 1; j <= n; j++)
        {
            if (i == j)
                dist[i][j] = 0;
            else
                dist[i][j] = inf;
        }
    for (ll i = 1; i <= m; i++)
    {
        ll x,y,z;
        scanf("%lld%lld%lld",&x,&y,&z);
        dist[x][y] = dist[y][x] = min(dist[x][y],z);
    }
    for (ll k = 1; k <= n; k++)
        for (ll i = 1; i <= n; i++)
            for (ll j = 1; j <= n; j++)
                dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j]);
    solve();
    printf("%lld\n",ans);

    return 0;
}