BZOJ 1070 [费用流]

1070: [SCOI2007]修车
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)

刚开始看到这道题，一脸懵逼。。。。。还很愚蠢的以为直接二分图匹配。后来发现不行，因为每一个技术人员不一定只匹配到一辆车。
其实看下数据范围，发现很小，不如把每个技术人员拆点。点（i， j）表示第i个技术人员修理倒数第j辆车的状态。。为什么要倒数呢，因为每一个技术人员如果按顺数的话，在第修理第j辆车时，等待时间无法计算出来（因为不知道之前的每一辆车是否修理），所以要倒数。那么这一条边的话费（或者说是对答案的影响）就为j * t（t为修理车的时间）所以就可以这么建边

  for(int i = 1; i <= m; i++)
    for(int j = 1; j <= n; j++) {
      Cnt++;
      for(int k = 1; k <= n; k++)
        add_edge(Cnt, k, 1, j * map[i][k]);
    }

另外添加超级源和超级汇，求最小费用最大流即可。
代码：

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <queue>
#define N 65 * 65 * 65
#define oo 0x3f3f3f3f
#define MIN 10000
using namespace std;

int n, m, ans = 0, cnt = 0, Cnt = 0, s, t;
int map[65][65], head[N], p[N], a[N], dist[N];
bool vis[N];
struct edge {
  int from, to, flow, cap, cost, next;
  edge(void) {}
  edge(int f, int t, int fl, int c, int co, int n)
    :from(f), to(t), flow(fl), cap(c), cost(co), next(n) {}
}G[1000000];
queue<int> Q;

inline char get(void) {
  static char buf[100000], *p1 = buf, *p2 = buf;
  if (p1 == p2) {
    p2 = (p1 = buf) + fread(buf, 1, 100000, stdin);
    if (p1 == p2) return EOF;
  }
  return *p1++;
}
inline void read(int &x) {
  x = 0; char c;
  for(c = getchar(); c < '0' || c > '9'; c = get());
  for(; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = get());
}
inline void add_edge(int from, int to, int cap, int cost) {
  G[cnt] = edge(from, to, 0, cap, cost, head[from]);
  head[from] = cnt++;
  G[cnt] = edge(to, from, 0, 0, -cost, head[to]);
  head[to] = cnt++;
}
int spfa(int s, int t, int &cost) {
  memset(dist, 0x3f, sizeof(dist)); p[s] = 0;
  a[s] = oo; vis[s] = 1; Q.push(s); dist[s] = 0;
  while (!Q.empty()) {
    int x = Q.front(); Q.pop(); vis[x] = 0;
    for(int i = head[x]; i != -1; i = G[i].next) {
      edge &e = G[i];
      if (e.cap > e.flow && dist[e.to] > dist[x] + e.cost) {
        dist[e.to] = dist[x] + e.cost;
        p[e.to] = i; a[e.to] = min(a[x], e.cap - e.flow);
        if (!vis[e.to]) {
          vis[e.to] = 1; Q.push(e.to);
        }
      }
    }
  }
  if (dist[t] == oo) return 0;
  cost += dist[t] * a[t];
  for(int i = t; i != s; i = G[p[i]].from) {
    G[p[i]].flow += a[t];
    G[p[i] ^ 1].flow -= a[t];
  }
  return cost;
}
void MinCostMaxFlow(int s, int t, int &cost) {
  cost = 0;
  while(spfa(s, t, cost)) {
    s = s;
  };
}

int main(void) {
  read(m); read(n);//m workers, n customers
  memset(head, -1, sizeof(head));
  for(int i = 1; i <= n; i++)
    for(int j = 1; j <= m; j++)
      read(map[j][i]);
  Cnt = n; s = 0;
  for(int i = 1; i <= m; i++)
    for(int j = 1; j <= n; j++) {
      Cnt++;
      for(int k = 1; k <= n; k++)
        add_edge(Cnt, k, 1, j * map[i][k]);
    }
  t = Cnt + 1;
  for(int i = n + 1; i <= Cnt; i++) add_edge(s, i, 1, 0);
  for(int i = 1; i <= n; i++) add_edge(i, t, 1, 0);
  MinCostMaxFlow(s, t, ans);
  printf("%.2f\n", (ans * 1.0) / n);
  return 0;
}