[Luogu P2053] [BZOJ 1070] [SCOI2007]修车

最新推荐文章于 2023-12-31 14:58:10 发布

LPA20020220

最新推荐文章于 2023-12-31 14:58:10 发布

阅读量182

点赞数 1

分类专栏：费用流网络流文章标签：费用流网络流

本文链接：https://blog.csdn.net/LPA20020220/article/details/81705193

版权

网络流同时被 2 个专栏收录

32 篇文章 0 订阅

订阅专栏

费用流

14 篇文章 0 订阅

订阅专栏

洛谷传送门

BZOJ传送门

题目描述

同一时刻有 $N$ 位车主带着他们的爱车来到了汽车维修中心。维修中心共有 $M$ 位技术人员，不同的技术人员对不同的车进行维修所用的时间是不同的。现在需要安排这 $M$ 位技术人员所维修的车及顺序，使得顾客平均等待的时间最小。

说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

输入输出格式

输入格式：

第一行有两个数 $M,N$ ，表示技术人员数与顾客数。

接下来 $n$ 行，每行 $m$ 个整数。第 $i+1$ 行第 $j$ 个数表示第 $j$ 位技术人员维修第 $i$ 辆车需要用的时间 $T$ 。

输出格式：

最小平均等待时间，答案精确到小数点后 $2$ 位。

输入输出样例

输入样例#1：

2 2
3 2
1 4

输出样例#1：

1.50

说明

$(2\leq M\leq 9,1\leq N\leq 60), (1\leq T\leq 1000)$

解题分析

对于一个工人，假如他要修的车按顺序排列为 $C_1,C_2,C_3,...,C_k$ ，那么总的等待时间为 $\sum_{i=1}^{k}T_i\times(k-i+1)$ 。

}因此，每个工人可以拆作 $N$ 个点，表示他修第 $k$ 辆车的状态。每辆车向所有的 $N\times M$ 个状态连边，第 $k$ 辆车向第 $i$ 个工人的第 $j$ 个状态的边的流量为 $1$ ，花费为 $j\times T_{ki}$ 。最后一遍费用流即可。

代码如下：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <cstdlib>
#include <queue>
#include <algorithm>
#define R register
#define IN inline
#define gc getchar()
#define W while
#define MX 1005
#define S 0
#define T 1000
#define INF 100000000
#define base 100
template <class TT>
IN void in(TT &x)
{
    x = 0; R char c = gc;
    for (; !isdigit(c); c = gc);
    for (;  isdigit(c); c = gc)
    x = (x << 1) + (x << 3) + c - 48;
}
struct Edge {int to, fl, cost, nex;} edge[500000];
int head[MX], layer[MX], dis[MX], del[MX], pre[MX], mp[15][100];
std::queue <int> q;
bool inq[MX];
int man, cnt = -1, car, ans;
IN void add(R int from, R int to, R int cost, R int fl)
{
    edge[++cnt] = {to, fl, cost, head[from]}, head[from] = cnt;
    edge[++cnt] = {from, 0, -cost, head[to]}, head[to] = cnt;
}
namespace MCMF
{
    IN bool SPFA()
    {
        std::memset(dis, 63, sizeof(dis));
        dis[S] = 0; del[S] = INF; q.push(S);
        R int now;
        W (!q.empty())
        {
            now = q.front(); q.pop();
            for (R int i = head[now]; ~i; i = edge[i].nex)
            {
                if(edge[i].fl > 0 && dis[edge[i].to] > dis[now] + edge[i].cost)
                {
                    dis[edge[i].to] = dis[now] + edge[i].cost;
                    del[edge[i].to] = std::min(edge[i].fl, del[now]);
                    pre[edge[i].to] = i;
                    if(!inq[edge[i].to]) q.push(edge[i].to), inq[edge[i].to] = true;
                }
            }
            inq[now] = false;
        }
        return dis[T] < INF;
    }
    IN void updata()
    {
        ans += dis[T] * del[T];
        R int now = T, pr;
        W (now != S)
        {
            pr = pre[now];
            edge[pr].fl -= del[T];
            edge[pr ^ 1].fl += del[T];
            now = edge[pr ^ 1].to;
        }
    }
    void init() {W (SPFA()) updata();}
}
int main(void)
{
    std::memset(head, -1, sizeof(head));
    in(man), in(car);
    for (R int i = 1; i <= car; ++i) add(S, i, 0, 1);
    for (R int i = 1; i <= car; ++i)
    for (R int j = 1; j <= man; ++j) in(mp[j][i]);
    for (R int i = 1; i <= car; ++i)
    {
        for (R int j = 1; j <= man; ++j)
        {
            for (R int k = 1; k <= car; ++k)
            add(i, base + (j - 1) * car + k, k * mp[j][i], 1);
        }
    }
    for (R int j = 1; j <= man; ++j)
    for (R int k = 1; k <= car; ++k) add(base + (j - 1) * car + k, T, 0, 1);
    MCMF::init();
    printf("%.2lf", 1.0 * ans / car);
}