匈牙利算法再读 python

最新推荐文章于 2024-02-25 12:33:56 发布
最新推荐文章于 2024-02-25 12:33:56 发布
阅读量298 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40297851/article/details/104991934
版权

匈牙利算法

1.增广路径：看了好多对增广路径解释的都不清楚，这篇我觉的解释非常清楚。

https://blog.csdn.net/reid_zhang1993/article/details/44080167

2.最大匹配，最优匹配

最大是实现边路最多，最优是带加权的最大匹配。

3.讲解实例

a.DFS

                    

注意return位置！！！

从A开始，visited置0， ,寻找增广路径，进入Y队列循环，E，if  edge[A][E]==1 and visited[E]==0, if cy[E]==-1，匹配A、E，返回。

此时匹配为A、E

B，visited置0， 寻找增广路径，进入Y队列循环，E，if  edge[B][E]==1 and visited[E]==0,不匹配。

                                                                                F ，if  edge[B][F]==1 and visited[E]==0,if cy[F]==-1匹配B、F。返回

此时匹配为A、E;B、F

C，visited置0， 寻找增广路径，进入Y队列循环，E，if  edge[C][E]==1 and visited[E]==0,匹配。if cy[E]==-1，不满足，进入else，删掉A、E匹配，再递归，进入A的路径寻找。如果能找到，则返回匹配。

此时匹配为B、F；A、G；C、E

D，visited置0， 寻找增广路径，进入Y队列循环，E，if  edge[D][E]==1 and visited[E]==0,不匹配

                                                                                F，if  edge[D][E]==1 and visited[E]==0,不匹配

                                                                                G，if  edge[D][E]==1 and visited[E]==0,匹配。if cy[G]==-1，不满足，进入else，删掉A、G匹配，再递归，进入A的路径寻找。如果能找到，则返回匹配。D-G-A-E-C-H，能找到增广路径，返回匹配。

M=[]
class DFS_hungary():

    def __init__(self, nx, ny, edge, cx, cy, visited):
        self.nx, self.ny=nx, ny
        self.edge = edge
        self.cx, self.cy=cx,cy
        self.visited=visited

    def max_match(self):   #X序列循环匹配，从A-B-C-D...
        res=0
        for i in self.nx:
            print(i)
            if self.cx[i]==-1:
                for key in self.ny:         # 将visited置0表示未访问过
                    self.visited[key]=0
                res+=self.path(i)
                print(nx,ny)
                print(edge)
                print(cx,cy)
                print(visited)
                print('This is M:',M)
        return res,M

    def path(self, u):    #寻找增广路径
        for v in self.ny:
            if self.edge[u][v] and (not self.visited[v]):
                self.visited[v]=1
                print('---')
                print(self.visited)
                print('---')
                if self.cy[v]==-1:
                    self.cx[u] = v
                    self.cy[v] = u
                    M.append((u,v))
                    return 1
                else:
                    M.remove((self.cy[v], v))
                    if self.path(self.cy[v]):    #递归
                        self.cx[u] = v
                        self.cy[v] = u
                        M.append((u, v))
                        return 1
        return 0

if __name__ == '__main__':
    nx, ny = ['A', 'B', 'C', 'D'], ['E', 'F', 'G', 'H']
    edge = {'A':{'E': 1, 'F': 0, 'G': 1, 'H':0}, 'B':{'E': 0, 'F': 1, 'G': 0, 'H':1}, 'C':{'E': 1, 'F': 0, 'G': 0, 'H':1}, 'D':{'E': 0, 'F': 0, 'G': 1, 'H':0}} # 1 表示可以匹配， 0 表示不能匹配
    cx, cy = {'A':-1,'B':-1,'C':-1,'D':-1}, {'E':-1,'F':-1,'G':-1,'H':-1}
    visited = {'E': 0, 'F': 0, 'G': 0,'H':0}

    print (DFS_hungary(nx, ny, edge, cx, cy, visited).max_match())

