一、問題描述

問題描述：N個人分配N項任務，一個人只能分配一項任務，一項任務只能分配給一個人，將一項任務分配給一個人是需要支付報酬，如何分配任務，保證支付的報酬總數最小。

問題數學描述：

　　

二、例項分析---全排列法

在講將匈牙利演算法解決任務分配問題之前，先分析幾個具體例項。

以3個工作人員和3項任務為例項，下圖為薪酬圖表和根據薪酬圖表所得的cost矩陣。

　　

利用最簡單的方法(全排列法)進行求解，計算出所有分配情況的總薪酬開銷，然後求最小值。

total_cost1 = 250 + 600 + 250 = 1100;  x00 = 1,x11 = 1,x22 = 1;

total_cost2 = 250 + 350 + 400 = 1000;  x00 = 1,x12 = 1,x21 = 1;

total_cost3 = 400 + 400 + 250 = 1050;  x01 = 1,x10 = 1,x22 = 1;

total_cost4 = 400 + 350 + 200 = 950;   x01 = 1,x12 = 1,x20 = 1;  //最優分配

total_cost5 = 350 + 400 + 400 = 1150; x02 = 1,x10 = 1,x21 = 1;

total_cost6 = 350 + 600 + 250 = 1150; x02 = 1,x11 = 1,x22 = 1;

對於任務數和人員數較少時，可利用全排列法計算結果。

若將N任務分配給N個人員，其包含的所有分配情況數目為N!，N增大時，全排列法將難以完成任務。

三、匈牙利演算法

下面簡要介紹匈牙利演算法。

其基本的理論基礎是針對cost矩陣，將cost矩陣的一行或一列資料加上或減去一個數，其最優任務分配求解問題不變。

　　

演算法的基本步驟如下：

　　

四、例項分析---匈牙利演算法

下面結合具體例項，分析匈牙利演算法如何解決任務分配問題。

以N = 4為例項，下圖為cost列表和cost矩陣。

　　

Step1.從第1行減去75，第2行減去35，第3行減去90，第4行減去45。

　　

Step2.從第1列減去0，第2列減去0，第3列減去0，第4列減去5。

　　

Step3.利用最少的水平線或垂直線覆蓋所有的0。

　　

Step4.由於水平線和垂直線的總數是3，少於4，進入Step5。

Step5.沒有被覆蓋的最小值是5，沒有被覆蓋的每行減去最小值5，被覆蓋的每列加上最小值5，然後跳轉到步驟3.

　　

Step3.利用最少的水平線或垂直線覆蓋所有的0。

　　

Step4.由於水平線和垂直線的總數是3，少於4，進入Step5。

Step5.沒有被覆蓋的最小值是20，沒有被覆蓋的每行減去最小值20，被覆蓋的每列加上最小值20，然後跳轉到步驟3.

　　

Step3.利用最少的水平線或垂直線覆蓋所有的0。

　　

Step4.由於水平線和垂直線的總數是4，演算法結束，分配結果如下圖所示。

　　

其中，黃色框表示分配結果，左邊矩陣的最優分配等價於左邊矩陣的最優分配。

以上內容為轉載部分，下面程式碼內容為原創

五、python程式碼

