POJ2112 Optimal Milking---二分+Floyd+网络流

题目链接：

https://vjudge.net/problem/POJ-2112

题目大意：

k个机器，每个机器最多服务m头牛。

c头牛，每个牛需要1台机器来服务。

告诉你牛与机器每个之间的直接距离。

问：让所有的牛都被服务的情况下，使走的最远的牛的距离最短，求这个距离。

解题思路：

二分枚举距离，实际距离满足当前枚举距离限制的可以加入这条边。枚举的距离中符合条件的最小值就是答案。

建图过程：

一个超级汇点，每个机器和汇点的容量都是m。

一个超级源点，和每头牛的容量都是1.

机器i与牛j之间的距离如果小于等于当前枚举值mid，连接i，j，容量1.

这样最大流的意义就是能够服务的牛最多是多少，如果最大流等于牛的总数c，表示当前枚举值mid符合条件，同时说明mid值还可能可以更小，更新二分右边界r = mid .（最终答案也是r不是mid）

如果小于牛的总数，说明mid偏小，更新二分左边界，l = mid + 1.

机器与牛之间的最短距离可以用floyd预处理出来。

#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 300 + 10;
const int INF = 0x3f3f3f3f;
struct edge
{
    int u, v, c, f;
    edge(int u, int v, int c, int f):u(u), v(v), c(c), f(f){}
};
vector<edge>e;
vector<int>G[maxn];
int a[maxn], p[maxn];
void init(int n)
{
    e.clear();
    for(int i = 0; i <= n; i++)G[i].clear();
}
void addedge(int u, int v, int c)
{
    //cout<<u<<" "<<v<<" "<<c<<endl;
    e.push_back(edge(u, v, c, 0));
    e.push_back(edge(v, u, 0, 0));
    int m = e.size();
    G[u].push_back(m - 2);
    G[v].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 u = q.front();
            q.pop();
            for(int i = 0; i < G[u].size(); i++)
            {
                edge& now = e[G[u][i]];
                int v = now.v;
                if(!a[v] && now.c > now.f)//还未流经并且边还有容量
                {
                    p[v] = G[u][i];
                    a[v] = min(a[u], now.c - now.f);
                    q.push(v);
                }
            }
            if(a[t])break;//已经到达汇点
        }
        if(!a[t])break;//已经没有增广路
        for(int u = t; u != s; u = e[p[u]].u)
        {
            e[p[u]].f += a[t];
            e[p[u] ^ 1].f -= a[t];
        }
        flow += a[t];
    }
    return flow;
}
int k, c, m, n;
int s, t;
int Map[maxn][maxn];
void build_map(int Maxdist_min)
{
    init(n);//每次构建容量网络清空边
    //超级源点s和所有牛建边，权值为1
    for(int i = k + 1; i <= n; i++)addedge(s, i, 1);
    //所有挤奶机和超级汇点建边，权值为m（也就是一台挤奶机可供牛的最大数目）
    for(int i = 1; i <= k; i++)addedge(i, t, m);
    for(int i = k + 1; i <= n; i++)//牛的编号，后c个
    {
        for(int j = 1; j <= k; j++)//挤奶机编号，前k个
        {
            if(Map[i][j] <= Maxdist_min)//小于最大距离，那么可以直达
                addedge(i, j, 1);//牛和挤奶机可以配对
        }
    }
}
int main()
{
    cin >> k >> c >> m;
    n = k + c;
    for(int i = 1; i <= n; i++)//前k个点为挤奶机，后c个点为牛
    {
        for(int j = 1; j <= n; j++)
        {
            cin >> Map[i][j];
            if(Map[i][j] == 0)Map[i][j] = INF;
        }
    }
    //Floyd求最短路
    for(int k = 1; k <= n; k++)
    {
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                Map[i][j] = min(Map[i][j], Map[i][k] + Map[k][j]);
            }
        }
    }
    int l = 0, r = 10000, mid;//此处最大距离不能是200，题目说的200只是一条边，可能要走很多条边
    s = 0, t = n + 1;
    while(l < r)
    {
        mid = (l + r) / 2;
        //cout<<mid<<endl;
        build_map(mid);
        if(Maxflow(s, t) >= c)//说明所有的牛已经到达，最大距离可以更小
            r = mid;
        else l = mid + 1;
    }
    cout<<r<<endl;//最大距离最小,这里的最大距离是r不是mid，因为最后一次循环的时候可能只更新mid和l，没有更新r
}