poj 2112 最大流+二分法

最新推荐文章于 2018-08-02 15:25:11 发布

nielaishan

最新推荐文章于 2018-08-02 15:25:11 发布

阅读量258

点赞数

分类专栏： ACM 文章标签： c语言 poj 算法

本文链接：https://blog.csdn.net/NLSQQ/article/details/52043510

版权

ACM 专栏收录该内容

62 篇文章 0 订阅

订阅专栏

博客介绍了如何利用Floyd算法和二分查找法解决POJ 2112题目，即最小化C头牛到达挤奶器的最大路程。首先计算奶牛到所有挤奶器的最短距离，接着通过二分法确定最大距离限制，每次二分后重新构建图，包括超级源点和超级汇点，并应用最大流算法进行匹配。

摘要由CSDN通过智能技术生成

链接

http://poj.org/problem?id=2112

题意

安排C头牛到某个挤奶器，使得每头牛需要走的路程中最大路程的距离最小。

解析

先用floyd算法，求出奶牛到每个挤奶器的最短距离，然后从最大的距离二分，当此距离可以使C头牛，匹配成功，就让右区间r=mid;若不成功，就让左区间l=mid;之后继续二分。每次二分后，都要重新建图，另外加超级源点s和超级汇点t，让每头牛与汇点建边，容量为1，每个挤奶器与源点建边，容量为M，挤奶器与奶牛的距离<=mid，就建容量为1的边。之后用最大流算法，即可。

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include<queue>
#include <algorithm>
#include <map>
#include <set>
using namespace std;
const int maxn = 500+10;
const int inf = 0x3f3f3f3f;
int dis[maxn][maxn];
int level[maxn];
int n, K, C, M;
struct node {
    int t;
    int v;
    int next;
}edge[maxn*maxn];
int head[maxn];
int cnt=0;
void init() {
    cnt = 0;
    memset(head, -1, sizeof(head));
}

void add(int u, int v, int c) {
    edge[cnt].t = v;
    edge[cnt].v = c;
    edge[cnt].next = head[u];
    head[u] = cnt;
    cnt++;
    edge[cnt].t = u;
    edge[cnt].v = 0;
    edge[cnt].next = head[v];
    head[v] = cnt;
    cnt++;
}

void build(int Dis) {
    int s = 0;
    int t = n+1;
    init();
    for (int i=K+1; i<=n; i++)
        add(i, t, 1);
    for (int i=1; i<=K; i++)
        add(s, i, M);
    for (int i=1; i<=K; i++) {
        for (int j=K+1; j<=n; j++)
            if (dis[i][j] <= Dis)
                add(i, j, 1);
    }
}

bool bfs() {
    int q[maxn], front=0, tail = 0;
    memset(level, -1, sizeof(level));
    level[0] = 1;
    q[tail++] = 0;
    while (tail > front) {
        int u = q[front];
        front++;
        if (u == n+1)
            return true;
        for (int i=head[u]; i!=-1; i=edge[i].next) {
            int v = edge[i].t;
            if (level[v] == -1 && edge[i].v) {
                level[v] = level[u]+1;
                q[tail++] = v;;
            }
        }
    }
    return false;
}

int dfs(int u, int minf) {  // 增广多条路
    if (u == n+1)
        return minf;
    int ret  = 0;   //记录所有增广路的流量和
    for (int i=head[u]; i!=-1; i=edge[i].next) {
        int v = edge[i].t, f;
        if (level[v] == level[u]+1 && edge[i].v) {
            int Min = min(minf-ret, edge[i].v);
            f = dfs(v, Min);
            edge[i].v -= f;
            edge[i^1].v += f;
            ret += f;
            if (ret == minf)
                return ret;
        }
    }
    return ret;
}


int dinic() {
    int flow = 0;
    while (bfs())
    flow += dfs(0, inf);
    return flow;
}

int main()
{
    while (scanf("%d%d%d", &K, &C, &M)!=EOF) {
        n = K+C;
        for (int i=1; i<=n; i++) {
            for (int j=1; j<=n; j++) 
            {
                scanf("%d", &dis[i][j]);
                if (dis[i][j] == 0)
                    dis[i][j] = inf;
            }
        }
        for (int k=1; k<=n; k++) {
            for (int i=1; i<=n; i++) {
                    for (int j=1; j<=n; j++)
                        dis[i][j] = min(dis[i][j], dis[i][k]+dis[k][j]);
            }
        }
        int l=0, r=300*n;
        int ans=0;
        while (r-l > 1) {
            int mid = (l+r)/2;
            build(mid);
            int F;
            F = dinic();
            if (F >= C) {
                r = mid;
                ans = mid;
            }
            else
                l = mid;
        }
        printf("%d\n", ans);
    }
    return 0;
}