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

Solution

  我目前为止一道费用流的模型都不会建T_T

  构造一个图,左边$n*m$个点,表示第$j$个技术人员修的倒数第$i$辆车,右边$n$个点,表示第$k$辆车

  源点向左边的点连$(w=1, cost=0)$的边,因为每个人同一时刻只能修一辆车

  左边$m*n$个点再分别向右边$n$个点连边,左边第$(i, j)$个点向右边第$k$个点连$(w=INF, cost=i*t[i][j])$的边

  相当于此时有$i$个人在等待着这辆车修完,代价就是等待的人数$*$修这辆车的时间

  右边的点向汇点连$(w=1, cost=0)$的边,表示每辆车只能被一个人修

  容易看出,此时最大流一定是$n$,每一条$w=1$的流表示第$j$个人修的倒数第$i$辆车是第$k$辆车

  那么最小费用除以$n$就是我们的答案

  总点数是$2+m*n+n$,不超过$602$;边数是$2*(m*n+m*n*n+n)$,不超过$70000$

  欸我好像擅长将源点设成n+1将汇点设成n+2...

  可以加一个不知道是不是优化的优化:中间的所有边的边权可以只设为$1$,因为这条边本身流量最大值也是$1$

  (如果这条边流过,其边权变成了$0$,貌似可以使$SPFA$中该点的入队次数变少一些...只是本人猜测)

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 const int INF = 1000000000;
 4 struct edge
 5 {
 6     int u, v, w, c, nxt;
 7 }e[70005];
 8 int n, fst[605], t[65][15], etot = 1, level[605];
 9 int q[605], pth[605];
10 bool inq[605];
11  
12 void addedge(int u, int v, int w, int c)
13 {
14     e[++etot] = (edge){u, v, w, c, fst[u]}, fst[u] = etot;
15     e[++etot] = (edge){v, u, 0, -c, fst[v]}, fst[v] = etot;
16 }
17  
18 bool SPFA()
19 {
20     int front = 0, back, u;
21     memset(level, 63, sizeof(level));
22     level[n + 1] = 0;
23     q[back = 1] = n + 1, inq[n + 1] = true;
24     while(front != back)
25     {
26         u = q[(++front % 605)];
27         front %= 605, inq[u] = false;
28         for(int i = fst[u]; i; i = e[i].nxt)
29             if(e[i].w && level[e[i].v] > level[u] + e[i].c)
30             {
31                 level[e[i].v] = level[u] + e[i].c;
32                 pth[e[i].v] = i;
33                 if(!inq[e[i].v])
34                 {
35                     q[(++back % 605)] = e[i].v;
36                     back %= 605, inq[e[i].v] = true;
37                 }
38             }
39     }
40     return level[n + 2] < INF;
41 }
42  
43 int Edmond_Karp()
44 {
45     int flow = INF;
46     for(int i = pth[n + 2]; i; i = pth[e[i].u])
47         flow = min(flow, e[i].w);
48     for(int i = pth[n + 2]; i; i = pth[e[i].u])
49         e[i].w -= flow, e[i ^ 1].w += flow;
50     return flow * level[n + 2];
51 }
52  
53 int main()
54 {
55     int m, ptot, ans = 0;
56     scanf("%d%d", &m, &n);
57     for(int i = 1; i <= n; ++i)
58         for(int j = 1; j <= m; ++j)
59             scanf("%d", &t[i][j]);
60     for(int i = 1; i <= n; ++i)
61         addedge(i, n + 2, 1, 0);
62     ptot = n + 2;
63     for(int i = 1; i <= m; ++i)
64         for(int j = 1; j <= n; ++j)
65         {
66             ++ptot;
67             for(int k = 1; k <= n; ++k)
68                 addedge(ptot, k, 1, t[k][i] * j);
69         }
70     for(int i = n + 3; i <= ptot; ++i)
71         addedge(n + 1, i, 1, 0);
72     while(SPFA())
73         ans += Edmond_Karp();
74     printf("%.2f\n", (double)ans / n);
75     return 0;
76 }
View Code

相关文章:

  • 2022-02-17
  • 2021-12-23
  • 2021-09-12
  • 2022-01-12
  • 2021-10-08
猜你喜欢
  • 2022-02-07
  • 2022-02-05
  • 2021-11-25
  • 2021-07-23
  • 2021-11-21
  • 2021-12-22
  • 2022-03-02
相关资源
相似解决方案