'''
nx,ny表示X、Y序列
edge 表示匹配初始关系
cx、cy表示匹配过程中的配对关系
visited 表示是否访问过。？？？
在此过程中注意return的使用位置，很有讲究。
'''
'''
运行结果
A
---
{'F': 0, 'G': 0, 'H': 0, 'E': 1}
---
['A', 'B', 'C', 'D'] ['E', 'F', 'G', 'H']
{'D': {'F': 0, 'G': 1, 'H': 0, 'E': 0}, 'C': {'F': 0, 'G': 0, 'H': 1, 'E': 1}, 'A': {'F': 0, 'G': 1, 'H': 0, 'E': 1}, 'B': {'F': 1, 'G': 0, 'H': 1, 'E': 0}}
{'D': -1, 'C': -1, 'A': 'E', 'B': -1} {'F': -1, 'G': -1, 'H': -1, 'E': 'A'}
{'F': 0, 'G': 0, 'H': 0, 'E': 1}
This is M: [('A', 'E')]
B
---
{'F': 1, 'G': 0, 'H': 0, 'E': 0}
---
['A', 'B', 'C', 'D'] ['E', 'F', 'G', 'H']
{'D': {'F': 0, 'G': 1, 'H': 0, 'E': 0}, 'C': {'F': 0, 'G': 0, 'H': 1, 'E': 1}, 'A': {'F': 0, 'G': 1, 'H': 0, 'E': 1}, 'B': {'F': 1, 'G': 0, 'H': 1, 'E': 0}}
{'D': -1, 'C': -1, 'A': 'E', 'B': 'F'} {'F': 'B', 'G': -1, 'H': -1, 'E': 'A'}
{'F': 1, 'G': 0, 'H': 0, 'E': 0}
This is M: [('A', 'E'), ('B', 'F')]
C
---
{'F': 0, 'G': 0, 'H': 0, 'E': 1}
---
---
{'F': 0, 'G': 1, 'H': 0, 'E': 1}
---
['A', 'B', 'C', 'D'] ['E', 'F', 'G', 'H']
{'D': {'F': 0, 'G': 1, 'H': 0, 'E': 0}, 'C': {'F': 0, 'G': 0, 'H': 1, 'E': 1}, 'A': {'F': 0, 'G': 1, 'H': 0, 'E': 1}, 'B': {'F': 1, 'G': 0, 'H': 1, 'E': 0}}
{'D': -1, 'C': 'E', 'A': 'G', 'B': 'F'} {'F': 'B', 'G': 'A', 'H': -1, 'E': 'C'}
{'F': 0, 'G': 1, 'H': 0, 'E': 1}
This is M: [('B', 'F'), ('A', 'G'), ('C', 'E')]
D
---
{'F': 0, 'G': 1, 'H': 0, 'E': 0}
---
---
{'F': 0, 'G': 1, 'H': 0, 'E': 1}
---
---
{'F': 0, 'G': 1, 'H': 1, 'E': 1}
---
['A', 'B', 'C', 'D'] ['E', 'F', 'G', 'H']
{'D': {'F': 0, 'G': 1, 'H': 0, 'E': 0}, 'C': {'F': 0, 'G': 0, 'H': 1, 'E': 1}, 'A': {'F': 0, 'G': 1, 'H': 0, 'E': 1}, 'B': {'F': 1, 'G': 0, 'H': 1, 'E': 0}}
{'D': 'G', 'C': 'H', 'A': 'E', 'B': 'F'} {'F': 'B', 'G': 'D', 'H': 'C', 'E': 'A'}
{'F': 0, 'G': 1, 'H': 1, 'E': 1}
This is M: [('B', 'F'), ('C', 'H'), ('A', 'E'), ('D', 'G')]
(4, [('B', 'F'), ('C', 'H'), ('A', 'E'), ('D', 'G')])
'''

b.BFS

