POJ 3686.The Windy's 最小费用最大流

The Windy‘s

Time Limit: 5000MS   Memory Limit: 65536K
Total Submissions: 5477   Accepted: 2285

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

Source

POJ Founder Monthly Contest – 2008.08.31, windy7926778

题目链接:http://poj.org/problem?id=3686

题意:有n个玩具m个工厂,一个工厂同时只能生产一个玩具。问平均每个玩具的生产时间。

思路:现在有n个玩具,m个工厂,但是一个工厂可以生产多个玩具。当一个工厂按顺序生产a1,a2,a3...,an玩具,每个玩具的生产时间为Za1,Za1+Za2,Za1+Za2+Za3,...,Za1+Za2+Za3+...+Zan。T=n*Za1+(n-1)*Za2+(n-2)*Za3+...+Zan。这个式子也可以理解为,多个只能生产1个玩具的工厂,但是时间为1~n倍。

代码:

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define PI acos(-1.0)
const int maxn=3e5+100,maxm=1e5+100,inf=0x3f3f3f3f,mod=1e9+7;
const ll INF=1e18+7;
struct edge
{
    int from,to;
    int cap,cost;
    int rev;
};
int NN;
vector<edge>G[maxn];
int h[maxn];
///顶点的势,取h(u)=(s到u的最短距离),边e=(u,v)的长度变成d`(e)=d(e)+h(u)-h(v)>=0
int dist[maxn];
int prevv[maxn],preve[maxn];///前驱结点和对应的边
void addedge(int u,int v,int cap,int cost)
{
    edge e;
    e.from=u,e.to=v,e.cap=cap,e.cost=cost,e.rev=G[v].size();
    G[u].push_back(e);
    e.from=v,e.to=u,e.cap=0,e.cost=-cost,e.rev=G[u].size()-1;
    G[v].push_back(e);
}
int min_cost_flow(int s,int t,int f)
{
    int res=0;
    fill(h,h+NN,0);
    while(f>0)
    {
        priority_queue<P,vector<P>,greater<P> >q;
        fill(dist+1,dist+NN,inf);
        dist[s]=0;
        q.push(P(dist[s],s));
        while(!q.empty())
        {
            P p=q.top();
            q.pop();
            int u=p.second;
            if(dist[u]<p.first) continue;
            for(int i=0; i<G[u].size(); i++)
            {
                edge e=G[u][i];
                if(e.cap>0&&dist[e.to]>dist[u]+e.cost+h[u]-h[e.to])
                {
                    dist[e.to]=dist[u]+e.cost+h[u]-h[e.to];
                    prevv[e.to]=u;
                    preve[e.to]=i;
                    q.push(P(dist[e.to],e.to));
                }
            }
        }
        if(dist[t]==inf) return res;
        for(int i=0; i<NN; i++) h[i]+=dist[i];
        int d=f;
        for(int i=t; i!=s; i=prevv[i])
            d=min(d,G[prevv[i]][preve[i]].cap);
        f-=d;
        res+=d*h[t];
        for(int i=t; i!=s; i=prevv[i])
        {
            //cout<<i<<" ";
            edge &e=G[prevv[i]][preve[i]];
            e.cap-=d;
            G[i][e.rev].cap+=d;
        }
        //cout<<s<<endl;
    }
    return res;
}
int z[100][100];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        int s=0,t=n+n*m+1;
        NN=t+1;
        for(int i=1; i<=n; i++)
        {
            addedge(s,i,1,0);
            for(int j=1; j<=m; j++)
            {
                scanf("%d",&z[i][j]);
                for(int k=1; k<=n; k++)
                    addedge(i,n+(j-1)*n+k,1,k*z[i][j]);
            }
        }
        for(int j=1; j<=m; j++)
        {
            for(int k=1; k<=n; k++)
                addedge(n+(j-1)*n+k,t,1,0);
        }
        printf("%.6f\n",min_cost_flow(s,t,inf)*1.0/n);
        for(int i=0; i<NN; i++) G[i].clear();
    }
    return 0;
}

最小费用最大流

POJ 3686.The Windy's 最小费用最大流

时间: 2024-12-24 14:15:30

POJ 3686.The Windy's 最小费用最大流的相关文章

POJ 3686 The Windy&#39;s 最小权值匹配

点击打开链接 The Windy's Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 3788   Accepted: 1630 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.

poj 2135 Farm Tour (最小费用最大流模板)

