poj 2455 Secret Milking Machine

 

【题意】：(半天没懂题目什么意思，诶。。)FJ有N块地，这些地之间有P条双向路，每条路的都有固定的长度l。现在要你找出从第1块地到第n块地的T条不同路  

              径，每条路径上的路不能与先前的路径重复，问这些路径中的最长路的最小是多少。

【思路】二分判定最长路的最小值，再用小于这个值的边建图跑最大流。建图的话，整张无向图（记得是无向图！ 对一条边正向方向都要添加wa 好久  ）加一个源点和点1 连边容量无穷大，n点和会汇点连边，容量无穷大，最大流是多少能够找到的不同的路径就是多少。

 

#include<iostream>
#include<vector>
#include<string.h>
#include<queue>
#include<cstdio>
using namespace std;
struct E{int from;int to;int c;int f;};
vector <int> g[220];
vector<E> edge;
int d[220],vis[220],cur[220],num[220],p[220];
#define INF 10000000

struct node{int v,w;};
vector<node> mapp[220];
int n,T;

void add(int from,int to,int c)
{
    E temp1,temp2;
    temp1.from =from; temp1.to=to; temp1.c=c;temp1.f=0;
    temp2.from =to; temp2.to=from; temp2.c=0;temp2.f=0;
    edge.push_back (temp1);
    edge.push_back (temp2);
    int m=edge.size ();
    g[from].push_back (m-2);
    g[to].push_back (m-1);
}

void bfs(int s,int t)
{
    int i;
    queue<int > q;
    q.push (t);
    d[t]=0;
    memset(vis,0,sizeof(vis));
    vis[t]=1;
    while(!q.empty ())
    {
        int t=q.front ();q.pop ();
        for(i=0;i<g[t].size ();i++)
        {
           E e;e=edge[g[t][i]];
           if(!vis[e.to])
           {
               q.push (e.to);
               vis[e.to]=1;
               d[e.to]=d[t]+1;
           }
        }
    }
}

int zg(int s,int t)
{
    int x=t,a=INF;
    while(x!=s)
    {
        //printf("x   %d\n",x);
        E e=edge[p[x]];
        if(a>e.c-e.f)
            a=e.c-e.f;
        x=e.from;
    }
    x=t;
    while(x!=s)
    {
        edge[p[x]].f+=a;
        edge[p[x]^1].f-=a;
        x=edge[p[x]].from ;
    }
    return a;
}

int maxflow(int s,int t,int n)// n: 包源点汇点的所有点数-1
{
    int flow=0,i;
    bfs(s,t);
    memset(num,0,sizeof(num));
    memset(cur,0,sizeof(cur));
    for(i=0;i<=t;i++)
        num[d[i]]++;
    int x=s;
    while(d[s]<=n)
    {
        if(x==t)
        {
            flow+=zg(s,t);
            x=s;
            //printf("flow  %d\n",flow);
        }
        int ok=0;
        for(i=cur[x];i<g[x].size ();i++)
        {
            E e;
            e=edge[g[x][i]];
            if(e.c>e.f&&d[x]==d[e.to]+1)
            {
                ok=1;

                p[e.to]=g[x][i];

                cur[x]=i;
                x=e.to;//!@#$%^&
                break;
            }
        }
        if(ok==0)
        {
            int m=n;
            for(i=0;i<g[x].size ();i++)
            {
                E e;
                e=edge[g[x][i]];
                if(e.c>e.f&&m>d[e.to])
                    m=d[e.to];
            }
            if(--num[d[x]]==0)  break;
            num[d[x]=m+1]++;
            cur[x]=0;////!@#$%^^&
            if(x!=s)
                x=edge[p[x]].from ;

        }
    }
    return flow;
}

bool ok(int x)
{
    edge.clear();
    for(int i=0;i<=n+1;i++)
        g[i].clear();
    add(0,1,INF);
    for(int i=1;i<=n;i++)
        for(int j=0;j<mapp[i].size();j++)
            if(mapp[i][j].w<=x)
                 {
                     add(i,mapp[i][j].v,1);
                     add(mapp[i][j].v,i,1);
                 }
                     
    add(n,n+1,INF);
    int flow;
    flow=maxflow(0,n+1,n+1);
   // printf("flow %d    x %d\n",flow,x);
    if(flow>=T)
        return true;
    return false;
}

int solve(int maxe)
{
    int left=0,right=maxe,ans=INF;
    while(left<=right)
    {
        int mid=(left+right)/2;
        if(ok(mid))
        {
            ans=min(ans,mid);
            right=mid-1;
        }
        else left=mid+1;
    }
    return ans;
}

int main()
{
    int m,a,b,c;
    while(~scanf("%d%d%d",&n,&m,&T))
    {
        for(int i=0;i<=n;i++)
            mapp[i].clear();
        int maxe=0;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            node temp; temp.v=b; temp.w=c;
            mapp[a].push_back(temp);
            maxe=max(maxe,c);
        }
        printf("%d\n",solve(maxe));
    }
    return 0;
}