N

题意：有K太挤奶机，C头奶牛，每个挤奶机每天只能为M头奶牛服务，下面给的K+C的矩阵，是形容相互之间的距离，求出来走最远的那头奶牛要走多远

分析：应该先使用floyd求出来点之间的最短路？？（不晓得给的图是不是最短路的），二分出来最短的路径。先做做看吧。

注意：分析的没有错误，确实是这么做的，矩阵的前K行是机械到机械和奶牛的距离，后C行是奶牛到机械和奶牛的距离，0代表两点间没有路，应该置为INF，二分的时候R应该值为INF，最短的200是直接距离，有些地方是直接到达不了的。ps：二分匹配确实很快

*************************************************************************

#include<stdio.h>
#include<string.h>
#include<vector>
using namespace std;

const int MAXN = 305;
const int oo = 1e9+7;

int G[MAXN][MAXN], N, K, C, M;
bool used[MAXN];
struct Link{int link[MAXN], len;}Ly[MAXN];

void Floyd()
{
    for(int k=1; k<=N; k++)
    for(int i=1; i<=N; i++)
    for(int j=1; j<=N; j++)
        G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
}
bool Find(int i, int Mid)
{
    for(int j=1; j<=K; j++)
    {
        if( G[i][j] <= Mid && !used[j] )
        {
            used[j] = true;

            if( Ly[j].len < M )
            {
                Ly[j].link[ Ly[j].len++ ] = i;
                return true;
            }
            for(int k=0; k<Ly[j].len; k++)
            {
                if( Find( Ly[j].link[k], Mid ) == true )
                {
                    Ly[j].link[k] = i;
                    return true;
                }
            }
        }
    }

    return false;
}
bool XYL(int Mid)
{
    memset(Ly, false, sizeof(Ly));

    for(int i=K+1; i<=N; i++)
    {
        memset(used, false, sizeof(used));
        if( Find(i, Mid) == false )
            return false;
    }

    return true;
}

int main()
{
    while(scanf("%d%d%d", &K, &C, &M) != EOF)
    {
        int i, j; N = K+C;

        for(i=1; i<=N; i++)
        for(j=1; j<=N; j++)
        {
            scanf("%d", &G[i][j]);
            if(i != j && !G[i][j])
                G[i][j] = oo;
        }

        Floyd();

        int L=0, R=oo, ans;

        while(L <= R)
        {
            int Mid = (L+R)>>1;

            if( XYL( Mid ) == true )
                R = Mid - 1, ans = Mid;
            else
                L = Mid + 1;
        }

        printf("%d
", ans);
    }

    return 0; 

}