POJ 2112 Optimal Milking【网络流+二分+最短路】

求使所有牛都可以被挤牛奶的条件下牛走的最长距离。

Floyd求出两两节点之间的最短路，然后二分距离。

构图：

将每一个milking machine与源点连接，边权为最大值m，每个cow与汇点连接，边权为1，然后根据二分的距离x，将g[i][j] < x的milking machine节点i与cow节点j连接，边权为1，其他的赋值为零。

最大流的结果是可以被挤奶的cow数量，判断是否等于总的cow总量即可。

#include <iostream>
#include <cstring>
#include <vector>
#include <cstdio>
#include <algorithm>
using namespace std;
#define N 240
#define INF 0x3f3f3f3f

class Dinic {
public:
    int n, s, t, l[N], c[N][N], e[N];
    int flow(int maxf = INF) {
        int left = maxf;
        while (build()) left -= push(s, left);
        return maxf - left;
    }
    int push(int x, int f) {
        if (x == t) return f;
        int &y = e[x], sum = f;
        for (; y<n; y++)
            if (c[x][y] > 0 && l[x]+1==l[y]) {
                int cnt = push(y, min(sum, c[x][y]));
                c[x][y] -= cnt;
                c[y][x] += cnt;
                sum -= cnt;
                if (!sum) return f;
            }
        return f-sum;
    }
    bool build() {
        int m = 0;
        memset(l, -1, sizeof(l));
        l[e[m++]=s] = 0;
        for (int i=0; i<m; i++) for (int y=0; y<n; y++)
            if (c[e[i]][y] > 0 && l[y]<0) l[e[m++]=y] = l[e[i]] + 1;
        memset(e, 0, sizeof(e));
        return l[t] >= 0;
    }
} net;
int g[N][N], n, k, c, m;

bool ok(int x) {
    memset(net.c, 0, sizeof(net.c));
    net.s = 0, net.t = n + 1, net.n = n + 2;

    for (int i=1; i<=k; i++) net.c[0][i] = m;
    for (int i=k+1; i<=n; i++) net.c[i][net.t] = 1;

    for (int i=1; i<=k; i++)
        for (int j=k+1; j<=n; j++)
            if (g[i][j] <= x) net.c[i][j] = 1;
            else net.c[i][j] = 0;

    return net.flow() == c;
}
int main() {

    while (scanf("%d%d%d", &k, &c, &m) == 3) {
        n = k + c;
        for (int i=1; i<=n; i++)
            for (int j=1; j<=n; j++) {
                scanf(" %d", &g[i][j]);
                if (g[i][j] == 0 && i != j) g[i][j] = INF;
            }
        for (int p=1; p<=n; p++) for (int i=1; i<=n; i++)
            for (int j=1; j<=n; j++) g[i][j] = min(g[i][j], g[i][p] + g[p][j]);

        int l = 0, r = INF, mid, ans;
        while (l <= r) {
            mid = (l + r) >> 1;
            if (ok(mid)) {
                ans = mid;
                r = mid -1;
            } else l = mid + 1;
        }
        cout << ans << endl;
    }
    return 0;
}