POJ 2146 Minimum Cost KM/最小费用流

最新推荐文章于 2018-07-29 22:33:57 发布
最新推荐文章于 2018-07-29 22:33:57 发布
阅读量99 收藏
点赞数
原文链接：http://www.cnblogs.com/sdau10kuaile/archive/2012/02/23/2364105.html
版权

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

题意：N个批发商，M个供应商，K种商品，每个批发商每种商品都需要一定的数量，每个供应商每种商品都提供一定的数量。

    每个供应商向每个批发商运送某种单位数量的商品

KM  思路：每种商品 需要a个，那x边就有a个点，该种商品供应有b个，那y边就有b个点，

 权值为，运费。。。说的有点乱。就是我看了别人的这种思路之后，输入还是没搞定。。。这输入也挺有技巧的，我是

这样觉得   匈牙利算法时间复杂度O(ne) ,KM每找到一条增广路径要顶标调整，复杂度O(ne^2) 不知道我这个KM的复杂度

是不是那么小

代码（KM)：

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#define inf 1<<30
#define Max(a,b)a>b?a:b
#define Min(a,b)a<b?a:b
#define nMAX 155
using namespace std;

int map[nMAX][nMAX],link[nMAX],lx[nMAX],ly[nMAX];
bool vx[nMAX],vy[nMAX];
int n,m;

bool dfs(int u)
{
    int j;
    vx[u]=1;
    for(j=1;j<=m;j++)
       if(!vy[j]&&map[u][j]==lx[u]+ly[j])//!!!map[u][j]==lx[u]+ly[j]
       {
           vy[j]=1;
           if(!link[j]||dfs(link[j]))
              {
                  link[j]=u;
                  return true;
              }
       }
     return false;
}

int KM()
{
    int i,j,k;
    for(i=1;i<=n;i++)
    {   lx[i]=-inf;
       for(j=1;j<=m;j++)
         lx[i]=Max(lx[i],map[i][j]);//每个map[i][j]都已初始化
    }
    memset(ly,0,sizeof(ly));

    memset(link,0,sizeof(link));
    for(i=1;i<=n;i++)
    {
        while(1)
        {
            memset(vx,0,sizeof(vx));
            memset(vy,0,sizeof(vy));
            if(dfs(i))break;
            //修改 lx ly
            int MIN=inf;

            for(j=1;j<=n;j++)
              if(vx[j])
                for(k=1;k<=m;k++)
                 if(!vy[k])
                   MIN=Min(MIN,lx[j]+ly[k]-map[j][k]);

            for(j=1;j<=n;j++)if(vx[j])lx[j]-=MIN;//lx[j]--;错错错
            for(j=1;j<=m;j++)if(vy[j])ly[j]+=MIN;
        }
    }
    int ANS=0;
    for(i=1;i<=m;i++)
       if(link[i]) ANS+=map[link[i]][i];
    return ANS;
}

int main()
{
    int cn[55][nMAX],cm[55][nMAX],com1[55],com2[55],f[55][55];
    int N,M,K;
    int i,j,h,cnt;
    while(scanf("%d%d%d",&N,&M,&K))
    {
        if(N==0&&M==0&&K==0)break;

        memset(com1,0,sizeof(com1));
        memset(com2,0,sizeof(com2));
       // memset(cn,0,sizeof(cn));
       // memset(cm,0,sizeof(cm));
        for(i=1;i<=N;i++)
         for(j=1;j<=K;j++)
         {
             scanf("%d",&cnt);
             while(cnt--)
             cn[j][++com1[j]]=i; //第com1[j]件第j中商品，第i个shop需要
         }

        for(i=1;i<=M;i++)
          for(j=1;j<=K;j++)
          {
              scanf("%d",&cnt);
              while(cnt--)
              cm[j][++com2[j]]=i; //同理
          }

        bool flag=1;
        int ans=0;
        for(h=1;h<=K;h++)
        {
            for(i=1;i<=N;i++)
             for(j=1;j<=M;j++)
                 scanf("%d",&f[i][j]);

            if(com1[h]>com2[h])
            {
                flag=0;
                continue;
            }
            memset(map,0,sizeof(map));
            for(i=1;i<=com1[h];i++)
             for(j=1;j<=com2[h];j++)
             {
                map[i][j]=-f[cn[h][i]][cm[h][j]];
             }
             n=com1[h];
             m=com2[h];
             ans-=KM();
        }
        if(!flag)printf("%d\n",-1);
        else printf("%d\n",ans);
    }
    return 0;
}

　最小费用最大流

