指派问题——匈牙利Hungary算法（用python实现）
注：昨天刚刚看了关于python的关于数组的简单操作，就将匈牙利算法用python实现了以下。其中可能有很多点可以用python中数组本身属性实现，但由于初学，所以不熟悉而导致步骤繁琐的望指出～
1.匈牙利算法的简单例子
（1）矩阵所表示的就是从A点到B所要付出的代价，一般目标函数都是使得代价最小，那么匈牙利算法就是一种精确算法，求解在多个出发点和多个目标点的情况下得出最小代价。约束是一个出发点只能对应一个目标点，在操作矩阵上的表现为某行某列只能选择一个数，即基于所选择的数画十字，这个十字上没有其他任何对应选择。
（2）初始矩阵
[12 7 9 7 9]
[ 8 9 6 6 6]
[ 7 17 12 14 9]
[15 14 6 11 10]
[ 4 10 7 10 9]（3）矩阵每行每列都减去该行该列的最小元素（此处每行每列至少出现一个0）
[ 5 0 2 0 2]
[ 2 3 0 0 0]
[ 0 10 5 7 2]
[ 9 8 0 5 4]
[ 0 6 3 6 5]（4）制定完全分配方案（即每个目标每个地点都被匹配）
- 从第一行开始，依次检查各行，直到找出只有一个未标记的0元素的一行。【圆括号表示选中标记，双引号表示忽略标记，即如果某数上有符号，表示该数已标记】。对未标记的0元素进行圆括号选中标记，并对同一列上的其他0元素进行双引号忽略标记。重复这一过程，直到每行没有尚未标记的0元素或至少有2个以上的0元素。
[ 5 0 2 0 2]
[ 2 3 “0“ 0 0]
[ (0) 10 5 7 2]
[ 9 8 (0) 5 4]
[ “0“ 6 3 6 5]- 现在，依次检查每列。规则同上。
[ 5 (0) 2 “0“ 2]
[ 2 3 “0“ (0) “0“]
[ (0) 10 5 7 2]
[ 9 8 (0) 5 4]
[ “0“ 6 3 6 5]- 最后如果还存在都行多列同时有两个或两个以上的尚未标记的0元素，则可将其中任意行或列的一个为标记的0元素作选中标记，并将同行同列的其他0元素作忽略标记。
- 以上并没有做到完全分配（第四行还有进行选中），于是根据以下步骤调整矩阵
a.检查尚未标记（）的行，并且打勾☑️，得
[ 5 (0) 2 “0“ 2]
[ 2 3 “0“ (0) “0“]
[ (0) 10 5 7 2]
[ 9 8 (0) 5 4]
[ “0“ 6 3 6 5] ☑️b.在已☑️的行中对所有有0元素的列打☑️
c.在对已☑️的列中对已有标记()的行进行☑️，得
[ 5 (0) 2 “0“ 2]
[ 2 3 “0“ (0) “0“]
[ (0) 10 5 7 2] ☑️
[ 9 8 (0) 5 4]
[ “0“ 6 3 6 5] ☑️
☑️d.重复b和c步骤，直到不能打勾为止
e.对未☑️的行 和 已☑️的列 划去元素， 得
[ ]
[ 10 5 7 2] ☑️
[ ]
[ 6 3 6 5] ☑️
☑️f.在剩余元素中找出最小元素，本例中为2，并对已☑️的行的每个元素进行减去最小元素的操作，
[[ 5 0 2 0 2]
[ 2 3 0 0 0]
[-2 8 3 5 0]
[ 9 8 0 5 4]
[-2 4 1 4 3]]g.将出现负数的列在加上之前的最小值使得=负数变为0，得
[[ 7 0 2 0 2]
[ 4 3 0 0 0]
[ 0 8 3 5 0]
[ 11 8 0 5 4]
[ 0 4 1 4 3]]e.如此反复，直到能作出完全分配为止
[ 7 (0) 2 0 2]
[ 4 3 0 (0) 0]
[ 0 8 3 5 (0)]
[ 11 8 (0) 5 4]
[ (0) 4 1 4 3]所以本例最优解为32（0对应原矩阵位置元素之和）
2.代码
import numpy as np
# 行归约
def smallizeRow(p, dim):
min_row = np.zeros(dim)
for i in range(0, dim):
min_row[i] = min(p[i, :])
for i in range(0, dim):
p[i, :] = p[i, :] - min_row[i]
# 列归约
def smallizeCol(p, dim):
min_col = np.zeros(dim)
for i in range(0, dim):
min_col[i] = min(p[:, i])
for i in range(0, dim):
p[:, i] = p[:, i] - min_col[i]
# 计算每行每列的0元素的个数
def countZero(p, row, col, dim):
for i in range(0, dim):
for j in range(0, dim):
if( p[i, j] == 0) :
row[i,0] = row[i, 0] + 1;
col[0, j] = col[0, j] + 1;
# 对0元素进行标记
def markZero(p, row, col, visited, dim):
# 检查行
for i in range(0, dim):
if(row[i, 0] == 1):
# 若该元素为0 且 未被圆括号标记 且未被双引号标记 再进行访问操作
if(p[i ,j] == 0 and visited[i, j] != 1 and visited[i, j] != -1):
visited[i, j] = 1;
row[i, 0] -= 1
col[0, j] -= 1
for m in range(0, dim):
if(p[m, j] == 0 and visited[m, j] != 1 and visited[m, j] != -1):
visited[m, j] = -1
row[m, 0] -= 1
col[0, j] -= 1
# 检查列
for j in range(0, dim):
if(col[0, j] == 1):
for i in range(0, dim):
if(p[i ,j] == 0 and visited[i, j] != 1 and visited[i, j] != -1):
visited[i, j] = 1
col[0, j] -= 1
row[i, 0] -= 1
for m in range(0, dim):
if(p[i, m] == 0 and visited[i, m] != 1 and visited[i, m] != -1):
visited[i, m] = -1
row[i, 0] -= 1
col[0, m] -= 1
# 对多行多列存在两个及两个以上的为标记的0的操作
for i in range(0, dim):
if (row[i, 0] >= 2 ):
for j in range(0, dim):
if(p[i ,j] == 0 and visited[i, j] != 1 and visited[i, j] != -1):
visited[i, j] = 1;
row[i, 0] -= 1
col[0, j] -= 1
for m in range(0, dim):
if(p[m, j] == 0 and visited[m, j] != 1 and visited[m, j] != -1):
visited[m, j] = -1
row[m, 0] -= 1
col[0, j] -= 1
for n in range(0, dim):
if(p[i, n] == 0 and visited[i, n] != 1 and visited[i, n] != -1):
visited[i, n] = -1
row[i , 0] -= 1
col[0, n] -= 1
for j in range(0, dim):
if(col[0, j] >= 2):
for i in range(0, dim):
if(p[i ,j] == 0 and visited[i, j] != 1 and visited[i, j] != -1):
visited[i, j] = 1
col[0, j] -= 1
row[i, 0] -= 1
for m in range(0, dim):
if(p[i, m] == 0 and visited[i, m] != 1 and visited[i, m] != -1):
visited[i, m] = -1
row[i, 0] -= 1
col[0, m] -= 1
for n in range(0, dim):
if(p[n, j] == 0 and visited[n, j] != 1 and visited[n, j] != -1):
visited[n, j] = -1
row[n, 0] -= 1
col[0, j] -= 1
# 找出最小元素便于更新矩阵
def drawline(p, visited, marked_row, marked_col, dim):
tempmin = 10000
# 不相关元素进行标记，便于之后的最小元素的选择
drawline = np.zeros((dim, dim))
# 检查行是否有被圆括号标记的0元素
flag = np.zeros(dim)
for i in range(0, dim):
for j in range(0, dim):
if(visited[i][j] == 1):
flag[i] = 1
for i in range(0, dim):
if(flag[i] == 0):
marked_row[i, 0] =1
for m in range(0, dim):
if(p[i][m] == 0):
marked_col[0, m] = 1;
for n in range(0, dim):
if(visited[n][m] == 1):
marked_row[n, 0] = 1
for i in range(0, dim):
if marked_row[i, 0] == 0 :
drawline[i, :] = 1
if marked_col[0, i] == 1:
drawline[:, i] = 1
for i in range(0, dim):
for j in range(0, dim):
if drawline[i, j] != 1 and p[i, j]!= 0 and p[i, j] < tempmin:
tempmin = p[i, j]
return tempmin
# 更新矩阵便于第二次迭代寻找完全分配
def updata(p, marked_row, tempmin, dim):
for i in range(0, dim):
if marked_row[i] == 1:
p[i, :] = p[i, :] - tempmin
# print(p)
for i in range(0, dim):
for j in range(0, dim):
if p[i, j] < 0 :
p[:, j] = p[:, j] + tempmin
if __name__ == '__main__':
# 数组维度
dim = 5
# 原始数组
p = np.array([12, 7, 9, 7, 9, 8, 9, 6, 6, 6, 7, 17, 12, 14, 9, 15, 14, 6, 11, 10, 4, 10, 7, 10, 9])
p = p.reshape((dim, dim))
# 记录原始数组值
q = p.copy()
print("原始矩阵为：\n"， p)
# 标记是否已找到完全分配
flag = 0
#行列归约
smallizeRow(p, dim)
smallizeCol(p, dim)
print("归约后矩阵为：\n", p)
while(flag == 0):
# 统计每行0的个数
row = np.zeros((dim, 1))
# 统计每列0的个数
col = np.zeros((1, dim))
# 标记0元素的被访问类型，当访问次数标记为1时，表示括号，-1为双引号
visited = np.zeros((dim, dim))
# 标记打勾的行与列
marked_row = np.zeros((dim, 1))
marked_col = np.zeros((1, dim))
# 标记是否完全分配, 当count=5时表示已完全分配
count = 0
solution = 0
countZero(p, row, col, dim)
# print(row)
# print(col)
markZero(p, row, col, visited, dim)
# print(p)
print("迭代标记矩阵为：\n", visited)
# print(row)
# print(col)
tempmin = drawline(p, visited, marked_row, marked_col, dim)
# print(marked_row)
# print(marked_col)
# print(tempmin)
updata(p, marked_row, tempmin, dim)
print("迭代后的矩阵为：\n", p)
for i in range(0, dim):
for j in range(0, dim):
if visited[i, j] == 1:
count += 1
solution += q[i, j]
if count == dim:
flag = 1
print("the best solution is : ", solution )
break
print("再次迭代求完全分配")运行结果为：
初始矩阵为：
[[12 7 9 7 9]
[ 8 9 6 6 6]
[ 7 17 12 14 9]
[15 14 6 11 10]
[ 4 10 7 10 9]]
归约后的矩阵：
[[ 5 0 2 0 2]
[ 2 3 0 0 0]
[ 0 10 5 7 2]
[ 9 8 0 5 4]
[ 0 6 3 6 5]]
迭代后的标记矩阵为：
[[ 0. 1. 0. -1. 0.]
[ 0. 0. -1. 1. -1.]
[ 1. 0. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[-1. 0. 0. 0. 0.]]
迭代之后的矩阵为:
[[ 7 0 2 0 2]
[ 4 3 0 0 0]
[ 0 8 3 5 0]
[11 8 0 5 4]
[ 0 4 1 4 3]]
再次迭代求最优解
迭代后的标记矩阵为：
[[ 0. 1. 0. -1. 0.]
[ 0. 0. -1. 1. -1.]
[-1. 0. 0. 0. 1.]
[ 0. 0. 1. 0. 0.]
[ 1. 0. 0. 0. 0.]]
迭代之后的矩阵为:
[[ 7 0 2 0 2]
[ 4 3 0 0 0]
[ 0 8 3 5 0]
[11 8 0 5 4]
[ 0 4 1 4 3]]
the best solution is : 323.思考
关于其时空复杂度分别为O(n^3), O(n), n为节点个数。在面对目标过多的情况下，效率不高，考虑贪心算法。即从第一行开始每行选择最小的数，然后划区所选数的当前行当前列，不列入选择范围，然后依次重复下面每行，获得次优解。然后对列进行同样的操作得到结果。将行列得到的结果比较选择更优解作为解。显然这样的时空复杂度为O(n),O(1)，且结构和最优解接近。同以上例子的贪心结果为：32。