POJ 2112 Optimal Milking 最优挤奶方案 Floyd算法+二分查找+最大流

最新推荐文章于 2021-10-25 10:51:11 发布
最新推荐文章于 2021-10-25 10:51:11 发布
阅读量7.5k 收藏
点赞数
分类专栏： 图论 ISAP EK POJ 网络流 Dinic
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011439796/article/details/39538971
版权
图论 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
POJ
17 篇文章 0 订阅
订阅专栏
网络流
7 篇文章 0 订阅
订阅专栏

题目链接：POJ 2112 Optimal Milking

Optimal Milking
Time Limit: 2000MS Memory Limit: 30000K
Total Submissions: 12446 Accepted: 4494
Case Time Limit: 1000MS

Description

FJ has moved his K (1 <= K <= 30) milking machines out into the cow pastures among the C (1 <= C <= 200) cows. A set of paths of various lengths runs among the cows and the milking machines. The milking machine locations are named by ID numbers 1..K; the cow locations are named by ID numbers K+1..K+C. 

Each milking point can "process" at most M (1 <= M <= 15) cows each day. 

Write a program to find an assignment for each cow to some milking machine so that the distance the furthest-walking cow travels is minimized (and, of course, the milking machines are not overutilized). At least one legal assignment is possible for all input data sets. Cows can traverse several paths on the way to their milking machine. 

Input

* Line 1: A single line with three space-separated integers: K, C, and M. 

* Lines 2.. ...: Each of these K+C lines of K+C space-separated integers describes the distances between pairs of various entities. The input forms a symmetric matrix. Line 2 tells the distances from milking machine 1 to each of the other entities; line 3 tells the distances from machine 2 to each of the other entities, and so on. Distances of entities directly connected by a path are positive integers no larger than 200. Entities not directly connected by a path have a distance of 0. The distance from an entity to itself (i.e., all numbers on the diagonal) is also given as 0. To keep the input lines of reasonable length, when K+C > 15, a row is broken into successive lines of 15 numbers and a potentially shorter line to finish up a row. Each new row begins on its own line. 

Output

A single line with a single integer that is the minimum possible total distance for the furthest walking cow. 

Sample Input

2 3 2
0 3 2 1 1
3 0 3 2 0
2 3 0 1 0
1 2 1 0 2
1 0 0 2 0

Sample Output

2

Source

USACO 2003 U S Open

题意：

K个挤奶器（编号1~K），每个每天最多挤M头奶牛。共有C头奶牛（编号K+1~K+C）。挤奶器和奶牛间有不同长度的路。

编写程序，寻找一个方案，安排每头牛到某个挤奶器挤奶，并使得C头奶牛需要走的所有路程的最大路程最小。

分析：

因为有多个挤奶器和多头奶牛，因而要求最短路需要Floyd。然后用最大流算法求解；搜索最大距离的最小值采用二分枚举。

关键问题是构图：

构图思路：

（1）以0为源点s，n+1为汇点t。

（2）s向每头奶牛引一条边，容量为1，代表s走向每头奶牛的最大奶牛数。

（3）每个挤奶器向t引一条边，容量为M，代表每个挤奶器最多向t走M头奶牛。

（4）对于每头奶牛通向每个挤奶器的最短路，如果小于枚举当前距离，说明能够走到，那么从奶牛到挤奶器引一条边，容量为1。

（5）构图完毕。

最大流：

最大流可以用三种方法实现：

（1）EK，普通的SAP算法，因要不断BFS，复杂度较高：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

#define maxn 1010
#define INF 0x3f3f3f3f
int s, t, n, K, C, M;
int a[maxn], pre[maxn];
int flow[maxn][maxn];
int cap[maxn][maxn], mp[maxn][maxn];

