POJ2112题解

题目大意：K个挤奶机，C头牛，每个挤奶机最多可以接待M头牛，各个K，C之间可能有道路连接，要让每个牛都找到挤奶机，求最小的走的路程最远的牛所需走的距离。

思路：首先看到要最小化最大值，所以需要二分。可以先用Floyd算法预处理出个点之间最短距离。之后来进行二分的判断，对于每个牛都要匹配到一个挤奶机，而每个挤奶机可以匹配多头牛，所以可以用二分图匹配，建立源汇点S,T，S与每个牛连一条cap为1的边，而每台挤奶机要与T连一条cap为M的边。对于每个要判断的距离，如果牛-挤奶机之间的距离小于此，就连一条边，否则不连边。之后求最大流即可，如果正好等于C，也就是所有牛都完成匹配，说明判断的这个距离可行。

代码：

//POJ.2112
#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)

typedef long long ll;
#define INF 0x3f3f3f3f
const int maxv = 1010;

int V;
int D[maxv][maxv];

int K, C, M;

struct edge {
	int to, cap, rev;
};

vector<edge> G[maxv];
int level[maxv];
int iter[maxv];

void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge{ to, cap, (int)G[to].size() });
	G[to].push_back(edge{ from, 0, (int)G[from].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 = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}

int dfs(int v, int t, int f)//找增广路
{
	if (v == t)
		return f;
	for (int& i = iter[v]; i < G[v].size(); i++)
	{
		edge& e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			int d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}

	return 0;
}

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

bool E(int f)//看最多仅需f距离是否可行
{
	//S=V,T=V+1
	for (int i = 0; i < V + 2; i++)//最大流建图
		G[i].clear();
	for (int i = 0; i < K; i++)//挤奶-T连边
		add_edge(i, V + 1, M);
	for (int i = K; i < V; i++)//S-牛连边
		add_edge(V, i, 1);
	for (int i = 0; i < K; i++)//牛-挤奶之间，如果最短路小于f，连边容量1，否则不连边（只看《=f的边）
	{
		for (int j = K; j < V; j++)
		{
			if (D[j][i] <= f)
				add_edge(j, i, 1);
		}
	}
	return max_flow(V, V + 1) == C;
}

void FloydWarshell()
{

	for (int k = 0; k < V; k++)
	{
		for (int i = 0; i < V; i++)
		{
			for (int j = 0; j < V; j++)
				D[i][j] = min(D[i][j], D[i][k] + D[k][j]);
		}
	}
}

void solve()
{
	FloydWarshell();
	int lo = 0, hi = 1000 * V;
	while (hi - lo > 1)
	{
		int mi = (lo + hi) / 2;
		if (E(mi))
			hi = mi;
		else
			lo = mi;
	}
	printf("%d\n", hi);
}

int main()
{
	scanf("%d%d%d", &K, &C, &M);
	V = K + C;
	for (int i = 0; i < V; i++)
	{
		for (int j = 0; j < V; j++)
		{
			int d;
			scanf("%d", &d);
			D[i][j] = d ? d : INF;
		}
	}
	solve();

	return 0;
}