POJ 3686：The Windy's（最小费用最大流）***

http://poj.org/problem?id=3686

题意：给出n个玩具和m个工厂，每个工厂加工每个玩具有一个时间，问要加工完这n个玩具最少需要等待的平均时间。例如加工1号玩具时间为t1，加工2号玩具时间为t2。那么先加工玩具1再加工玩具2花费的时间是t1+（t1+t2），先加工玩具2在加工玩具1花费的时间是t2+（t1+t2）。

思路：假设所有玩具在一个工厂加工，那么等待的时间是

t1 + (t1 + t2) + (t1 + t2 + t3) + ……

= t1 * n + t2 * (n-1) + t3 * (n-2) + ……

那么可以把每个工厂能够加工n个玩具转化成有n个工厂每个只能够加工一个玩具，即每个工厂被划分成权值w为1，2，3，……，n的工厂，然后每个工厂制造某个玩具花费的时间为权值*本来需要的时间。

建图即：

源点向每个玩具连流量为1，费用为0的边，

每个玩具向每个工厂连流量为1，费用为w（w为工厂的权值）*cost的边，

每个工厂向源点连流量为1，费用为0的边。

然后跑一遍最小费用最大流，最后把答案除以玩具数就是最终答案。

这个建图思维很厉害。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <queue>
 using namespace std;
 #define N 2666
 #define INF 0x3f3f3f3f
 struct Edge {
     int u, v, nxt, cap, cost;
     Edge () {}
     Edge (int u, int v, int nxt, int cap, int cost) : u(u), v(v), nxt(nxt), cap(cap), cost(cost) {}
 } edge[N*N];
 int n, m, mp[][], head[N], tot, pre[N], dis[N], vis[N], S, T;

 void Add(int u, int v, int cap, int cost) {
     edge[tot] = Edge(u, v, head[u], cap, cost); head[u] = tot++;
     edge[tot] = Edge(v, u, head[v], , -cost); head[v] = tot++;
 }

 bool SPFA(int S, int T) {
     queue<int> que; que.push(S);
     memset(dis, INF, sizeof(dis));
     memset(vis, , sizeof(vis));
     dis[S] = , vis[S] = ;
     while(!que.empty()) {
         int u = que.front(); que.pop();
         vis[u] = ; // 忘了这句.WA了N久
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v, cap = edge[i].cap, cost = edge[i].cost;
             if(dis[v] > dis[u] + cost && cap > ) {
                 dis[v] = dis[u] + cost; pre[v] = i;
                 if(!vis[v]) vis[v] = , que.push(v);
             }
         }
     }
     return dis[T] < INF;
 }

 double MFMC(int S, int T) {
     int u, flow;
     double ans = ;
     while(SPFA(S, T)) {
         u = T, flow = INF;
         while(u != S) {
             if(flow > edge[pre[u]].cap) flow = edge[pre[u]].cap;
             u = edge[pre[u]].u;
         } u = T;
         while(u != S) {
             edge[pre[u]].cap -= flow, edge[pre[u]^].cap += flow;
             ans += edge[pre[u]].cost * flow;
             u = edge[pre[u]].u;
         }
     }
     return ans;
 }

 int main() {
     int t; scanf("%d", &t);
     while(t--) {
         scanf("%d%d", &n, &m);
         for(int i = ; i <= n; i++)
             for(int j = ; j <= m; j++)
                 scanf("%d", &mp[i][j]);
         S = , T = n * m + n + ;
         memset(head, -, sizeof(head)); tot = ;
         for(int i = ; i <= n; i++) {
             Add(S, i, , );
             for(int j = ; j <= m; j++) {
                 Add(j * n + i, T, , );
                 for(int k = ; k <= n; k++) {
                     Add(i, j * n + k, , k * mp[i][j]);
                 }
             }
         }
         printf("%.6f\n", MFMC(S, T) / n);
     }
     return ;
 }