Secret Milking Machine
Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 12324   Accepted: 3589

 

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个节点p条边，要求在图中从1到n找到t条路径，并且使这t条路径中的最长边最小，输出这个最小的最长边

思路：我们可以二分枚举最小的最长边的长度，然后建图，长度小于等于枚举值的边可以连上，容量为1，建完之后跑最大流，此时最大流的意义是从1到n有几条路径，因此我们二分搜索加最大流便可以求出最长边的最小值。
注意：重边时不能用邻接矩阵保存边值，此题中也不能只取最小值，而是全部保存
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <bitset>

using namespace std;

#define LL long long
const int INF = 0x3f3f3f3f;
#define MAXN 500

struct node
{
    int u, v, next, cap;
} edge[MAXN*MAXN],mp[MAXN*MAXN];
int nt[MAXN], s[MAXN], d[MAXN], visit[MAXN],p[MAXN];
int cnt;
int ct;
int n,m,k;

int N;
void init()
{
    cnt = 0;
    memset(s, -1, sizeof(s));
}

void add(int u, int v, int c)
{
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].cap = c;
    edge[cnt].next = s[u];
    s[u] = cnt++;
    edge[cnt].u = v;
    edge[cnt].v = u;
    edge[cnt].cap = c;
    edge[cnt].next = s[v];
    s[v] = cnt++;
}

bool BFS(int ss, int ee)
{
    memset(d, 0, sizeof d);
    d[ss] = 1;
    queue<int>q;
    q.push(ss);
    while (!q.empty())
    {
        int pre = q.front();
        q.pop();
        for (int i = s[pre]; ~i; i = edge[i].next)
        {
            int v = edge[i].v;
            if (edge[i].cap > 0 && !d[v])
            {
                d[v] = d[pre] + 1;
                q.push(v);
            }
        }
    }
    return d[ee];
}

int DFS(int x, int exp, int ee)
{
    if (x == ee||!exp) return exp;
    int temp,flow=0;
    for (int i = nt[x]; ~i ; i = edge[i].next, nt[x] = i)
    {
        int v = edge[i].v;
        if (d[v] == d[x] + 1&&(temp = (DFS(v, min(exp, edge[i].cap), ee))) > 0)
        {
            edge[i].cap -= temp;
            edge[i ^ 1].cap += temp;
            flow += temp;
            exp -= temp;
            if (!exp) break;
        }
    }
    if (!flow) d[x] = 0;
    return flow;
}

int Dinic_flow(int mid)
{
    init();
    for(int i=1; i<=n; i++)
        for(int j=p[i]; ~j; j=mp[j].next)
            if(mp[j].cap<=mid)
                add(mp[j].u,mp[j].v,1);
    int ss=1,ee=n;
    int ans = 0;
    while (BFS(ss, ee))
    {
        for (int i = 0; i <=ee; i++) nt[i] = s[i];
        ans+= DFS(ss, INF, ee);
    }
    return ans;
}

int main()
{
    int u,v,c;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        ct=0;
        memset(p,-1,sizeof p);
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&c);
           mp[ct].u=u;
           mp[ct].v=v;
           mp[ct].cap=c;
           mp[ct].next=p[u];
           p[u]=ct++;
        }
        int l=0,r=INF;
        int ans=0;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(Dinic_flow(mid)>=k) ans=mid,r=mid-1;
            else l=mid+1;
        }
        printf("%d\n",ans);
    }
    return 0;
}