带权二分图匹配KM算法

最新推荐文章于 2024-01-15 21:06:32 发布
最新推荐文章于 2024-01-15 21:06:32 发布
阅读量698 收藏
点赞数
分类专栏： 存模板 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ACMer_ZP/article/details/53130904
版权 
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int INF=1e9;
int flag;
struct zp
{
    int x,y;
}man[200],house[200];
int x[200][200],mn,ho,lx[200],ly[200];
void build_map()//建图，单向图
{
    for(int i=0; i<mn; i++)
    {
        for(int j=0; j<ho; j++)
        {
            x[i+1][j+1]=abs(man[i].x-house[j].x)+abs(man[i].y-house[j].y);
        }
    }
}
int visx[200],visy[200],dis[200],ans;
int dfspath(int k)//匈牙利算法，寻找路径
{
    visx[k]=1;
    for(int i=1; i<=mn; i++)
    {
        if(!visy[i]&&lx[k]+ly[i]==x[k][i])
        {
            visy[i]=1;
            if(dis[i]==-1||dfspath(dis[i]))
            {
                dis[i]=k;
                return 1;
            }
        }
    }
    return 0;
}
int KM()
{
    if(!flag)//最小权值处理
    {
        for(int i=1;i<=mn;i++)
            for(int j=1;j<=ho;j++)
            x[i][j]=-x[i][j];
    }
    for(int i=1;i<=mn;i++)//初始化x点集标号
    {
        lx[i]=x[i][1];
        for(int j=2;j<=ho;j++)
            lx[i]=max(lx[i],x[i][j]);
    }
    memset(ly,0,sizeof(ly));//初始化y点集标号
    memset(dis,-1,sizeof(dis));//保存对应关系
    for(int i=1; i<=mn; i++)
    {
        while(1)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(dfspath(i))//找到路径
                break;
                int Min=INF+1;
                for(int j=1;j<=mn;j++)//扩大子图范围
                {
                    if(visx[j])
                        for(int k=1;k<=ho;k++)
                        if(!visy[k])
                        Min=min(Min,lx[j]+ly[k]-x[j][k]);
                }
                for(int j=1;j<=mn;j++)//更新x点集标号
                    if(visx[j])
                    lx[j]-=Min;
                for(int j=1;j<=ho;j++)//更新y点集标号
                    if(visy[j])
                    ly[j]+=Min;
        }
    }
    ans=0;
    for(int i=1;i<=ho;i++)//计算权值和1
        ans+=x[dis[i]][i];
        if(!flag)//求最小权值
            ans=-ans;
        return ans;//返回权值
}
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m)&&(n||m))
    {
        mn=ho=0;
        char a[200];
        memset(x,0,sizeof(x));
        //flag=1;//最大权匹配
        flag=0;//最小权匹配 ，把权值取反然后求最大权匹配然后把结果取反
        for(int i=0; i<n; i++)
        {
            scanf("%s",a);
            for(int j=0; j<m; j++)
            {
                if(a[j]=='m') man[mn].x=i+1,man[mn++].y=j+1;
                else if(a[j]=='H') house[ho].x=i+1,house[ho++].y=j+1;
            }
        }
        build_map();
        printf("%d\n",KM());
    }
}

上面题目链接
题目大概意思是让求所有的m到H走的所有路之和最小，每一个H只能承载1个m。
KM的一点优化，有两种方式
hdu 2255题目
一般解法:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int INF=1e9;
int flag;
int x[500][500],n,lx[500],ly[500];
int visx[500],visy[500],dis[500],ans;
int dfspath(int k)//匈牙利算法，寻找路径
{
    visx[k]=1;
    for(int i=0; i<n; i++)
    {
        if(!visy[i]&&lx[k]+ly[i]==x[k][i])
        {
            visy[i]=1;
            if(dis[i]==-1||dfspath(dis[i]))
            {
                dis[i]=k;
                return 1;
            }
        }
    }
    return 0;
}
int KM()
{
//    if(!flag)//最小权值处理
//    {
//        for(int i=0;i<=n;i++)
//            for(int j=0;j<n;j++)
//            x[i][j]=-x[i][j];
//    }
    memset(lx,0,sizeof(lx));
    memset(ly,0,sizeof(ly));//初始化y点集标号
    memset(dis,-1,sizeof(dis));//保存对应关系
    for(int i=0; i<n; i++) //初始化x点集标号
        for(int j=0; j<n; j++)
            lx[i]=max(lx[i],x[i][j]);
    for(int i=0; i<n; i++)
    {
        while(1)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            if(dfspath(i))//找到路径
                break;
            int Min=INF+1;
            for(int j=0; j<n; j++) //扩大子图范围
            {
                if(visx[j])
                    for(int k=0; k<n; k++)
                        if(!visy[k])
                            Min=min(Min,lx[j]+ly[k]-x[j][k]);
            }
            for(int j=0; j<n; j++) //更新x,y点集标号
            {
                if(visx[j])
                    lx[j]-=Min;
                if(visy[j])
                    ly[j]+=Min;
            }
        }
    }
    ans=0;
    for(int i=0; i<n; i++) //计算权值和1
        ans+=x[dis[i]][i];
