今天讲的建图方法主要用来解决同时做问题，和第一期讲的拆点法有点相似，但是实际上却有很大差距，第一期的酒店之王拆点法，就要原因是为了解决一个点可能会被多次匹配的问题，也就是说主要作用是限流的作用，而这次的拆点主要是解决同时做的问题，也就是把一个点拆成n个，使之具有n种状态，还是会重题目说起洛谷2053

题目描述
同一时刻有N位车主带着他们的爱车来到了汽车维修中心。维修中心共有M位技术人员，不同的技术人员对不同的车进行维修所用的时间是不同的。现在需要安排这M位技术人员所维修的车及顺序，使得顾客平均等待的时间最小。

说明：顾客的等待时间是指从他把车送至维修中心到维修完毕所用的时间。

输入格式
第一行有两个数M,N，表示技术人员数与顾客数。

接下来n行，每行m个整数。第i+1行第j个数表示第j位技术人员维修第i辆车需要用的时间T。

输出格式
最小平均等待时间，答案精确到小数点后2位

输入
2 2
3 2
1 4
输出
1.50

---------------------------------------------------------------------------------------------------------------------------------------
我们首先分析一下这道题目我们就会发现这是一个二分图匹配问题，我们完全可以将其建一个二分图，一面是车，一面是修理师傅，但是问题来了就是，每个师傅修每辆车所用的时间都不同，或者说有N种状态，那么我们怎么办，如何去解决这个问题，其实这个问题很容易想到，我们把每个师傅拆成N个点，代表N中状态就OKK了接下来看AC代码
---------------------------------------------------------------------------------------------------------------------------------------

AC代码

#pragma GCC optimize(2)//02优化
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>


using namespace std;

const int MAXN = 1e5 + 5;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int to, w, f, next;
}edg[MAXN];

int head[MAXN], flow[MAXN], dis[MAXN], visit[MAXN], pre[MAXN], last[MAXN], cnt = 0;

void init()
{
    memset(head, -1, sizeof(head));
    cnt = 0;
}

inline void Add_edge(int u, int v, int w, int f)
{
    edg[cnt].w = w;
    edg[cnt].f = f;
    edg[cnt].to = v;
    edg[cnt].next = head[u];
    head[u] = cnt++;
    edg[cnt].w = 0;
    edg[cnt].f = -f;
    edg[cnt].to = u;
    edg[cnt].next = head[v];
    head[v] = cnt++;
}

bool SPFA(int s, int t)
{
// memset(visit, 0, sizeof(visit));
    memset(flow, INF, sizeof(flow));
    memset(dis, INF, sizeof(dis));
    queue<int>q;
    while(!q.empty()) q.pop();
    dis[s] = 0;
    pre[t] = 0;
    flow[s] = INF;
    q.push(s);
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        visit[u] = 0;
        for(int i = head[u]; i != -1; i = edg[i].next)
        {
            int v = edg[i].to;
            int newdis = dis[u] + edg[i].f;
            if(dis[v] > newdis && edg[i].w)
            {
                dis[v] = newdis;
                pre[v] = u;
                last[v] = i;
                flow[v] = min(flow[u], edg[i].w);
                if(!visit[v])
                {
                     q.push(v);
                     visit[v] = 1;
                }
            }
        }
    }
    return pre[t];
}

int Mincost(int s, int t)
{
    int mincost = 0;
    while(SPFA(s, t))
    {
        mincost += dis[t] * flow[t];
        int now = t;
        while(now != s)
        {
            edg[last[now]].w -= flow[t];
            edg[last[now]^1].w += flow[t];
            now = pre[now];
        }
    }
    return mincost;
}

int main()
{
    int m, n;
    int x;
    scanf("%d %d", &m, &n);
    init();
    int s = 0, t = n + (n * m) + 2;
    for(register int i = 1; i <= n; ++i)
    {
        Add_edge(s, i, 1, 0);
    }
    for(register int i = 1; i <= m; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            Add_edge(n + (i - 1) * n + j, t, 1, 0);
        }
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= m; ++j)
        {
            scanf("%d", &x);
            for(int k = 1; k <= n; ++k)
            Add_edge(i,n + (j - 1) * n + k, 1, x * k);
        }
    }
    int ans = Mincost(s, t);
    //printf("%d\n", ans);
    printf("%.2lf\n", ((double)ans) / (double(n)));
}