思路：因为涉及到K种商品，所以 考虑到 N*K个需求者，M*K个供应者，就是一种需求者只需求一种产品，一种供应者只提供一种产品；需求第i 个产品的需求者 向提供第i的供应真连线，cap=inf,cost=运费,源点到需求者连线 cap=需求量，cost=0 ，供应者到汇点连线，cap=提供量，cost=0。。。就是基于把每个需求者分成K个需求者，把每个供应者分成K个供应者。。。结果TLE,囧  时间复杂度 最坏有2500+2500+2个点，（2500*50+2500*2）*2=26*10^4 条边 ，费用流的时间复杂度是O(2*M*C)吧？！好像是，m是边，C是流量3 ， O(2*M)是spfa的复杂度, 最后用时 26*10^4*2*2500*3=3.9*10^9  怪不得超时

然后网上是单独的算出每种产品的费用，因为每种产品是相互独立的，然后加起来，那时间复杂度是多少呢？每一种产品 最坏情况用50+50+2个点，（50*50+50*2）*2=5200条边  O(2*m*c)=1.56*10^6  ,50种产品就有  50*1.56*10^6=7.8*10^7

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define nMAX 110
#define mMAX 6000
#define inf 1<<26
using namespace std;
int s,n;
int head[nMAX],s_edge,ans,dis[nMAX],pre[nMAX],qu[nMAX],num;
int need[55][55],provide[55][55],cntn[55],cntp[55];
bool vs[nMAX];
struct Edge
{
    int u,v,cap,cost,nxt;
}edge[mMAX];

void addedge(int u,int v,int cap,int cost)
{
    s_edge++;
    edge[s_edge].v=v;
    edge[s_edge].cap=cap;
    edge[s_edge].cost=cost;
    edge[s_edge].nxt=head[u];
    head[u]=s_edge;

    s_edge++;
    edge[s_edge].v=u;
    edge[s_edge].cap=0;
    edge[s_edge].cost=-cost;
    edge[s_edge].nxt=head[v];
    head[v]=s_edge;
}
bool spfa()
{
    int i,beg,tail;
    for(i=0;i<=n;i++)
    {
        dis[i]=inf;
        vs[i]=0;
    }
    beg=0,tail=1;
    dis[s]=0;
    vs[s]=1;
    qu[0]=s;
    while(beg!=tail)
    {
        int u=qu[beg++];
        for(int e=head[u];e;e=edge[e].nxt)
        {
            int v=edge[e].v;
            if(edge[e].cap&&dis[v]-dis[u]>edge[e].cost)
            {
                dis[v]=dis[u]+edge[e].cost;
                pre[v]=e;
                if(!vs[v])
                {
                    vs[v]=1;
                    qu[tail++]=v;
                    if(tail==nMAX)tail=0;
                }
            }
        }
        vs[u]=0;
        if(beg==nMAX)beg=0;
    }
   if(dis[n]!=inf)return 1;
   return 0;
}
void end()
{
    int u,p;
    int MIN=inf;
    for(u=n;u!=s;u=edge[p^1].v)
    {
        p=pre[u];
        MIN=MIN<edge[p].cap?MIN:edge[p].cap;

    }
    num+=MIN;
    for(u=n;u!=s;u=edge[p^1].v)
    {
        p=pre[u];
        edge[p].cap-=MIN;
        edge[p^1].cap+=MIN;
        ans+=(edge[p].cost*MIN);
    }
}
int main()
{
    int N,M,K,i,j,f,w;
    while(~scanf("%d%d%d",&N,&M,&K))
    {
        if(N==0&&M==0&&K==0)break;
        memset(cntn,0,sizeof(cntn));
        memset(cntp,0,sizeof(cntp));
        for(i=1;i<=N;i++)
            for(j=1;j<=K;j++)
            {
                scanf("%d",&need[i][j]);
                cntn[j]+=need[i][j];
            }
        for(i=1;i<=M;i++)
            for(j=1;j<=K;j++)
            {
                 scanf("%d",&provide[i][j]);
                 cntp[j]+=provide[i][j];
            }
        bool fg=1;
        ans=0;
        for(i=1;i<=K;i++)
        {  
            s_edge=1;
            memset(head,0,sizeof(head));
            s=0,n=N+M+1;
            for(j=1;j<=N;j++)
                for(f=1;f<=M;f++)
                {
                    scanf("%d",&w);
                    addedge(j,N+f,inf,w);
                }
            if(cntp[i]<cntn[i]){fg=0;continue;}
            for(j=1;j<=N;j++)
                addedge(s,j,need[j][i],0);
            for(j=1;j<=M;j++)
                addedge(N+j,n,provide[j][i],0);
            num=0;
            if(fg)
                while(spfa())
                {
                    end();
                }
            if(num<cntn[i])fg=0;//不能break啊,数据读不完就WA!!!^ ^
        }
        if(fg)
            printf("%d\n",ans);
        else
            printf("-1\n");
    }
    return 0;
}

　　

 

  

转载于:https://www.cnblogs.com/sdau10kuaile/archive/2012/02/23/2364105.html