int EK()
{
    queue<int> q;
    memset(flow, 0, sizeof(flow));
    int ans = 0;
    while(1)
    {
        memset(a, 0, sizeof(a));
        a[s] = INF;
        q.push(s);
        while(!q.empty())   //bfs找增广路径
        {
            int u = q.front();
            q.pop();
            for(int v = 1; v <= n; v++)
                if(!a[v] && cap[u][v] > flow[u][v])
                {
                    pre[v] = u;
                    q.push(v);
                    a[v] = min(a[u], cap[u][v]-flow[u][v]);
                }
        }
        if(a[t] == 0) break;
        for(int u = t; u != s; u = pre[u])  //改进网络流
        {
            flow[pre[u]][u] += a[t];
            flow[u][pre[u]] -= a[t];
        }
        ans += a[t];
    }
    return ans;
}
void Floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++) {
            if(mp[i][k] != INF)
                for(int j = 1; j <= n; j++)
                    mp[i][j] = min(mp[i][j], mp[i][k]+mp[k][j]);
        }
}
void build(int mid)
{
    n = K+C;
    memset(cap, 0, sizeof(cap));
    for(int i = K+1; i <= n; i++)
        cap[s][i] = 1;
    for(int i = 1; i <= K; i++)
        cap[i][t] = M;
    for(int i = K+1; i <= n; i++)
        for(int j = 1; j <= K; j++)
            if(mp[i][j] <= mid)
                cap[i][j] = 1;
    n = K+C+2;
}
void Solve()
{
    s = 0, t = n+1;
    int l = 0, r = 10000;
    while(l < r)
    {
        int mid = (l+r)/2;
        build(mid);
        int ans = EK();
        if(ans >= C) r = mid;
        else l = mid+1;
    }
    printf("%d\n", r);
}
int main()
{
    //freopen("poj_2112.txt", "r", stdin);
    while(~scanf("%d%d%d", &K, &C, &M)) {
        n = K+C;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++) {
                scanf("%d", &mp[i][j]);
                if(mp[i][j] == 0) mp[i][j] = INF;
            }
    Floyd();
    Solve();
    }
    return 0;
}
（2）Dinic，SAP的一种优化方案，保存层次网络，用DFS增广更加快速。 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

#define maxn 250
#define INF 0x3f3f3f3f

struct Edge
{
    int from, to, cap;
};

vector<Edge> EG;
vector<int> G[maxn];
int n, s, t, d[maxn], cur[maxn], mp[maxn][maxn];
int K, C, M;
void addEdge(int from, int to, int cap)
{
    EG.push_back((Edge){from, to, cap});
    EG.push_back((Edge){to, from, 0});
    int x = EG.size();
    G[from].push_back(x-2);
    G[to].push_back(x-1);
}

bool bfs()
{
    memset(d, -1, sizeof(d));
    queue<int> q;
    q.push(s);
    d[s] = 0;
    while(!q.empty())
    {
        int x = q.front();
        q.pop();
        for(int i = 0; i < G[x].size(); i++)
        {
            Edge& e = EG[G[x][i]];
            if(d[e.to] == -1 && e.cap > 0)
            {
                d[e.to] = d[x]+1;
                q.push(e.to);
            }
        }
    }
    return (d[t]!=-1);
}

int dfs(int x, int a)
{
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++)
    {
        Edge& e = EG[G[x][i]];
        if(d[x]+1 == d[e.to] && (f = dfs(e.to, min(a, e.cap))) > 0)
        {
            e.cap -= f;
            EG[G[x][i]^1].cap += f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}
int Dinic()
{
    int ans = 0;
    while(bfs())
    {
        memset(cur, 0, sizeof(cur));
        ans += dfs(s, INF);
    }
    EG.clear();
    for(int i = 0; i < n; ++i)
        G[i].clear();
    return ans;
}
void Floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++) {
            if(mp[i][k] != INF)
                for(int j = 1; j <= n; j++)
                    mp[i][j] = min(mp[i][j], mp[i][k]+mp[k][j]);
        }
}
void build(int mid)
{
    n = K+C;
    for(int i = K+1; i <= n; i++)
        addEdge(s, i, 1);
    for(int i = 1; i <= K; i++)
        addEdge(i, t, M);
    for(int i = K+1; i <= n; i++)
        for(int j = 1; j <= K; j++)
            if(mp[i][j] <= mid)
                addEdge(i, j, 1);
    n = K+C+2;
}
void Solve()
{
    s = 0, t = n+1;
    int l = 0, r = 10000;
    while(l < r)
    {
        int mid = (l+r)/2;
        build(mid);
        int ans = Dinic();
        if(ans >= C) r = mid;
        else l = mid+1;
    }
    printf("%d\n", r);
}
int main()
{
    //freopen("poj_2112.txt", "r", stdin);
    while(~scanf("%d%d%d", &K, &C, &M)) {
        n = K+C;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++) {
                scanf("%d", &mp[i][j]);
                if(mp[i][j] == 0) mp[i][j] = INF;
            }
    Floyd();
    Solve();
    }
    return 0;
}
（3）ISAP，改进SAP，更加优化，活用层次网络，只需要一遍BFS，然后进行增广。 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;

