POJ 2112 Optimal Milking (二分 + 最大流)

题目大意：

在一个农场里面，有k个挤奶机，编号分别是 1..k，有c头奶牛，编号分别是k+1 .. k+c，每个挤奶机一天最让可以挤m头奶牛的奶，奶牛和挤奶机之间用邻接矩阵给出距离。求让所有奶牛都挤到

奶的情况下，走的最远的那头奶牛走的距离最小是多少。

数据保证有解。

算法讨论：

首先可以想到是二分，然后在选择流网络的时候，一开始选择的最小费用最大流，让二分的边权充当最小费用，但是这样跑发现每次二分的是我们要跑的答案，不可行。所以就改用最大流。

最大流肯定是在二分的情况下判定最大流是否等于c，即是否所有的奶牛都可以挤到奶，所以一开始我的做法是直接把所有的边都加进去，然后在跑bfs的时候把边权大于二分值的边卡掉，但是发现这样是不可行的，（至于为什么不可行，有待思考。。。。）然后另一种做法就是每一次二分的时候都是重新加边（当前是小于二分值的边），然后跑最大流。但是不知道为什么我跑出来那么的效率低下。加边就是这样加：从超级源点向每头牛加流量为1的边，每头牛向距离小于二分当前值的挤奶机加流量为1的边，每个挤奶机向超级汇点加流量为m的边，根据入流等于出流的原理，这样就可以保证每个挤奶机至多只挤m头牛的奶了。

Codes：

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

 using namespace std;

 int k, c, mm, l, r, Mid;
 int arr[][];

 struct MF{
     static const int N =  + ;
     static const int M =  *  + ;
     static const int oo = 0x3f3f3f3f;

     int n, m, s, t, tot;
     int first[N], next[M];
     int u[M], v[M], cap[M], flow[M];
     int dis[N], cur[N];
     bool vi[M];

     void Clear(){
         tot = ;
         memset(first, -, sizeof first);
         memset(flow,  ,sizeof flow);
     }
     void Add(int from, int to, int cp, int flw){
         u[tot] = from; v[tot] = to; cap[tot] = cp; flow[tot] = flw;
         next[tot] = first[u[tot]];
         first[u[tot]] = tot;
         ++ tot;
     }
     bool bfs(){
         memset(vi, false, sizeof vi);

         queue <int> q;
         dis[s] = ;vi[s] = true;
         q.push(s);

         while(!q.empty()){
             int now = q.front();q.pop();
             for(int i = first[now]; i != -; i = next[i]){
                 if(!vi[v[i]] && cap[i] > flow[i]){
                     vi[v[i]] = true;
                     dis[v[i]] = dis[now] + ;
                     q.push(v[i]);
                 }
             }
         }
         return vi[t];
     }
     int dfs(int x, int a){
         if(x == t || a == ) return a;
         int flw = , f;
         int &i = cur[x];
         for(i = first[x]; i != -; i = next[i]){
             if(dis[x] +  == dis[v[i]] && (f = dfs(v[i], min(a, cap[i]-flow[i]))) > ){
                 flow[i] += f; flow[i^] -= f;
                 a -= f; flw += f;
                 if(a == ) break;
             }
         }
         return flw;
     }
     int MaxFlow(int s, int t){
         this->s = s;this->t = t;
         int flw = ;
         while(bfs()){
             memset(cur, , sizeof cur);
             flw += dfs(s, oo);
         }
         return flw;
     }
 }Net;

 void Floyed(){
     for(int kk = ; kk <= k + c; ++ kk)
         for(int i = ; i <= k + c; ++ i)
             for(int j = ; j <= k + c; ++ j)
                 if(kk != i && i != j && kk != j)
                     if(arr[i][kk] <  && arr[kk][j] < )
                         arr[i][j] = min(arr[i][j], arr[i][kk] + arr[kk][j]);
 }

 bool check(){
     Net.Clear();
     for(int i = ; i <= c; ++ i){
         Net.Add(, i + k, , );
         Net.Add(i + k, , , );
     }
     for(int i = ; i <= k; ++ i){
         Net.Add(i, Net.n + , mm, );
         Net.Add(Net.n + , i, , );
     }
     for(int i = k + ; i <= k + c; ++ i){
         for(int j = ; j <= k; ++ j){
             if(arr[i][j] <= Mid){
                 Net.Add(i, j, , );
                 Net.Add(j, i, , );
             }
         }
     }
     if(Net.MaxFlow(, Net.n + ) == c) return true;
     return false;
 }

 void Solve(){
     int ans=;l = ;r = ;
     while(l <= r){
         Mid = l + (r - l) / ;
         if(check()){
             ans = Mid;r = Mid - ;
         }
         else l = Mid + ;
     }
     printf("%d\n", ans);
 }
 int main(){

     scanf("%d%d%d", &k, &c, &mm);
     Net.n = k + c;
     memset(arr, /, sizeof arr);
     for(int i = ; i <= k + c; ++ i)
         for(int j = ; j <= k + c; ++ j){
             scanf("%d", &arr[i][j]);
             arr[i][j] = arr[i][j] ==  ? Net.oo : arr[i][j];
         }
     Floyed();
     Solve();
     return ;
 }

POJ 2112