poj - 3686 The Windy's (KM算法)

题意：n个订单和m个生产车间,每个订单在不同的车间生产所需要的时间不一样,并且每个订单只能在同一个车间中完成,直到这个车间完成这个订单就可以生产下一个订单.现在需要求完成n个订单的平均时间最少是多少.(每个订单的单独时间之和/n,包括等待时间)。

主要是建图,考虑第i个订单在第j个车间倒数第k个被生产,那么第i个订单在第j个区间所花费的时间为k*mat[i][j].

每个区间最多生产n个订单,那么就可以把n*m的图转化成n*(n*m)的图进而用km算法求最小权值。

所以把每个权值取反进而求最大权匹配,但是为什么不能直接求最小权匹配还是没想清楚.

注意G++用%f输出,否则wa.

参考：http://www.tuicool.com/articles/jmYNryf

 #include<iostream>
 #define max(a,b) ((a)>(b)?(a):(b))
 #define min(a,b) ((a)<(b)?(a):(b))
 using namespace std;
 const int nMax = ;
 const int mMax = ;
 const int inf = ;

 int n, m;                     //  n为X集合顶点数量，m为Y集合顶点数量。(1~n和1~m)
 int map[nMax][mMax];          //  map[i][j]：记录X集合中的i到Y集合中的j所需的费用。
 int lx[nMax], ly[mMax];
 int link[mMax];
 bool x[nMax], y[mMax];

 bool dfs(int u){              //  判断能否找到最大完全匹配。
     x[u] = true;
     for(int v = ; v <= m; v ++)
         if(!y[v] && lx[u] + ly[v] == map[u][v]){
             y[v] = true;
             if(!link[v] || dfs(link[v])){
                 link[v] = u;
                 return true;
             }
         }
     return false;
 }

 int KM(){                     //  KM算法。
     int i, j, k, mi;
     for(i = ; i <= n; i ++)
         for(lx[i] = -inf, j = ; j <= m; j ++)
             lx[i] = max(lx[i], map[i][j]);
     memset(ly, , sizeof(ly));
     memset(link, , sizeof(link));
     for(k = ; k <= n; k ++){
         while(){
             memset(x, , sizeof(x));
             memset(y, , sizeof(y));
             if(dfs(k)) break;
             mi = inf;
             for(i = ; i <= n; i ++)
                 if(x[i])
                     for(j = ; j <= m; j ++)
                         if(!y[j])
                             mi = min(mi, lx[i] + ly[j] - map[i][j]);
             for(i = ; i <= n; i ++) if(x[i]) lx[i] -= mi;
             for(i = ; i <= m; i ++) if(y[i]) ly[i] += mi;
         }
     }
     int ans = ;
     for(i = ; i <= m; i ++)
         if(link[i] > )
             ans += map[link[i]][i];
     return ans;
 }

 int main(){
     int t, N, M, i, j, k, mat[nMax][nMax];
     scanf("%d", &t);
     while(t --){
         scanf("%d%d", &N, &M);
         for(i = ; i <= N; i ++)
             for(j = ; j <= M; j ++)
                 scanf("%d", &mat[i][j]);
         n = N, m = N * M;
         for(i = ; i <= N; i ++)         //  KM算法是求最大权，故这里存负数，最后取反求最小权。
             for(j = ; j <= N; j ++)
                 for(k = ; k <= M; k ++){
                     map[i][(k-)*N+j] = -j*mat[i][k];
                     //cout << i << ' ' << (k-1)*N+j << ' ' << j*mat[i][k] << endl;
                 }
         double ans = 1.0*(-KM())/N;      //  精度必须取double才AC。
         printf("%.6f\n", ans);
     }
     return ;
 }

这题还可以用费用流来解决.不过效率没有KM高.

初始源点和每个订单相连,每个车间拆成n*m个车间,然后和汇点相连.然后和km考虑的一样在订单和车间之间连边.

 #include<cstdio>
 #include<queue>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int maxn = ;
 const int INF = 1e9;
 struct edge{
     int to,next;
     int cap,flow,cost;
 }e[maxn*maxn];
 int n,m;
 int head[maxn],sz,res;
 bool inq[maxn];
 int p[maxn],d[maxn],a[maxn];
 void addedge(int u,int v,int cap,int cost){
     e[sz].to = v;e[sz].next = head[u];
     e[sz].cap = cap;e[sz].flow = ;e[sz].cost = cost;
     head[u] = sz ++;
     e[sz].to = u;e[sz].next = head[v];
     e[sz].cap = ;e[sz].flow = ;e[sz].cost = -cost;
     head[v] = sz ++;
 }
 void init(){
     memset(head,-,sizeof(head));
     sz = ;
 }
 queue<int> Q;
 int SPFA(int s,int t){
     memset(inq,,sizeof(inq));
     for(int i =  ; i <= t ; i ++) d[i] = INF;
     inq[s] = ;d[s] = ;p[s] = -;
     a[s] = INF;
     Q.push(s);
     while(!Q.empty()){
         int u = Q.front();Q.pop();
         inq[u] = ;
         for(int i = head[u] ; i != - ; i = e[i].next){
             int v = e[i].to;
             if(e[i].cap - e[i].flow >  && e[i].cost + d[u] < d[v]){
                 d[v] = d[u] + e[i].cost;
                 a[v] = min(e[i].cap - e[i].flow,a[u]);
                 p[v] = i;
                 if(!inq[v]){
                     inq[v] = ;
                     Q.push(v);
                 }
             }
         }
     }
     int u = t;
     if(d[t] == INF) return ;
     res += d[t] * a[t];
     while(u != s){
         e[ p[u] ].flow += a[t];
         e[ p[u] ^  ].flow -= a[t];
         u = e[ p[u] ^  ].to;
     }
     return ;
 }

 void MCMF(int s,int t){
     res = ;
     while(SPFA(s,t));
     printf("%.6f\n",res*1.0/n);
 }

 void solve(){
     init();
     int s,t,mat[][];
     scanf("%d%d",&n,&m);
     s = ;t = n * m + n + ;
     for(int i=;i<=n;i++)
         for(int j=;j<=m;j++)
         scanf("%d",&mat[i][j]);
     for(int i = ; i <= n; i ++)
     {
         addedge(s,i,,);
         for(int j = ; j <= n; j ++)
         {
             for(int k = ; k <= m; k ++)
             {
                 addedge(i,n+(k-)*n+j,,j*mat[i][k]);
             }
         }
     }
     for(int i=n+;i<=n*m+n;i++)
         addedge(i,t,,);
     MCMF(s,t);
 }
 int main()
 {
    //freopen("a.txt","r",stdin);
     int t;
     scanf("%d",&t);
     while(t--) solve();
     return ;
 }