poj 2516 Minimum Cost

最新推荐文章于 2019-07-24 12:51:23 发布
最新推荐文章于 2019-07-24 12:51:23 发布
阅读量295 收藏
点赞数
分类专栏： ACM算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/const_qiu/article/details/47126431
版权

Minimum Cost

题意：给出： 

n个客户，m个仓库，k种商品

每个客户对每种商品的需求书

每个仓库里每种商品的数目

对于每种商品，每个客户在各个仓库的进价

（具体可以见输入代码注释）

求所有客户购买需要的所有商品的最小费用，如果某个客户不能购买到某种商品那么输出-1


思路：最小费用最大流


解题方法：对每种商品算一次最小费用最大流

主要是建图：对于每次求解：令源点为0，仓库为[1~m]，客户为[m+1,m+n],汇点为n+m+1。源点与仓库连接，单价为0，容量为该仓库拥有该商品的数目；仓库与客户相连，单价为题目给出的单价，容量为INF；客户与汇点连接，费用为0，容量为该客户对该商品的需求量；


代码如下：两种存边方法，时间都差不多，可参考

一：手写模拟邻接表

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define MAXN 110
#define MAXE 6000
#define INF 0x3f3f3f3f
#define MIN(a,b) a<b?a:b
using namespace std;
int shkp[MAXN][MAXN],supp[MAXN][MAXN],cost[MAXN][MAXN][MAXN];
int head[MAXN],dist[MAXN],vist[MAXN],pre[MAXN],pos[MAXN];
int cnt;
int mincost,maxflow;
struct Edge{
    int to;
    int cap;
    int cost;
    int next;
}edge[MAXE];
void add(int u,int v,int cap,int cost){
    edge[cnt].to = v;
    edge[cnt].cap = cap;
    edge[cnt].cost = cost;
    edge[cnt].next = head[u];
    head[u]=cnt++;

    edge[cnt].to = u;
    edge[cnt].cap = 0;
    edge[cnt].cost = -cost;
    edge[cnt].next = head[v];
    head[v]=cnt++;
}

void MCMF(int s,int e){
    int i,u,v;
    int aug;
    mincost=maxflow=0;
    for(;;){
        memset(vist,0,sizeof(vist));
        memset(pre,-1,sizeof(pre));
        for(int i=0;i<=e;i++)
            dist[i]=INF;
        dist[s]=0;
        pre[s]=s;
        vist[s]=1;
        queue<int>q;
        q.push(s);
        while(!q.empty()){
            u=q.front();
            q.pop();
            vist[u]=0;
            for(int i=head[u];i!=-1;i=edge[i].next){
                v=edge[i].to;
                if(edge[i].cap>0&&dist[v]>dist[u]+edge[i].cost){
                    dist[v]=dist[u]+edge[i].cost;
                    pre[v]=u;
                    pos[v]=i;
                    if(!vist[v]){
                        vist[v]=1;
                        q.push(v);
                    }
                }
            }
        }
        if(dist[e]==INF) break;
        aug=INF;
        for(int u=e;u!=s;u=pre[u]){
            aug=MIN(aug,edge[pos[u]].cap);
        }
        maxflow+=aug;
        mincost+=dist[e]*aug;
        for(int u=e;u!=s;u=pre[u]){
            edge[pos[u]].cap-=aug;
            edge[pos[u]^1].cap+=aug;
        }
    }
}

int main(){
    int n,m,k;
    int need,totalcost,totalflow;
    ///n=客户,m=仓库,k=商品
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        if(n==0&&m==0&&k==0) break;
        need=totalcost=totalflow=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=k;j++){
                ///shkp[i][j]:客户i需要j商品的个数
                scanf("%d",&shkp[i][j]);
                need+=shkp[i][j];
            }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=k;j++){
                ///supp[i][j]:仓库i存有j商品的个数
                scanf("%d",&supp[i][j]);
            }
        for(int r=1;r<=k;r++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                ///cost[r][i][j]:i客户需要在j仓库采购r商品的单价
                    scanf("%d",&cost[r][i][j]);
                }
            }
        }
        for(int r=1;r<=k;r++){
           // cout<<"he"<<endl;
            cnt=0;
            memset(head,-1,sizeof(head));
            for(int i=1;i<=m;i++){
                add(0,i,supp[i][r],0);
            }
            for(int i=1;i<=n;i++){
                add(i+m,n+m+1,shkp[i][r],0);
            }
            for(int i=1;i<=n;i++)
                for(int j=1;j<=m;j++)
                    add(j,i+m,INF,cost[r][i][j]);
            MCMF(0,n+m+1);
            totalcost+=mincost;
            totalflow+=maxflow;

        }
        if(totalflow!=need){
            totalcost=-1;
        }
        printf("%d\n",totalcost);

    }
    return 0;
}

