poj 2112 Optimal Milking 二分 + floyd + 最大流

题目链接

二分距离，把那些边小于等于这个距离的留下来

加一个源点到牛所在的点容量为1，机器到汇点，容量为M，牛到机器的边容量为他们的最短路。跑最大流判断可不可行，如果s-t的流量为C则可行。

dinic 代码如下：

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	> File Name: fl.cpp
	> Author: kdh
	> Mail: oralce__o@163.com
	> Created Time: Wed 10 Sep 2014 01:14:01 PM CST
 ************************************************************************/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
const int INF = 2000000;
const int N = 400;
int C,K,M,n,cnt;
int d[N][N];
int eh[N];
struct Edge
{
    int from,cap,to,flow,next;
    Edge(){}
    Edge(int u,int v,int c,int f,int n):from(u),cap(c),to(v),flow(f),next(n){}
}edge[N*100];
void Floyd()
{
    for(int i = 1; i <= n; ++i)
         for(int j = 1; j <= n; ++j){
            if(d[i][j] == 0 && i != j) {d[i][j] = INF;
            }
         }
    for(int k = 1;k <= n; ++k)
        for(int i = 1;i <= n; ++i)
            for(int j = 1;j <= n; ++j)
                d[i][j] = min(d[i][k] + d[k][j], d[i][j]);
}
void addedge(int u,int v,int c)
{
    edge[cnt] = Edge(u,v,c,0,eh[u]);
    eh[u] = cnt++;
    edge[cnt] = Edge(v,u,0,0,eh[v]);
    eh[v] = cnt++;
}
void init()
{
    memset(eh,-1,sizeof(eh));
    cnt = 0;
}
void getg(int mid)
{
    init();
    for(int i = 1; i <= C; ++i){
        addedge(i, n + 2,M);
    }
    for(int i = C + 1; i <= n; ++i)
      for(int j = 1; j <= C; ++j){
            if(d[i][j] <= mid) addedge(i,j,1);
       }
    for(int i = C + 1;i <= n; ++i)
        addedge(n + 1,i,1);
}
struct Dinic
{
    int s,t;
    bool vis[N];
    int d[N];
    int cur[100*N];
    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();
            for(int i = eh[x];i != -1;i = edge[i].next){
                Edge &e = edge[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;
        for(int & i = cur[x]; i != -1; i = edge[i].next){
            Edge &e = edge[i];
            if(d[x] + 1 == d[e.to] && (f = DFS(e.to,min(a,e.cap - e.flow))) > 0){

                e.flow += f;
                edge[i ^ 1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
        return flow;
    }
    int maxflow()
    {
        int s = n + 1,t = n + 2;
        this ->s = s;this ->t = t;
        int flow = 0;
        while(BFS()){
            for(int i = 1;i <= n + 2; ++i) cur[i] = eh[i];
            flow += DFS(s,INF);
        }
        return flow;
    }
};
Dinic di;
int main(){

    while(~scanf("%d%d%d",&K,&C,&M)){
        swap(K,C);
        n = C + K;
        for(int i = 1;i <= n; ++i)
            for(int j = 1; j <= n; ++j)
                scanf("%d",&d[i][j]);
        Floyd();
        int ans = INF;
        int L = 0,R = INF,mid;
            while(L <= R){
                mid = (L + R) >> 1;
                getg(mid);
                if(di.maxflow() == K){R = mid - 1;ans = mid;}
                else L = mid + 1;
            }
        printf("%d\n",ans);
   }
   return 0;
}