#define maxn 250
#define INF 0x3f3f3f3f

struct Edge
{
    int from, to, cap, flow;
};

vector<Edge> EG;
vector<int> G[maxn];
int n, s, t, d[maxn], cur[maxn], p[maxn], num[maxn], mp[maxn][maxn];
bool vis[maxn];
int K, C, M;

void addEdge(int from, int to, int cap)
{
    EG.push_back((Edge){from, to, cap, 0});
    EG.push_back((Edge){to, from, 0, 0});
    int x = EG.size();
    G[from].push_back(x-2);
    G[to].push_back(x-1);
}

void bfs()
{
    memset(vis, false, sizeof(vis));
    queue<int> q;
    vis[t] = true;
    d[t] = 0;
    q.push(t);
    while(!q.empty()) {
        int x = q.front();
        q.pop();
        for(int i = 0; i < G[x].size(); i++) {
            Edge& e = EG[G[x][i]^1];
            if(!vis[e.from] && e.cap > e.flow) {
                vis[e.from] = true;
                d[e.from] = d[x]+1;
                q.push(e.from);
            }
        }
    }
}

int augment()
{
    int x = t, a = INF;
    while(x != s) {
        Edge& e = EG[p[x]];
        a = min(a, e.cap-e.flow);
        x = EG[p[x]].from;
    }
    x = t;
    while(x != s) {
        EG[p[x]].flow += a;
        EG[p[x]^1].flow -= a;
        x = EG[p[x]].from;
    }
    return a;
}
int ISAP()
{
    int ans =0;
    bfs();
    memset(num, 0, sizeof(num));
    for(int i = 0; i < n; i++)
        num[d[i]]++;
    int x = s;
    memset(cur, 0, sizeof(cur));
    while(d[s] < n) {
        if(x == t) {
            ans += augment();
            x = s;
        }
        bool flag = false;
        for(int i = cur[x]; i < G[x].size(); i++) {
            Edge& e = EG[G[x][i]];
            if(e.cap > e.flow && d[x] == d[e.to]+1) {
                flag = true;
                p[e.to] = G[x][i];
                cur[x] = i;
                x = e.to;
                break;
            }
        }
        if(!flag) {
            int m = n-1;
            for(int i = 0; i < G[x].size(); i++) {
                Edge& e = EG[G[x][i]];
                if(e.cap > e.flow)
                    m = min(m, d[e.to]);
            }
            if(--num[d[x]] == 0) break;
            num[d[x] = m+1]++;
            cur[x] = 0;
            if(x != s)
                x = EG[p[x]].from;
        }
    }
    EG.clear();
    for(int i = 0; i < n; ++i)
        G[i].clear();
    return ans;
}

void Floyd()
{
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++) {
            if(mp[i][k] != INF)
                for(int j = 1; j <= n; j++)
                    mp[i][j] = min(mp[i][j], mp[i][k]+mp[k][j]);
        }
}
void build(int mid)
{
    n = K+C;
    for(int i = K+1; i <= n; i++)
        addEdge(s, i, 1);
    for(int i = 1; i <= K; i++)
        addEdge(i, t, M);
    for(int i = K+1; i <= n; i++)
        for(int j = 1; j <= K; j++)
            if(mp[i][j] <= mid)
                addEdge(i, j, 1);
    n = K+C+2;
}
void Solve()
{
    s = 0, t = n+1;
    int l = 0, r = 10000;
    while(l < r)
    {
        int mid = (l+r)/2;
        build(mid);
        int ans = ISAP();
        if(ans >= C) r = mid;
        else l = mid+1;
    }
    printf("%d\n", r);
}
int main()
{
    //freopen("poj_2112.txt", "r", stdin);
    while(~scanf("%d%d%d", &K, &C, &M)) {
        n = K+C;
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++) {
                scanf("%d", &mp[i][j]);
                if(mp[i][j] == 0) mp[i][j] = INF;
            }
    Floyd();
    Solve();
    }
    return 0;
}

时间比较：

