bzoj 1070[SCOI2007]修车 - 费用流

1070: [SCOI2007]修车

Time Limit: 1 Sec  Memory Limit: 128 MB

Description

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

Input

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

Output

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

Sample Input

2 2
3 2
1 4

Sample Output

1.50

HINT

 

数据范围: (2<=M<=9,1<=N<=60), (1<=T<=1000)

 

对维修工拆点， 第k个维修工表示这辆车是他修的倒数k辆

对于 第 j 辆车连向第i个维修工的第k个节点的权值就是 k * a[i][j], 因为在他之后修的车都会加上等待的时间。

根据网络流的性质，他会优先跑小的边

所以跑费用流就是总的等待时间

 

 

#include <iostream> 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define LL long long 

using namespace std;

queue<int> q;
int cnt = 0;
const int MAXN = 1e3;
int ti;
int dis[MAXN];
int flag[MAXN];
int head[MAXN];
int N, M;
int V;
int S, T;
int pre[MAXN];
int e[MAXN];
struct edge {
    int v;
    int next;
    int w;
    int cost;
} g[600 * 600 * 10];

double ans = 0;
void addedge(int u, int v, int w, double cost)
{
    g[cnt].v = v;
    g[cnt].w = w;
    g[cnt].cost = cost;
    g[cnt].next = head[u];
    head[u] = cnt++;
}
inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

bool SPFA()
{
    while(!q.empty()) {
        q.pop();
    }
    memset(pre, 0, sizeof pre);
    memset(flag, 0, sizeof flag);
    memset(dis, 0x3f, sizeof dis);
    dis[0] = 0;
    q.push(S);
    while(!q.empty()) {
        int t = q.front();
        flag[t] = 0;
        q.pop();
        for(int j = head[t]; j != -1; j = g[j].next) {
            int to = g[j].v;
            if(dis[to] > dis[t] + g[j].cost && g[j].w > 0) {
                dis[to] = dis[t] + g[j].cost;
            //    cout<<dis[to]<<endl;
                pre[to] = t;
                /*if(dis[to] < 0 && to == 0) {
                    for(int j = t; j ; j = pre[j]) {
                        cout<<j<<" "<<dis[j]<<endl;
                    }
                    cout<<endl;
                    exit(0);
                }*/
                e[to] = j;
                if(!flag[to]) {
                    flag[to] = 1;
                    q.push(to);
                }
            }
        }
    }
    if(!pre[T]) {
        return false;
    }
    ans += dis[T];
    int minflow = 1e9;
    for(int j = T; j; j = pre[j]) {
        //cout<<j<<" ";
        minflow = min(minflow, g[e[j]].w);
    }
    //cout<<endl;
    //cout<<dis[T]<<" "<<minflow<<endl<<endl;
    for(int j = T; j; j = pre[j]) {
        g[e[j]].w -= minflow;
        g[e[j] ^ 1].w += minflow;
    }
    return true;
}

int main()
{
    memset(head, -1, sizeof head);
    M = read(), N = read();
    V = M * N;
    S = 0, T = V + N + 1;
    for(int i = 1; i <= N; i++) {
        addedge(S, V + i, 1, 0);
        addedge(V + i,S, 0, 0);
        for(int j = 1; j <= M; j++) {
            scanf("%d", &ti);
            for(int t = 1; t <= N; t++) {
                addedge((t - 1) * M + j, V + i, 0, -1 * ti * t);
                addedge(V + i, (t - 1) * M + j, 1, 1 * ti * t);
            }
        }
    }
    for(int i = 1; i <= M * N; i++) {
        addedge(i, T, 1, 0);
        addedge(T, i, 0, 0);
    }
    while(SPFA()) {
    }
    printf("%.2lf\n", ans / N);
    return 0;
}

/*
2 2
3 2
1 4

*/