POJ 3686 The Windy's

题意：一个工厂接到了N张订单。他们有M个车间，如果第i张单在第j个车间加工需要花费Zij的时间。现在给出这个Z的矩阵，问做完这N张单需要时间的平均值（总时间/N）包括等待时间。（比如说我在一个车间连续以1个时间单位接了3张单，那么总时间为1+2+3=6，平均值为6/3=2）(N,M<=50)

给了5000ms。假设第i个单子在第j个车间倒数第k个被加工，那么对应总时间会增加k*Zij。那么接下来的做法就显而易见了，拆下点，将(车间号,倒数第k个加工的席位)作为点来建图，从订单i向这些点连边，边权为k*Zij。KM或者费用流都可以上。ZKWflow跑了1000MS，普通的费用流跑了2000+MS，KM可以跑到0MS。。。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <queue>
#define maxn 2600
#define maxm 1000000
#define INF 1<<30
using namespace std;

struct ZKW_flow{
    int src,sink,e,n;
    int first[maxn];
    int cap[maxm],cost[maxm],v[maxm],next[maxm];
    void init(){
        e = 0;
        memset(first,-1,sizeof(first));
    }

    void add_edge(int a,int b,int cc,int ww){
        cap[e] = cc;cost[e] = ww;v[e] = b;
        next[e] = first[a];first[a] = e++;
        cap[e] = 0;cost[e] = -ww;v[e] = a;
        next[e] = first[b];first[b] = e++;
    }

    int d[maxn];

    void spfa(){
        for(int i = 1;i <= n;i++)   d[i] = INF;
        priority_queue<pair<int,int> > q;
        d[src] = 0;
        q.push(make_pair(0,src));
        while(!q.empty()){
            int u = q.top().second,dd = -q.top().first;
            q.pop();
            if(d[u] != dd)   continue;
            for(int i = first[u];i != -1;i = next[i]){
                if(cap[i] && d[v[i]] > dd + cost[i]){
                    d[v[i]] = dd + cost[i];
                    q.push(make_pair(-d[v[i]],v[i]));
                }
            }
        }
        for(int i = 1;i <= n;i++)   d[i] = d[sink] - d[i];
    }

    int Mincost,Maxflow;
    bool used[maxn];

    int add_flow(int u,int flow){
        if(u == sink){
            Maxflow += flow;
            Mincost += d[src] * flow;
            return flow;
        }
        used[u] = true;
        int now = flow;
        for(int i = first[u];i != -1;i = next[i]){
            int &vv = v[i];
            if(cap[i] && !used[vv] && d[u] == d[vv] + cost[i]){
                int tmp = add_flow(vv,min(now,cap[i]));
                cap[i] -= tmp;
                cap[i^1] += tmp;
                now -= tmp;
                if(!now) break;
            }
        }
        return flow - now;
    }

    bool modify_label(){
        int dd = INF;
        for(int u = 1;u <= n;u++)   if(used[u])
            for(int i = first[u];i != -1;i = next[i]){
                int &vv = v[i];
                if(cap[i] && !used[vv]) dd = min(dd,d[vv] + cost[i] - d[u]);
            }
        if(dd == INF)    return false;
        for(int i = 1;i <= n;i++)   if(used[i]) d[i] += dd;
        return true;
    }

    int min_cost_flow(int ss,int tt,int nn){
        src = ss,sink = tt,n = nn;
        Mincost = Maxflow = 0;
        spfa();
        while(1){
            while(1){
                for(int i = 1;i <= n;i++) used[i] = 0;
                if(!add_flow(src,INF))  break;
            }
            if(!modify_label()) break;
        }
        return Mincost;
    }
};

ZKW_flow g;

int main(){
    int kase,n,m,z;
    scanf("%d",&kase);
    while(kase--){
        g.init();
        scanf("%d%d",&n,&m);
        int S = n+n*m+1,T = n+n*m+2;
        for(int i = 1;i <= n;i++)   g.add_edge(S,i,1,0);
        for(int i = 1;i <= n*m;i++) g.add_edge(i+n,T,1,0);
        for(int i = 1;i <= n;i++){
            for(int j = 1;j <= m;j++){
                scanf("%d",&z);
                for(int k = 1;k <= n;k++)   g.add_edge(i,n+(j-1)*n+k,1,k*z);
            }
        }
        int ans = g.min_cost_flow(S,T,T);
        printf("%.6f
",(ans+0.0)/n);
    }
    return 0;
}