【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+],dist[MAXK+MAXC+][MAXK+MAXC+],
     U[MAXC*+],V[MAXC*+],W[MAXC*+],Head[MAXC*+],
     Next[MAXC*+],other[MAXC*+];

template <typename T> inline void read(T &x) {
        LL f = ; x = ;
        char c = getchar();
        for (; !isdigit(c); c = getchar()) { if (c=='-') f = -f; }
        for (; isdigit(c); c = getchar()) x=x*+c-'';
        x*=f;
}

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

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

inline void floyed() {
        LL i,j,k;
        for (k = ; k <= K + C; k++) {
              for (i = ; i <= K + C; i++) {
                        if (i == k) continue;
                        for (j = ; 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] = ;
        Next[tot] = Head[b]; Head[b] = tot;
        other[tot] = tot - ;
}

inline bool BFS() {
        LL i,x,y;
        queue<LL> q;
        memset(h,,sizeof(h));
        h[st] = ; 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] > ) && (!h[y])) {
                                h[y] = h[x] + ;
                                q.push(y);
                        }
                }
        }
        if (h[ed]) return true;
        else return false;
}

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

inline bool check(LL ml) {
        LL i,j,sum=;
        tot = ;
        memset(Head,,sizeof(Head));
        for (i = K + ; i <= K + C; i++) {
                for (j = ; j <= K; j++) {
                        if (dist[i][j] <= ml)
                                add(i,j,);
                }
        }
        for (i = K + ; i <= K + C; i++) add(st,i,);
        for (i = ; 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 + ; ed = st + ;

        for (i = ; i <= K + C; i++) {
                for (j = ; j <= K + C; j++) {
                        read(dist[i][j]);
                        if (!dist[i][j]) dist[i][j] = 2e9;
                }
        }    

        floyed();

        for (i = K + ; i <= K + C; i++) {
                for (j = ; j <= K; j++) {
                        if (dist[i][j] != 2e9)
                                high = max(high,dist[i][j]);
                }
        }    

        low = ; 

        while (low <= high) {
                mid = (low + high) >> ;
                if (check(mid)) {
                        high = mid - ;
                        ans = mid;
                }    else
                        low = mid + ;
        }
        writeln(ans);

        return ;

}