def BFS_hungary(g,Nx,Ny,Mx,My,chk,Q,prev):
    res=0
    for i in range(Nx):
        print('第几轮：',i)
        if Mx[i]==-1:
            qs=qe=0
            print('qs:',qs,'qe:',qe)
            Q[qe]=i
            print('qe:',qe,'Q:',Q)
            qe+=1
            print('qe:',qe)
            prev[i]=-1
            print('prev',prev)
            flag=0
            while(qs<qe and not flag):
                u=Q[qs]
                print('u:',u)
                for v in range(Ny):
                    print('----------')
                    if flag:continue
                    if g[u][v] and chk[v]!=i:
                        chk[v]=i
                        print('v:',v,'chk:',chk)
                        Q[qe]=My[v]
                        print('qe',qe,'Q',Q)
                        qe+=1
                        print('qe',qe)
                        if My[v]>=0:
                            prev[My[v]]=u
                            print('prev',prev)
                            print('lala')
                        else:
                            flag=1
                            d,e=u,v
                            print('d:',d,'e:',e)
                            while d!=-1:
                                t=Mx[d]
                                print('t:',t)
                                Mx[d]=e
                                print('d:',d,'Mx',Mx)
                                My[e]=d
                                print('e:',e,'My:',My)
                                d=prev[d]
                                print('d:',d)
                                e=t
                                print('e:',e)
                    print('-----')
                qs+=1
            if Mx[i]!=-1:
                res+=1
        print('Mx:',Mx,'My:',My,'chk:',chk,'Q:',Q,'prev',prev)
        print('----------------------------------------------------------------------------------')
    return res

if __name__ == '__main__':
       g=[[1,0,1,0],[0,1,0,1],[1,0,0,1],[0,0,1,0]]
       Nx=4
       Ny=4
       Mx=[-1,-1,-1,-1]
       My=[-1,-1,-1,-1]
       chk=[-1,-1,-1,-1]
       Q=[0 for i in range(5)]
       #原代码
       # Q=[0 for i in range(100)]
       prev=[0,0,0,0]
       print(BFS_hungary(g,Nx,Ny,Mx,My,chk,Q,prev))

'''
Mx 为以X序列对应的Y的序号
My 为以Y序列对应的X的序号
chk,  v   该轮对应的匹配关系以Y为底
qe的数目代表v运行的次数，qe=1，代表v循环了一次。
  qe=0  qe=1    qe=2
Q[ u,   My[v],  My[v],  0  ,   0]
prev[，，，]代表是否访问过  -1，,-1，-1，-1  代表此前没有访问过，2 代表访问过两次。有两个X访问。
'''

