KM算法实现带权匹配C#版本和C++两个版本实现O^3

最新推荐文章于 2024-04-20 20:18:23 发布
最新推荐文章于 2024-04-20 20:18:23 发布
阅读量1.1k 收藏 4
点赞数
文章标签： 算法 c++ c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wys8fb8/article/details/123793360
版权

C# 版本

using System;
using System.Collections.Generic;
using System.Text;

namespace Agorithm
{
    public struct KMConst
    {
        public const int MaxN = 101;
        public const int INF = 1000000000+7;
        public const int NPOS = -1;
    }

    public class KmMatrix
    {
        public int[,] W = new int[KMConst.MaxN, KMConst.MaxN];
        public int[] Lx = new int[KMConst.MaxN];
        public int[] Ly = new int[KMConst.MaxN];
        public int[] MatchY = new int[KMConst.MaxN];
        public int[] VisX = new int[KMConst.MaxN];
        public int[] VisY = new int[KMConst.MaxN];
        public int[] Slack = new int[KMConst.MaxN];
        public int Nx { get; set; }
        public int Ny { get; set; }

        protected void Memset(int[] arr, int ini)
        {
            for(int i =0; i< arr.Length; i++)
            {
                arr[i] = ini;
            }
        }

    }

    /// <summary>
    /// 使用km算法返回最带权匹配
    /// </summary>
    public class KuhnMunkres : KmMatrix
    {
        public KuhnMunkres(int x, int y)
        {
            Nx = x;
            Ny = y;
        }

        bool Find(int x)
        {
            VisX[x] = 1;
            for (int y = 0; y < Ny; y++)
            {
                if (VisY[y]==1)
                    continue;
                int t = Lx[x] + Ly[y] - W[x,y];
                if (t == 0)
                {
                    VisY[y] = 1;
                    if (MatchY[y] == -1 || Find(MatchY[y]))
                    {
                        MatchY[y] = x;
                        return true;//找到增广轨
                    }
                }
                else if (Slack[y] > t)
                    Slack[y] = t;
            }
            return false;//没有找到增广轨（说明顶点x没有对应的匹配，与完备匹配(相等子图的完备匹配)不符）
        }

        public int KM()//返回最优匹配的值
        {
            int i, j;
            Memset(MatchY, -1);
            Memset(Ly, 0);
            for (i = 0; i < Nx; i++)
                for (j = 0, Lx[i] = -KMConst.INF; j < Ny; j++)
                    if (W[i,j] > Lx[i])
                        Lx[i] = W[i,j];
            for (int x = 0; x < Nx; x++)
            {
                for (i = 0; i < Ny; i++)
                    Slack[i] = KMConst.INF;
                while (true)
                {
                    Memset(VisX, 0);
                    Memset(VisY, 0);
                    if (Find(x))//找到增广轨，退出
                        break;
                    int d = KMConst.INF;
                    for (i = 0; i < Ny; i++)//没找到，对l做调整(这会增加相等子图的边)，重新找
                    {
                        if (!(VisY[i]!=0) && d > Slack[i])
                            d = Slack[i];
                    }
                    for (i = 0; i < Nx; i++)
                    {
                        if (VisX[i]!=0)
                            Lx[i] -= d;
                    }
                    for (i = 0; i < Ny; i++)
                    {
                        if (VisY[i]!=0)
                            Ly[i] += d;
                        else
                            Slack[i] -= d;
                    }
                }
            }
            int result = 0;
            for (i = 0; i < Ny; i++)
                if (MatchY[i] > -1)
                    result += W[MatchY[i],i];
            return result;
        }
    }
}

在这里插入图片描述

int maxn = 4; 
KuhnMunkres km = new KuhnMunkres(maxn, maxn); 
// 初始化权重
int maxn = 4; 
KuhnMunkres km = new KuhnMunkres(maxn, maxn); 
// 初始化权重
km.W[0, 0] = 2;
km.W[0, 1] = 5;
km.W[0, 2] = 1;
km.W[0, 3] = 0;
km.W[1, 0] = 8;
km.W[1, 1] = 3;
km.W[1, 2] = 9;
km.W[1, 3] = 0;
km.W[2, 0] = 4;
km.W[2, 1] = 9;
km.W[2, 2] = 2;
km.W[2, 3] = 0;
km.W[3, 0] = 3;
km.W[3, 1] = 5;
km.W[3, 2] = 6;
km.W[3, 3] = 0;
int maxWeight = km.KM(); // 获取最大权
var matchs = km.MatchY.ToList().Where(p=>p!=-1).ToList(); // 获取匹配

输出 maxWeight = 23
matchs = {1,2,3,0};
即最大权匹配
(1,0) = 8;
(2,1) = 9;
(3,2) = 6;
(0, 3) = 0;

C++ 版本

