POJ 3686_The Windy's

题意:

N个工件要在M个工厂加工，一个工件必须在一个工厂做完，工厂一次只能处理一个工件。给定每个工件在每个工厂加工所需时间，求出每个工件加工结束的最小时间平均值。

分析：

工厂一次只能处理一个工件，那么其他要在这个工厂处理的工件就要排队等待，如果有a个工件要在该厂处理，花的时间分别为n1,n1+n2,...,n1+n2+n3..na，该工厂花的总时间就为a∗n1+(a−1)∗n2+...+1∗na，这样将每个工厂拆为N个点，表示每个工件的完成花费了1..N倍的时间（别的工件等待的时间+处理该工件的时间），便可以转化为二分图最大权匹配问题。

代码：

最小费用最大流解法：

#include<cstdio>
#include<vector>
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
#define se second
#define fi first
typedef pair<int, int>pii;//first 顶点距离，secon顶点编号
struct edge{int to, cap, cost, rev;};
const int maxn = 30005, maxm = 500, INF =0x3f3f3f3f;
int V, s, t;
vector<edge>G[maxn];
int dist[maxn], prevv[maxn], preve[maxn], h[maxn];//h记录顶点的势
int z[maxm][maxm];
void add_edge(int from, int to, int cap, int cost)
{
    G[from].push_back((edge){to, cap, cost, G[to].size()});
    G[to].push_back((edge){from, 0, -cost, G[from].size() - 1});
}
int min_cost_flow(int s, int f)
{
    int res = 0;
    fill(h, h + V + 1, 0);
    while(f > 0){
        priority_queue<pii, vector<pii>, greater<pii> >que;
        fill(dist, dist + V + 1, INF);
        dist[s] = 0;
        que.push(pii(0, s));
        while(!que.empty()){
            pii p = que.top();que.pop();
            int v = p.se;
            if(dist[v] < p.fi) continue;
            for(int i = 0; i < G[v].size(); i++){
                edge &e = G[v][i];
                if(e.cap>0&&dist[e.to]>dist[v] + e.cost + h[v] - h[e.to]){
                    dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
                    prevv[e.to] = v; preve[e.to] = i;
                    que.push(pii(dist[e.to], e.to));
                }
            }
        }
        if(dist[t] == INF) return -1;
        for(int i = 1; i <= V; i++) h[i] +=dist[i];
        int d = f;
        for(int v = t; v != s; v = prevv[v]){
            d = min(d, G[prevv[v]][preve[v]].cap);
        }
        f -= d;
        res += d * h[t];
        for(int v = t; v!= s; v = prevv[v]){
            edge &e = G[prevv[v]][preve[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}
int main (void)
{
    int c;scanf("%d",&c);
    while(c--){
          memset(G, 0, sizeof(G));
          int N, M;scanf("%d%d",&N,&M);
            s = N * (M + 1), t = s + 1;
            for(int i = 0; i < N; i++){
                add_edge(s, i, 1, 0);
                for(int j = 0; j < M; j++){
                    scanf("%d",&z[i][j]);
                }
            }
            for(int j = 0; j < M; j++){
                for(int k = 0; k < N; k++){
                    add_edge(N + j * N + k, t, 1, 0);
                    for(int i = 0; i < N; i++)
                        add_edge(i, N + j * N + k, 1, z[i][j] * (k + 1));
                }
        }
        V = t + 1;
        printf("%.6f
", (double)min_cost_flow(s, N)/N);
    }

}

KM算法：

很清晰的KM讲解1
很清晰的讲解2
非常生动的匈牙利算法讲解
求解二分图最大权匹配，KM时间复杂度O(n3)，比最小费用最大流解法快多了！

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
int N, M, nm, nn;
const int maxn = 2555, INF = 0x3f3f3f3f;
int usex[55], usey[maxn], match[maxn], lx[55], ly[maxn], slack[maxn];
int z[55][maxn];
bool Find(int x)
{
    usex[x] = 1;
    for(int i = 0; i < nm; i++){
        if(usey[i]) continue;
        int s = lx[x] + ly[i] - z[x][i];
        if(s == 0){
            usey[i] = 1;
            if(match[i] == -1|| Find(match[i] )){
                match[i] = x;
                return true;
            }
        }else if(slack[i] > s){
            slack[i] = s;
        }
    }
    return false;
}
int KM()
{
    memset(ly, 0, sizeof(ly));
    memset(match, -1, sizeof(match));
    for(int i = 0; i <nn; i++){
        lx[i] = - INF;
        for(int j = 0; j < nm; j++){
            if(lx[i] < z[i][j])
                lx[i] = z[i][j];
        }
    }
    for(int a = 0; a < nn; a++){
        memset(slack, 0x3f, sizeof(slack));
        for(;;){
            memset(usex, 0,sizeof(usex));
            memset(usey, 0, sizeof(usey));
            if(Find(a)) break;
            int d = INF;
            for(int i = 0; i < nm; i++){
                if(!usey[i] && d > slack[i]){
                    d = slack[i];
                }
            }
            for(int i = 0; i < nn; i++){
                if(usex[i]) lx[i] -= d;
            }
            for(int i = 0; i < nm; i++){
                if(usey[i]) ly[i] += d;
                else slack[i] -= d;
            }
        }
    }
    int sum = 0;
    for(int i = 0; i < nm; i++){
        if(match[i] > -1){
            sum += z[match[i]][i];
        }
    }
    return -sum;
}
int main (void)
{
    int c;scanf("%d",&c);
    while(c--){
        scanf("%d%d",&N,&M);
        int t;
        nn = N, nm = N * M;
        for(int i = 0; i < N; i++){
            for(int j = 0; j < M; j++){
                scanf("%d",&t);
                for(int k = 0; k < N; k++)
                    z[i][j * N + k] = - t * (k + 1);
            }
        }
        printf("%.6f
", (double)KM()/N);
    }
}

垃圾WA，垃圾垃圾！

---

关于KM的拓展：

• 如果是求最小权，则可以把lx[i[初始化为min(g[i][j])，并在find函数中进行相应改变，也可以简单的将所有边取负数，计算最大权，然后结果再取负数即可。
• 权的最大积的话，把边取对数，然后计算最大权就好啦~最后记得答案要取e的幂~