POJ 2391 Ombrophobic Bovines

POJ_2391

    这个题涉及控制时间的问题，然而时间是不好控制的，换个思路想一下实际上时间的长短反映的只是可否从一个点到达另一个点，因此我们不妨控制一个点到达另一个点是否有通路，这样就等效成控制时间了。

    于是不妨先将两两之间最短路求出来，然后二分时间，如果两点之间最短路小于或等于这个时间就看成有这条路，然后建立源点、汇点做最大流，如果最大流等于奶牛的数量就说明这个时间是可以的。需要注意的是，我们需要把field拆点，即点i看成i和i'两个点，连i-j的边时就连i-j'和j-i'两条边，而不能直接在原图上连边。比如样例，如果现在时间是70，那么我们可以连1-2和2-3两条边，如果直接在原图上连的话那么就等效成1-3是相连的了，然而实际上1到3是需要110的时间的，这样就会出现错误的解。

    还有一个思路就是做完最短路之后，将两两之间的边按长度升序排序，然后依次加入各条边，每次在原基础上继续寻找增广路，当出现最大流等于奶牛的数量时就可以break了，下面的程序就是按这种思路写的，不过这样写效率好像会低不少。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXD 410
#define MAXM 82010
#define INF 0x3f3f3f3f3f3f3f3fll
#define inf 0x3f3f3f3f
int N, M, S, T, X, first[MAXD], e, next[MAXM], v[MAXM], flow[MAXM], ANS, SUM;
int d[MAXD], q[MAXD], work[MAXD];
long long f[MAXD][MAXD];
struct Edge
{
    int x, y;
    long long z;
    bool operator < (const Edge &t) const
    {
        return z < t.z;    
    }
}edge[MAXM];
void add(int x, int y, int z)
{
    v[e] = y, flow[e] = z;
    next[e] = first[x], first[x] = e ++;    
}
void floyd()
{
    int i, j, k;
    for(i = 1; i <= N; i ++) f[i][i] = 0;
    for(k = 1; k <= N; k ++)
        for(i = 1; i <= N; i ++)
            for(j = 1; j <= N; j ++)
                f[i][j] = std::min(f[i][j], f[i][k] + f[k][j]);    
}
void init()
{
    int i, j, x, y, z;
    S = 0, T = N << 1 | 1;
    memset(first, -1, sizeof(first));
    SUM = e = 0;
    for(i = 1; i <= N; i ++)
    {
        scanf("%d%d", &x, &y);
        SUM += x;
        add(S, i, x), add(i, S, 0);
        add(N + i, T, y), add(T, N + i, 0);
        add(i, N + i, inf), add(N + i, i, 0);
    }
    memset(f, 0x3f, sizeof(f));
    for(i = 0; i < M; i ++)
    {
        scanf("%d%d%d", &x, &y, &z);
        f[x][y] = f[y][x] = std::min(f[x][y], (long long)z);
    }
    floyd();
    X = 0;
    for(i = 1; i <= N; i ++)
        for(j = i + 1; j <= N; j ++)
            if(f[i][j] < INF)
                edge[X].x = i, edge[X].y = j, edge[X].z = f[i][j], ++ X;
    std::sort(edge, edge + X);
}
int bfs()
{
    int i, j, rear = 0;
    memset(d, -1, sizeof(d[0]) * (T + 1));
    d[S] = 0, q[rear ++] = S;
    for(i = 0; i < rear; i ++)
    {
        for(j = first[q[i]]; j != -1; j = next[j])
            if(flow[j] && d[v[j]] == -1)
            {
                d[v[j]] = d[q[i]] + 1, q[rear ++] = v[j];
                if(v[j] == T)
                    return 1;    
            }    
    }
    return 0;
}
int dfs(int cur, int a)
{
    if(cur == T)
        return a;
    int t;    
    for(int &i = work[cur]; i != -1; i = next[i])
        if(flow[i] && d[v[i]] == d[cur] + 1)
            if(t = dfs(v[i], a < flow[i] ? a : flow[i]))
            {
                flow[i] -= t, flow[i ^ 1] += t;
                return t;    
            }
    return 0;
}
void dinic()
{
    int t;
    while(bfs())
    {
        memcpy(work, first, sizeof(first[0]) * (T + 1));
        while(t = dfs(S, inf))
            ANS += t;    
    }    
}
void solve()
{
    int i;
    edge[X].z = -1;
    for(i = 0; i < X; i ++)
    {
        if(i == 0 || edge[i].z != edge[i - 1].z)
        {
            dinic();
            if(ANS == SUM)
            {
                printf("%lld\n", i == 0 ? 0ll : edge[i - 1].z);
                return;    
            }    
        }
        add(edge[i].x, N + edge[i].y, inf), add(N + edge[i].y, edge[i].x, 0);
        add(edge[i].y, N + edge[i].x, inf), add(N + edge[i].x, edge[i].y, 0);
    }
    dinic();
    if(ANS == SUM)
        printf("%lld\n", edge[X - 1].z);
    else
        printf("-1\n");
}
int main()
{
    while(scanf("%d%d", &N, &M) == 2)
    {
        init();
        solve();
    }
    return 0;    
}