解题报告 之 POJ3686 The Windy‘s
Description
The Windy‘s is a world famous toy factory that owns M top-class workshop to make toys. This year the manager receives N orders for toys. The manager knows that every order will take different amount of hours in different workshops. More
precisely, the i-th order will take Zij hours if the toys are making in the j-th workshop. Moreover, each order‘s work must be wholly completed in the same workshop. And a workshop can not switch to another order until
it has finished the previous one. The switch does not cost any time.
The manager wants to minimize the average of the finishing time of the N orders. Can you help him?
Input
The first line of input is the number of test case. The first line of each test case contains two integers, N and M (1 ≤ N,M ≤ 50).
The next N lines each contain M integers, describing the matrix Zij (1 ≤ Zij ≤ 100,000) There is a blank line before each test case.
Output
For each test case output the answer on a single line. The result should be rounded to six decimal places.
Sample Input
3 3 4 100 100 100 1 99 99 99 1 98 98 98 1 3 4 1 100 100 100 99 1 99 99 98 98 1 98 3 4 1 100 100 100 1 99 99 99 98 1 98 98
Sample Output
2.000000 1.000000 1.333333
题目大意：有n个玩具要生产，有m个工厂，每个工厂同时只能加工一个玩具，给出每个工厂生产不同玩具所需的时间，问每个玩具生产平均需要花的时间最少为多少？
分析：这个题比较抽象，不是很好想明白。首先很简单可以得到的结论是：如果只有一个工厂，那么它一定是先生产时间少的玩具，再生产时间多的玩具（想想为啥？）。那么最终这个工厂花费的时间就是
T = Z1+(Z1+Z2)+(Z1+Z2+Z3)+……+(Z1+Z2+Z3……+Zn) 。 化简得到：
T = N*Z1+(N-1)*Z2+(N-2)*Z3+……+Zn。 **
注意这个公式要从抽象的层面去看待，不要试图寻找其中的含义不然会很绕。
然后我们的大问题就转化为，将n种玩具分配给m家工厂，每家工厂都按照上述的最佳策略去生产分配到的玩具。即我们现在需要考虑的是，如何分配这n种玩具？首先很明显枚举肯定超，就不说了。那么我们怎么想呢，这里借助了最小费用流的想法。先考虑简单的情形：如果问题是每个厂家仅分配一个玩具，那么直接上最小费用流跑即可。这里变成了多个厂家，我们根据**公式，假设一个厂家分配到了一些玩具，假设为K个玩具好了，那么它就按照上面的公式运算即可。那某个厂家到底分配到了几个玩具，又是哪几个呢？这里我们交给最小费用流去试验，而没有一种确定的方法。
具体操作是，超级源点连接没一个玩具节点，负载为1，费用为0。然后将每个厂家分成n个节点，厂家j的第k个节点表示**公式中的系数k（k=1，2，3……N）应的是哪个玩具
i，当然费用对应的增长k*cost[j][i]。当然对于每一个厂家，不一定1~n都有玩具，这交给最小费用流去解决。然后每个厂家的所有节点都连接到超级汇点。最后跑最小费用流min_cost_flow（n）即可自动规划出一条最优方案。
Q：如果某玩具选择了厂家k较大的一条路但该厂家k小的路却没用怎么办？
A：不会出现这种情况，因为是最小费用流，当然会优选k小的路。
Q：如果多个玩具同时选了厂家j的系数k节点不是就重复了么？
A：不会，建图的时候厂家j的系数k节点连到des负载为1，所以不会重复。
上代码：
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<deque>
using namespace std;
const int MAXN = 3010;
const int MAXM = 1100000;
const int INF = 0x3f3f3f3f;
struct Edge
{
int from, to, cap, next, cost;
};
Edge edge[MAXM];
int prevv[MAXN];
int preve[MAXN];
int dist[MAXN];
int head[MAXN];
int h[MAXN]; //标号数组
int cost[MAXN][MAXN];
int src, des, cnt;
void addedge( int from, int to, int cap, int cost )
{
edge[cnt].from = from;
edge[cnt].to = to;
edge[cnt].cap = cap;
edge[cnt].cost = cost;
edge[cnt].next = head[from];
head[from] = cnt++;
swap( from, to );
edge[cnt].from = from;
edge[cnt].to = to;
edge[cnt].cap = 0;
edge[cnt].cost = -cost;
edge[cnt].next = head[from];
head[from] = cnt++;
}
int SPFA( )
{
deque<int> dq;
bool inqueue[MAXN];
memset( dist, INF, sizeof dist );
memset( inqueue, 0, sizeof inqueue );
dq.push_back( src );
inqueue[src] = 1;
dist[src] = 0;
while(!dq.empty( ))
{
int u = dq.front( );
dq.pop_front( );
inqueue[u] = 0;
for(int i = head[u]; i != -1; i = edge[i].next)
{
int v = edge[i].to;
if(edge[i].cap > 0 && dist[u] + edge[i].cost + h[u] - h[v]< dist[v])
{
dist[v] = dist[u] + edge[i].cost + h[u] - h[v];
prevv[v] = u;
preve[v] = i;
if(!inqueue[v])
{
if(!dq.empty( ) && dist[v] <= dist[dq.front( )])
{
dq.push_front( v );
}
else
dq.push_back( v );
}
}
}
}
return 0;
}
int min_cost_flow( int f )
{
memset( h, 0, sizeof h );
int cost = 0;
while(f > 0)
{
SPFA( );
if(dist[des] == INF)
{
return -1;
}
for(int u = 1; u < MAXN; u++)
h[u] += dist[u];
int d = f;
for(int i = des; i != src; i = prevv[i])
{
d = min( d, edge[preve[i]].cap );
}
f -= d;
cost += d*h[des];
for(int i = des; i != src; i = prevv[i])
{
edge[preve[i]].cap -= d;
edge[preve[i] ^ 1].cap += d;
}
}
return cost;
}
int main( )
{
int n, m;
int kase;
cin >> kase;
src = 0;
des = 3005;
while(kase--)
{
cin >> n >> m;
memset( head, -1, sizeof head );
cnt = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
cin >> cost[i][j];
}
}
for(int i = 1; i <= n; i++)
{
addedge( src, i, 1, 0 );
}
for(int j = 1; j <= m; j++)
{
for(int k = 1; k <= n; k++)
{
addedge( j * 50 + k, des, 1, 0 );
for(int i = 1; i <= n; i++)
{
addedge( i, j * 50 + k, 1, k*cost[i][j] );
}
}
}
printf( "%.6lf\n", min_cost_flow( n ) / (double)n );
}
return 0;
}
~ 代码狗祝你劳动节快乐 ~
解题报告 之 POJ3686 The Windy's