Optimal Milking POJ-2112（最大流）

题意：

有C头奶牛和K台挤奶机，已知每台挤奶机只能给M头牛挤奶。奶牛编号从K+1 到 K+C，挤奶机编号从1 到 K。现在给你一个 (K + C) * (K + C)的矩阵，矩阵第 i 行 第 j 列 的元素代表第i个点到第j个点的距离。求给每头奶牛挤奶的，使得C头奶牛需要行走的路程中的最大路程的最小值。

思路:

Floyd求每头奶牛到挤奶机的最小距离，二分答案，每次 check 对于距离小于 mid 的 i ，j 建边，判断最大流是否等于奶牛数。

代码:

//#include<bits/stdc++.h>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <string>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>

#define ll long long
#define pll pair<ll,ll>
#define pii pair<int,int>
#define bug printf("*********
")
#define FIN freopen("input.txt","r",stdin);
#define FON freopen("output.txt","w+",stdout);
#define IO ios::sync_with_stdio(false),cin.tie(0)
#define ls root<<1
#define rs root<<1|1
#define Q(a) cout<<a<<endl

using namespace std;
const int inf = 0x3f3f3f3f;
const ll Inf = 1e18 + 7;
const int maxn = 1e5 + 5;
const int mod = 1e9 + 7;

ll gcd(ll a, ll b)
{
    return b ? gcd(b, a % b) : a;
}

ll lcm(ll a, ll b)
{
    return a / gcd(a, b) * b;
}

ll read()
{
    ll p = 0, sum = 0;
    char ch;
    ch = getchar();
    while (1)
    {
        if (ch == '-' || (ch >= '0' && ch <= '9'))
            break;
        ch = getchar();
    }

    if (ch == '-')
    {
        p = 1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9')
    {
        sum = sum * 10 + ch - '0';
        ch = getchar();
    }
    return p ? -sum : sum;
}

struct Dinic
{
    int head[maxn], tot, cur[maxn];
    int dis[maxn];
    int s, e;
    queue<int>q;

    struct node
    {
        int v, w;
        int next;
    }p[maxn];

    void init()
    {
        tot = 0;
        memset(head, -1, sizeof head);
    }

    void add(int u, int v, int w)
    {
        p[tot].v = v;
        p[tot].w = w;
        p[tot].next = head[u];
        head[u] = tot++;
    }

    void addEdge(int u, int v, int w)
    {
        add(u, v, w);
        add(v, u, 0);
    }

    bool bfs()
    {
        memset(dis, 0, sizeof dis);
        while (!q.empty())   q.pop();
        dis[s] = 1;
        q.push(s);
        while (!q.empty())
        {
            int x = q.front();
            q.pop();
            for (int i = head[x]; i != -1; i = p[i].next)
            {
                int v = p[i].v, w = p[i].w;
                if (!dis[v] && w)
                {
                    dis[v] = dis[x] + 1;
                    q.push(v);
                }
            }
        }
        if (dis[e])  return true;
        return false;
    }

    int dfs(int x, int W)
    {
        if (x == e || W == 0)  return W;
        int res = 0;
        for (int i = cur[x]; i != -1; i = p[i].next)
        {
            cur[x] = p[i].next;
            int v = p[i].v, w = p[i].w;
            if (dis[v] == dis[x] + 1)
            {
                int f = dfs(v, min(w, W));
                p[i].w -= f;
                p[i ^ 1].w += f;
                W -= f;
                res += f;
                if (W == 0)    break;
            }
        }
        return res;
    }

    int getMaxFlow()
    {
        int ans = 0;
        while (bfs())
        {
            for (int i = s; i <= e; ++i) cur[i] = head[i];
            ans += dfs(s, inf);
        }
        return ans;
    }
}DC;

struct stortest_Floyd {
    int a[5000][5000];
    void floyd(int num) {
        for (int k = 1; k <= num; k++) {
            for (int i = 1; i <= num; i++) {
                for (int j = 1; j <= num; j++) {
                    if (a[i][j] > a[i][k] + a[k][j]) {
                        a[i][j] = a[i][k] + a[k][j];
                    }
                }
            }
        }
    }
}Floyd;

int k, c, m;
int num;

void add(int x)
{
    for (int i = 1; i <= k; ++i)
    {
        for (int j = k + 1; j <= num; ++j)
        {
            if (Floyd.a[i][j] <= x)
                DC.addEdge(j, i, 1);
        }
    }
    for (int i = 1; i <= k; ++i)
    {
        DC.addEdge(i, DC.e, m);
    }
    for (int i = k + 1; i <= num; ++i)
    {
        DC.addEdge(DC.s, i, 1);
    }
}

int main()
{
    while (~scanf("%d %d %d", &k, &c, &m))
    {
        num = k + c;
        DC.s = 0, DC.e = num + 1;
        int nv = num + 2;

        for (int i = 1; i <= num; ++i)
        {
            for (int j = 1; j <= num; ++j)
            {
                scanf("%d", &Floyd.a[i][j]);
                if (i != j && !Floyd.a[i][j])
                {
                    Floyd.a[i][j] = inf;
                }
            }
        }
        Floyd.floyd(num);

        int l = 0, r = inf;
        int ans = 0;
        while (l <= r)
        {
            int mid = (l + r) / 2;
            DC.init();
            add(mid);
            int res = DC.getMaxFlow();
            if (res == c)
            {
                ans = mid;
                r = mid - 1;
            }
            else l = mid + 1;
        }
        printf("%d
", ans);
    }
}