POJ 2112 Optimal Milking 二分图多重匹配 网络流+Floyd+二分

超级经典的一道题目。。二分图多重匹配 网络流+Floyd+二分，这几个部分最近我都在做，竟然组合在一起了。。竟然1A 了，好开心

由于牛可以再牛的位置和牛奶机的位置来回走，所以先用Floyd预处理出任意牛的位置到任意奶牛机的位置的最短距离。然后二分处理，对于某个最大距离，统计出有多少头牛可以走到：用最大流处理，在每条d<枚举值的边建一条容量为1的边，超级源点与每头牛连一条容量为1 的边，每个奶牛机与超级汇点连一条容量为m的边（多重匹配都可以这么做吧），然后就是用Dinic算法求最大流了。

//Memory: 1224K		Time: 141MS
#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;

const int maxk = 30;
const int maxc = 200;
const int maxm = 15;
const int inf = 0x7fffffff;
int d[maxk+maxc+5][maxk+maxc+5];

struct edge{
    int to, cap, flow;
    edge(int to, int cap, int flow) :
        to(to), cap(cap), flow(flow) {}
};

const int maxv = maxk + maxc;
vector<int> G[maxv+5];
vector<edge> es;
int level[maxv+5];
int iter[maxv+5];
int k, c, m;

void Floyd(){
    int v = k+c;
    for(int k=0; k<=v+1; k++){
        for(int i=0; i<=v+1; i++){
            if(d[i][k] != inf)
            for(int j=0; j<=v+1; j++){
                if(d[k][j] != inf)
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

inline void AddEdge(int from, int to, int cap){
    es.push_back(edge(to, cap, 0));
    G[from].push_back(es.size() - 1);
    es.push_back(edge(from, 0, 0));
    G[to].push_back(es.size() - 1);
}

void bfs(int s){
    memset(level, -1, sizeof(level));
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while(!que.empty()){
        int v = que.front(); que.pop();
        for(int i=0; i<G[v].size(); i++){
            edge& e = es[G[v][i]];
            if(e.flow < e.cap && level[e.to] < 0){
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int rem){
    if(v == t) return rem;
    for(int& i=iter[v]; i<G[v].size(); i++){
        edge& e = es[G[v][i]];
        if(e.flow < e.cap && level[v] < level[e.to]){
            int d = dfs(e.to, t, min(rem, e.cap - e.flow));
            if(d > 0){
                e.flow += d;
                es[G[v][i]^1].flow -= d;
                return d;
            }
        }
    }
    return 0;
}

int MaxFlow(int s, int t){
    int flow = 0;
    while(true){
        bfs(s);
        if(level[t] < 0) return flow;
        memset(iter, 0, sizeof(iter));
        int f;
        while((f = dfs(s, t, inf)) > 0){
            flow += f;
        }
    }
}

int main(){
    while(~scanf("%d%d%d", &k, &c, &m)){
        for(int i=0; i<c+k+5; i++)
            for(int j=0; j<c+k+5; j++){
                if(i == j) d[i][j] = 0;
                else d[i][j] = inf;
            }
        for(int i=1; i<=k+c; i++)
        for(int j=1; j<=k+c; j++){
            int dis; scanf("%d", &dis);
            if(dis != 0) d[i][j] = dis;
        }
        Floyd();
        int l = 0, r = 60000;
        while(l < r){
            int mid = (l+r)>>1;
            for(int i=1; i<=k; i++)
                AddEdge(i, k+c+1, m);
            for(int i=k+1; i<=k+c; i++)
                AddEdge(0, i, 1);
            for(int i=1; i<=k; i++)
            for(int j=k+1; j<=k+c; j++){
                if(d[i][j] <= mid) AddEdge(j, i, 1);
            }
            int res = MaxFlow(0, k+c+1);
            if(res >= c) r = mid;
            else l = mid + 1;
            for(int i=0; i<c+k+5; i++) G[i].clear();
            es.clear();
        }
        printf("%d\n", l);
    }
    return 0;
}