矩阵中数字分布的算法

Question

这是我关于堆栈交换的第一个问题。我正在解决一个问题，我需要在矩阵中找到非负整数的分布，其中每行和每列加起来就是目标总数。我确信有一种算法可以做到这一点（或者一个理论说什么时候可以，什么时候不可以），但我在网上找到这个的运气并不好。

在附加的图像 (Image) 中，我有一个解决方案示例，我为该问题的特定实例找到了该解决方案，但没有涉及可定义的算法。灰色总计是每列和每行的目标总计，而浅蓝色总计是显示的当前分布的总计。在算法开始时只提供总数，所以我从一个空矩阵开始。

有人可以为我指出这个问题的资源/解决方案吗？

谢谢

Answer 1

这看起来是个难题（可能是 np-hard）。

您最好的选择（忽略与领域相关的高度调整的算法）是组合优化的经典方法：

• 元启发式（禁忌搜索、模拟退火等）
  • 需要一些调整/邻域定义...
• SAT 求解器
  • 需要烦人的加法器仿真
  • 完全（可以证明，无解）
• 约束编程
  • 易于配制
  • 可以调整
  • 完成
• 整数编程
  • 易于制定，如下所示
  • 提供非常好的商业求解器
  • 完成 我将介绍后者的简单版本（这可能是其中最糟糕的方法；至少对于这个问题！）

它在 python 中实现并使用开源工具cvxpy（公式）和cbc（MIP-solver）。

代码

更新：先验修复一些元素值！

from cvxpy import *

targets_X = [17, 45, 7, 6]
targets_Y = [3 for i in range(11)] + [2 for i in range(21)]
fixed_elements_indices_x, fixed_elements_indices_y = [0, 1, 2], [0, 1, 2]
fixed_elements_values = [3, 3, 3]
dim_x, dim_y = len(targets_X), len(targets_Y)

# Vars
T = Int(dim_x, dim_y)

# Constraints
constraints = []
constraints.append(T >= 0)
constraints.append(sum_entries(T, axis=1) == targets_X)
constraints.append(sum_entries(T, axis=0).T == targets_Y)
constraints.append(T[fixed_elements_indices_x, fixed_elements_indices_y] == fixed_elements_values)
problem = Problem(Minimize(0), constraints)
problem.solve(CBC, verbose=True)

print(T.value.T)

输出

Clp0006I 0  Obj 0 Primal inf 159 (39)
Clp0006I 36  Obj 0 Primal inf 98.999998 (19)
Clp0006I 69  Obj 0
Clp0006I 69  Obj 0
Clp0000I Optimal - objective value 0
Cbc0045I No integer variables out of 128 objects (128 integer) have costs
Cbc0045I branch on satisfied N create fake objective Y random cost Y
Clp0000I Optimal - objective value 0
Node 0 depth 0 unsatisfied 0 sum 0 obj 0 guess 0 branching on -1
Clp0000I Optimal - objective value 0
Cbc0004I Integer solution of 0 found after 0 iterations and 0 nodes (0.00 seconds)
Cbc0001I Search completed - best objective 0, took 0 iterations and 0 nodes (0.00 seconds)
Cbc0035I Maximum depth 0, 0 variables fixed on reduced cost
Clp0000I Optimal - objective value 0
Clp0000I Optimal - objective value 0
[[ 3.  0.  0.  0.]
 [ 0.  3.  0.  0.]
 [ 0.  0.  3.  0.]
 [ 0.  3.  0.  0.]
 [ 0.  0.  3.  0.]
 [ 0.  0.  0.  3.]
 [ 0.  0.  0.  3.]
 [ 0.  2.  1.  0.]
 [ 0.  3.  0.  0.]
 [ 0.  3.  0.  0.]
 [ 0.  3.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 0.  2.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]
 [ 2.  0.  0.  0.]]

Answer 2

您可以使用maximum flow algorithm 在多项式时间内解决此问题。

设置一个源节点，每行一个节点，每列一个节点和一个目标节点。

从源到行节点的边的容量应该等于给定的行总和。

从 col 节点到 dest 的边的容量应该等于给定的列总和。

根据矩阵中允许的值，从行节点到 col 节点的边应具有容量。 （例如，如果第 x 行的条目，矩阵的 col y 必须为零，则将行节点 x 到 col 节点 y 的边的容量设置为 0。）

然后计算从源到目的地的最大流量，行节点和列节点之间的流量给出矩阵中的条目。

nxn 矩阵的解的复​​杂度为 O(n^3)。