前两个分别为EK和ISAP算法，后面的为Dinic。不知为何我写的ISAP时间要比Dinic总是慢那么一点点，不过能顺利过题目就好了。

可以看出EK效率多差了吧：

Run IDUserProblemResultMemoryTimeLanguageCode LengthSubmit Time
13475128xxx2112Accepted9584K1875MSG++2266B2014-09-25 02:39:13
13475120xxx2112Accepted1328K157MSG++3678B2014-09-25 02:35:15
13475117xxx2112Accepted1236K125MSG++2812B2014-09-25 02:33:48
13475113xxx2112Accepted1236K141MSG++2814B2014-09-25 02:33:09
13475102xxx2112Accepted1236K94MSG++2814B2014-09-25 02:26:43

I_Array
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法实验（二分+中位数-9-11题）1
08-03
分治+中位数第 9 题：poj1723 SOLDIERSN soldiers of the land Gridland are randomly scatter
Milking Cows
weixin_30246221的博客
04-01 196
Description 三个农民每天清晨5点起床，然后去牛棚给3头牛挤奶。第一个农民在300时刻(从5点开始计时，秒为单位)给他的牛挤奶，一直到1000时刻。第二个农民在700时刻开始，在 1200时刻结束。第三个农民在1500时刻开始2100时刻结束。期间最长的至少有一个农民在挤奶的连续时间为900秒(从300时刻到1200时刻)，而最长的无人挤奶的连续时间(从挤奶开始一直到...
USACO1.2 挤牛奶Milking Cows
闲人请进
02-04 5137
挤牛奶 题目描述 三个农民每天清晨5点起床，然后去牛棚给3头牛挤奶。第一个农民在300秒(从5点开始计时)给他的牛挤奶，一直到1000秒。第二个农民在700秒开始，在 1200秒结束。第三个农民在1500秒开始2100秒结束。期间最长的至少有一个农民在挤奶的连续时间为900秒(从300秒到1200秒)，而最长的无人挤奶的连续时间(从挤奶开始一直到挤奶结束)为300秒(从1200
poj2112Optimal Milking(最优秀的挤奶方案)——floyd+最大流+二分
fsdcyr
02-11 2790
http://poj.org/problem?id=2112题目描述： 农场主John 将他的K(1≤K≤30)个挤奶器运到牧场，在那里有C(1≤C≤200)头奶牛，在奶 牛和挤奶器之间有一组不同长度的路。K个挤奶器的位置用1～K的编号标明，奶牛的位置用K+1～ K+C 的编号标明。 每台挤奶器每天最多能为M(1≤M≤15)头奶牛挤奶。 编写程序，寻找一个方案，安排每头奶牛到某个挤奶器挤奶
POJ 3616 奶牛挤奶
dicuan6029的博客
04-26 423
Milking Time 贝茜是一个勤劳的牛。事实上，她如此​​专注于最大化她的生产力，于是她决定安排下一个N（1≤N≤1,000,000）小时（方便地标记为0..N-1），以便她生产尽可能多的牛奶。 农民约翰有一个M（1≤M≤1,000）可能重叠的间隔列表，他可以在那里进行挤奶。每个区间我有一个起始小时（0≤starting_houri≤N），一个结束小时（starting_hou...
luogu P2852 [USACO06DEC]牛奶模式Milk Patterns
ehdhg13455的博客
08-28 9264
指针又一次被我写挂了。。（一定要记得循环出去后一定得更新一下答案） #include <bits/stdc++.h> using namespace std; typedef long long LL; typedef int lint; const lint maxn = 20005; const lint log_maxn = 20; typedef int lint; str...
POJ3308-Paratroopers 【Dinic算法求最大流】
09-17
【二分图顶点覆盖->最小割->最大流->Dinic算法求解】 解题报告+AC代码 http://hi.csdn.net/!s/WKVPR0 ----> 我的所有POJ解题报告 http://blog.csdn.net/lyy289065406/article/details/6642573
POJ算法题目分类
04-04
POJ题目分类，列出了所有的类目，里面写了一些很好的框架。
poj算法题目实现.zip_algorithm_arrangement4hv_conditionyis_poj problems
09-15
解决算法问题 poj1082, poj1150, poj1180, poj1201, poj1222，代码完成所给题目要求。
POJ分类题（按照算法分类）
08-02
分类很好，我自己也在做，我不是为了赚积分，只是为了分享给大家，2个积分，很便宜～
USACO题目Milking Cows及代码解析
10-23
USACO题目Milking Cows及代码解析
java P1204 [USACO1.2]挤牛奶Milking Cows
热门推荐
qq_43457125的博客
05-14 3万+
题目描述 三个农民每天清晨 5 点起床，然后去牛棚给三头牛挤奶。 第一个农民在 300 秒 (从 5 点开始计时) 给他的牛挤奶，一直到 1000 秒。第二个农民在 700 秒开始，在 1200 秒结束。第三个农民在 1500 秒开始2100 秒结束。 期间最长的至少有一个农民在挤奶的连续时间为 900 秒 (从 300 秒到 1200 秒)，而最长的无人挤奶的连续时间(从挤奶开始一直到挤奶结束)为 300 秒 (从 1200 秒到 1500 秒)。 你的任务是编一个程序，读入一个有 n 个农民挤 n 头牛
poj 2112(二分+网络流)
weixin_30783629的博客
06-03 79
Optimal Milking Time Limit: 2000MS Memory Limit: 30000K Total Submissions: 15749 Accepted: 5617 Case Time Limit: 1000MS Description FJ has moved his K (1 <= K &...
POJ -2112（二分多重匹配）
Soul
09-01 353
题意:给你K台机器，C头牛，每台机器最多承受M头牛，然后k+C行表示机器到牛的距离，牛到机器的距离，如果距离是0的话表示这两个点道路不存在，要求所有牛到机器中的距离最大值最小 题解:Floyd一下K+C个点之间所有的最短距离,最后距离二分一下，然后就是二分多重匹配在距离的限制下是否可以都匹配成功 #include #include #include #include using namespa
poj2112（floyd+二分+二分图多重匹配）
gronkie的博客
10-25 185
（感觉是一个比较基础的二分图多重匹配） 题目意思大概就是有K个挤奶点，C个奶牛，一个挤奶点能容下M个奶牛，问如果所有奶牛都被放入挤奶点时，距离最远奶牛得最短距离（距离可以经过其他点） 首先看到可以经过其他点，就直接无脑用floyd，求出各个点之间得最短距离 然后要求的是最远距离最短情况，用二分求解 （注意：二分的范围需要考虑清楚，并不是200，因为可能要经过别的路到达，所以应该设大点，200*200能过，实在不放心，10的九次方也能过） 最后就是二分判断条件，即二分图多重匹配，用一个match数组存储C匹配
POJ 2112（二分，最大流）
qq_45863710的博客
08-06 304
POJ2112 题目链接 题意就是c头牛要去往k头奶牛工厂，每个奶牛工厂的承重是m头牛。然后告诉我们每两个点的距离。然后算出在每头奶牛都到达一个奶牛工厂的情况下，行走距离最长的奶牛的最短的情况是多少。那其实一开始的思路是比较明显的，要算最短的最长距离，怎么走路也没限制，那肯定每头牛都走最短路。那就首先用floyd算出任意两点的最短路。然后再把奶牛到工厂的路挑出来保存一下，答案就在这其中的一条了。我们可以对奶牛到工厂的路排序，因为我们要答案尽量小，那我们只要二分下标（二分答案也一样的道理），让mid代表假定的
poj2112,最大流,最优挤奶方案
Beyyes
05-29 1355
按图论列表上来说是基础题。 这道题是省赛之前过的，现在想再拿出来总结一下，感觉这个类型的题很经典。 题意不叙述了，就是有奶牛和机器，每台奶牛分配一个机器， 牛与牛、牛与机器、机器与机器之间都有一距离，求分配后的最大距离的最小值。 一开始没明白啥叫“最大距离的最小值”，就是C头奶牛、K个挤奶器，C头奶牛若想到全部的挤奶器那里去需要一定的距离， C头奶牛当中某一头奶牛需要走的
[USACO13DEC]最优挤奶Optimal Milking（zkw写法）
mk703的博客
02-25 381
USACO 2013 dec optimal milking
poj2366C语言二分查找
最新发布
11-21
下面是一个使用C语言二分查找的例子： ```c #include #include #include using namespace std; int a[50005]; int main() { int n, m, k, flag = 0; scanf("%d", &n); for (int i = 0; i ; i++) { scanf...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值