图论中的基本概念

二分图:
一个图中的所有顶点可划分为两个不相交的集合 U 和 V ，使得每一条边都分别连接U、V中的顶点。如果存在这样的划分，则此图为一个二分图。
匹配:
一个匹配就是一个边的集合，这个边集合中的任意两条边没有公共的顶点。
最大匹配:
一个图的所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。
最大匹配数:
最大匹配的匹配边的数目。
完美匹配:
如果一个图的某个匹配中，所有的顶点都是匹配点，那么它就是一个完美匹配。显然，完美匹配一定是最大匹配（完美匹配的任何一个点都已经匹配，添加一条新的匹配边一定会与已有的匹配边冲突）。但并非每个图都存在完美匹配。
最小顶点覆盖数:
选取最少的点，使二分图中任意一条边至少有一个端点被选择。最小覆盖要求用最少的点（U集合或V集合的都行）让每条边都至少和其中一个点关联。可以证明：最少的点（即覆盖数）＝最大匹配数
最大独立数:
选取最多的点，使任意所选两点均不相连。
最小路径覆盖数:
对于一个 DAG（有向无环图），选取最少条数的路径，使得每个顶点属于且仅属于一条路径，路径长可以为 0（即单个点）。也就是说用尽量少的不相交简单路径覆盖DAG的所有结点。
一些性质:
定理1：最大匹配数=最小点覆盖数（Konig 定理）
定理2：最大匹配数=最大独立数
定理3：最小路径覆盖数=顶点数-最大匹配数

匈牙利算法中的基本概念

交替路:
从一个未匹配的点出发，依次经过非匹配边、匹配边、非匹配边······这样形成的路径叫交替路。
增广路:
从一个未匹配的点出发，走交替路，如果路过一个未匹配的点（第一个点除外），这条交替路叫增广路。
增广路有一个重要特点：非匹配边比匹配边多一条。因此，研究增广路的意义是改进匹配。只要把增广路中的匹配边和非匹配边的身份交换即可。由于中间的匹配节点不存在其他相连的匹配边，所以这样做不会破坏匹配的性质。交换后，图中的匹配边数目比原来多了 1 条。
我们可以通过不停地找增广路来增加匹配中的匹配边和匹配点。找不到增广路时，达到最大匹配（这是增广路定理）。匈牙利算法正是这么做的，这也是算法的核心。

匈牙利匹配算法

论文:The Hungarian Method for the Assignment Problem
论文地址:https://web.eecs.umich.edu/~pettie/matching/Kuhn-hungarian-assignment.pdf 。
重要定理:
如果从一个点A出发，没有找到增广路径，那么无论再从别的点出发找到多少增广路径来改变现在的匹配，从点A出发都永远找不到增广路径。
匈牙利算法的核心思想:
初始时最大匹配为控，然后不断寻找增广路，并扩展增广路。不断重复这一过程直到找不到增广路为止。
如果二分图左半边U集合中共有n个点，那么最多找n条增广路径。如果图中共有m条边，那么每找一条增广路径（DFS或BFS）时最多把所有边遍历一遍，所花时间也就是m。所以总时间大概就是O（nm）。
使用DFS查找的匈牙利匹配算法流程:
从左边U集合找出第一个未匹配点（假设为点1）进行BFS边搜索，寻找一条未匹配边。如果找到一条未匹配边（假设为边1），这个边的另一头是右边V集合中的一个未匹配点（假设为点A），说明寻找成功。更新路径信息，匹配边数+1；
再找到左边U集合的第二个未匹配点（假设为点2），进行BFS边搜索。假如搜索到一条边（假设为边2），该边连接的另一个点V集合中前一轮已经匹配的点（点A），那么我们将边2作为点2和点A的未匹配边，然后对放弃的未匹配边（边1）的另一个点（点1）重新进行BFS边搜索（这次搜索跳过已经选择过的边1），寻找另一条未匹配边。假设我们找到了新的一条为匹配边（边3），该边连接点1和点C。
对于后面的每一轮，我们都从左边U集合中找出一个未匹配点x，然后进行BFS边搜索，如果搜到一条边，其另一点是V集合中前几轮中已经匹配的点y’，那么我们找到y’以前的未匹配边t，找到该边另一头属于左边U集合的点x’，对x’进行BFS边搜索（跳过前面已经选择的边），继续寻找未匹配边。如果x’BFS搜索到下一条边的另一点也是V集合中前几轮中已经匹配的点y’’，那么继续迭代执行上述过程。直到最后迭代找到的点的所有边都搜索过，且找不到为匹配边为止，此时我们就认为本轮最初选择的未匹配点x和点y’无法配对，我们不再从这个点x开始搜索。