weixin_30614587
关注
POJ 1265 pick 定理
MR CODER
08-28 1069
首先来脑补一下几个几何知识 非常奇妙的证明：图形必在格点之外 从cut-the-knot上看到的。 问题：     设想一个平面上布满间距为1的横纵直线，形成由一个个1×1正方形组成的网格。任意给一个面积小于1个单位的图形，证明这个图形总能放在网格中而不包含任何一个格点。         证明：     我们可以这样考虑这个问题：把图形随意放在网格中，如何移动网格使每个格
POJ 刷题顺序
热门推荐
thestoryofsnow的专栏
11-09 31万+
POJ从简到难（按照AC数目排序）的列表如下，作为小弱的刷题
poj 超详细分类
liangkk的博客
07-23 8210
POJ各题算法
poj 2146 一道 求最短编辑距离的dp
mindmb的专栏
04-30 2124
d
csu2146 神奇的金字塔（寻找通项）
FLY_WHITE的博客
07-29 237
D - 神奇的金字塔  CSU - 2146  总所周知，CSU没有金字塔，但在世界某地有一座神奇的金字塔。 神奇的金字塔位于N*N的网格地上。 第0分钟时，金字塔底面很小，只占据(x,y) 这个格子，之后每过一分钟，金字塔会长大，就算超过边界也会继续长大，不过边界外是无限深渊，所以超过边界的部分不算占据的面积，而且由于是无限深渊，不需要考虑什么时候被填满的问题。 那么现在问题来...
com.harmonyos.exception.WebViewRenderingException.md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
基于STM32f103的重力点阵屏
11-11
基于STM32f103的重力点阵屏
com.pureharmony.exception.DisplayFailureException解决方案(亲测可用).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
一个基于Bootstrap框架的个人秀项目
11-11
功能和部分： - 介绍部分（About Me）：包含个人简介、背景信息、教育经历等。 - 技能部分（Skills）：展示技术技能和专业能力。 - 项目部分（Portfolio）：展示个人参与或完成的项目。 - 联系部分（Contact）：提供联系方式，如邮箱、社交媒体链接等。 - 博客部分（Blog）：用于分享个人的技术文章或观点（可选）。 - 侧边栏（sidebar）：用于在页面的不同部分之间进行导航。
com.pureharmony.exception.ImageProcessingException解决方案(亲测可用).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
com.harmonyos.exception.AppCrashException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
EaseUSDataRecoveryWizard v2.2.1.1技术级终身版.txt
11-11
EASEUS Data Recovery Wizard 1、恢复从回收站清空的文件 2、恢复格式化后的文件，即使你已经重装系统（和重装系统各好像没啥关系） 3、硬盘恢复，当硬盘损坏后 4、可以在windows下面恢复linux分区中的文件。（这个文件恢复软件不仅支持fat32和NTFS，并且linux下面的EXT2和EXT3文件系统也一并支持，这个在同类软件中也是很少见到的，但很可惜的是好像没有对EXT4的支持），所以如果你是ubuntu新手，并且在linux下有重要文件，那么ext3文件格式是个好选择。 5、找回某个硬盘分区出错后的文件 6、可以恢复办公文件，照片，图片，视频，音乐，电子邮件等资料 7、可以恢复移动设备上的文件，包括U盘，记忆棒，照相机，SD卡 8、小巧，这个软件只有4M不到，虽然没有中文界面，但是操作是极其简单的。 需要软件请加qq群221906427，验证信息：数据恢复
com.harmonyos4.exception.BatteryDepletionException解决方案(亲测可用).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
软件设计方案案例.docx
11-11
此方案包含用户界面设计、编码设计、算法设计、数据库设计几个方面的具体诸多细则，规范，标准，约定。旨在使团队成员遵循统一的标准规范，开发出统一的，标准的，高质量的软件系统，为效率，维护打下坚实的基础。
纯Tailwind 实现消息弹窗 + 优美对话框
最新发布
11-11
纯Tailwind 实现消息弹窗 + 优美对话框
elasticsearch-8.15.3，linux安装包
11-11
es，elasticsearch在linux服务器下的安装包
QT金属风格的qss文件
11-11
QT金属风格的qss文件
毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集
11-11
毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集，该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源主要针对计算机、通信、人工智能、自动化等相关专业的学生、老师或从业者下载使用，亦可作为期末课程设计、课程大作业、毕业设计等。项目整体具有较高的学习借鉴价值！基础能力强的可以在此基础上修改调整，以实现不同的功能。 毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表面缺陷检测项目源码+文档说明+所需数据集毕业设计-基于pytorch+CNN网络的金属表
极客学院.zip 小程序源码
11-11
演示：https://blog.csdn.net/m0_54925305/article/details/143660348?spm=1001.2014.3001.5501
最优匹配：最小费用最大流与KM算法应用
在这个特定的讨论中，我们关注的主要算法包括最小费用最大流（Minimum Cost Flow，MCF）和Kuhn-Munkres（KM）算法。这两种算法在处理这类问题时各有优势。 首先，最小费用最大流算法，如SPFA（Shortest Path Faster...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值