BZOJ 1070: [SCOI2007]修车

1070: [SCOI2007]修车

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 4983  Solved: 2049
[Submit][Status][Discuss]

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)

Source

 

[Submit][Status][Discuss]

所有的点：

源点S

汇点T

N*M 第i名维修工，倒数第j次维修

N 第i辆汽车

所有的边：

S向N*M个拆分后的维修点，各连一条容量为1，费用为0的边。

每个汽车点向T连一条容量为1，费用为0的边。

第i名维修工在倒数第j次维修，修汽车k，造成的代价为 维修时间*j。

跑最小费用最大流。

#include <bits/stdc++.h>

#define fread_siz 1024

inline int get_c(void)
{
    static char buf[fread_siz];
    static char *head = buf + fread_siz;
    static char *tail = buf + fread_siz;

    if (head == tail)
        fread(head = buf, 1, fread_siz, stdin);

    return *head++;
}

inline int get_i(void)
{
    register int ret = 0;
    register int neg = false;
    register int bit = get_c();

    for (; bit < 48; bit = get_c())
        if (bit == '-')neg ^= true;

    for (; bit > 47; bit = get_c())
        ret = ret * 10 + bit - 48;

    return neg ? -ret : ret;
}

template <class T>
inline T min(T a, T b)
{
    return a < b ? a : b;
}

const int maxn = 500005;
const int inf = 0x3f3f3f3f;

int n, m;
int s, t;
int cost;
int edges;
int hd[maxn];
int to[maxn];
int nt[maxn];
int vl[maxn];
int fl[maxn];

inline void add_edge(int u, int v, int f, int w)
{    
    nt[edges] = hd[u]; to[edges] = v; fl[edges] = f; vl[edges] = +w; hd[u] = edges++;
    nt[edges] = hd[v]; to[edges] = u; fl[edges] = 0; vl[edges] = -w; hd[v] = edges++;
}

inline bool bfs(void)
{
    static int dis[maxn];
    static int que[maxn];
    static int inq[maxn];
    static int pre[maxn];
    static int head, tail;
    
    memset(inq, 0, sizeof(inq));
    memset(dis, inf, sizeof(dis));
    
    head = 0, tail = 0;
    que[tail++] = s;
    pre[s] = -1;
    dis[s] = 0;
    inq[s] = 1;
    
    while (head != tail)
    {
        int u = que[head++], v; inq[u] = 0;
        
        if (head >= maxn)
            head = 0;
        
        for (int i = hd[u]; ~i; i = nt[i])
            if (fl[i] && dis[v = to[i]] > dis[u] + vl[i])
            {
                dis[v] = dis[u] + vl[i], pre[v] = i^1; 
                if (!inq[v])
                    inq[v] = 1, que[tail++] = v;
                if (tail >= maxn)
                    tail = maxn;
            }
    }

    if (dis[t] >= inf)
        return false;
        
    int flow = inf;
    
    for (int i = pre[t]; ~i; i = pre[to[i]])
        if (flow > fl[i ^ 1])
            flow = fl[i ^ 1];
            
    for (int i = pre[t]; ~i; i = pre[to[i]])
        fl[i] += flow, fl[i ^ 1] -= flow;
        
    cost += flow * dis[t];
        
    return true;
}

inline void max_flow(void)
{
    while (bfs());
}

signed main(void)
{
    n = get_i();
    m = get_i();
    
    s = 0, t = n*m + m + 1;
    
    memset(hd, -1, sizeof(hd));
    
    for (int i = 1; i <= n*m; ++i)
        add_edge(s, i, 1, 0);
    
    for (int i = 1; i <= m; ++i)
        add_edge(i + n*m, t, 1, 0);
        
    for (int i = 1; i <= m; ++i)
        for (int j = 1; j <= n; ++j)
        {
            int w = get_i();
            for (int k = 1; k <= m; ++k)
                add_edge((j - 1)*m + k, n*m + i, 1, w*k); 
        }
        
    max_flow();
    
    printf("%.2f
", (float)cost / m);
}

@Author: YouSiki