HDU 1839 Delay Constrained Maximum Capacity Path（二分+SPFA）

   题目大意：有输入多组，第二行n,m,k三个数,分别表示点的个数，边，总的运输时间，第三行有4个数

分别是，a,b,cap,t分别为两个点，及其容量，及此段运输的时间。求其中一条最大的运输量（取决于此路上容量最

小的）。

  思路：一开始以为是网络流，但是题目说是找到其中一条路上的有时间限制的最大运输量所以应该是最短路。

之所以是最短路因为在最短的限制时间内，找到最大的容量。因为数据较大直接是SPFA+二分。

具体的实现方法： 关键是怎么处理所给定的容量、限制条件和给定运输条件之间的关系，既然我们找的是最大的运输量所以二分枚举cap（容量）。枚举的时候注意要找到最大的运输量必定是在给定的时间限制内。所以二分一个当前值（也就是这条路上的最小值）就要SPFA去构造最小的时间，如果最后整条路的运输时间<=T(限制时间),就继续在二分的右边，找看是否有更大的符合解。（注意二分写成r=m-1的形式）

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<cmath>
#include<math.h>
#include<set>
#include<ctime>
#include<cstdlib>
#include<algorithm>
#define inf 0x3f3f3f3f
#define LL __int64
using namespace std ;
LL n,T,head[1000000],lim,di[1000000],cnt;
bool vis[1000000];
LL cap[1000000];
struct node
{
    LL to,w,next,t;
}q[1000000];
void bu(LL a,LL b,LL c,LL d)
{
    q[cnt].to=b;
    q[cnt].w=c;
    q[cnt].t=d;
    q[cnt].next=head[a];
    head[a]=cnt++;
}
LL SPFA()
{
    for(int i=0;i<=n;i++)
    {
        di[i]=inf;
        //vis[i]=false;
    }
    di[1]=0;
    queue<LL>Q;
    while(!Q.empty())
        Q.pop();
    vis[1]=true;
    Q.push(1);
    while(!Q.empty())
    {
        LL v=Q.front();Q.pop();vis[v]=false;
        for(int i=head[v];~i;i=q[i].next)
        {
            if(lim<=q[i].w)
            {
                if(di[q[i].to ]>di[v ]+q[i].t )
                {
                    di[q[i].to ]=di[ v]+q[i].t;
                    if(!vis[q[i].to ])
                    {
                        vis[q[i].to ]=true;
                        Q.push(q[i].to);
                    }
                }
            }
        }
    }
    return di[n];

}
int main()
{
    int m,i,j,k,cla;LL a,b,c,d;
    scanf("%d",&cla);
    while(cla--)
    {
        scanf("%d%d%d",&n,&m,&T);
        cnt=0;
        memset(head,-1,sizeof(head));
        memset(vis,false,sizeof(vis));
        for(i=0;i<m;i++)
        {
            scanf("%I64d%I64d%I64d%I64d",&a,&b,&c,&d);
            cap[i]=c;
            bu(a,b,c,d);
            bu(b,a,c,d);
        }
        sort(cap,cap+m);
        LL l=0,r=m-1,ans=0;
        while(l<=r)
        {
            int mid=(l+r)/2;
            lim=cap[mid];
            LL tmp=SPFA();
            if(tmp<=T)
            {
                ans=max(ans,cap[mid]);
                l=mid+1;
            }
            else
                r=mid-1;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}