#include<pch.h>
#include <iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
const int MaxN = 101;
const int INF = (1 << 31) - 1;
int W[MaxN][MaxN];
int Lx[MaxN], Ly[MaxN]; //顶标
int MatchY[MaxN];
int VisX[MaxN], VisY[MaxN];
int Slack[MaxN];
int Nx, Ny;
bool find(int x)
{
    VisX[x] = true;
    for (int y = 0; y < Ny; y++)
    {
        if (VisY[y])
            continue;
        int t = Lx[x] + Ly[y] - W[x][y];
        if (t == 0)
        {
            VisY[y] = true;
            if (MatchY[y] == -1 || find(MatchY[y]))
            {
                MatchY[y] = x;
                return true;        //找到增广轨
            }
        }
        else if (Slack[y] > t)
            Slack[y] = t;
    }
    return false;                   //没有找到增广轨（说明顶点x没有对应的匹配，与完备匹配(相等子图的完备匹配)不符）
}

int KM()                //返回最优匹配的值
{
    int i, j;
    memset(MatchY, -1, sizeof(MatchY));
    memset(Ly, 0, sizeof(Ly));
    for (i = 0; i < Nx; i++)
        for (j = 0, Lx[i] = -INF; j < Ny; j++)
            if (W[i][j] > Lx[i])
                Lx[i] = W[i][j];
    for (int x = 0; x < Nx; x++)
    {
        for (i = 0; i < Ny; i++)
            Slack[i] = INF;
        while (true)
        {
            memset(VisX, 0, sizeof(VisX));
            memset(VisY, 0, sizeof(VisY));
            if (find(x))                     //找到增广轨，退出
                break;
            int d = INF;
            for (i = 0; i < Ny; i++)          //没找到，对l做调整(这会增加相等子图的边)，重新找
            {
                if (!VisY[i] && d > Slack[i])
                    d = Slack[i];
            }
            for (i = 0; i < Nx; i++)
            {
                if (VisX[i])
                    Lx[i] -= d;
            }
            for (i = 0; i < Ny; i++)
            {
                if (VisY[i])
                    Ly[i] += d;
                else
                    Slack[i] -= d;
            }
        }
    }
    int result = 0;
    for (i = 0; i < Ny; i++)
        if (MatchY[i] > -1)
            result += W[MatchY[i]][i];
    return result;
}

int main()
{
    while (true)
    {
        Nx = 4;
        Ny = 4;
        W[0][0] = 2;  W[0][1] = 5;   W[0][2] = 1;  W[0][3] = 0; 
        W[1][0] = 8;   W[1][1] = 3;   W[1][2] = 9;  W[1][3] = 0;  
        W[2][0] = 4;  W[2][1] = 9;  W[2][2] = 2; W[2][3] = 0; 
        W[3][0] = 3;   W[3][1] = 5;  W[3][2] = 6; W[3][3] = 0; 
        printf("%d\n", KM());
        break;
    }
    return 0;
}

具体KM实现步骤可以参考https://blog.csdn.net/u013044116/article/details/45228057
本文的C版本就是来自于这个文章。

