傳送門：https://www.luogu.org/problemnew/show/P2053

教練我想學數學建模。

網路流和最小費用流的題目不存在程式碼難度，程式碼不存在變形(目前來說是的，不知道是不是我沒做過對於模板修改的題目)

難度主要在於，你能看出來它是個網路流，並且還能正確的建模。

大喊一句，教練我想學數學建模！

這個題目建模不是很簡單。

首先，我們要知道一個人可以修n輛車，那麼m個人就可以修n*m輛車車啦，但是每個人只能修一輛車，想要修下一輛就要排隊等待這一輛維修完畢。

那我們怎麼給它建模呢。

很顯然，如果有3個人想要找技術人員 j 修車，那麼第一個人要等待t[1]的時間，第二個人需要等待t[1]+t[2]的時間，第三個人要等待t[1]+t[2]+t[3]的時間。那麼總的等待時間為t[1]+(t[1]+t[2])+(t[1]+t[2]+t[3]) = 3*t[1]+2*t[2]+t[3]。

所以我們把每個人拆成n個點，然後每個點連一條邊，容量為1，權值為k*w[i]。然後跑最小費用流就OK啦啦啦！

程式碼在下面啦：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
const int maxn= 2020;
using namespace std;
struct edge
{
    int to, cap, cost, rev;
};
vector<edge>G[maxn];
int dis[maxn];
int pv[maxn], pe[maxn];
int h[maxn];
void add_edge(int from, int to, int cap, int cost) 
{
    G[from].push_back({to, cap, cost, G[to].size()});
    G[to].push_back({from, 0, -cost, G[from].size()-1});
}
void dijkstra(int s) 
{
    struct node 
	{
        int now;
        int cost;
        bool operator < (const node &a) const 
		{
            return cost > a.cost;
        }
    };
    memset(dis,INF,sizeof(dis));
    dis[s] = 0;
    priority_queue<node>q;
    q.push({s, dis[s]});
    while (!q.empty()) {
        int now = q.top().now;
        int nowc = q.top().cost;
        q.pop();
        if(dis[now]<nowc) continue;
        for (int i = 0; i < G[now].size(); ++i) 
		{
            edge &e = G[now][i];
            if (e.cap > 0 && dis[e.to] > dis[now] + e.cost + h[now]-h[e.to]) 
			{
                dis[e.to] = dis[now] + e.cost + h[now] - h[e.to];
                pv[e.to] = now;
                pe[e.to] = i;
                q.push({e.to, dis[e.to]});
            }
        }
    }
}
pair<int, int> min_cost_max_flow(int s, int t) {
    int flow = 0;
    int cost = 0;
    while (true) 
	{
        dijkstra(s);
        if (dis[t] == INF) return {flow, cost};
        for(int i=0;i<maxn;i++)
        {
        	h[i] += dis[i];
		}
        int d = INF;
        for (int v = t; v != s; v = pv[v]) 
		{
            d = min(d, G[pv[v]][pe[v]].cap);
        }
        flow += d;
        cost += d*h[t];
        for (int v = t; v != s; v = pv[v]) 
		{
			edge &e = G[pv[v]][pe[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }       
    }
}
int main() 
{
    int n,m;
    cin>>m>>n;
    int tmp = 0;
    int s = 0;
    int t = n+n*m+1;
    for(int i=1;i<=n;i++)
    {
    	for(int j=1;j<=m;j++)
    	{
    		cin>>tmp;
    		for(int k=1;k<=n;k++)
    		{
    			add_edge(i,j+n+(k-1)*m,1,k*tmp);
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		add_edge(s,i,1,0); 
	}
	for(int i=n+1;i<t;i++)
	{
		add_edge(i,t,1,0);
	}
	printf("%.2lf\n",(double)min_cost_max_flow(s,t).second/(1.0*n));
    return 0;
}