[网络流]poj2112 Optimal Milking

题意：

有K头奶牛和C台挤奶机，每台挤奶机最多供M头奶牛使用，给出奶牛与挤奶机之间的距离（邻接矩阵），求走得最多的奶牛最少要走多少才能保证每一个奶牛都能找到挤奶机。

思路：

首先给出的距离必然不是最短路，那么要让求的时候尽可能简单，使用Floyd算一下最短路。

然后求最大值最小，想到用二分的办法，让求解区间成为[l,r），最后返回r即为答案。

可以想到，l = 0是必然不成立，而r = 200*(k + c)是必然成立的，每一头奶牛走的路程可能不一样，可能要从第一个走到最后一个，所以最大值必然为上述的r

接着就是想如何判定

可以建立一个源点和一个汇点

从源点开始，连接每一头奶牛，奶牛连接的机器的路程必须在最大值之下，做一次最大流，看结果是否等于k，即所有的奶牛都能找到

按这样算，自然很容易得到答案，但是代码量很大……

鉴定完毕，码农题一道……

代码：

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

using namespace std;

const int MAXN = 500 + 10,
           INF = 0x3f3f3f3f;

struct Edge {
    int from, to, cap, flow;
    Edge(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};

struct EdmondsKarp {
    int n, m;
    vector < Edge > edges;
    vector < int > G[MAXN];
    int a[MAXN];
    int p[MAXN];

    void init(int n) {
        edges.clear();

        for(int i = 0; i < n; ++i) {
            G[i].clear();
        }
    }

    void AddEdge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }

    int Maxflow(int s, int t) {
        int flow = 0;

        for(;;) {
            memset(a, 0, sizeof a);
            queue < int > Q;
            Q.push(s);
            a[s] = INF;

            while(!Q.empty()) {
                int x = Q.front();
                Q.pop();

                for(int i = 0; i < G[x].size(); ++i) {
                    Edge& e = edges[G[x][i]];

                    if(!a[e.to] && e.cap > e.flow) {
                        a[e.to] = min(a[x], e.cap - e.flow);
                        p[e.to] = G[x][i];
                        Q.push(e.to);
                    }
                }

                if(a[t]) {
                    break;
                }
            }

            if(!a[t]) {
                break;
            }

            for(int u = t; u != s; u = edges[p[u]].from) {
                edges[p[u]].flow += a[t];
                edges[p[u] ^ 1].flow -= a[t];
            }

            flow += a[t];
        }

        return flow;
    }
};

int n;
int k, c, m;
int dis[MAXN][MAXN];

void Floyd() {
    for(int k = 0; k < n; ++k) {
        for(int i = 0; i < n; ++i) {
            for(int j = 0; j < n; ++j) {
                if(dis[i][k] + dis[k][j] < dis[i][j]) {
                    dis[i][j] = dis[i][k] + dis[k][j];
                }
            }
        }
    }
}

int check(int x) {
    EdmondsKarp ek;
    int s = n, t = n + 1;

    for(int i = 0; i < k; ++i) {
        ek.AddEdge(i, t, m);
    }

    for(int i = k; i < n; ++i) {
        ek.AddEdge(s, i, 1);
    }

    for(int i = 0; i < k; ++i) {
        for(int j = k; j < n; ++j) {
            if(dis[i][j] <= x) {
                ek.AddEdge(j, i, 1);
            }
        }
    }

    return ek.Maxflow(s, t) == c;
}

int solve() {
    int l = 0, r = 200 * n;

    while(l + 1 < r) {
        int mid = l + r >> 1;
        (check(mid) ? r : l) = mid;
    }

    return r;
}

int main(void) {
    cin >> k >> c >> m;

    n = k + c;

    for(int i = 0; i < n; ++i) {
        for(int j = 0; j < n; ++j) {
            cin >> dis[i][j];
            dis[i][j] = dis[i][j] ? dis[i][j] : INF;
        }
    }

    Floyd();

    cout << solve() << endl;
    return 0;
}