HDU-4807-Lunch Time(二分+费用流，思维)

这道题非常好，如果没有真正弄懂费用流算法的人，只会套模版的人是肯定做不出来的。

我们其实这样考虑，费用流真正的思想是吧费用作为长度，然后跑最短路，同时保证路上的流量不为0，也就是增广；

跑到终点后，回溯把路上的流量进行修改。一直这样下去直到无法增广。

这道题也是一样，我们把路径长度看成费用，路径限制看成流量限制。

每次增广到终点后，得到的dis[t]代表源点到汇点的路径长度，incf[t]代表的是这条路上的流量限制。

每一次增广成功，我们都会获得一个和之前不同的路径。

这样我们就能够得到所有s-t路径长度，以及长度对应的流量限制。并且他们所有路径都是满足在流量限制条件下的。

然后其实就很简单了，我们知道我们需要运输的人数，同时知道每一条路径对应的路径的路径运输能力和路径长度，那么我们对答案进行二分，也就是对总共用的时间进行二分。

对于所有路径长度是>=总共运输时间的（每次速度为1），也就是说对于当前的时间内，这条路是可以运载一些人到终点的，那么这条路运输的人数其实就是  e[i].flow*(t-e[i].dist+1)

也就是当前道路的流量*（所用的时间-从起点到终点的时间+1），因为当前道路的在前dist-1的时间内，人还在路上，没有抵达，在dist时间以后，人会源源不断的来到。

注意k可能是0，需要先特判k=0，再特判最大流量=0。不然会错。。。

#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
#define LL long long
using namespace std;
const int maxx = 2e5+;
const LL INF = 1e18;
int ver[maxx],head[maxx],Next[maxx];
LL incf[maxx];
LL cost[maxx],edge[maxx];
int v[maxx],pre[maxx];
LL d[maxx];
int tot,cnt,n,m,s,t;
LL ans,k,maxflow;
struct node
{
    LL flow;
    LL w;
} a[maxx];
void add(int x,int y,LL z,LL c)
{
    ver[++tot]=y;
    edge[tot]=z;
    cost[tot]=c;
    Next[tot]=head[x];
    head[x]=tot;
    ver[++tot]=x;
    edge[tot]=;
    cost[tot]=-c;
    Next[tot]=head[y];
    head[y]=tot;
}
bool spfa()
{
    queue<int>q;
    while(q.size())q.pop();
    for (int i=; i<=n+; i++)
    {
        d[i]=INF;
        v[i]=;
    }
    q.push(s);
    d[s]=;
    v[s]=;
    incf[s]=INF;
    while(q.size())
    {
        int x=q.front();
        v[x]=;
        q.pop();
        for (int i=head[x]; i; i=Next[i])
        {
            if (!edge[i])
                continue;
            int y=ver[i];
            //cout<<x<<" "<<y<<" "<<edge[i]<<endl;
            if(d[y]>d[x]+cost[i])
            {
                d[y]=d[x]+cost[i];
                incf[y]=min(incf[x],edge[i]);
                pre[y]=i;
                if(!v[y])v[y]=,q.push(y);
            }
        }
    }
    if(d[t]==INF)return false;
    else return true;
}
void update()
{
    int x=t;
    cnt++;
    a[cnt].w=d[t];
  //  cout<<t-1<<"---"<<incf[t]<<"--"<<d[t]<<endl;
    a[cnt].flow=incf[t];
    while(x!=s)
    {
        int i=pre[x];
        edge[i]-=incf[t];
        edge[i^]+=incf[t];
        x=ver[i^];
   //     printf("%d-->",x-1);
    }
  //  cout<<endl;
    maxflow+=incf[t];
}
bool check(LL x)
{
    LL sum=;
    for (int i=; i<=cnt; i++)
    {
        if (a[i].w<=x)
        {
            sum+=(LL)a[i].flow*(x-a[i].w+);
        }
    }
    return sum>=k;
}
int main()
{
    int uu,vv,c;
    while(~scanf("%d%d%lld",&n,&m,&k))
    {
        cnt=;
        tot=;
        maxflow=;
        s=;
        t=n;
        memset(head,,sizeof(head));
        for (int i=; i<=m; i++)
        {
            scanf("%d%d%d",&uu,&vv,&c);
            add(uu+,vv+,c,);
        }
        while(spfa())update();
        if (k==)
        {
            printf("0\n");
        }
        else if (maxflow==){
            printf("No solution\n");
        }else {
            int l=,r=1e9;
            while(l<=r)
            {
                int mid=(l+r)>>;
                if (check(mid))
                {
                    r=mid-;
                    ans=mid;
                }
                else
                {
                    l=mid+;
                }
            }
            printf("%lld\n",ans);
        }
    }
    return ;
}