[BZOJ1070] [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)

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$中该点的入队次数变少一些...只是本人猜测）

 #include <bits/stdc++.h>
 using namespace std;
 const int INF = ;
 struct edge
 {
     int u, v, w, c, nxt;
 }e[];
 int n, fst[], t[][], etot = , level[];
 int q[], pth[];
 bool inq[];

 void addedge(int u, int v, int w, int c)
 {
     e[++etot] = (edge){u, v, w, c, fst[u]}, fst[u] = etot;
     e[++etot] = (edge){v, u, , -c, fst[v]}, fst[v] = etot;
 }

 bool SPFA()
 {
     int front = , back, u;
     memset(level, , sizeof(level));
     level[n + ] = ;
     q[back = ] = n + , inq[n + ] = true;
     while(front != back)
     {
         u = q[(++front % )];
         front %= , inq[u] = false;
         for(int i = fst[u]; i; i = e[i].nxt)
             if(e[i].w && level[e[i].v] > level[u] + e[i].c)
             {
                 level[e[i].v] = level[u] + e[i].c;
                 pth[e[i].v] = i;
                 if(!inq[e[i].v])
                 {
                     q[(++back % )] = e[i].v;
                     back %= , inq[e[i].v] = true;
                 }
             }
     }
     return level[n + ] < INF;
 }

 int Edmond_Karp()
 {
     int flow = INF;
     for(int i = pth[n + ]; i; i = pth[e[i].u])
         flow = min(flow, e[i].w);
     for(int i = pth[n + ]; i; i = pth[e[i].u])
         e[i].w -= flow, e[i ^ ].w += flow;
     return flow * level[n + ];
 }

 int main()
 {
     int m, ptot, ans = ;
     scanf("%d%d", &m, &n);
     for(int i = ; i <= n; ++i)
         for(int j = ; j <= m; ++j)
             scanf("%d", &t[i][j]);
     for(int i = ; i <= n; ++i)
         addedge(i, n + , , );
     ptot = n + ;
     for(int i = ; i <= m; ++i)
         for(int j = ; j <= n; ++j)
         {
             ++ptot;
             for(int k = ; k <= n; ++k)
                 addedge(ptot, k, , t[k][i] * j);
         }
     for(int i = n + ; i <= ptot; ++i)
         addedge(n + , i, , );
     while(SPFA())
         ans += Edmond_Karp();
     printf("%.2f\n", (double)ans / n);
     return ;
 }

　　但是！这道题的总时限是$1s$，这种图需要大概$1.4s$，严格来说是超时的

　　我们有一种优化方法：

　　如果第$j$个人没修倒数第$i$辆车，他一定不会修倒数第$i+1$、$i+2$...辆车

　　所以初始的图左边只需要有$m$个点，表示每个人的倒数第$1$辆车

　　当图中左边点$(j, i)$到右边点$k$流了$1$时，我们再将左边的$(j, i+1)$和右边的$k$连上边（权值和之前说的一样）

　　这样总点数是$2+m+n+n$，不超过$131$，总边数是$2*(m+m*n+n)+2*(n+2)*n$，不超过$10000$，EK党的胜利！

　　你们四不四洒，就不会合作修同一辆车吗

 #include <bits/stdc++.h>
 using namespace std;
 const int INF = ;
 struct edge
 {
     int u, v, w, c, nxt;
 }e[];
 int n, fst[], t[][], etot = , level[];
 int q[], pth[], belong[], fin[], use;
 bool inq[];

 void addedge(int u, int v, int w, int c)
 {
     e[++etot] = (edge){u, v, w, c, fst[u]}, fst[u] = etot;
     e[++etot] = (edge){v, u, , -c, fst[v]}, fst[v] = etot;
 }

 bool SPFA()
 {
     int front = , back, u;
     memset(level, , sizeof(level));
     level[n + ] = ;
     q[back = ] = n + , inq[n + ] = true;
     while(front != back)
     {
         u = q[(++front % )];
         front %= , inq[u] = false;
         for(int i = fst[u]; i; i = e[i].nxt)
             if(e[i].w && level[e[i].v] > level[u] + e[i].c)
             {
                 level[e[i].v] = level[u] + e[i].c;
                 pth[e[i].v] = i;
                 if(!inq[e[i].v])
                 {
                     q[(++back % )] = e[i].v;
                     back %= , inq[e[i].v] = true;
                 }
             }
     }
     return level[n + ] < INF;
 }

 int Edmond_Karp()
 {
     for(int i = pth[n + ]; i; i = pth[e[i].u])
     {
         --e[i].w, ++e[i ^ ].w;
         if(e[i].u == n + ) use = e[i].v;
     }
     return level[n + ];
 }

 int main()
 {
     int m, ptot, ans = , k;
     scanf("%d%d", &m, &n);
     for(int i = ; i <= n; ++i)
         for(int j = ; j <= m; ++j)
             scanf("%d", &t[i][j]);
     for(int i = ; i <= n; ++i)
         addedge(i, n + , , );
     ptot = n + ;
     for(int i = ; i <= m; ++i)
     {
         belong[++ptot] = i, ++fin[i];
         for(int j = ; j <= n; ++j)
             addedge(ptot, j, , t[j][i]);
     }
     for(int i = n + ; i <= ptot; ++i)
         addedge(n + , i, , );
     while(SPFA())
     {
         ans += Edmond_Karp();
         k = belong[++ptot] = belong[use], ++fin[k];
         for(int i = ; i <= n; ++i)
             addedge(ptot, i, , t[i][k] * fin[k]);
         addedge(n + , ptot, , );
     }
     printf("%.2f\n", (double)ans / n);
     return ;
 }