'''
运行结果：
第几轮： 0
qs: 0 qe: 0
qe: 0 Q: [0, 0, 0, 0, 0]
qe: 1
prev [-1, 0, 0, 0]
u: 0
----------
v: 0 chk: [0, -1, -1, -1]
qe 1 Q [0, -1, 0, 0, 0]
qe 2
d: 0 e: 0
t: -1
d: 0 Mx [0, -1, -1, -1]
e: 0 My: [0, -1, -1, -1]
d: -1
e: -1
-----
----------
----------
----------
Mx: [0, -1, -1, -1] My: [0, -1, -1, -1] chk: [0, -1, -1, -1] Q: [0, -1, 0, 0, 0] prev [-1, 0, 0, 0]
----------------------------------------------------------------------------------
第几轮： 1
qs: 0 qe: 0
qe: 0 Q: [1, -1, 0, 0, 0]
qe: 1
prev [-1, -1, 0, 0]
u: 1
----------
-----
----------
v: 1 chk: [0, 1, -1, -1]
qe 1 Q [1, -1, 0, 0, 0]
qe 2
d: 1 e: 1
t: -1
d: 1 Mx [0, 1, -1, -1]
e: 1 My: [0, 1, -1, -1]
d: -1
e: -1
-----
----------
----------
Mx: [0, 1, -1, -1] My: [0, 1, -1, -1] chk: [0, 1, -1, -1] Q: [1, -1, 0, 0, 0] prev [-1, -1, 0, 0]
----------------------------------------------------------------------------------
第几轮： 2
qs: 0 qe: 0
qe: 0 Q: [2, -1, 0, 0, 0]
qe: 1
prev [-1, -1, -1, 0]
u: 2
----------
v: 0 chk: [2, 1, -1, -1]
qe 1 Q [2, 0, 0, 0, 0]
qe 2
prev [2, -1, -1, 0]
lala
-----
----------
-----
----------
-----
----------
v: 3 chk: [2, 1, -1, 2]
qe 2 Q [2, 0, -1, 0, 0]
qe 3
d: 2 e: 3
t: -1
d: 2 Mx [0, 1, 3, -1]
e: 3 My: [0, 1, -1, 2]
d: -1
e: -1
-----
Mx: [0, 1, 3, -1] My: [0, 1, -1, 2] chk: [2, 1, -1, 2] Q: [2, 0, -1, 0, 0] prev [2, -1, -1, 0]
----------------------------------------------------------------------------------
第几轮： 3
qs: 0 qe: 0
qe: 0 Q: [3, 0, -1, 0, 0]
qe: 1
prev [2, -1, -1, -1]
u: 3
----------
-----
----------
-----
----------
v: 2 chk: [2, 1, 3, 2]
qe 1 Q [3, -1, -1, 0, 0]
qe 2
d: 3 e: 2
t: -1
d: 3 Mx [0, 1, 3, 2]
e: 2 My: [0, 1, 3, 2]
d: -1
e: -1
-----
----------
Mx: [0, 1, 3, 2] My: [0, 1, 3, 2] chk: [2, 1, 3, 2] Q: [3, -1, -1, 0, 0] prev [2, -1, -1, -1]
----------------------------------------------------------------------------------
4
'''

c.BFS与DFS比较

https://www.cnblogs.com/wzl19981116/p/9397203.html

BFS节约时间，浪费空间。DFS节约空间，浪费时间。

 

代码部分来自

https://www.cnblogs.com/jamespei/p/5555734.html

感谢！

