如何使用动态规划在矩阵中求和

Question

请，我想找出每行只有一个值的最大总和。我已经通过蛮力做出了决议，它是O（N ^ 5）。现在我想找到一种动态编程的方法或另一种降低复杂性的方法。

例如：

矩阵：

  100   5   4   3  1

  90   80  70  60  50

  70   69  65  20  10

  60   20  10   5   1

  50   45  15   6   1

5套解决方案：

1. 100 + 90 + 70 + 60 + 50 = 370

2. 100 + 90 + 69 + 60 + 50 = 369

3. 100 + 90 + 70 + 60 + 45 = 365

4. 100 + 90 + 65 + 60 + 50 = 365

5. 100 + 90 + 69 + 60 + 45 = 364

总和：1833

蛮力求和的例子：

  for(int i=0; i<matrix[0].size(); i++) {
    for(int j=0; j<matrix[1].size(); j++) {
      for(int k=0; k<matrix[2].size(); k++) {
        for(int l=0; l<matrix[3].size(); l++) {
          for(int x=0; x<matrix[4].size(); x++) {
            sum.push_back(matrix[0][i] + matrix[1][j] + matrix[2][k] + matrix[3][l] + matrix[4][x]);
          }
        }
      }
    }
  }
  
sort(sum.begin(), sum.end(), mySort);

谢谢！

Answer 1

更新我之前用过贪心算法，对这个问题不起作用。这是一个更通用的解决方案。

假设我们已经找到了总和最高的 m 个组合。下一个最高组合（数字 m+1）必须与其中一个相距 1 步，其中一步定义为在矩阵的其中一行中将焦点向右移动一列。 （任何距离所有顶部 m 组合超过一步的组合不能是 m+1 最高的，因为您可以将其转换为更高的组合，即通过撤消这些步骤之一，即返回到现有组合之一，不在顶部 m。）

对于 m = 1，我们知道“m 最高组合”仅表示取矩阵每一行的第一个元素的组合（假设每个行从高到低排序）。那么我们可以从那里开始工作：

1. 创建一组候选组合以考虑下一个最高位置。这最初将只保存可能的最高组合（矩阵的第一列）。

2. 找出总和最高的候选人并将其移至结果中。

3. 找出与刚刚添加到结果中的组合相距 1 步的所有组合。将所有这些添加到候选组合集中。每轮只会添加其中的 n 个，其中 n 是矩阵中的行数。有些可能与之前确定的候选者重复，应该忽略。

4. 返回第 2 步。重复直到有 5 个结果。

下面是一些执行此操作的 Python 代码：

m = [
    [100, 5, 4, 3, 1],
    [90, 80, 70, 60, 50],
    [70, 69, 65, 20, 10],
    [60, 20, 10, 5, 1],
    [50, 45, 15, 6, 1]
]
n_cols = len(m[0]) # matrix width

# helper function to calculate the sum for any combination,
# where a "combination" is a list of column indexes for each row
score = lambda combo: sum(m[r][c] for r, c in enumerate(combo))

# define candidate set, initially with single highest combination
# (this set could also store the score for each combination
# to avoid calculating it repeatedly)
candidates = {tuple(0 for row in m)}
results = set()

# get 5 highest-scoring combinations
for i in range(5):
    result = max(candidates, key=score)
    results.add(result)
    candidates.remove(result)  # don't test it again
    # find combinations one step away from latest result
    # and add them to the candidates set
    for j, c in enumerate(result):
        if c+1 >= n_cols:
            continue  # don't step past edge of matrix
        combo = result[:j] + (c+1,) + result[j+1:]
        if combo not in results:
            candidates.add(combo)  # drops dups

# convert from column indexes to actual values
final = [
    [m[r][c] for r, c in enumerate(combo)]
    for combo in results
]
final.sort(key=sum, reverse=True)
print(final)
# [
#     [100, 90, 70, 60, 50]
#     [100, 90, 69, 60, 50], 
#     [100, 90, 70, 60, 45], 
#     [100, 90, 65, 60, 50], 
#     [100, 90, 69, 60, 45], 
# ]

Answer 2

您可以使用Dijkstra's algorithm 在O(k*log k) 时间内解决它。图中的一个节点由一个列表表示，该列表具有矩阵相应行中数字的 5 个索引。

例如在矩阵中

100 5  4  3  1
90  80 70 60 50
70  69 65 20 10
60  20 10 5  1
50  45 15 6  1

节点[0, 0, 2, 0, 1]代表数字[100, 90, 65, 60, 45]

初始节点是[0, 0, 0, 0, 0]。每个节点最多有5条出边，5个索引中的1个加1，节点之间的距离是索引数之和的绝对差。

因此对于该矩阵，来自节点[0, 0, 2, 0, 1] 的边领先：

• 到[1, 0, 2, 0, 1]，距离为 100 - 5 = 95
• 到[0, 1, 2, 0, 1]，距离为 90 - 80 = 10
• 到[0, 0, 3, 0, 1]，距离为 65 - 20 = 45
• 到[0, 0, 2, 1, 1]，距离为 60 - 20 = 40
• 到[0, 0, 2, 0, 2]，距离为 45 - 15 = 30

通过此设置，您可以使用 Dijkstra 算法来查找与初始节点最近的 k - 1 节点。

Answer 3

如果您只想要最大总和，则在每一行求和最大值。 也就是说，

M = [[100, 5, 4, 3, 1],
 [90, 80, 70, 60, 50],
 [70, 69, 65, 20, 10],
 [60, 20, 10, 5, 1],
 [50, 45, 15, 6, 1]]

sum(max(row) for row in M)

编辑

不必使用动态规划等。
有一个简单的规则：考虑数字与当前数字之间的差异选择下一个数字。

这是一个使用 numpy 的代码。

import numpy as np
M = np.array(M)
M = -np.sort(-M, axis = 1)
k = 3

answer = []
ind = np.zeros(M.shape[0], dtype = int)
for _ in range(k):
    answer.append(sum(M[list(range(M.shape[0])), ind]))
    min_ind = np.argmin(M[list(range(len(ind))), ind] - M[list(range(len(ind))), ind+1])
    ind[min_ind] += 1

结果是[370, 369, 365]。