【BZOJ1070】[SCOI2007]修车

题面

以后要多写题面flag

题目描述

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

客平均等待的时间最小。

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

输入格式

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

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

输出格式

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

样例

输入样例

输出样例

1.50

说明

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

题解

设某个技术人员的修车序列为$a_1,a_2...a_n$

则这个人所用时间

\[\sum_{i=1}^nT_{a_i}*(n-i+1)\\
\Leftrightarrow n*T_{a_1}+(n-1)*T_{a_2}+...+1*T_{a_n}
\]

这样的话，我们可以将一次在第$k$次修决策化为一次

费用为$T_{i,j}*k$的决策

因此我们可以得到一个决策集合：决策$\left(i,j,k\right)=T\left(i,j\right)\ast k$表示“把第i辆车让第j个人在“需要消耗k次时间”的那个个位置修”

那实际上我们就是对于每个$i$选取一个这样的决策，同时这个决策的$\left(j,k\right)$不能相同

最后怎么办呢？

建一个$n*m$的决策图，表示决策$j,k$

再建$n$个车的点，表示那辆车

再对于决策图的每一层，向车$i$连$Ti,j*层数$费用，容量为$1$的边

最后连$S,T$即可

代码

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <queue>

using namespace std;

const int MAX_N = 300;

const int INF = 1e9;

struct Graph { int to, cap, cost, next; } e[MAX_N * MAX_N << 2];

int fir[MAX_N * MAX_N], e_cnt, V;

void clearGraph() { memset(fir, -1, sizeof(fir)); e_cnt = 0; }

void Add_Edge(int u, int v, int cap, int cost) {

    e[e_cnt] = (Graph){v, cap, cost, fir[u]}; fir[u] = e_cnt++;

    e[e_cnt] = (Graph){u, 0, -cost, fir[v]}; fir[v] = e_cnt++;

}

int dis[MAX_N * MAX_N], preve[MAX_N * MAX_N], prevv[MAX_N * MAX_N];

bool inq[MAX_N * MAX_N];

int min_cost_flow(int s, int t) {

    static queue<int> que; int res = 0;

    while (1) {

        fill(&dis[0], &dis[V + 1], INF);

        fill(&inq[0], &inq[V + 1], 0);

        que.push(s), dis[s] = 0, inq[s] = 1;

        while (!que.empty()) {

            int x = que.front(); que.pop();

            for (int i = fir[x]; ~i; i = e[i].next) {

                int v = e[i].to;

                if (dis[x] + e[i].cost < dis[v] && e[i].cap > 0) {

                    dis[v] = dis[x] + e[i].cost;

                    preve[v] = i, prevv[v] = x;

                    if (!inq[v]) que.push(v), inq[v] = 1;

                }

            }

            inq[x] = 0;

        }

        if (dis[t] == INF) return res;

        int d = INF;

        for (int x = t; x != s; x = prevv[x]) d = min(d, e[preve[x]].cap);

        res += dis[t] * d;

        for (int x = t; x != s; x = prevv[x]) {

            e[preve[x]].cap -= d;

            e[preve[x] ^ 1].cap += d;

        }

    }

}

int N, M, id[MAX_N][MAX_N], T[MAX_N][MAX_N];

int main () {

    clearGraph();

    cin >> M >> N; int s = 0, t, tot = 0;

    for (int i = 1; i <= N; i++)

        for (int j = 1; j <= M; j++) id[i][j] = ++tot;

    for (int i = 1; i <= N; i++)

        for (int j = 1; j <= M; j++) cin >> T[i][j];

    V = t = (N + 1) * M + 1;

    for (int i = 1; i <= N; i++) Add_Edge(s, i, 1, 0);

    for (int i = 1; i <= N; i++)

        for (int j = 1; j <= M; j++) Add_Edge(N + id[i][j], t, 1, 0);

    for (int i = 1; i <= N; i++)

        for (int j = 1; j <= M; j++)

            for (int k = 1; k <= N; k++)

                Add_Edge(i, N + id[k][j], 1, T[i][j] * k);

    printf("%0.2lf\n", 1.0 * min_cost_flow(s, t) / N);

    return 0;

}