POJ 2112 —— Optimal Milking 二分+Floyd+最大流

原题：http://poj.org/problem?id=2112

#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<vector>
#include<algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int maxn = 250;
int dis[maxn][maxn];
int k, c, m;
int num_nodes;

struct Edge
{
    int from, to, flow, cap;
}edge[maxn*maxn*2];  

vector<int>G[maxn];
int edgenum;
void add(int u, int v, int c)
{
    edge[edgenum].from = u;
    edge[edgenum].to = v;
    edge[edgenum].flow = 0;
    edge[edgenum].cap = c;
    edgenum++;  

    edge[edgenum].from = v;
    edge[edgenum].to = u;
    edge[edgenum].flow = 0;
    edge[edgenum].cap = 0;
    edgenum++;  

    G[u].push_back(edgenum-2);
    G[v].push_back(edgenum-1);
}  

int deep[maxn];
bool vis[maxn];
void BFS(int s, int t)
{
    queue<int>Q;
    memset(vis, false, sizeof vis);
    Q.push(t);
    vis[t] = true;
    deep[t] = 0;
    while(!Q.empty())
    {
        int now = Q.front();
        Q.pop();
        for(int i = 0;i<(int)G[now].size();i++)
        {
            int v = edge[G[now][i]].to;
            if(!vis[v])
			{
                deep[v] = deep[now] + 1;
                vis[v] = true;
                Q.push(v);
            }
        }
    }
}  

int gap[maxn];
int cur[maxn];
int front[maxn];
int Augment(int s, int t)
{
    int minflow = inf;
    int begin = t;
    while(begin != s)
    {
        Edge& e = edge[front[begin]];
        minflow = min(minflow, e.cap - e.flow);
        begin = e.from;
    }  

    begin = t;
    while(begin != s)
    {
        edge[front[begin]].flow += minflow;
        edge[front[begin]^1].flow -= minflow;
        begin = edge[front[begin]].from;
    }
    return minflow;
}  

int Maxflow(int s, int t)
{
    int flow = 0;
    BFS(s, t);
    memset(gap, 0, sizeof gap);
    memset(cur, 0, sizeof cur);
    for(int i = 0;i<num_nodes;i++)  gap[deep[i]]++;
    int begin = s;
    while(deep[s] < num_nodes)
    {
        if(begin == t)
		{
            flow += Augment(s, t);
            begin = s;
        }  

        bool flag = false;
        for(int i = cur[begin];i<(int)G[begin].size();i++)
        {
            Edge& e = edge[G[begin][i]];
            if(e.cap > e.flow && deep[begin] == deep[e.to] + 1)
			{
                front[e.to] = G[begin][i];
                cur[begin] = i;
                flag = true;
                begin = e.to;
                break;
            }
        }  

        if(!flag)
        {
            int k = num_nodes-1;
            for(int i = 0;i<(int)G[begin].size();i++)
			{
                Edge& e = edge[G[begin][i]];
                if(e.cap > e.flow)
                    k = min(k, deep[e.to]);
            }
            if(--gap[deep[begin]] == 0) break;
            gap[deep[begin] = k+1]++;
            cur[begin] = 0;
            if(begin != s)
                begin = edge[front[begin]].from;
        }
    }
    return flow;
}  

void init()
{
    for(int i = 0;i<num_nodes+2;i++) G[i].clear();
    edgenum = 0;
    memset(deep, 0, sizeof deep);
}

void Floyd()
{
	for(int t = 1;t<=k+c;t++)
	{
		for(int i = 1;i<=k+c;i++)
		{
			for(int j = 1;j<=k+c;j++)
			dis[i][j] = min(dis[i][j], dis[i][t]+dis[t][j]);
		}
	}
}

int main()
{
	while(~scanf("%d%d%d", &k, &c, &m))
	{
		for(int i = 1;i<=k+c;i++)
		{
			for(int j = 1;j<=k+c;j++)
			{
				scanf("%d", &dis[i][j]);
				if(i != j && dis[i][j] == 0)
					dis[i][j] = inf;
			}
		}
		Floyd();
		int l = 0, r = 10000;
		int s = 0, t = k+c+1;
		num_nodes = t+1;
		int ans = inf;
		while(l <= r)
		{
			int mid = (l+r)/2;
			init();
			for(int i = k+1;i<=k+c;i++)
			{
				for(int j = 1;j<=k;j++)
				{
					if(dis[i][j] <= mid)
					add(i, j, 1);
				}
			}
			for(int i = k+1;i<=k+c;i++)
				add(s, i, 1);
			for(int i = 1;i<=k;i++)
				add(i, t, m);
			int flow = Maxflow(s, t);
			if(flow != c)
				l = mid + 1;
			else
			{
				ans = min(ans, mid);
				r = mid - 1;
			}
		}
		printf("%d\n", ans);
	}
	return 0;
}