POJ 2455 二分+边排序构图+最大流

题目链接： http://poj.org/problem?id=2455

题目大意：

　　从1到n有至少T条无相同道路的路径，即每条边只能用一次，每个点可以多次经过，然后要求所有的路径中最大的边的最小值，每条边只能用一次，注意会有重边。

分析：

　　这个题确实是好题，更确切地说是一道需要非常丰富的经验才可以过的题。

　　很容易联想到网络流，求最小的最大可以用二分，用二分出的距离进行限制构图，但是我一直错了，后来也注意到了重边，用了vector<int> map[i][j]来存重边但是一直超时，然后我就看了解题报告了，居然换了一种方式存边并且由于对边进行了排序所以在二分的时候重新构图就非常有效了，这点真的非常值得借鉴，包括二分时上下限的确定取所有边权的最小最大值（可以加速很多）。

　　步骤：

　　1、 保存所有边按边权从小到大排序，并且确定二分时的上下限;

　　2、 二分答案mid;

　　3、 对每个mid，构图：  将1中排序后的边选边权w<=mid的边<u,v>，u->v，边权+1， v->u，边权+1;（注意这题无向图并结合题目应该是用双向边），然后跑一遍最大流flow，看flow >= T 是否满足，并更新二分中的l，r;

代码：

/*2455    Accepted    900K    579MS    C++    2770B    2012-06-16 18:56:23*/

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

#define mpair make_pair
#define pii pair<int,int>
#define MM(a,b) memset(a,b,sizeof(a));
typedef long long lld;
typedef unsigned long long u64;
template<class T> bool up_max(T& a,const T& b){return b>a? a=b,1 : 0;}
template<class T> bool up_min(T& a,const T& b){return b<a? a=b,1 : 0;}
#define maxn 210
const int inf= 2100000000;

int n,m,tot;
int ST,ED;
int g[maxn][maxn];
pair< int, pii > edge[40010];
/// vector<int> map[maxn][maxn];

bool vis[maxn];
int que[maxn], pre[maxn];
bool bfs(){
    fill( vis, vis+1+n, 0 );
    int head=0, tail=0;
    que[tail++]= ST;
    vis[ST]= 1;
    while( head<tail ){
        int u= que[head++];
        for(int v=1;v<=n;++v){
            if( g[u][v]>0 && !vis[v] ){
                pre[v]= u;
                if( v==ED ) return 1;
                que[tail++]= v;
                vis[v]= 1;
            }
        }
    }
    return 0;
}

#define x first
#define y second
void build_graph(int len){
    for(int i=1;i<=n;++i)for(int j=1;j<=n;++j)g[i][j]= 0;
    for(int i=1;i<=m;++i){
        if( edge[i].x > len ) break;
        ++g[ edge[i].y.x ][ edge[i].y.y ];
        ++g[ edge[i].y.y ][ edge[i].y.x ];
    }
    /*for(int i=1;i<=n;++i)
        for(int j=1;j<=n;++j){
            g[i][j]= 0;
            for(int k=0;k<map[i][j].size();++k)
                g[i][j]+= map[i][j][k]<=len;
        }*/
}

int Edmond_karp(int mid){
    build_graph( mid );
    int ret= 0;
    while( bfs() ){
        int t= inf;
        for(int i=ED;i!=ST;i=pre[i])
            up_min( t, g[pre[i]][i] );
        ret+= t;
        for(int i=ED;i!=ST;i=pre[i]){
            g[pre[i]][i]-= t;
            g[i][pre[i]]+= t;
        }
    }
    return ret;
}

int down, up;
int solve(){
    ST= 1, ED= n;
    int l=down, r=up, mid;
    while( l<=r ){
        mid= (l+r)>>1;
        if( Edmond_karp(mid) >= tot ) r= mid-1;
        else l= mid+1;
    }
    return l;
}

int main()
{
    //freopen("poj2455.in","r",stdin);
    while( cin>>n>>m>>tot ){
        up= -inf;
        down= inf;
        for(int i=1;i<=m;++i){
            int u,v,t;
            scanf("%d%d%d", &u,&v,&t);
            up_max( up, t );
            up_min( down, t );
            edge[i]= mpair( t, pii( u, v ) );
            /// map[x][y].push_back(t);
            /// map[y][x].push_back(t);
            /// if( up_min( map[x][y], t ) ) map[y][x]= t;
        }
        /// for(int i=1;i<=n;++i)for(int j=1;j<=n;++j) if( map[i][j]!=inf ) up_max( limit, map[i][j] );
        sort( edge+1, edge+1+m );
        cout<< solve() <<endl;
    }
}