wys8fb8
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MATLAB算法实战应用案例精讲-【数模应用】KM算法（附C语言和C++代码）
qq_36130719的博客
01-17 272
KM算法，用于求二分图匹配的最佳匹配。X部中的每一个顶点都与Y部中的一个顶点匹配，或者Y部中的每一个顶点也与X部中的一个顶点匹配，则该匹配为完备匹配。如果顶点集V可分割为两个互不相交的子集X和Y，并且图中每条边连接的两个顶点一个在X中，另一个在Y中，则称图G为二分图。若P是图G中一条连通两个未匹配顶点的路径，并且属于M的边和不属于M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径。最大二分匹配：在一个二分图中找到P->q的一个匹配方案，使得匹配中的边数量不小于任何其他的匹配。
C# 实现匈牙利算法
10-03
C# 实现匈牙利算法 平台 vs2008
【坤坤讲师--图】KM算法
lljloimjo的博客
02-03 388
在寻找增广路的过程中，检查边(i,j)时，如果它不在相等子图中，则让slack[j]变成原值与A[i]+B[j]-w[i,j]的较小值。初始时为了使A[i]+B[j]>=w[i,j]恒成立，令A[i]为所有与顶点Xi关联的边的最大权，B[j]=0。若由二分图中所有满足A[i]+B[j]=w[i,j]的边(i,j)构成的子图（称做相等子图）有完备匹配，那么这个完备匹配就是二分图的最大权匹配。3）X端不在交错树中，Y端在交错树中的边(i,j)，它的A[i]+B[j]的值有所增大。现在的问题就是求d值了。
Munkres 分配算法
yiran103的专栏
01-03 7294
匈牙利方法（或 Kuhn 算法）是由4个基本步骤组成的迭代过程。该方法使用“最小行集”覆盖“操纵”成本矩阵的零点，当所需的“最小行集”等于给定成本矩阵的维数时，过程终止。 Munkres 算法是一种最优分配算法，可以看作是匈牙利算法的一个变种。它的不同之处在于处理过程中： 包含所有零的“最小行集” 独立零点的“最大集” 该算法的一个重要特征是它的发明人在介绍该算法的论文中还导出了一个方程来计算...
【总结】KM算法
cqbzlydd的博客
05-02 1176
upd on 2023/10/26 ：修改了代码和一些不知所云的内容。
KM算法入门
weixin_43984457的博客
04-01 4293
KM算法入门 在学习KM算法前，我们先感受一下匈牙利算法（由匈牙利数学家Edmonds提出）。 匈牙利算法 解决何种问题的呢 匈牙利算法是解决二分图的最大匹配度问题。 何为二分图 如果用染色法来判断的话，那么整幅图最后只会有两种颜色的元素；所谓二分图，就是可以划分为两个集合，且同一集合中的元素是互不相连的，不同集合中的元素是可以相连的。 下面我们通过一个简单的例子来说明： 现在...
C#实现KMP模式匹配算法学习记录
weixin_46081729的博客
05-17 188
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、官方定义二、了解KMP模式匹配的原理1.引入概念2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、官方定义 KMP算法是一种改进的字符串匹配算法,KMP算法的核心是利用匹配失败后的信息,尽量减少模式串与主串的匹配次数以达到快速匹配的.
cpp.zip_KM算法_KM算法 c++ 实现_KM算法c++_km算法 C++
07-14
km算法的c++程序，能够跑通，是值得新手直接上手的程序
C.zip_C语言_KM算法_km匹配_匈牙利算法
07-13
KM算法可以计算二分图的最大权匹配，匈牙利算法可以计算最大匹配
KM_KM算法_km匹配_km_scenegmf_图论_
10-03
图论中KM算法程序子程序，进行最优匹配，可解决分配问题
最佳分配算法C#示例.rar
09-10
二阵图最佳分配
二分图匹配-匈牙利算法和KM算法简介 精品资料.pptx
10-24
匈牙利算法和KM算法简
km算法C++实现
03-18
km算法的C++实现，以及调用DEMO,通过取邻接矩阵的相反数可以实现最小权匹配
二分图 最佳匹配 KM算法模板 -- HDU 2255 奔小康赚大钱
dajiangyou123456的博客
08-19 202
HDU 2255 奔小康赚大钱 题意： n个村民重新分配n间房子，接下来n行表示，第i个村民对第j个房子出的价格，问怎样才能使村里的机构获得最大收入。 思路： KM算法模板。 KM算法详解： https://www.cnblogs.com/fzl194/p/8848061.html https://www.cnblogs.com/fzl194/p/8834847.html code： #include<iostream> #include<cstdio> #include<c
KM算法讲解（含C++代码）
liuzich的博客
05-05 3435
假设有3个女的要嫁给三个男的，各有各的期望值。 如何让期望值之和最大？ 此时我们就要用到传说中的km算法了。 这个算法本质上是贪心算法，怎么算呢？ 举个例子吧 首先看女1，女1与男1间的边权值+男1期望值=3,而3不等于女一的期望值，所以配对失败。接着女1与男3间的边权值+男3的期望值=4，刚好4与女1的期望值相等，配对成功！ 接着让女2找对象，匹配的过程就省略了，最后发现跟男3可以配对，而男...
KM算法
热门推荐
XiaoZheng的博客
05-02 1万+
最佳匹配什么是完美匹配如果一个二分图，X部和Y部的顶点数相等，若存在一个匹配包含X部与Y部的所有顶点，则称为完美匹配。 换句话说：若二分图X部的每一个顶点都与Y中的一个顶点匹配，**并且**Y部中的每一个顶点也与X部中的一个顶点匹配，则该匹配为完美匹配。什么是完备匹配如果一个二分图，X部中的每一个顶点都与Y部中的一个顶点匹配，**或者**Y部中的每一个顶点也与X部中的一个顶点匹配，则该匹配为完备匹
【原创】【KM算法】POJ 2516 Minimum cost（拆点+多次KM）
致上
07-07 443
Minimum Cost POJ - 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
KM算法详解+模板
AC_Dreameng
10-07 1340
http://www.cnblogs.com/wenruo/p/5264235.html KM算法用来求二分图最大权完美匹配。 本文配合该博文服用更佳：趣写算法系列之--匈牙利算法     现在有N男N女，男生和女生每两个人之间有好感度，我们希望把他们两两配对，并且最后希望好感度和最大。 怎么选择最优的配对方法呢？ 首先，每个妹子会有一个期望值，就
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
最新发布
2301_79614379的博客
04-20 1063
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
km算法邻接表实现复杂度
09-14
km算法邻接表实现的时间复杂度为O(n^3)，空间复杂度为O(mn)，其中n为图中顶点的数量，m为图中边的数量。这是因为km算法的关键步骤是通过不断寻找增广路径来更新当前的最大匹配，而在邻接表实现中，寻找增广路径的时间复杂度为O(nm)，需要重复进行n次。而在邻接表实现中，需要使用额外的空间来存储图的邻接关系，因此空间复杂度为O(mn)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值