修车[SCOI2007]

                     题目传送门

            1383. [SCOI 2007] 修车

★★★   输入文件：scoi2007_repair.in   输出文件：scoi2007_repair.out   简单对比
时间限制：1 s   内存限制：256 MB

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

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

输入

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

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

输出

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

样例

repair.in

2 2

3 2

1 4

repair.out

1.50

数据范围:

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

　　求平均时间最小等于求每个人等的总时间最小。

　　如果一个人可以多线程工作的话这题就很好做了，然而如果一个人干完一个活才能干下一个，就要考虑前面的对后面的影响。对于一个工人来说，假设他修了n辆车，那么这n个车主等的总时间为w1*n+w2*(n-1)+...+wn*1（wi表示该工人修第i辆车的耗时），也就是说倒数第i辆车对总时间的贡献为w*i。所以我们把每个工人分出n个时段，每个第i个时段的耗时为i*w。最后跑一边最小费用最大流即可。

　　具体建模方式：n辆车与n*m个工人时段分属两个不同集合。第i辆车与第j个工人的第k个时段之间连容量为1，费用为k*wi,j的边。s向每辆车连容量为1，费用为0的边。每个工人时段向t连容量为1，费用为0的边。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<bitset>
#define LL long long
#define RI register int
using namespace std;
const int INF = 0x7ffffff ;
const int N = 60 + 2 ;
const int M = 9 + 2 ;
const int NN = 600 + 10 ;
const int FN = 1000 + 10 ;
const int MM = 1e6 + 10 ;

inline int read() {
    int k = 0 , f = 1 ; char c = getchar() ;
    for( ; !isdigit(c) ; c = getchar())
      if(c == '-') f = -1 ;
    for( ; isdigit(c) ; c = getchar())
      k = k*10 + c-'0' ;
    return k*f ;
}
struct Edge {
    int to, next, flow, cost ;
}e[MM] ;
int n, m, s, t, ansf, ansc ; int head[FN], dis[FN] ; bool vis[FN] ;
inline void add_edge(int x,int y,int ff,int cc) {
    static int cnt = 1 ;
    e[++cnt].to = y, e[cnt].next = head[x], head[x] = cnt, e[cnt].flow = ff, e[cnt].cost = cc ;
    e[++cnt].to = x, e[cnt].next = head[y], head[y] = cnt, e[cnt].flow = 0, e[cnt].cost = -cc ;
}

inline bool spfa() {
    for(int i=1;i<=t;i++) dis[i] = INF ; dis[s] = 0 ;
    deque<int>q ; q.push_back(s) ; bitset<FN>inq ; inq[s] = 1 ;
    while(!q.empty()) {
        int x = q.front() ; q.pop_front() ; inq[x] = 0 ;
        for(int i=head[x];i;i=e[i].next) {
            int y = e[i].to ; if(!e[i].flow) continue ;
            if(dis[y] > dis[x]+e[i].cost) {
                dis[y] = dis[x]+e[i].cost ;
                if(!inq[y]) {
                    inq[y] = 1 ;
                    if(!q.empty() && dis[y] < dis[q.front()]) q.push_front(y) ;
                    else q.push_back(y) ;
                }
            }
        }
    }
    return dis[t] < INF ;
}
int FFdfs(int x,int minflow) {
    vis[x] = 1 ;
    if(x == t || !minflow) return minflow ;
    int fflow = 0 ;
    for(int i=head[x];i;i=e[i].next) {
        int y = e[i].to ; if(!e[i].flow || vis[y] || dis[y] != dis[x]+e[i].cost) continue ;
        int temp = FFdfs(y,min(minflow,e[i].flow)) ;
        fflow += temp, minflow -= temp ;
        e[i].flow -= temp, e[i^1].flow += temp ;
        ansc += temp*e[i].cost ;
        if(!minflow) break ;
    }
    return fflow ;
}

int main() {
    freopen("scoi2007_repair.in","r",stdin) ;
    freopen("scoi2007_repair.out","w",stdout) ;
    m = read(), n = read() ; s = n+NN+1, t = s+1 ;
    for(int i=1;i<=n;i++) {
        add_edge(s,i+NN,1,0) ;
        for(int j=1;j<=m;j++) {
            int x = read() ;
            for(int k=1;k<=n;k++) {
                add_edge(i+NN,(j-1)*n+k,1,k*x) ;
            }
        }
    }
    for(int i=1;i<=n*m;i++) add_edge(i,t,1,0) ;
    while(spfa()) {
        vis[t] = 1 ;
        while(vis[t]) {
            memset(vis,0,sizeof(vis)) ;
            ansf += FFdfs(s,INF) ;
        }
    }
    double ans = (double)ansc/(double)n ;
    printf("%.2lf",ans) ;
    return 0 ;
}