poj 2455

题意:由一个点走到另一个点,中间的点可以重复到达,但边只能经过一次,问T条边不重复的路径里,最长的边的最小值.

分析:由于点是可以重用的,因此不必拆点.这道题有重边,而且重边都必须保留,因为点是可以重复走的.二分最长的边长,用最大流来验证.

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 const int MAXN=;//点数的最大值
 const int MAXM=;//边数的最大值
 const int INF=0x3fffffff;

 struct Node
 {
     int from,to,next;
     int cap;
 }edge[MAXM];

 int tol;
 int head[MAXN];
 int dep[MAXN];
 int gap[MAXN];//gap[x]=y :说明残留网络中dep[i]==x的个数为y
 int n;//n是总的点的个数，包括源点和汇点
 Node container[];

 void init()
 {
     tol=;
     memset(head,-,sizeof(head));
 }

 void addedge(int u,int v,int w)
 {
     edge[tol].from=u;
     edge[tol].to=v;
     edge[tol].cap=w;
     edge[tol].next=head[u];
     head[u]=tol++;
     edge[tol].from=v;
     edge[tol].to=u;
     edge[tol].cap=;
     edge[tol].next=head[v];
     head[v]=tol++;
 }
 void BFS(int start,int end)
 {
     memset(dep,-,sizeof(dep));
     memset(gap,,sizeof(gap));
     gap[]=;
     int que[MAXN];
     int front,rear;
     front=rear=;
     dep[end]=;
     que[rear++]=end;
     while(front!=rear)
     {
         int u=que[front++];
         if(front==MAXN)front=;
         for(int i=head[u];i!=-;i=edge[i].next)
         {
             int v=edge[i].to;
             if(dep[v]!=-)continue;
             que[rear++]=v;
             if(rear==MAXN)rear=;
             dep[v]=dep[u]+;
             ++gap[dep[v]];
         }
     }
 }
 int SAP(int start,int end)
 {
     int res=;
     BFS(start,end);
     int cur[MAXN];
     int S[MAXN];
     int top=;
     memcpy(cur,head,sizeof(head));
     int u=start;
     int i;
     while(dep[start]<n)
     {
         if(u==end)
         {
             int temp=INF;
             int inser;
             for(i=;i<top;i++)
                if(temp>edge[S[i]].cap)
                {
                    temp=edge[S[i]].cap;
                    inser=i;
                }
             for(i=;i<top;i++)
             {
                 edge[S[i]].cap-=temp;
                 edge[S[i]^].cap+=temp;
             }
             res+=temp;
             top=inser;
             u=edge[S[top]].from;
         }
         if(u!=end&&gap[dep[u]-]==)//出现断层，无增广路
           break;
         for(i=cur[u];i!=-;i=edge[i].next)
            if(edge[i].cap!=&&dep[u]==dep[edge[i].to]+)
              break;
         if(i!=-)
         {
             cur[u]=i;
             S[top++]=i;
             u=edge[i].to;
         }
         else
         {
             int min=n;
             for(i=head[u];i!=-;i=edge[i].next)
             {
                 if(edge[i].cap==)continue;
                 if(min>dep[edge[i].to])
                 {
                     min=dep[edge[i].to];
                     cur[u]=i;
                 }
             }
             --gap[dep[u]];
             dep[u]=min+;
             ++gap[dep[u]];
             if(u!=start)u=edge[S[--top]].from;
         }
     }
     return res;
 }
 int main()
 {
     int N,P,T;
     while(~scanf("%d%d%d",&N,&P,&T))
     {
         n = N;
         int left = INF,right = ;
         for(int i = ;i < P;i++)
         {
             scanf("%d%d%d",&container[i].from,&container[i].to,&container[i].cap);
             left = std::min(container[i].cap,left);
             right = std::max(container[i].cap,right);
         }
         left--;
         while(left +  < right)
         {
             int mid = (left + right) / ;
             init();
             for(int i = ;i < P;i++)
             {
                 if(container[i].cap <= mid)
                 {
                     addedge(container[i].from,container[i].to,);
                     addedge(container[i].to,container[i].from,);
                 }
             }
             if(SAP(,n) >= T)
             {
                 right = mid;
             }
             else
             {
                 left = mid;
             }
         }
         printf("%d\n",right);
     }
     return ;
 }