POJ 2455 Secret Milking Machine 求最长路径最短边(二分最大流)

点击打开链接

Secret Milking Machine

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 8828		Accepted: 2645

Description

Farmer John is constructing a new milking machine and wishes to keep it secret as long as possible. He has hidden in it deep within his farm and needs to be able to get to the machine without being detected. He must make a total of T (1 <= T <= 200) trips to the machine during its construction. He has a secret tunnel that he uses only for the return trips.

The farm comprises N (2 <= N <= 200) landmarks (numbered 1..N) connected by P (1 <= P <= 40,000) bidirectional trails (numbered 1..P) and with a positive length that does not exceed 1,000,000. Multiple trails might join a pair of landmarks.

To minimize his chances of detection, FJ knows he cannot use any trail on the farm more than once and that he should try to use the shortest trails.

Help FJ get from the barn (landmark 1) to the secret milking machine (landmark N) a total of T times. Find the minimum possible length of the longest single trail that he will have to use, subject to the constraint that he use no trail more than once. (Note well: The goal is to minimize the length of the longest trail, not the sum of the trail lengths.)

It is guaranteed that FJ can make all T trips without reusing a trail.

Input

* Line 1: Three space-separated integers: N, P, and T

* Lines 2..P+1: Line i+1 contains three space-separated integers, A_i, B_i, and L_i, indicating that a trail connects landmark A_i to landmark B_i with length L_i.

Output

* Line 1: A single integer that is the minimum possible length of the longest segment of Farmer John's route.

Sample Input

7 9 2
1 2 2
2 3 5
3 7 5
1 4 1
4 3 1
4 5 7
5 7 1
1 6 3
6 7 3

Sample Output

5

Hint

Farmer John can travel trails 1 - 2 - 3 - 7 and 1 - 6 - 7. None of the trails travelled exceeds 5 units in length. It is impossible for Farmer John to travel from 1 to 7 twice without using at least one trail of length 5.

Huge input data,scanf is recommended.

Source

USACO 2005 February Gold

有n个点，m条路，John想从1号点走到n号点，一共有至少k条路可以从1号点到n号点，而且保证这k条路没有重复的边，让你求从这k条路中选择路径最长的那条要求最长边尽量短。
二分最大流。
二分的是路的长度，因为要保证每条路只能走一遍，所以建图的时候就要确保能够相连的点之间的流量是1，然后判断求出的最大流是否大于等于k，如果是则说明此长度满足，则r=mid-1，否则l=mid+1.

//1788K	250MS
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define inf 0x3f3f3f3f
#define M 1007
#define MIN(a,b) a>b?b:a;
using namespace std;
struct E
{
    int v,w,next;
} edg[1000000];
int dis[2000],gap[2000],head[2000],nodes;
int sourse,sink,nn;
int u[40100],v[40100],c[40100];
int n,m,k;
void addedge(int u,int v,int w)
{
    edg[nodes].v=v;
    edg[nodes].w=w;
    edg[nodes].next=head[u];
    head[u]=nodes++;
    edg[nodes].v=u;
    edg[nodes].w=w;
    edg[nodes].next=head[v];
    head[v]=nodes++;
}
int dfs(int src,int aug)
{
    if(src==sink)return aug;
    int left=aug,mindis=nn;
    for(int j=head[src]; j!=-1; j=edg[j].next)
    {
        int v=edg[j].v;
        if(edg[j].w)
        {
            if(dis[v]+1==dis[src])
            {
                int minn=MIN(left,edg[j].w);
                minn=dfs(v,minn);
                edg[j].w-=minn;
                edg[j^1].w+=minn;
                left-=minn;
                if(dis[sourse]>=nn)return aug-left;
                if(left==0)break;
            }
            if(dis[v]<mindis)
                mindis=dis[v];
        }
    }
    if(left==aug)
    {
        if(!(--gap[dis[src]]))dis[sourse]=nn;
        dis[src]=mindis+1;
        gap[dis[src]]++;
    }
    return aug-left;
}
int sap(int s,int e)
{
    int ans=0;
    nn=e+1;
    memset(dis,0,sizeof(dis));
    memset(gap,0,sizeof(gap));
    gap[0]=nn;
    sourse=s;
    sink=e;
    while(dis[sourse]<nn)
        ans+=dfs(sourse,inf);
    return ans;
}
int build(int mid)
{
    memset(head,-1,sizeof(head));
    nodes=0;
    for(int i=1; i<=m; i++)
        if(c[i]<=mid)addedge(u[i],v[i],1);//将长度小于mid的边建图
    int ans=sap(1,n);
    return ans>=k;//返回路径的条数是否大于等于k
}
int main()
{
    //freopen("in.txt","r",stdin);
    while(scanf("%d%d%d",&n,&m,&k)!=EOF)
    {
        int maxx=-1,minn=inf;
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&u[i],&v[i],&c[i]);
            maxx=max(maxx,c[i]);
            minn=min(minn,c[i]);
        }
        int l=minn,r=maxx;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(build(mid))r=mid-1;//如果此长度满足，则继续缩小此长度
            else l=mid+1;
        }
        printf("%d\n",r+1);
    }
    return 0;
}