指派问题数学建模详解
指派问题（Assignment Problem）起源于20世纪40年代，最初由匈牙利数学家科尼希（Dénes Kőnig）和埃贡·埃根普（Egon Egerváry）等人提出。该问题属于线性规划中的特殊类型，指派问题可以看作是运输问题的特例，运输问题是指派问题的松弛问题，指派问题类似于整数运输问题。指派问题是将一个集合中的元素（如工人、任务等）与另一个集合中的元素进行一对一匹配。每种匹配都有一个对应的成本，目标是找到一种总成本最低的匹配方式。随着计算机技术的发展，指派问题的求解算法也逐渐成熟。早期的求解方法主要包括匈牙利算法和拉格朗日松弛法。匈牙利算法由哈罗德·库恩（Harold Kuhn）于1955年提出，基于二分图的匹配理论，是一种可以在多项式时间内求解指派问题的经典算法。相比之下，拉格朗日松弛法则适用于更复杂的指派问题，例如含有额外约束的广义指派问题。指派问题逐渐应用扩展到更多实际应用场景，如车辆路径规划、网络优化以及云计算资源分配等。
| 最小化指派问题 | 二分图问题 |
|---|---|
 |
 |
一、标准的指派问题与其数学模型
指派问题有如下假设：
唯一性和完备性：每个工人只能分配一个任务，每个任务也只能由一个工人完成，且所有工人和任务必须全部分配。
成本或效益确定性：每个工人完成任务的成本或效益是确定的，并且在问题解决过程中保持不变。
非负性和独立性：所有任务的完成成本是非负的，且一个工人的任务分配不会影响其他工人的分配成本。
工人和任务的离散性：工人和任务的数量是有限的，且每个工人和任务都是独立的个体。
任务与工人之间无偏好或技能差异：所有工人可以完成任何任务，且没有预先指定的配对，也不考虑工人的技能差异。
标准的指派问题是一个经典的优化问题，目的是将\(n\)项任务分配给\(n\)个工人（或资源）。由于任务的性质和工人的技能各不相同，每个工人完成不同任务的效率或成本也不同，因此需要合理安排每个工人去完成特定的任务，以达到最优的分配方案。在标准的指派问题中，每个工人只能完成一个任务，每个任务也只能被一个工人完成。目标是找到一种分配方案，使得完成所有任务的总成本最小。这种问题通常可以用一个\(n×n\)的矩阵来表示，称为成本矩阵或消耗矩阵，矩阵中的每个元素\(c_{ij}\)表示第\(i\)个人完成第\(j\)项任务所需要的成本或代价，即
\[C = \begin{bmatrix}
c_{11} & c_{12} & ... & c_{1n} \\
c_{21} & c_{22} & ... & c_{2n} \\
... & ... & ... & ... \\
c_{n1} & c_{n2} & ... & c_{nn}
\end{bmatrix}
\]
1.1 数学模型
- 决策变量：定义二元决策变量$ x_{ij}$
\[x_{ij} = \begin{cases}
1, & \text{如果第 } i \text{ 个人分配给第 } j \text{ 个任务} \\
0, & \text{否则}
\end{cases}
\]
- 目标函数：
我们的目标是最小化总成本指派问题，目标函数可以写为：
\[\text{min } Z = \sum_{i=1}^{n} \sum_{j=1}^{n} c_{ij} x_{ij}
\]
- 约束条件：
- 每个人只能分配给一个任务：
每个\(i\) 只能选择一个$ j$，即：
\[\sum_{j=1}^{n} x_{ij} = 1, \quad \forall i = 1, 2, \dots, n \]- 每个任务只能被一个人分配：
每个任务$ j$ 只能分配给一个人$ i$，即：
\[\sum_{i=1}^{n} x_{ij} = 1, \quad \forall j = 1, 2, \dots, n \]- 二进制变量约束：
每个$ x_{ij}$ 都是二进制变量，表示任务是否被分配：
\[x_{ij} \in \{0, 1\}, \quad \forall i, j \] - 每个人只能分配给一个任务：
- 数学模型
\[\begin{align*}
\text{min} \quad & \sum_{i \in W} \sum_{j \in J} x_{ij} c_{ij} \\
\text{s.t.} \quad & \sum_{j \in J} x_{ij} = 1, & \forall i \in \{1,2,...,n\} \\
& \sum_{i \in W} x_{ij} = 1, & \forall j \in \{1,2,...,n\} \\
& x_{ij} \in \{0, 1\}, & \forall i \in \{1,2,...,n\}, \forall j \in \{1,2,...,n\}
\end{align*}
\]
1.2 练习
考虑下面指派问题。假设我们有四个员工A、B、C和D和4项任务甲、乙、丙和丁，需要为每个员工分配一个任务，使得总时间最短。下面的矩阵显示了员工和任务的每种组合所需的时间（以分钟为单位），表中数据表示表示第 \(i\)个员工完成第\(j\)个任务的时间。
| 甲 | 乙 | 丙 | 丁 | |
|---|---|---|---|---|
| A | 85 | 95 | 82 | 86 |
| B | 85 | 87 | 83 | 90 |
| C | 92 | 78 | 79 | 80 |
| D | 73 | 95 | 90 | 88 |
- 问题描述
有 4 个员工：A、B、C 和 D，以及 4 个任务：甲、乙、丙和丁。任务和员工之间的时间成本由如下矩阵给出：
\[C = \begin{bmatrix}
85 & 95 & 82 & 86 \\
85 & 87 & 83 & 90 \\
92 & 78 & 79 & 80 \\
73 & 95 & 90 & 88 \\
\end{bmatrix} \]
目标是分配任务给员工，使总时间最短。
- 决策变量：
\[x_{ij} = \begin{cases}
1, & \text{如果第 } i \text{ 个员工被分配给第 } j \text{ 个任务} \\
0, & \text{否则}
\end{cases}\]
| 甲 | 乙 | 丙 | 丁 | |
|---|---|---|---|---|
| A | $ x_{11}$ | $ x_{12}$ | $ x_{13}$ | $ x_{14}$ |
| B | $ x_{21}$ | $ x_{22}$ | $ x_{23}$ | $ x_{24}$ |
| C | $ x_{31}$ | $ x_{32}$ | $ x_{33}$ | $ x_{34}$ |
| D | $ x_{41}$ | $ x_{42}$ | $ x_{43}$ | $ x_{44}$ |
- 目标函数：
\[\text{min } Z = \sum_{i=1}^{4} \sum_{j=1}^{4} c_{ij} x_{ij}
\]
- 约束条件：
- 每个员工只能分配一个任务$$\sum_{j=1}^{4} x_{ij} = 1, \quad \forall i = 1, 2, 3, 4$$
- 每个任务只能分配给一个员工$$\sum_{i=1}^{4} x_{ij} = 1, \quad \forall j = 1, 2, 3, 4$$
- 二进制变量:
\[x_{ij} \in \{0, 1\}, \quad \forall i, j
\]
- 数学模型
\[\begin{align*}
\text{min Z} = & 85x_{11} + 95x_{12} + 82x_{13} + 86x_{14} + \\
& 85x_{21} + 87x_{22} + 83x_{23} + 90x_{24} + \\
& 92x_{31} + 78x_{32} + 79x_{33} + 80x_{34} + \\
& 73x_{41} + 95x_{42} + 90x_{43} + 88x_{44}
\end{align*}\\
\text{s.t.}
\begin{cases}
x_{11} + x_{12} + x_{13} + x_{14} = 1 \\
x_{21} + x_{22} + x_{23} + x_{24} = 1 \\
x_{31} + x_{32} + x_{33} + x_{34} = 1 \\
x_{41} + x_{42} + x_{43} + x_{44} = 1 \\
x_{11} + x_{21} + x_{31} + x_{41} = 1 \\
x_{12} + x_{22} + x_{32} + x_{42} = 1 \\
x_{13} + x_{23} + x_{33} + x_{43} = 1 \\
x_{14} + x_{24} + x_{34} + x_{44} = 1 \\
x_{ij} = 0, 1 \quad (i, j = 1, 2, 3, 4)
\end{cases}\]
import numpy as np
from scipy.optimize import linear_sum_assignment
# 成本矩阵
cost_matrix = np.array([
[85, 95, 82, 86],
[85, 87, 83, 90],
[92, 78, 79, 80],
[73, 95, 90, 88]
])
# 使用匈牙利算法求解最优分配
row_ind, col_ind = linear_sum_assignment(cost_matrix)
# 输出结果
print("最优分配方案:")
for i, j in zip(row_ind, col_ind):
print(f"员工 {chr(i + 65)} 分配到任务 {['甲', '乙', '丙', '丁'][j]}，所需时间：{cost_matrix[i, j]} 分钟")
# 计算总最小时间
total_time = cost_matrix[row_ind, col_ind].sum()
print(f"\n最小总时间: {total_time} 分钟")
最优分配方案:
员工 A 分配到任务 丁，所需时间：86 分钟
员工 B 分配到任务 丙，所需时间：83 分钟
员工 C 分配到任务 乙，所需时间：78 分钟
员工 D 分配到任务 甲，所需时间：73 分钟
最小总时间: 320 分钟
二、不匹配的指派问题
指派问题的标准形式要求任务数和工人数相等，且每个工人只能分配一个任务。但在实际应用中，往往会遇到一些不匹配问题，如任务数多于工人数，或反之，甚至是最大化指派问题。在最大化指派问题中，目标是找到一种任务与工人的分配方式，使得总效益最大化，而不是最小化成本。这种问题广泛应用于资源优化分配、最大化收益的场景中，如项目调度、广告投放等。在模型求解时，可以通过引入虚拟任务或工人来处理不匹配情况。
2.1 最大化指派问题
在最大化指派问题中，我们的目标是将任务分配给工人，使得总效益（或利润）最大化。然而，大多数指派问题的求解算法（如匈牙利算法）都是针对最小化问题设计的。因此，我们需要将最大化问题转换为等价的最小化问题，以便应用这些算法。将最大化问题转换为最小化问题的基本思路是对原效益矩阵进行转换，使得最大化总效益的问题等价于最小化某种“成本”的问题。具体步骤如下：
- 确定效益矩阵： 建立任务和工人之间的效益矩阵\(P = [p_{ij}]\)，其中\(p_{ij}\)表示工人\(i\)完成任务\(j\)的效益。
- 找到效益矩阵中的最大值： 设矩阵\(P\) 中的最大元素为\(p_{\text{max}}\)。
- 构建成本矩阵： 使用以下公式将效益矩阵转换为成本矩阵\(C = [c_{ij}]\)：\[c_{ij} = p_{\text{max}} - p_{ij} \]这样，原本效益高的分配在成本矩阵中对应较低的成本。
- 求解最小化问题： 使用标准的最小化指派问题求解方法（如匈牙利算法）对成本矩阵\(C\)进行求解。
例1：假设我们有 4 个工人和 4 个任务，效益矩阵\(P\)如下：
| 任务 1 | 任务 2 | 任务 3 | 任务 4 | |
|---|---|---|---|---|
| 工人1 | 62 | 75 | 80 | 93 |
| 工人2 | 75 | 80 | 82 | 85 |
| 工人3 | 80 | 75 | 75 | 73 |
| 工人4 | 93 | 88 | 85 | 77 |
要求分配任务给工人，使总效益最大化。
- 找到效益矩阵中的最大值：矩阵\(P\)中的最大值为\(p_{\text{max}} = 93\)
- 构建成本矩阵:使用公式\(c_{ij} = p_{\text{max}} - p_{ij}\)构建成本矩阵\(C\)
\[C = \begin{bmatrix}
93 - 62 & 93 - 75 & 93 - 80 & 93 - 93 \\
93 - 75 & 93 - 80 & 93 - 82 & 93 - 85 \\
93 - 80 & 93 - 75 & 93 - 75 & 93 - 73 \\
93 - 93 & 93 - 88 & 93 - 85 & 93 - 77 \\
\end{bmatrix} = \begin{bmatrix}
31 & 18 & 13 & 0 \\
18 & 13 & 11 & 8 \\
13 & 18 & 18 & 20 \\
0 & 5 & 8 & 16 \\
\end{bmatrix}\]
import numpy as np
from scipy.optimize import linear_sum_assignment
# 效益矩阵
profit_matrix = np.array([
[62, 75, 80, 93],
[75, 80, 82, 85],
[80, 75, 75, 73],
[93, 88, 85, 77]
])
# 转化为成本矩阵
p_max = np.max(profit_matrix)
cost_matrix = p_max - profit_matrix
# 求解最小化指派问题
row_ind, col_ind = linear_sum_assignment(cost_matrix)
# 输出结果
print("最优分配方案:")
tasks = ['任务 1', '任务 2', '任务 3', '任务 4']
workers = ['工人 1', '工人 2', '工人 3', '工人 4']
total_profit = 0
for i, j in zip(row_ind, col_ind):
print(f"{workers[i]} 分配到 {tasks[j]}，效益：{profit_matrix[i, j]}")
total_profit += profit_matrix[i, j]
print(f"\n最大总效益: {total_profit}")
最优分配方案:
工人 1 分配到 任务 4，效益：93
工人 2 分配到 任务 3，效益：82
工人 3 分配到 任务 1，效益：80
工人 4 分配到 任务 2，效益：88
2.2 任务数多于工人数
在这种情况下，一些任务可能不会被分配到任何工人。我们可以通过引入虚拟工人来将问题转换为标准的指派问题。虚拟工人完成任务的成本设置为一个较大的值（如无穷大），以避免这些任务被分配给虚拟工人。转化步骤：
- 如果任务数\(n\)多于工人数\(m\)，添加\(n-m\)个虚拟工人。每个虚拟工人完成任何任务的成本都设置为一个很大的数\(M\)，表示实际情况下不希望分配给虚拟工人。
- 形成一个新的\(n \times n\)的成本矩阵。
例2：假设有 3 个工人和 5 个任务，原始的成本矩阵为
| 任务 1 | 任务 2 | 任务 3 | 任务 4 | 任务 5 | |
|---|---|---|---|---|---|
| A | 9 | 2 | 7 | 8 | 6 |
| B | 6 | 4 | 3 | 7 | 5 |
| C | 5 | 8 | 1 | 6 | 4 |
新的成本矩阵为：
| 任务 1 | 任务 2 | 任务 3 | 任务 4 | 任务 5 | |
|---|---|---|---|---|---|
| A | 9 | 2 | 7 | 8 | 6 |
| B | 6 | 4 | 3 | 7 | 5 |
| C | 5 | 8 | 1 | 6 | 4 |
| 虚拟工人 1 | 100 | 100 | 100 | 100 | 100 |
| 虚拟工人 2 | 100 | 100 | 100 | 100 | 100 |
import numpy as np
from scipy.optimize import linear_sum_assignment
# 原始成本矩阵
cost_matrix = np.array([
[9, 2, 7, 8, 6],
[6, 4, 3, 7, 5],
[5, 8, 1, 6, 4]
])
# 添加虚拟工人，虚拟工人的成本设置为100
num_workers = cost_matrix.shape[0]
num_tasks = cost_matrix.shape[1]
# 扩展成本矩阵，添加虚拟工人
M = 100 # 虚拟工人的成本
extended_cost_matrix = np.vstack([
cost_matrix,
M * np.ones((num_tasks - num_workers, num_tasks))
])
# 使用匈牙利算法求解最小化指派问题
row_ind, col_ind = linear_sum_assignment(extended_cost_matrix)
# 输出结果
print("最优分配方案:")
total_cost = 0
for i, j in zip(row_ind, col_ind):
if i < num_workers: # 只考虑实际的工人
print(f"工人 {chr(i + 65)} 分配到任务 {j + 1}，成本：{extended_cost_matrix[i, j]}")
total_cost += extended_cost_matrix[i, j]
print(f"\n最小总成本: {total_cost}")
最优分配方案:
工人 A 分配到任务 2，成本：2.0
工人 B 分配到任务 5，成本：5.0
工人 C 分配到任务 3，成本：1.0
最小总成本: 8.0
2.3 任务数少于工人数
当工人数多于任务数时，一些工人将没有任务可做。可以通过引入虚拟任务来转换问题，每个虚拟任务的成本设置为 0，表示工人不需要完成任务。转化步骤：
- 如果工人数\(m\)多于任务数\(n\)，添加\(m-n\) 个虚拟任务。虚拟任务的完成成本为 0，表示这些工人没有任务可以做。
- 形成一个新的\(m \times m\)的成本矩阵。
例3：假设有 5 个工人和 3 个任务，原始的成本矩阵为
| 任务 1 | 任务 2 | 任务 3 | |
|---|---|---|---|
| A | 9 | 2 | 7 |
| B | 6 | 4 | 3 |
| C | 5 | 8 | 1 |
| D | 8 | 7 | 4 |
| E | 6 | 5 | 8 |
| 任务 1 | 任务 2 | 任务 3 | 虚拟任务 1 | 虚拟任务 2 | |
|---|---|---|---|---|---|
| A | 9 | 2 | 7 | 0 | 0 |
| B | 6 | 4 | 3 | 0 | 0 |
| C | 5 | 8 | 1 | 0 | 0 |
| D | 8 | 7 | 4 | 0 | 0 |
| E | 6 | 5 | 8 | 0 | 0 |
import numpy as np
from scipy.optimize import linear_sum_assignment
# 原始成本矩阵
cost_matrix = np.array([
[9, 2, 7],
[6, 4, 3],
[5, 8, 1],
[8, 7, 4],
[6, 5, 8]
])
# 工人数和任务数
num_workers = 5
num_tasks = 3
# 引入虚拟任务
cost_matrix = np.hstack([cost_matrix, np.zeros((num_workers, num_workers - num_tasks))])
# 求解最小化指派问题
row_ind, col_ind = linear_sum_assignment(cost_matrix)
# 输出结果
print("最优分配方案:")
for i, j in zip(row_ind, col_ind):
if j < num_tasks: # 只输出实际任务的分配方案
print(f"工人 {chr(65+i)} 分配到 任务 {j+1}，成本：{cost_matrix[i, j]}")
最优分配方案:
工人 A 分配到 任务 2，成本：2.0
工人 C 分配到 任务 3，成本：1.0
工人 E 分配到 任务 1，成本：6.0
三、指派问题的Python求解
例4：分配甲、乙、丙、丁4个人去完成A、B、C、D、E 5项任务，每个人完成各项任务的时间见下表。由于任务数多于人数，故考虑：
(1) 任务E必须完成，其他4项中可任选3项完成；
(2) 其中有一人完成两项，其他每人完成一项。
试分别确定最优分配方案，使完成任务的总时间为最少。
| 人员\任务 | A | B | C | D | E |
|---|---|---|---|---|---|
| 甲 | 25 | 29 | 31 | 42 | 37 |
| 乙 | 39 | 38 | 26 | 20 | 33 |
| 丙 | 34 | 27 | 28 | 40 | 32 |
| 丁 | 24 | 42 | 36 | 23 | 45 |
3.1 （1）问题指派分析
为了确定最优分配方案，使完成任务的总时间最少，我们可以按照以下步骤进行求解：
- 确定任务选择：
- 任务E必须完成，所以必须包含在选择的任务中。
- 在A、B、C、D四项任务中任选三项，共有\(\binom{4}{3} = 4\)种选择。
- 即选择组合为：{A, B, C, E}、{A, B, D, E}、{A, C, D, E}、{B, C, D, E}。
- 任务分配方案：
- 每个任务选择组合确定后，分配4个人完成这4项任务，计算所有可能的分配情况，选择总时间最少的方案。
- 计算最优方案：
- 对于每一种任务组合，使用计算机算法（如动态规划或组合搜索）来计算所有可能的分配方案，求出总时间最少的方案。
3.2 （1）问题的Python程序
import itertools
import numpy as np
from scipy.optimize import linear_sum_assignment
# 定义任务时间表
time_table = {
'A': [25, 39, 34, 24],
'B': [29, 38, 27, 42],
'C': [31, 26, 28, 36],
'D': [42, 20, 40, 23],
'E': [37, 33, 32, 45]
}
tasks = ['A', 'B', 'C', 'D', 'E']
persons = [0, 1, 2, 3] # 0: 甲, 1: 乙, 2: 丙, 3: 丁
# 任务组合
task_combinations = [
['A', 'B', 'C', 'E'],
['A', 'B', 'D', 'E'],
['A', 'C', 'D', 'E'],
['B', 'C', 'D', 'E']
]
def calculate_assignment_cost(cost_matrix):
row_ind, col_ind = linear_sum_assignment(cost_matrix)
return cost_matrix[row_ind, col_ind].sum(), list(zip(row_ind, col_ind))
best_time = float('inf')
best_combination = None
best_assignment = None
# 存储每个组合的最小总时间
combination_times = {}
for comb in task_combinations:
# 构建成本矩阵
cost_matrix = []
for person in persons:
cost_row = []
for task in comb:
cost_row.append(time_table[task][person])
cost_matrix.append(cost_row)
cost_matrix = np.array(cost_matrix)
# 计算最优分配
time, assignment = calculate_assignment_cost(cost_matrix)
combination_times[tuple(comb)] = time
if time < best_time:
best_time = time
best_combination = comb
best_assignment = assignment
# 输出每个任务组合的最小总时间
print("各任务组合的最小总时间:")
for comb, time in combination_times.items():
print(f"任务组合 {comb}: 最小总时间 {time}分钟")
# 输出最优方案
person_names = ['甲', '乙', '丙', '丁']
assignment_str = {best_combination[task]: person_names[person] for person, task in best_assignment}
print("\n最优方案:")
print(f"最优任务组合: {best_combination}")
print(f"最优分配方案: {assignment_str}")
print(f"最少总时间: {best_time}分钟")
各任务组合的最小总时间:
任务组合 ('A', 'B', 'C', 'E'): 最小总时间 111分钟
任务组合 ('A', 'B', 'D', 'E'): 最小总时间 105分钟
任务组合 ('A', 'C', 'D', 'E'): 最小总时间 106分钟
任务组合 ('B', 'C', 'D', 'E'): 最小总时间 110分钟
最优方案:
最优任务组合: ['A', 'B', 'D', 'E']
最优分配方案: {'B': '甲', 'D': '乙', 'E': '丙', 'A': '丁'}
最少总时间: 105分钟
3.3 （2）问题的指派分析
要解决这个问题，我们可以使用组合与排列的方法生成所有可能的任务分配方案，然后计算每个方案的总时间，选择最小的一个。具体步骤如下：
对4个人中的每一个考虑分配两个任务，其余三个人各分配一个任务，共有\(\binom{5}{2} = 10\)。
生成新的时间矩阵，对于每一个人承担两个任务的情况，计算出所有可能的任务分配组合。
对每个生成的时间矩阵，使用匈牙利算法（Hungarian Algorithm）来求解最优任务分配问题。
比较所有情况的最小总时间，找到最优分配方案。
3.4（2）问题的Python程序
import numpy as np
from scipy.optimize import linear_sum_assignment
# 给定的时间表
time_table = {
'A': [25, 39, 34, 24],
'B': [29, 38, 27, 42],
'C': [31, 26, 28, 36],
'D': [42, 20, 40, 23],
'E': [37, 33, 32, 45]
}
tasks = ['A', 'B', 'C', 'D', 'E']
persons = ['甲', '乙', '丙', '丁'] # 0: 甲, 1: 乙, 2: 丙, 3: 丁
# 将time_table转换为二维数组
time_matrix = np.array([time_table[task] for task in tasks]).T
# 创建新矩阵并输出
new_matrices = []
for i in range(time_matrix.shape[0]):
new_row = time_matrix[i, :]
new_matrix = np.vstack([time_matrix, new_row])
new_matrices.append((new_matrix, i))
# 对new_matrices进行指派问题求解并打印每个最优值
best_total_time = float('inf')
best_assignment = None
best_matrix = None
best_row_index = None
for idx, (matrix, row_index) in enumerate(new_matrices):
row_ind, col_ind = linear_sum_assignment(matrix)
total_time = matrix[row_ind, col_ind].sum()
print(f"新矩阵 {idx + 1} 的最优值: {total_time} 分钟")
if total_time < best_total_time:
best_total_time = total_time
best_assignment = list(zip(row_ind, col_ind))
best_matrix = matrix
best_row_index = row_index
# 输出最优指派方案和最小值
print("\n最优指派方案:")
for person, task in best_assignment:
person_name = persons[person] if person < len(persons) else '完成两个任务的人员'
task_name = tasks[task] if task < len(tasks) else '额外的任务'
time_spent = best_matrix[person, task]
print(f"{person_name} 负责任务 {task_name}, 所需时间: {time_spent} 分钟")
print(f"最小总时间: {best_total_time} 分钟")
print(f"添加的行: {best_row_index+1}，即完成两个任务的人员: {persons[best_row_index]}")
新矩阵 1 的最优值: 135 分钟
新矩阵 2 的最优值: 131 分钟
新矩阵 3 的最优值: 133 分钟
新矩阵 4 的最优值: 134 分钟
最优指派方案:
甲 负责任务 B, 所需时间: 29 分钟
乙 负责任务 C, 所需时间: 26 分钟
丙 负责任务 E, 所需时间: 32 分钟
丁 负责任务 A, 所需时间: 24 分钟
完成两个任务的人员 负责任务 D, 所需时间: 20 分钟
最小总时间: 131 分钟
添加的行: 2，即完成两个任务的人员: 乙
总结
指派问题是一类优化问题，其目标是将一组任务分配给一组工人，使得总成本最小或总效益最大。标准的指派问题要求工人数与任务数相等，但在实际中，常常会出现人数与任务数不匹配的情况。为了解决这些问题，通常采用引入虚拟工人或虚拟任务的方法进行转换。
任务多于工人数：在这种情况下，我们可以引入虚拟工人，这些虚拟工人无法实际完成任务，因此为其设置一个较大的虚拟成本，确保算法优先选择实际的工人完成任务。
工人数多于任务数：此时可以引入虚拟任务，虚拟任务的成本设置为 0，表示多余的工人没有任务可做，从而将问题转化为一个标准的指派问题。
无论是哪种情况，通过这些转换，均可以使用匈牙利算法等最小化问题的标准求解方法来获得最优解。这种方法确保了指派问题在不同的实际场景下都能得到有效的解决。