studieren666
关注
01-python核心编程
南柯一梦的江湖
06-10 239
python入门 1.python初步 1.1 计算机基础结构 1.1.1 硬件 1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。 五大组成部分：运算器、控制器、存储器、输入设备、输出设备。 – 运算器：按照程序中的指令，对数据进行加工处理。 – 控制器：根据程序需求，指挥计算机的各个部件协调工作。 通常将运算器和控制器集成在中央处理器（CPU）中。 – 存储器：保存各类程序的数据信息。 ​ 内存RAM – 容量小，速度快，临时存储数据 ​ 硬盘HDD – 容量大，速度慢，
AI人才招聘与团队建设原理与代码实战案例讲解
最新发布
AI天才研究院
09-21 941
AI人才招聘与团队建设原理与代码实战案例讲解 1. 背景介绍 1.1 问题的由来 随着人工智能技术的快速发展,AI人才的需求量与日俱增。然而,优秀的AI人才往往供不应求,企业在招聘和团队建设方面面临诸多挑战。如何高效地招募到合适的A
python实现匈牙利算法
qq_21201679的博客
04-16 3742
1.通过深度优先搜索实现匈牙利算法 #-*-coding:utf-8-*- #created by lixiao at 2019/4/16 class DFS_hungary(): def __init__(self, nx, ny, edge, cx, cy, visited): self.nx, self.ny=nx, ny #x和y集合中顶点的个数 ...
Python-匈牙利算法
bai_bai_bai_bai的博客
02-25 719
在一个二分图中，该算法能够找到最大的匹配，即在给定的两组顶点中找到最大数量的边，使得每个顶点都最多与一个相邻顶点相连。图中的数字代表边的权重。接着，我们看A - 4，这条边也没有匹配，我们可以将A与4匹配。现在我们有五个匹配：A - 3，A - 4，B - 1，C - 3，D - 2。现在我们有四个匹配：A - 3，A - 4，B - 1，C - 3。A - 3，这条边没有匹配，我们可以将A与3匹配。现在我们有三个匹配：A - 3，A - 4，B - 1。C - 3，这条边没有匹配，我们可以将C与3匹配。
匈牙利算法与python实现
weixin_40779727的博客
05-17 3804
匈牙利算法 0 引出 最近看DETR论文，发现其通过匈牙利算法来进行预测和ground truth匹配，从而实现set prediction。这个思路很有意思，并且该匹配算法能适用多种问题，因此，对其进行详细记录，便于后续回顾。 首先来看，匈牙利算法能够解决什么问题。不妨以宝可梦作为例子引入。 现在有五个工作（搬砖、送快递、洗衣服、打扫、做饭）需要安排给有5个宝可梦（皮卡丘、杰尼龟、喷火龙、小拳石、妙蛙草）。每个宝可梦对每一项工作收费标准不同。如何安排工作使得成本最低。 （注：①每个宝可梦只能做一项工作；②
匈牙利算法的python实现
wangyhwyh753的博客
04-15 703
该算法主要解决的是两个不相交的两个集合最大配对数的问题。假如有两个独立的集合A,B,在AB 中当满足一定条件时能进行匹配，但是每个元素的匹配可能不止一个，那么如何匹配使得AB两个之间匹配达到最大。 # 编写配置函数,其中used列表用来记录B是否被占用，这个在每次对A发现的时候需要清空 # match列表表示B与A中的匹配 # link表示A，B匹配的条件，满足返回真，失败返回FALSE d...
匈牙利算法python实现
alex1801
03-16 4275
多目标跟踪问题中都会遇到多个目标在两帧之间的匹配问题，这种多对多的匹配问题一般会使用匈牙利算法解决。匈牙利算法，本身解决的是一个指派问题。 指派问题描述： 实际中，会遇到这样的问题，有 m 项不同的任务，需要 n 个人分别完成其中的1项，每个人完成任务的时间不一样。于是就有一个问题，如何分配任务使得花费时间最少。转换到多目标跟踪中即可描述为：待跟踪匹配目标为 m 个，当前帧检测到 n 个目标，已知 m 个目标和 n 个检测结果之间的距离，求最有匹配，使得距离误差累计最小。...
python求解运输问题_【数学建模】线性规划各种问题的Python调包方法
weixin_39684235的博客
12-09 2844
关键词：Python、调包、线性规划、指派问题、运输问题、pulp、混合整数线性规划(MILP)注：此文章是线性规划的调包实现，具体步骤原理请搜索具体解法。本文章的各个问题可能会采用多种调用方法，为什么？因为这些包各有特点，有些语法特别像matlab，只要稍稍改变即可达成代码交换；而有些包利用了python本身的特性，在灵活度与代码的可读性上更高。我认为这些包各有优劣，各位各持所需吧。看了本文章能...
算法面试基本问题
MARY197011111的博客
05-21 2905
一、Java 1.一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。 2.对象：对象是类的一个实例，有状态和行为。 3.类：类是一个模板，它描述一类对象的行为和状态。 4.方法：方法就是行为，一个类可以有很多方法。 5.实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。 6.编写Java程序时，应注意以下几点： 大小写敏感 类名：每个单词的首字母应该大写 方法名：所有的方法名都应该以小写字母开头。如果方法
Maximum Bipartite Matching
Step up, Stack up
05-11 2983
算法旨在用尽可能简单的思路解决问题，理解算法也应该是一个越看越简单的过程，当你看到算法里的一串概念，或者一大坨代码，第一感觉是复杂，此时不妨从例子入手，通过一个简单的例子，并编程实现，这个过程其实就可以理解清楚算法里的最重要的思想，之后扩展，对算法的引理或者更复杂的情况，对算法进行改进。最后，再考虑时间和空间复杂度的问题。        了解这个算法是源于在Network Alignment问题
hungalg:匈牙利算法的python实现
05-12
汉加 python实现。 最初提出来解决。 问题描述 匈牙利算法解决了分配问题，定义如下： 有许多代理和许多任务。 可以分配任何座席以执行任何任务，这会产生一些费用，该费用可能会因座席任务分配而异。 要求执行所有任务，方法是将每个任务恰好分配给一个代理，将每个任务恰好分配给一个代理，以使分配的总成本最小化。 Hangalg模块可以最小化和最大化（“获利”）给定矩阵。 参考 [1] [2]
hungarian-python:匈牙利算法的Python实现
06-29
匈牙利Python 匈牙利算法的Python实现 要求 麻木的 麻麻 用法 from hungarian import Hungarian N = 10 # problem size cost_matrix = np . random . random (( N , N )) h = Hungarian ( N ) assignment , total_cost = h . execute ( cost_matrix )
超详细！！！匈牙利算法流程以及Python程序实现！！！通俗易懂
12-22
前不久在无人机检测跟踪的项目中用到了多目标跟踪算法（该项目后续会发贴介绍），其中需要涉及多个目标在两帧之间的匹配问题，最初使用的是最简单的距离最小化原则进行帧间多目标的匹配。后来通过实习和查阅论文等渠道了解到了多目标跟踪领域经典的Sort和DeepSort算法，其中都使用到了匈牙利算法解决匹配问题，因此开此贴记录一下算法的学习过程。 指派问题概述 首先，对匈牙利算法解决的问题进行概述：实际中，会遇到这样的问题，有n项不同的任务，需要n个人分别完成其中的1项，每个人完成任务的时间不一样。于是就有一个问题，如何分配任务使得花费时间最少。 通俗来讲，就是n*n矩阵中，选取n个元素，每行每列各有1个元
Python-匈牙利算法卡尔曼滤波器多目标跟踪器实现
08-11
匈牙利算法 卡尔曼滤波器多目标跟踪器实现
匈牙利算法原理与Python实现
FAQ的博客
03-21 1726
超详细！匈牙利算法的原理介绍，以及python实现！
指派问题中匈牙利算法----Python实现
qq_43434469的博客
04-12 7764
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 一、指派问题 指派问题是一个特殊的0-1规划问题。 1.标准形式指派问题 有n个人和n件事，已知第i人做第j事的费用为，要求确定人和事.
匈牙利算法代码用python写出来
06-03
匈牙利算法是一种求解二分图最大匹配的算法。以下是使用 Python 实现匈牙利算法的代码： ```python # 定义一个函数来实现匈牙利算法 def hungarian_algorithm(graph): # 初始化左部顶点和右部顶点的匹配情况为空 l_match = {l: None for l in graph.keys()} r_match = {r: None for r in set(v for values in graph.values() for v in values)} # 定义一个函数来搜索增广路径 def dfs(l): # 遍历左部顶点可到达的所有右部顶点 for r in graph[l]: # 如果当前右部顶点还没有被匹配，或者可以尝试修改当前匹配 if r_match[r] is None or dfs(r_match[r]): # 则更新匹配情况 l_match[l] = r r_match[r] = l return True return False # 遍历所有的左部顶点，尝试寻找增广路径 for l in graph.keys(): if l_match[l] is None: dfs(l) # 返回左部顶点和右部顶点的匹配情况 return l_match, r_match ``` 其中，`graph` 是一个字典，用于存储二分图的邻接表信息，例如： ```python graph = { 'a': ['x', 'y'], 'b': ['y', 'z'], 'c': ['y'] } ``` 表示左部顶点 `a` 可以与右部顶点 `x` 和 `y` 相连，左部顶点 `b` 可以与右部顶点 `y` 和 `z` 相连，左部顶点 `c` 可以与右部顶点 `y` 相连。在上面的代码中，我们使用了深度优先搜索来查找增广路径，直到无法找到新的增广路径为止。最后，返回左部顶点和右部顶点的匹配情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值