POJ 2112 Optimal Milking (网络流+二分）

首先floyd求出任意两点间最短路。

然后二分路径长度的最大值。 每次二分中：

1对于所有长度小于等于这个最大值的 从奶牛到机器的路径，建一条流量为无限的边。

2.再从源点到每头牛建一条流量为1的边。

3.从每个机器到汇点建一条流量为M的边

最后看看最大流是否等于C，等于则这个最大值合法。

注意： 若输入数据中不同两点间距离为0，表示的是到达不了。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define MAXN 1000
int K,C,M;
int a[MAXN][MAXN];
int c[MAXN][MAXN];
#define INF 100000000
#include <queue>
#include <vector>
struct Edge{
    int from,to,cap,flow;
    Edge(int f,int t,int c,int fl){
        from=f; to=t; cap=c; flow=fl;
    }
};


struct Dinic{
    int n,m,s,t;            //结点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;     //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[MAXN];    //邻接表，G[i][j]表示节点i和第j条边在e数组中的序号
    bool vis[MAXN];         //BFS使用
    int d[MAXN];            //从起点到i的距离
    int cur[MAXN];          //当前弧下标

    void clear_all(int n){
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }
    void clear_flow(){
        int len=edges.size();
        for(int i=0;i<len;i++) edges[i].flow=0;
    }
    void add_edge(int from,int to,int cap){
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    bool BFS(){
        memset(vis,0,sizeof(vis));
        queue<int> q;
        q.push(s);
        d[s]=0;
        vis[s]=1;
        while(!q.empty()){
            int x=q.front();
            q.pop();
            int len=G[x].size();
            for(int i=0;i<len;i++){
                Edge& e=edges[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow){
                    vis[e.to]=1;
                    d[e.to]=d[x]+1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a){
        if(x==t||a==0) return a;
        int flow=0,f,len=G[x].size();
        for(int& i=cur[x];i<len;i++){
            Edge& e=edges[G[x][i]];
            if(d[x]+1==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;
                edges[G[x][i]^1].flow-=f;
                flow+=f;
                a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }
    int maxflow(int s,int t){
        this->s=s;
        this->t=t;
        int flow=0;
        while(BFS()){
            memset(cur,0,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
    int mincut(){   //call this after maxflow
        int ans=0;
        int len=edges.size();
        for(int i=0;i<len;i++){
            Edge& e=edges[i];
            if(vis[e.from]&&!vis[e.to]&&e.cap>0) ans++;
        }
        return ans;
    }
    void reduce(){
        int len=edges.size();
        for(int i=0;i<len;i++) edges[i].cap-=edges[i].flow;
    }
}solver;

bool OK(int n){
    solver.clear_all(K+C+2);
    for(int i=K;i<K+C;i++){
        solver.add_edge(0,i+1,1);
    }
    for(int i=0;i<K;i++){
        solver.add_edge(i+1,K+C+1,M);
    }
    for(int i=K;i<K+C;i++){
        for(int j=0;j<K;j++){
            if(c[i][j]<=n){
                solver.add_edge(i+1,j+1,INF);
            }
        }
    }
    int res=solver.maxflow(0,K+C+1);
    if(res==C) return 1;
    return 0;
}



int main(){
    scanf("%d%d%d",&K,&C,&M);
    for(int i=0;i<K+C;i++){
        for(int j=0;j<K+C;j++){
            scanf("%d",&a[i][j]);
            if(i!=j&&!a[i][j]) a[i][j]=INF;
            c[i][j]=a[i][j];
        }
    }

    for(int k=0;k<K+C;k++){
        for(int i=0;i<K+C;i++){
            for(int j=0;j<K+C;j++){
                c[i][j]=min(c[i][j],c[i][k]+c[k][j]);
            }
        }
    }

    int l=0,r=INF;
    int res=0;
    while(l<=r){
        int mid=(l+r)/2;
        if(OK(mid)){
            res=mid;
            r=mid-1;
        }
        else l=mid+1;
    }
    printf("%d\n",res);
    return 0;
}