POJ 2112 Optimal Milking

大意：给定一些挤奶器以及牛牛们，试寻找一个方案，安排每头奶牛到某个挤奶器挤奶，并使得C头奶牛需要走的所有路程中的最大路程最小。

思路：这道题我前前后后思考了几天，由于我刚接触网络流，我建模的能力实在是太弱了，主要不知道网络流在哪里用得到？为什么要用网络流来求解，后来才知道原来网络流是用来求解一个方案是否可行的，总结一下大概这么几点。

1、本题要求C头奶牛需要走的最大距离的最小值，以前有一道类似的题，不过是一头奶牛，通过二分枚举来判断最大值，而这里是多头奶牛，而怎么去联系起来呢？我们可以通过二分枚举最大距离，建立一个超级源点、汇点，源点与牛牛们的容量为1，牛牛与挤奶器之间的容量为M，挤奶器与汇点之间的容量为INF即可，做一次网络流，如果流的容量大于C的话，说明最大距离偏大了，因为在这个最大距离之内，可以到达挤奶器的牛牛们有很多，反之，偏小了。

2、那我们怎么枚举最大距离去建图呢？题目有一个隐藏条件，就是牛牛可以通过一个挤奶器到达另一个挤奶器，并且最小距离不一定是直接相连的那条边，可以有中间点，于是可以做一次FLoyd即可。

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <string>
using namespace std;

const int MAXN = 1010;
const int MAXM = 50100;
const int INF = 0x3f3f3f3f;

struct Edge
{
	int v, next, f;
}edge[MAXM];

int k, c, m;
int n;

int cnt;
int first[MAXN], level[MAXN];
int d[MAXN][MAXN];
int q[MAXN];

void init()
{
	cnt = 0;
	memset(first, -1, sizeof(first));
}

void init_flow()
{
	for(int i = 0; i < cnt; i += 2)
	{
		edge[i].f += edge[i^1].f;
		edge[i^1].f = 0;
	}
}

void Floyd()
{
	for(int k = 1; k <= n; k++)
	for(int i = 1; i <= n; i++) if(d[i][k] != INF)
	{
		for(int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
	}
}

void read_graph(int u, int v, int f)  
{  
    edge[cnt].v = v, edge[cnt].f = f;  
    edge[cnt].next = first[u], first[u] = cnt++;  
    edge[cnt].v = u, edge[cnt].f = 0;
    edge[cnt].next = first[v], first[v] = cnt++;  
}  
  
int bfs(int s, int t)  
{  
    memset(level, 0, sizeof(level));  
    level[s] = 1;  
    int front = 0, rear = 1;  
    q[front] = s;
    while(front < rear)  
    {  
        int x = q[front++];  
        if(x == t) return 1;  
        for(int e = first[x]; e != -1; e = edge[e].next)  
        {  
            int v = edge[e].v, f = edge[e].f;  
            if(!level[v] && f)  
            {  
                level[v] = level[x] + 1;  
                q[rear++] = v;  
            }  
        }  
    }  
    return 0;  
}  
  
int dfs(int u, int maxf, int t)  
{  
    if(u == t) return maxf;  
    int ret = 0;  
    for(int e = first[u]; e != -1; e = edge[e].next)  
    {  
        int v = edge[e].v, f = edge[e].f;  
        if(level[u] + 1 == level[v] && f)  
        {  
            int Min = min(maxf-ret, f);  
            f = dfs(v, Min, t);  
            edge[e].f -= f;  
            edge[e^1].f += f;  
            ret += f;  
            if(ret == maxf) return ret;  
        }  
    }  
    return ret;  
}  

int Dinic(int s, int t)
{  
    int ans = 0;  
    while(bfs(s, t)) ans += dfs(s, INF, t);  
    return ans;  
}

void read_case()
{
	n = k+c;
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
		{
			scanf("%d", &d[i][j]);
			if(d[i][j] == 0) d[i][j] = INF;
		}
	}
	Floyd();
}

void build(int mid)
{
	init();
	for(int i = k+1; i <= n; i++) read_graph(0, i, 1);
	for(int i = 1; i <= k; i++) read_graph(i, n+1, m);
	for(int i = k+1; i <= n; i++)
	{
		for(int j = 1; j <= k; j++)
		{
			if(d[i][j] <= mid) read_graph(i, j, INF);
		}
	}
}

void solve()
{
	init();
	read_case();
	int x = 0, y = 10000;
	while(x <= y)
	{
		int mid = x+(y-x)/2;
		build(mid);
		int ans = Dinic(0, n+1);
		if(ans >= c) y = mid-1; //偏大 
		else x = mid+1; //偏小 
	}
	printf("%d\n", x);
}

int main()
{
	while(~scanf("%d%d%d", &k, &c, &m))
	{
		solve();
	}
	return 0;
}