Description
同一时刻有N位车主带着他们的爱车来到了汽车维修中心。维修中心共有M位技术人员，不同的技术人员对不同
的车进行维修所用的时间是不同的。现在需要安排这M位技术人员所维修的车及顺序，使得顾客平均等待的时间最
小。 说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。
Input
第一行有两个m,n，表示技术人员数与顾客数。 接下来n行，每行m个整数。第i+1行第j个数表示第j位技术人
员维修第i辆车需要用的时间T。
Output
最小平均等待时间，答案精确到小数点后2位。
Sample Input
3 2
1 4
Sample Output
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 ;
}