网络流的费用: 在实际应用中,与网络流有关的问题,不仅涉及流量,而且还有费用的因素.网络的每一条边(v,w)除了给定容量cap(v,w)外,还定义了一个单位流量费用cost(v,w) 最小费用最大流问题 给定网络G,要求G的一个最大用流flow,使流的总费用最小. 求解MCMF问题的算法: 最小费用最大流最常用和基本的算法我们可以称它为最小费用路算法,其思想与求最大流的增广路算法类似,不断在残流网络中寻找从源s到汇t的最小费用路,即残流网络中从s到t的以费用为权的最短路,然后沿最小费用路增流,直

POJ 2516 Minimum Cost(最小费用最大流啊)

题目链接:http://poj.org/problem?id=2516 Description Dearboy, a goods victualer, now comes to a big problem, and he needs your help. In his sale area there are N shopkeepers (marked from 1 to N) which stocks goods from him.Dearboy has M supply places (mar

POJ 2516 Minimum Cost (最小费用最大流)

POJ 2516 Minimum Cost 链接:http://poj.org/problem?id=2516 题意:有M个仓库,N个商人,K种物品.先输入N,M,K.然后输入N行K个数,每一行代表一个商人要购买的物品,其中K个数分别表示要购买的每件商品数.然后是M行K个数,每行表示仓库里的情况,其中K个数分别每种物品的库存量.接下来是K个矩阵,每个矩阵为N*M,分别表示第K种物品从M个仓库运到第N个商人的花费.问能否合理安排,使得花费最少,如果不行就输出-1. 思路: 一开始的时候,竟然构造了

poj 2516 Minimum Cost 【最小费用最大流】

题目:poj 2516 Minimum Cost 题意:有 n 个商店,k种物品和 m 个供货商,让你求进满足商店需求的货物的最小花费? 有必要说一下输入数据. 首先n ,k ,m 然后是一个n*m的矩阵,n个商店对每种货物的需求,表示第 i 个商店需要第 j 种货物 x个 然后是m * k 的矩阵,m个供货商可以供k种货物的数量,表示第 i 个供货商 提供第 j 中货物 x 个 接下来是 k 个 n * m 的矩阵,表示第 i 个货物,由 k 供应商发货给 j 商店的价格x (注意如果供不应求

poj 2526 Minimum Cost【最小费用最大流】

题目链接:http://poj.org/problem?id=2516 题意: n个店主 m个供应商 k种货物 给你店主对k种货物的需求及供货商k种货物的囤货量及K种运输费用. 解法:k次费用流,分别求每种货物的费用.源点到供应点建边,店主到汇点建边,费用均为0,容量为1.然后供应点到店主建边,费用为矩阵,容量无穷大即可. 代码: /* POJ 2195 Going Home 邻接矩阵形式最小费用最大流 */ #include<stdio.h> #include<iostream>

POJ - 2195 Going Home(最小费用最大流)

1.N*M的矩阵中,有k个人和k个房子,每个人分别进入一个房子中,求所有人移动的最小距离. 2.人看成源点,房子看成汇点,求最小费用最大流. 建图-- 人指向房子,容量为1,费用为人到房子的曼哈顿距离. 建立超级源点和超级汇点:超级源点指向人,容量为1,费用为0:超级汇点指向房子,容量为1,费用为0. 求超级源点到超级汇点的最小费用最大流即可. ps:容量为什么都设为1?---有待研究.. 3. 1.Bellman-Ford: #include<iostream> #include<st

POJ 2135 Farm Tour(最小费用最大流,变形)

题意:给一个无向图,FJ要从1号点出发到达n号点,再返回到1号点,但是路一旦走过了就会销毁(即回去不能经过),每条路长度不同,那么完成这趟旅行要走多长的路?(注:会有重边,点号无序,无向图!) 思路: 有重边,要用邻接表.所给的每条边都要变成4条有向边!否则可能一开始就到达不了终点了.最后要再加上一个源点和汇点,容量cap(源点,1)=2,指定只能走两次,再规定其他所给的边的容量是1就行了,当边被走过了,就自动增加了流,也就走不了了. 解释看代码更清晰. 1 //#pragma comment(

poj 2135 Farm Tour【 最小费用最大流 】

第一道费用流的题目--- 其实---还是不是很懂,只知道沿着最短路找增广路 建图 源点到1连一条容量为2(因为要来回),费用为0的边 n到汇点连一条容量为2,费用为0的边 另外的就是题目中输入的了 另外这题是无向边----- maxn 开到1000会re---- 存个模板先吧------------------------------------------ 1 #include<cstdio> 2 #include<cstring> 3 #include<cmath>