P2053 [SCOI2007]修车 费用流

Posted 2021-02-11 olinr

$ color{#0066ff}{ 题目描述 }$

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

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

(color{#0066ff}{输入格式})

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

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

(color{#0066ff}{输出格式})

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

(color{#0066ff}{输入样例})

2 2
3 2
1 4

(color{#0066ff}{输出样例})

1.50

(color{#0066ff}{数据范围与提示})

(2<=M<=9,1<=N<=60), (1<=T<=1000)

(color{#0066ff}{题解})

这种对应关系还有数据范围，显然就是费用流了

现在的问题是怎么建边

发现，每辆车的等待时间跟前面修车人所修的车有关

假设某人修了10辆车

那么他修第一辆的时候，后面9人都等了这个时间，也就是贡献+=9倍的这个时间

因此我们单独考虑这个人修的每一辆车对时间的贡献

把每个人都拆成n个点

对于一个人的第k个点，连向它的车代表他倒数第k次修它

也就是连T*k的边权，倒数第k次修它，那么后面k辆车就会产生这么多贡献

跑一遍费用流即可（zkw大法好）

// luogu-judger-enable-o2
#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 1e5 + 10;
const int inf = 0x7fffffff;
struct node {
    int to, can, dis;
    node *nxt, *rev;
    node(int to = 0, int can = 0, int dis = 0, node *nxt = NULL): to(to), can(can), dis(dis), nxt(nxt) {
        rev = NULL;
    }
};
node *head[maxn], *cur[maxn];
bool vis[maxn];
int n, m, s, t;
int dis[maxn];
void add(int from, int to, int can, int dis) {
    head[from] = new node(to, can, dis, head[from]);
}
void link(int from, int to, int can, int dis) {
    add(from, to, can, dis);
    add(to, from, 0, -dis);
    head[from]->rev = head[to];
    head[to]->rev = head[from];
}
bool spfa() {
    std::queue<int> q;
    for(int i = s; i <= t; i++) dis[i] = inf, vis[i] = false;
    q.push(t);
    dis[t] = 0;
    while(!q.empty()) {
        int tp = q.front(); q.pop();
        vis[tp] = false;
        for(node *i = head[tp]; i; i = i->nxt) {
            if(dis[i->to] > dis[tp] - i->dis && i->rev->can) {
                dis[i->to] = dis[tp] - i->dis;
                if(!vis[i->to]) {
                    q.push(i->to);
                    vis[i->to] = true;
                }
            }
        }
    }
    return dis[s] != inf;
}
int dfs(int x, int change) {
    
    if(x == t || !change) return change;
    int flow = 0, ls;
    vis[x] = true;
    for(node *i = head[x]; i; i = i->nxt) {
        if(!vis[i->to] && dis[i->to] == dis[x] - i->dis && (ls = dfs(i->to, std::min(change, i->can)))) {
            flow += ls;
            change -= ls;
            i->can -= ls;
            i->rev->can += ls;
            if(!change) break;
        }
    }
    return flow;
}

int zkw() {
    int cost = 0;
    while(spfa()) {
        vis[t] = true;
        while(vis[t]) {
            for(int i = s; i <= t; i++) vis[i] = false;
            cost += dis[s] * dfs(s, inf);
        }
    }
    return cost;
}
int main() { 
    m = in(), n = in(), s = 0, t = m * n + n + 1;
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= n; j++)
            link(s, (i - 1) * n + j, 1, 0);
    for(int i = 1; i <= n; i++) link(m * n + i, t, 1, 0);
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) {
            int x = in();
            for(int k = 1; k <= n; k++) link((j - 1) * n + k, n * m + i, 1, k * x);
        }
    printf("%.2f
", (double)zkw() / n);
    return 0;
}