匈牙利匹配算法举例

原始二分图中，集合U有点1、2、3、4，集合V中有点5、6、7、8，边有：1-5，1-6，2-5，3-6，3-8，4-7。

1---5
 /
/ 
2
6
/
/
3
7
 /
/ 
4
8

第一轮:
选取集合U中未匹配点1，进行BFS边搜索，找到第一条边1-5，5是集合V中未匹配点，这样我们找到了一条边，将集合U的未匹配点1和集合V的未匹配点5配对，我们用link[5] = 1来表示。
第二轮:
接着选取集合U中未匹配的点2，进行BFS边搜索，找到第一条边2-5，但关于5这个点前面已经标记了一个配对边1-5，那么我们再对原来的点1继续进行BFS边搜索，发现另一条边1-6，6是集合V中未匹配点，于是将集合U的未匹配点1和集合V的未匹配点6配对，用link[6] = 1表示，此时link[5] = 1不变，但是要注意它此时的含义是点2和点5配对。
第三轮:
接着选取集合U中未匹配的点3，进行BFS边搜索，找到第一条边3-6，由于link[6] = 1，于是向前找到原来与6配对的点1，对点1再做BFS边搜索，发现边1-5，但点5已经和点2配对了。那么再对点2做BFS边搜索，发现2只有边2-5，搜索到头了只能停止。因此点3不能和点6配对。
再找点3的第二条边，找到边3-8，8是集合V中未匹配点，这样我们将集合U的未匹配点3和集合V的未匹配点8配对，我们用link[8] = 1来表示。
第四轮:
接着选取集合U中未匹配点4，进行BFS边搜索，找到第一条边4-7，7是集合V中未匹配点，这样我们将集合U的未匹配点4和集合V的未匹配点7配对，我们用link[7] = 1来表示。

这样我们就找到了这个二分图的最大匹配。最大匹配中包含的边是1-6，2-5，3-8，4-7。

匈牙利匹配算法Python代码实现