二：vector： 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
#define MAXN 110
#define INF 0x3f3f3f3f
#define MIN(a,b) a<b?a:b;
struct Edge{
    int from;
    int to;
    int cap;
    int flow;
    int cost;
    Edge(int u,int v,int c,int f,int cost):from(u),to(v),cap(c),flow(f),cost(cost){}
};
struct MCMF{
    int m,mincost,maxflow;
    vector<Edge>edges;
    vector<int>G[MAXN];
    int inq[MAXN];
    int d[MAXN];
    int p[MAXN];
    int a[MAXN];
    void init(int n){
        this->maxflow=0;
        this->mincost=0;
        for(int i=0;i<=n;i++){
            G[i].clear();
        }
        edges.clear();
    }
    void addEdge(int u,int v,int cap,int cost){
        edges.push_back(Edge(u,v,cap,0,cost));
        edges.push_back(Edge(v,u,0,0,-cost));
        m=edges.size();
        G[u].push_back(m-2);
        G[v].push_back(m-1);
    }
    void MincostMaxflow(int s,int t){
        mincost=maxflow=0;
        for(;;){
            memset(inq,0,sizeof(inq));
            memset(p,-1,sizeof(p));
            for(int i=0;i<=t;i++) d[i]=INF;
            d[s]=0;
            inq[s]=1;
            p[s]=s;
            a[s]=INF;
            queue<int>Q;
            Q.push(s);
            while(!Q.empty()){
                int u = Q.front();Q.pop();
                inq[u]=0;
                for(int i=0;i<G[u].size();i++){
                    Edge &e = edges[G[u][i]];
                    if(e.cap>e.flow&&d[e.to]>d[u]+e.cost){
                        d[e.to]=d[u]+e.cost;
                        p[e.to]=G[u][i];
                        a[e.to]=MIN(a[u],e.cap-e.flow);
                        if(!inq[e.to]){
                            Q.push(e.to);
                            inq[e.to]=1;
                        }
                    }
                }
            }
            if(d[t]==INF) break;
            this->maxflow+=a[t];
            this->mincost+=d[t]*a[t];
            for(int u=t;u!=s;u=edges[p[u]].from){
                edges[p[u]].flow += a[t];
                edges[p[u]^1].flow -= a[t];
            }
        }
    }
};
int shkp[MAXN][MAXN],supp[MAXN][MAXN],cost[MAXN][MAXN][MAXN];
int main(){
    int need,totalcost,totalflow;
    ///n=客户,m=仓库,k=商品
    int n,m,k;
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        if(n==0&&m==0&&k==0) break;
        need=totalcost=totalflow=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=k;j++){
                ///shkp[i][j]:客户i需要j商品的个数
                scanf("%d",&shkp[i][j]);
                need+=shkp[i][j];
            }
        for(int i=1;i<=m;i++)
            for(int j=1;j<=k;j++){
                ///supp[i][j]:仓库i存有j商品的个数
                scanf("%d",&supp[i][j]);
            }
        for(int r=1;r<=k;r++){
            for(int i=1;i<=n;i++){
                for(int j=1;j<=m;j++){
                ///cost[r][i][j]:i客户需要在j仓库采购r商品的单价
                    scanf("%d",&cost[r][i][j]);
                }
            }
        }
        MCMF mcmf;
        for(int r=1;r<=k;r++){
            mcmf.init(n+m+1);
            for(int i=1;i<=m;i++){
                //add(0,i,supp[i][r],0);
                mcmf.addEdge(0,i,supp[i][r],0);
            }
            for(int i=1;i<=n;i++){
                mcmf.addEdge(i+m,n+m+1,shkp[i][r],0);
            }
            for(int i=1;i<=n;i++)
                for(int j=1;j<=m;j++)
                    mcmf.addEdge(j,i+m,INF,cost[r][i][j]);
            mcmf.MincostMaxflow(0,n+m+1);

            totalcost+=mcmf.mincost;
            totalflow+=mcmf.maxflow;
        }
        if(totalflow!=need){
            totalcost=-1;
        }
        printf("%d\n",totalcost);

    }
    return 0;
}