//        if(!flag)//求最小权值
//            ans=-ans;
    return ans;//返回权值
}
int main()
{
    while(~scanf("%d",&n))
    {
        //flag=1;//最大权匹配
        //flag=0;//最小权匹配 ，把权值取反然后求最大权匹配然后把结果取反
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                scanf("%d",&x[i][j]);
        //build_map();
        printf("%d\n",KM());
    }
}

优化后的:

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int INF=1e9;
int flag;
int x[500][500],n,lx[500],ly[500];
int visx[500],visy[500],dis[500],ans,slack[500],Min;
void build_map()//建图，单向图
{

}
int dfspath(int k)//匈牙利算法，寻找路径
{
    visx[k]=1;
    for(int i=0; i<n; i++)
    {
        if(visy[i])
            continue;
        int t=lx[k]+ly[i]-x[k][i];
        if(t==0)
        {
            visy[i]=1;
            if(dis[i]==-1||dfspath(dis[i]))
            {
                dis[i]=k;
                return 1;
            }
        }
        else
            //slack[i]=min(slack[i],t);//优化1
            Min=min(Min,t);//优化2
    }
    return 0;
}
int KM()
{
//    if(!flag)//最小权值处理
//    {
//        for(int i=0; i<n; i++)
//            for(int j=0; j<n; j++)
//                x[i][j]=-x[i][j];
//    }
    memset(lx,0,sizeof(lx));
    memset(ly,0,sizeof(ly));//初始化y点集标号
    memset(dis,-1,sizeof(dis));//保存对应关系
    for(int i=0; i<n; i++) //初始化x点集标号
        for(int j=0; j<n; j++)
            lx[i]=max(lx[i],x[i][j]);
    for(int i=0; i<n; i++)
    {
//        for(int j=0;j<=n;j++)//优化1
//            slack[j]=INF;
        while(1)
        {
            memset(visx,0,sizeof(visx));
            memset(visy,0,sizeof(visy));
            Min=INF+1;
            if(dfspath(i))//找到路径
                break;
//            for(int j=0; j<n; j++)//扩大子图范围  优化1 优化2不要这一步
//                if(!visy[j])
//                    Min=min(Min,slack[j]);
            for(int j=0; j<n; j++) //更新x点集标号
            {
                if(visx[j])
                    lx[j]-=Min;
                if(visy[j])
                    ly[j]+=Min;
//                else//有这一步会超时,但是有的人博客上有这一步,参考下
//                slack[i]-=Min;
            }
        }
    }
    ans=0;
    for(int i=0; i<n; i++) //计算权值和
        ans+=x[dis[i]][i];
//    if(!flag)//求最小权值
//        ans=-ans;
    return ans;//返回权值
}
int main()
{
    while(~scanf("%d",&n))
    {
        flag=1;
        for(int i=0; i<n; i++)
            for(int j=0; j<n; j++)
                scanf("%d",&x[i][j]);
        printf("%d\n",KM());
    }
}
acmer_zp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二分图带权最佳匹配 KM算法
glorious_dream的博客
04-21 874
题目大意： 给定每一对男女之间的优势，求如何组合能让优势的总和最大。 算法描述： 首先可以看出来，这道题是一个带权的二分图匹配，KM算法的裸题。 这个博客写的很好 先来用自己的话简单的说一下。 读入数据之后，需要把我们记录的数组先求好，也就是 表示女与男之间的优势，这个先处理好就可以。 然后说算法的核心。首先，需要先知道二分图最大匹配。 可以理解为中介帮你介绍房子的问题。给定两个集合，它们之间有一些边相连，但两个集合内部没有边相连，求最多能两个集合之间连多少条边。 著名的匈......
二分图最大匹配及最大权匹配（km算法）
06-14
二分图最大匹配及最大权匹配（km算法） 本文将详细介绍二分图最大匹配及最大权匹配（km算法），涵盖了增广路定理、Hall定理、匈牙利树算法、Edmonds-Karp算法、Hopcroft算法等相关知识点。 一、二分图最大匹配 在...
带权二分图匹配-KM算法
Ogmx的博客
11-26 5672
1.KM算法基础 每个员工做不同的工作效率不同，如何分配使总效率最大？ 暴力：用匈牙利算法求出所有最大匹配，再从中找出效率和最高的 KM算法：解决带权二分图最优匹配 2.KM算法流程 1.为各顶点赋值值，将左顶点赋值为最大权值，右顶点赋值为0 2.用匈牙利算法寻找完备匹配 3.若未找到完备匹配则修改顶点权值 4.重复(2)(3)直到找到完备匹配为止 时间复杂度O(n^3) 3.KM算法演示 (1...
二分图带权最大匹配-KM算法详解
最新发布
EQUINOX1的博客
01-15 2316
找不到对象就降低期望（
带权二分图最优匹配KM算法
fuhaitao9999的博客
03-13 328
KM 算法思想 设有A[]，B[]二分图，贪心的去找与A[i]的最大匹配，若没有找到就增加边，直到找到最优为止； 实现步骤 1.初始化l[],r[]，数组，设置顶标，即找到与A[i]最大匹配的B[],存在l[]数组中，r[]数组初始化为0； 2.dfs（）寻找增广路径（最大匹配），和匈牙利类似； a.如果找到匹配点就进入下一匹配点； b.如果没有找到就增加新的路径； 注意： 在实现最小匹配时，将两...
带权二分图匹配（KM算法）
Cruiying的博客
12-07 162
Problem Description 传说在遥远的地方有一个非常富裕的村落,有一天,村长决定进行制度改革：重新分配房子。 这可是一件大事,关系到人民的住房问题啊。村里共有n间房间,刚好有n家老百姓,考虑到每家都要有房住（如果有老百姓没房子住的话，容易引起不安定因素），每家必须分配到一间房子且只能得到一间房子。 另一方面,村长和另外的村领导希望得到最大的效益,这样村里的机构才会有钱.由于老百姓都比...
二分图带权最大匹配费用流_带权二分图匹配：KM算法与费用流建模
weixin_39736606的博客
01-17 137
KM似乎还是有点难以理解，看了半天资料仍有半懂不懂的感觉，或许以后多想想、画画，做些题能加深理解吧，当初学匈牙利的时候就是这样。相关资料题目：ural1076我的KM是抄nocow上的题解的，只不过出于习惯改了一个变量名。费用流的思路也是按nocow上的，计算出i种箱子装j种垃圾的费用然后求最小费用。根据自己的理解按照KM上的统计所有垃圾量-最大费用的程序也写了一个，不过陷入死循环中，有时间再调试...
带权二分图匹配（KM算法模板）
MM__1997的博客
08-04 373
    带权二分图匹配， KM算法   hdu2255      http://acm.hdu.edu.cn/showproblem.php?pid=2255 这是个裸模板题       AC代码： /************************************************* Author : NIYOUDUOGAO ...
带权二分图的最佳匹配（KM算法）
hit_buxiaoyu的博客
11-17 5074
该算法的思路写得太多了，懒得复述，直接贴链接了： https://blog.csdn.net/x_y_q_/article/details/51927054 重点是心得体会： 1.图论算法的精髓在于其本身是抽象的数学模型，通过模型转化可以解决众多表象不一的问题，帮助我们发现问题的本质； 2.二分图是图论中不可分割的一部分，在于其通过对一般图增加限制得到了很多优美的特性，也衍生出一堆复杂度很好...
Going Home（带权二分图最大匹配 KM算法）
jkchen's Haven
01-21 481
原题： http://acm.hdu.edu.cn/showproblem.php?pid=1533 题意： 求所有m到各自不同的H的最小花费 解析： 在二分图基础上，边加权，寻找权值的最大匹配问题，可以用KM算法。这里的最小只需要改成相反数即可。 KM算法： 设M是一个带权完全二分图G的一个完备匹配，给每个顶点一个可行顶标(第i个x顶点的可行标用lx[i]表示，第j个y顶点的可行标用ly[j]表...
二分图匹配匈牙利算法和KM算法简介.pptx
10-12
二分图匹配匈牙利算法和KM算法简介 二分图匹配是图论中的一种特殊模型，通过 匈牙利算法和KM算法可以解决二分图的最大匹配问题。二分图是指图论中的一种特殊模型，由两个互不相交的子集组成，每条边依附的两个顶点...
二分图最大匹配km算法
11-04
### 二分图最大匹配KM算法详解 #### KM算法概览 KM算法（Kuhn-Munkres Algorithm），也称为匈牙利算法的扩展版本，主要用于解决带权二分图的最佳匹配问题。简单来说，二分图是一种特殊的图结构，它可以被划分为两个...
二分图匹配-匈牙利算法和KM算法简介 精品资料.pptx
10-24
二分图匹配-匈牙利算法和KM算法简介 二分图的概念：在图论中，二分图是指一个无向图G=(V,E)，其中顶点集V可以分割为两个互不相交的子集，且图中每条边依附的两个顶点都属于不同的子集。二分图的这种特性使得它在...
最小费用流
ACMer_ZP的博客
11-12 1542
单向图#include<cstdio>//每次找费用的最短路，更新残留网络图直到找不到最短路为止 #include<cstring>//最大费用 权值取负值 结果取负值 #include<iostream> #include<algorithm> #include<queue> using namespace std; const int inf=0x3f3f3f3f; struct Node
最小割最小割边
ACMer_ZP的博客
11-20 1419
#include <cstdio>//最小割，图的割边，割断后无法从源点到汇点，最小割边的容量和为该图的最大流； #include <cstring>//最大点权独立和=所有点的权值和-最小割 #include <algorithm>//点即是边，拆点，拆边 #include <iostream> #include <queue> using namespace std; #define LL lo
最小费用最大流（拆边）
ACMer_ZP的博客
11-16 1098
题目大概意思是，有N个城市M条边，要从1城市到N城市运送K的物品，求最少花费，每个边有一个系数ai花费的钱是ai*这条边上运送物资数的平方，比如在系数为3的边上运送了2的物品，则需要3*2*2的花费； 思路：由于每条边的容量不超过5，所以可以把每一条边拆成容量条流量为1的边，他们的花费分别为1*ai,3*ai,5*ai,7*ai,9*ai; 花费依次递增，然后每次找的最短路都是最小的，前几次的加
bfs+预处理+路径回溯+字典序最小+hash
ACMer_ZP的博客
01-15 763
HDU 1043 Eight HDU 3567-Eight II HDU 1430 魔板 这两道题很像，在这里我们看第二道，第一道比第二道简单好多； 题目意思是给你起始和终止状态让你输出路径要求字典序最小； X代表空的位置每次X都可以和相应的上下左右互换位置，让求最终换到终止状态的路径字典序最小； 每一次都求一遍肯定会超时，因为每一种起始状态可以对应18W多的终止状态，200次； 在这
无向图欧拉路的判定
ACMer_ZP的博客
10-23 712
#include//图联通 并且有2个或者没有奇数度节点，没有的是欧拉回路 #include #include #include #include using namespace std; const int maxn=1e6+10; int bin[maxn]; int finds(int x) { int flag=x,j; while(x!=bin[x])
二分图最大匹配与匈牙利算法解析
二分图匹配可以分为两类：无权匹配和带权匹配。在无权匹配中，关注的是找到尽可能多的互不相邻的边；而在带权匹配中，每条边都赋予了一个权重，目标是找到一个匹配，使得这些匹配边的权重之和最大化。如果二分图的X...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值