from collections import deque
class HungarianAlgorithm(object):
def __init__(self, graph):
"""
这里的队列虽然用list也可以实现,但pop(0)的开销还是很大,因此还是用链式存储结构Deque
:param graph: 二分图的矩阵表示形式
"""
self.graph = graph
self.length = len(graph)
# x为输入的U集合中某个未匹配点，从V集合中寻找另一个未匹配点与其配对
def find(self, x):
for i in range(self.length):
# V集合中的点从第一个点开始遍历,如果两点之间有边且还没访问过V集合中这个点i
if self.graph[x][i] == 1 and not self.used[i]:
# 记录匹配边,放入交替路,记录V集合中的点i已访问过
self.used[i] = 1
# 如果点i之前已经访问过
# 如果V集合中的点i之前没有匹配过,或V集合中的点i之前匹配过,那么i的配对点为输入的x,x的配对点位i
if self.match[i] == -1 or self.find(self.match[i]) == 1:
# 那边令V集合的这个点匹配对象更新为x,
self.match[i] = x
self.match[x] = i
print(x + 1, '->', i + 1)
return 1
return 0
def hungarian1(self):
"""
递归形式的匈牙利匹配算法
:return:
"""
# 记录V集合中点的匹配情况的矩阵,一开始全初始化为-1,表示均未匹配
self.match = [-1] * self.length
# 记录是否访问过某个点(列表的某个元素,即矩阵的行向量)的矩阵,一开始全为False,表示全未访问过
self.used = [False] * self.length
m = 0
# 遍历所有U集合中的点(即列表的每个元素,每一个元素都是一个行向量,记录了这个U集合中的点与V集合中的哪些点有边)
for i in range(self.length):
# 如果U集合中第i个点还未匹配
if self.match[i] == -1:
# 令记录访问过的点记录的矩阵初始化,注意对U集合中每个未匹配点这个矩阵都要重新初始化一次
self.used = [False] * self.length
print("开始匹配U集合中第{}个点:".format(i + 1))
m += self.find(i)
# 返回的是最大匹配的边个数
return m
def hungarian2(self):
"""
循环形式的匈牙利匹配算法
:return:
"""
# 记录V集合中点的匹配情况的矩阵,一开始全初始化为-1,表示均未匹配
match = [-1] * self.length
# 记录是否访问过某个点(列表的某个元素,即矩阵的行向量)的矩阵,一开始全为False,表示全未访问过
used = [-1] * self.length
# 设置一个队列
q_list = deque()
# 记录最大匹配的边个数
ans = 0
# 代表上一个节点
prev = [0] * self.length
for i in range(self.length):
# 对U集合中第i个点,如果i还没有匹配过,清空队列,i假如队列
if match[i] == -1:
q_list.clear()
q_list.append(i)
# 设i为出发点
prev[i] = -1
# flag=False表示未找到增广路
flag = False
# 当队列不为空且还未找到增广路时
while len(q_list) > 0 and not flag:
# 队列左边出一个元素(即我们进队列的前面的点,最早进的点先出)
u = q_list.popleft()
# 查找V集合中的未匹配点
for j in range(self.length):
# 如果点U与V集合的点j有边且j的配对点不是i(即还未配对,或配对给其他点)
if not flag and self.graph[u][j] == 1 and used[j] != i:
# 配对
used[j] = i
# 如果u与j已经匹配过
if match[j] != -1:
# 把点j也加入队列
q_list.append(match[j])
# 记录点的顺序
prev[match[j]] = u
# 如果u与j没有匹配过,现在就开始匹配,且flag=True表示找到增广路
else:
flag = True
d = u
e = j
# 将原匹配的边去掉加入原来不在匹配中的边
while (d != -1):
t = match[d]
match[d] = e
match[e] = d
d = prev[d]
e = t
print('match:', match)
print('prev:', prev)
print('deque', q_list)
# 新增匹配边
if match[i] != -1:
ans += 1
# 返回的是最大匹配的边个数
return ans
# 二分图用矩阵形式存储,即有多少行U集合中集有几个点，有多少列V集合中就有几个点
# 两点之间如果有边则对应位置元素值为1(关于对角线对称)
graph_1 = [(0, 0, 0, 0, 1, 0, 1, 0),
(0, 0, 0, 0, 1, 0, 0, 0),
(0, 0, 0, 0, 1, 1, 0, 0),
(0, 0, 0, 0, 0, 0, 1, 1),
(1, 1, 1, 0, 0, 0, 0, 0),
(0, 0, 1, 0, 0, 0, 0, 0),
(1, 0, 0, 1, 0, 0, 0, 0),
(0, 0, 0, 1, 0, 0, 0, 0)]
def do_hungarian1(graph):
h = HungarianAlgorithm(graph)
# print(h.graph)
# print(h.length)
print("最大匹配边数:{}".format(h.hungarian1()))
def do_hungarian2(graph):
h = HungarianAlgorithm(graph)
# print(h.graph)
# print(h.length)
print("最大匹配边数:{}".format(h.hungarian2()))
do_hungarian1(graph_1)
do_hungarian2(graph_1)

运行结果如下:

开始匹配U集合中第1个点:
1 -> 5
开始匹配U集合中第2个点:
1 -> 7
2 -> 5
开始匹配U集合中第3个点:
3 -> 6
开始匹配U集合中第4个点:
4 -> 8
最大匹配边数:4
match: [4, -1, -1, -1, 0, -1, -1, -1]
prev: [-1, 0, 0, 0, 0, 0, 0, 0]
deque deque([])
match: [6, 4, -1, -1, 1, -1, 0, -1]
prev: [1, -1, 0, 0, 0, 0, 0, 0]
deque deque([])
match: [6, 4, 5, -1, 1, 2, 0, -1]
prev: [1, 2, -1, 0, 0, 0, 0, 0]
deque deque([1])
match: [6, 4, 5, 7, 1, 2, 0, 3]
prev: [3, 2, -1, -1, 0, 0, 0, 0]
deque deque([0])
最大匹配边数:4

最后

以上就是俊逸大地为你收集整理的匈牙利匹配算法原理图论中的基本概念匈牙利算法中的基本概念匈牙利匹配算法匈牙利匹配算法举例匈牙利匹配算法Python代码实现的全部内容，希望文章能够帮你解决匈牙利匹配算法原理图论中的基本概念匈牙利算法中的基本概念匈牙利匹配算法匈牙利匹配算法举例匈牙利匹配算法Python代码实现所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。