const_qiu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ2516-Minimum Cost
09-02
北大POJ2516-Minimum Cost 解题报告+AC代码 http://blog.csdn.net/lyy289065406/article/details/6742534
POJ 2516 Minimum Cost 费用流
Adolphrocs的博客
12-03 241
题目源：https://vjudge.net/problem/POJ-2516              http://poj.org/problem?id=2516 模板源：https://blog.csdn.net/Adolphrocs/article/details/84558274 题解：费用流 求出对于每个k，supply 与 shopkeeper的网络流，然后累加 #incl...
POJ 2516 Minimum Cost
InverseDZY的博客
02-22 120
第一道费用流的题目，看了别人博客大概学会了这种算法，就是问如果现在流量也是有单位费用的，如何最大流且有最小费用？ 解法是一种贪心，不停地去找费用最小的最短路，最后到无法增广时得到最小费用最大流。这题我用的邻接矩阵，注意题目的图必须分成K个去做，稍微有点复杂，但是基本是模版题，我的建图原则是源点与供应商的最大流量是它能提供的商品，供应商与商店流量无限大，商店与汇点的最大流量是它需要的商品个数（比较复...
poj2516 Minimum Cost
Elijahqi
12-25 155
elijahqi’s blog DescriptionDearboy, 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.Dea
POJ2516 Minimum Cost
H992109898的博客
04-30 419
最小费用最大流模板，邻接表。
POJ2516 Minimum Cost (费用流)
CY05627的博客
07-24 237
题意： 摘自：https://blog.csdn.net/qq_30974369/article/details/76648579 一行是三个数字:N,M,K 分别表示有N个商店，M个供货商，K中货物 接下来是N行，每行K个整数 对于第i行第j列，表示的是第i个商店对于货物j的需求 再接着，M行，每行K个整数 对于第i行第j列，表示的是第i个供货商对于货物j的存货 接下来有K个N*M的矩形 第X个...
POJ2516__最小费用最大流
10-23
poj2516代码最小费用最大流
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
HDU 2648 Shopping
const_qiu的专栏
01-06 919
Shopping Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2126    Accepted Submission(s): 712 Problem Description Every girl likes
ZOJ 2277 The Gate to Freedom（n^n）
const_qiu的专栏
07-31 841
The Gate to Freedom Time Limit: 2 Seconds      Memory Limit: 32768 KB Background It is dark at night. It is silence at night. It is she in the dark. It is she in the silence. Then a light
线段树总结（单点更新，区间更新，区间求和，区间求最值）
const_qiu的专栏
08-09 819
注：每个功能在代码中有注释，具体详解可自己输出测试 1：区间更新与区间求和 #include #include #include using namespace std; #define N 400010 #define LL long long LL sum[N],lazy[N]; ///向上更新求和 void pushUp(int root){ sum[root]=sum[
poj 3715 Blue and Red（二分图最大匹配+字典序输出）
const_qiu的专栏
08-11 577
注：题意纠结了半天，后来看了很多大牛的博客，才理解透，最后发现就是匈牙利，纯暴力~还有就是字典序总觉得难透~ Blue and Red 题意：有两个对，红队（0）和蓝队（1）。然后有n个人属于这两个队的某一只队，既然有人，那么肯定会有两两是朋友的，一共m对。但是现在有一个测试，某某不希望有不在同一个队的两个人是朋友关系，说什么会影响测试，所以需要把某些人删掉使这个条件成立，而且删人的话还要按字
HDU 1086 You can Solve a Geometry Problem too 判断任意两线段是否相交
const_qiu的专栏
10-09 485
题目链接:
zoj 1526 Big Number （N阶乘的位数）
const_qiu的专栏
08-01 469
注：还是推公式，类似zoj2277，打表超内存（话说才10^7数组就爆了），默默暴力计算930ms险过 Big Number Time Limit: 10 Seconds      Memory Limit: 32768 KB In many applications very large integers numbers are required. Some of
hdu 2952 Counting Sheep（简单dfs）
const_qiu的专栏
08-09 462
#include #include #include using namespace std; #define N 105 char map[N][N]; int go[4][2]={0,1,0,-1,1,0,-1,0};///四个方向判断 int m,n; void dfs(int s,int t){     if(map[s][t]=='.') return ;///碰到不是
2015 Multi-University Training Contest 7
const_qiu的专栏
08-11 429
注：只看了1005&&1007，个人水平比较low， 1005 - The shortest problem 乍看一眼，有点像前几天水的一道数论水题，说求一个数（2*10^9）的每位数之和，然后与此题无关系，其实题目就是不断求各位数的和然后补充上去，执行t次后判断得到的数时候能被11整除，很明显是有规律的，此数已经十几万位的数，不能直接%11，所以就会发现其实被11整除的数（只需判断奇数位的和
zoj 1730 Crazy Tea Party（方向感太差，遇环就晕）
const_qiu的专栏
08-01 425
注：怎么都说是个水题~~TTTT~~怪我方向感太差 Crazy Tea Party Time Limit: 2 Seconds      Memory Limit: 65536 KB n participants of "crazy tea party" sit around the table. Each minute one pair of neighbors can cha
POJ 2446 Chessboard
const_qiu的专栏
07-27 421
Chessboard 题意：一个n*m的矩阵方格，其中有k个1*1的小方格不能使用，问剩下的是否能恰好用1*2的方格铺满 思路：二分图的最大匹配 匈牙利算法 解题方法：要点1：一个1*2的方块可分成两个1*1的小方块，这两个小方块的横纵坐标和必定一个为奇数一个为偶数 要点2：将奇数的小方块作为二分图的左边，然后去找能够与它组成1*2的方块（也就是与它相邻的）构成二分图的右边
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值