1. import itertools
   
   import numpy as np
   
   from numpy import random
   
   from scipy.optimize import linear_sum_assignment
   
   
   
   # 任務分配類
   
   class TaskAssignment:
   
   
   # 類初始化，需要輸入引數有任務矩陣以及分配方式，其中分配方式有兩種，全排列方法all_permutation或匈牙利方法Hungary。
   
   def __init__(self, task_matrix, mode):
   
   self.task_matrix = task_matrix
   
   self.mode = mode
   
   if mode == 'all_permutation':
   
   self.min_cost, self.best_solution = self.all_permutation(task_matrix)
   
   if mode == 'Hungary':
   
   self.min_cost, self.best_solution = self.Hungary(task_matrix)
   
   
   # 全排列方法
   
   def all_permutation(self, task_matrix):
   
   number_of_choice = len(task_matrix)
   
   solutions = []
   
   values = []
   
   for each_solution in itertools.permutations(range(number_of_choice)):
   
   each_solution = list(each_solution)
   
   solution = []
   
   value = 0
   
   for i in range(len(task_matrix)):
   
   value += task_matrix[i][each_solution[i]]
   
   solution.append(task_matrix[i][each_solution[i]])
   
   values.append(value)
   
   solutions.append(solution)
   
   min_cost = np.min(values)
   
   best_solution = solutions[values.index(min_cost)]
   
   return min_cost, best_solution
   
   
   # 匈牙利方法
   
   def Hungary(self, task_matrix):
   
   b = task_matrix.copy()
   
   # 行和列減0
   
   for i in range(len(b)):
   
   row_min = np.min(b[i])
   
   for j in range(len(b[i])):
   
   b[i][j] -= row_min
   
   for i in range(len(b[0])):
   
   col_min = np.min(b[:, i])
   
   for j in range(len(b)):
   
   b[j][i] -= col_min
   
   line_count = 0
   
   # 線數目小於矩陣長度時，進行迴圈
   
   while (line_count < len(b)):
   
   line_count = 0
   
   row_zero_count = []
   
   col_zero_count = []
   
   for i in range(len(b)):
   
   row_zero_count.append(np.sum(b[i] == 0))
   
   for i in range(len(b[0])):
   
   col_zero_count.append((np.sum(b[:, i] == 0)))
   
   # 劃線的順序（分行或列）
   
   line_order = []
   
   row_or_col = []
   
   for i in range(len(b[0]), 0, -1):
   
   while (i in row_zero_count):
   
   line_order.append(row_zero_count.index(i))
   
   row_or_col.append(0)
   
   row_zero_count[row_zero_count.index(i)] = 0
   
   while (i in col_zero_count):
   
   line_order.append(col_zero_count.index(i))
   
   row_or_col.append(1)
   
   col_zero_count[col_zero_count.index(i)] = 0
   
   # 畫線覆蓋0，並得到行減最小值，列加最小值後的矩陣
   
   delete_count_of_row = []
   
   delete_count_of_rol = []
   
   row_and_col = [i for i in range(len(b))]
   
   for i in range(len(line_order)):
   
   if row_or_col[i] == 0:
   
   delete_count_of_row.append(line_order[i])
   
   else:
   
   delete_count_of_rol.append(line_order[i])
   
   c = np.delete(b, delete_count_of_row, axis=0)
   
   c = np.delete(c, delete_count_of_rol, axis=1)
   
   line_count = len(delete_count_of_row) + len(delete_count_of_rol)
   
   # 線數目等於矩陣長度時，跳出
   
   if line_count == len(b):
   
   break
   
   # 判斷是否畫線覆蓋所有0，若覆蓋，進行加減操作
   
   if 0 not in c:
   
   row_sub = list(set(row_and_col) - set(delete_count_of_row))
   
   min_value = np.min(c)
   
   for i in row_sub:
   
   b[i] = b[i] - min_value
   
   for i in delete_count_of_rol:
   
   b[:, i] = b[:, i] + min_value
   
   break
   
   row_ind, col_ind = linear_sum_assignment(b)
   
   min_cost = task_matrix[row_ind, col_ind].sum()
   
   best_solution = list(task_matrix[row_ind, col_ind])
   
   return min_cost, best_solution
   
   
   
   # 生成開銷矩陣
   
   rd = random.RandomState(10000)
   
   task_matrix = rd.randint(0, 100, size=(5, 5))
   
   # 用全排列方法實現任務分配
   
   ass_by_per = TaskAssignment(task_matrix, 'all_permutation')
   
   # 用匈牙利方法實現任務分配
   
   ass_by_Hun = TaskAssignment(task_matrix, 'Hungary')
   
   print('cost matrix = ', '\n', task_matrix)
   
   print('全排列方法任務分配：')
   
   print('min cost = ', ass_by_per.min_cost)
   
   print('best solution = ', ass_by_per.best_solution)
   
   print('匈牙利方法任務分配：')
   
   print('min cost = ', ass_by_Hun.min_cost)
   
   print('best solution = ', ass_by_Hun.best_solution)

    

2.  

程式碼執行例項：