[Poj2112][USACO2003 US OPEN] Optimal Milking [网络流，最大流][Dinic+当前弧优化]

题意：有K个挤奶机编号1~K，有C只奶牛编号(K+1)~(C+K),每个挤奶机之多能挤M头牛，现在让奶牛走到挤奶机处，求奶牛所走的最长的一条边至少是多少。

题解：从起点向挤奶机连边，容量为M，从挤奶机向奶牛连，边容量为1，从奶牛向汇点连边，容量为1。二分最长边的长度，每次重新构图，边权小于等于mid的可以走，其余为INF，每次检查汇点的流量是否为C即可。

代码如下：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <queue>

using namespace std;

template<const int _n>
struct Edge
{
    struct Edge_base { int    to,next,w; }e[_n];
    int    p[_n],cnt;
    void    insert(const int x,const int y,const int z)
    { e[++cnt].to=y; e[cnt].next=p[x]; e[cnt].w=z; p[x]=cnt; return ; }
    int    start(const int x) { return p[x]; }
    void    clear() { cnt=,memset(p,,sizeof(p)); return ; }
    Edge_base&    operator[](const int x) { return e[x]; }
};

int    n,cur[],SSS,TTT;
int    level[],K,C,M,Map[][];
Edge<>    e;

bool    Bfs(const int S)
{
    int    i,t;
    queue<int>    Q;
    memset(level,,sizeof(level));

    level[S]=;
    Q.push(S);
    while(!Q.empty())
    {
        t=Q.front();Q.pop();
        for(i=e.start(t);i;i=e[i].next)
        {
            if(!level[e[i].to] && e[i].w)
            {
                level[e[i].to]=level[t]+;
                Q.push(e[i].to);
            }
        }
    }
    return level[TTT];
}

int    Dfs(const int S,const int bk)
{
    if(S==TTT)return bk;
    int    rest=bk;
    for(int &i=cur[S];i;i=e[i].next)//这里地址（引用）符一定要加，这样cur才会变化，优化才有效
    {
        if(e[i].w && level[e[i].to]==level[S]+)
        {
            int    flow=Dfs(e[i].to,min(rest,e[i].w));
            e[i].w-=flow;
            e[i^].w+=flow;
            if((rest-=flow)==)break;
        }
    }
    if(rest==bk)level[S]=;
    return bk-rest;
}

int    Dinic()
{
    int    flow=,i;
    while(Bfs(SSS))
    {
        for(i=;i<=n;++i)cur[i]=e.start(i);//当前弧优化
　　　　　//据说这道题不加这个优化会变快。。可能是因为多了个for。。。
        flow+=Dfs(SSS,0x3f3f3ff);
    }
    return flow;
}

bool    Check(const int lim)
{
    int    i,j;
    e.clear();
    for(i=;i<=K;++i)
    {
        e.insert(SSS,i,M);
        e.insert(i,SSS,);
        for(j=K+;j<=K+C;++j)
        {
            if(Map[i][j]<=lim)
            {
                e.insert(i,j,);
                e.insert(j,i,);
            }
        }
    }
    for(i=K+;i<=C+K;++i)e.insert(i,TTT,),e.insert(TTT,i,);

    return Dinic()==C;
}

int main()
{
    int    i,j,k,l,r;

    scanf("%d%d%d",&K,&C,&M);
    n=K+C;
    for(i=;i<=n;++i)
        for(j=;j<=n;++j)
        {
            scanf("%d",&Map[i][j]);
            if(Map[i][j]==)Map[i][j]=0x3f3f3f3f;
        }

    for(k=;k<=n;++k)
        for(i=;i<=n;++i)
            for(j=;j<=n;++j)
                if(Map[i][k]+Map[k][j]<Map[i][j])
                    Map[i][j]=Map[i][k]+Map[k][j];

    l=;r=0x7fffffff;SSS=++n,TTT=++n;
    while(l<r-)
    {
        int    mid=l+((r-l)>>);
        if(Check(mid))r=mid;
        else    l=mid;
    }

    printf("%d\n",r);

    return ;
}