【USACO】Optimal Milking

题目链接 ：

       【POJ】点击打开链接

       【caioj】点击打开链接

算法 ：

1：跑一遍弗洛伊德，求出点与点之间的最短路径

2：二分答案，二分”最大值最小“

3.1：建边，将原点与每头奶牛连边，流量为1，记dist[i][j]为i到j的最短路径，若dist[i][j]<=mid (K+1<=i<=K+C,1<=j<=K)，则将i与j连边，流量为M，将每台挤奶机与汇点连边，流量为1

3.2 ： 跑网络流，这里笔者使用的是dinic算法

3.3 ： 判断最大流S是否等于K，等于K，则往小搜，否则往大搜

代码 ：

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
#include <stack>
#include <limits.h>
using namespace std;
#define MAXK 30
#define MAXC 200
#define MAXM 15

typedef long long LL;

LL i,j,low,high,mid,st,ed,K,C,M,tot,ans;
LL h[MAXK+MAXC+10],dist[MAXK+MAXC+10][MAXK+MAXC+10],
     U[MAXC*100+10],V[MAXC*100+10],W[MAXC*100+10],Head[MAXC*100+10],
     Next[MAXC*100+10],other[MAXC*100+10];
        
template <typename T> inline void read(T &x) {
        LL f = 1; x = 0;
        char c = getchar(); 
        for (; !isdigit(c); c = getchar()) { if (c=='-') f = -f; }
        for (; isdigit(c); c = getchar()) x=x*10+c-'0';
        x*=f;
}

template <typename T> inline void write(T x) {
        if (x < 0) { putchar('-'); x = -x; }
        if (x > 9) write(x/10);
        putchar(x % 10 + '0');    
}

template <typename T> inline void writeln(T x) {
        write(x);
        puts("");    
}

inline void floyed() {
        LL i,j,k;
        for (k = 1; k <= K + C; k++) {
              for (i = 1; i <= K + C; i++) {
                        if (i == k) continue;
                        for (j = 1; j <= K + C; j++) {
                                if ((k == j) || (i == j)) continue;
                                dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j]);                            
                        }    
                }
        }        
}

inline void add(LL a,LL b,LL c) {
        ++tot;
        U[tot] = a; V[tot] = b; W[tot] = c;
        Next[tot] = Head[a]; Head[a] = tot; 
        other[tot] = ++tot;
        U[tot] = b; V[tot] = a; W[tot] = 0;
        Next[tot] = Head[b]; Head[b] = tot;
        other[tot] = tot - 1;    
}

inline bool BFS() {
        LL i,x,y;
        queue<LL> q;
        memset(h,0,sizeof(h));
        h[st] = 1; q.push(st);
        while (!q.empty()) {
                x = q.front(); q.pop();
                for (i = Head[x]; i; i = Next[i]) {
                        y = V[i];
                        if ((W[i] > 0) && (!h[y])) {
                                h[y] = h[x] + 1;
                                q.push(y);
                        }
                }
        }
        if (h[ed]) return true;
        else return false;
}

inline LL maxflow(LL x,LL f) {
        LL i,t,y,sum=0;
        if (x == ed) return f;
        for (i = Head[x]; i; i = Next[i]) {
                y = V[i];
                if ((W[i] > 0) && (h[y] == h[x] + 1) && (sum < f)) {
                        sum += (t = maxflow(y,min(W[i],f-sum)));
                        W[i] -= t; W[other[i]] += t;
                }     
        }    
        if (!sum) h[x] = 0;
        return sum;
}

inline bool check(LL ml) {
        LL i,j,sum=0;
        tot = 0;
        memset(Head,0,sizeof(Head));
        for (i = K + 1; i <= K + C; i++) {
                for (j = 1; j <= K; j++) {
                        if (dist[i][j] <= ml)
                                add(i,j,1);
                }
        }    
        for (i = K + 1; i <= K + C; i++) add(st,i,1); 
        for (i = 1; i <= K; i++) add(i,ed,M);
        while (BFS()) {
                sum += maxflow(st,C);
        }
        return sum == C;
}

int main() {
        
        read(K); read(C); read(M);
        st = K + C + 1; ed = st + 1;
        
        for (i = 1; i <= K + C; i++) {
                for (j = 1; j <= K + C; j++) {
                        read(dist[i][j]);
                        if (!dist[i][j]) dist[i][j] = 2e9;
                }    
        }    
        
        floyed();
        
        for (i = K + 1; i <= K + C; i++) {
                for (j = 1; j <= K; j++) {
                        if (dist[i][j] != 2e9)
                                high = max(high,dist[i][j]);
                }    
        }    
        
        low = 1; 
        
        while (low <= high) {
                mid = (low + high) >> 1;
                if (check(mid)) {
                        high = mid - 1;
                        ans = mid;
                }    else
                        low = mid + 1;
        }
        writeln(ans);
        
        return 0;
    
}