无法理解有关矩阵的这个编程问题？

Question

谁能帮我吗？ 我无法理解 Java 中的这个编程问题？ 矩阵中的最大和是什么意思？ 在情况 1 中，如果我将第一行中的 5 中的每个数字添加到最后一行中的 1，它不会添加到 15。那么为什么输出结果是： 15 1 和 12 1 对于情况 2？

问题#1 你将得到一个 N 行 N 列 (1 == N<= 1000) 的方阵，其中包含绝对值不大于 1000 的正负整数。你需要通过走步计算可达到的最大和路径，从矩阵的任何单元格开始，并始终向下或向右移动。 此外，您必须报告可实现该值的次数。 N 将在输入的第一行。 N 行，每行 N 个整数。 您应该输出一行，其中包含两个由一个空格分隔的整数：第一个是最大和，第二个是可以达到该值的次数。

Case 1:
For the input provided as follows:
5
3 1 -2 1 1
-6 -1 4 -1 -4
1 1 1 1 1
2 2 2 2 2
1 1 1 1 1

Output of the program will be:
15 1

Case 2:
For the input provided as follows:
3
1 1 1
2 2 2
3 3 3

Output of the program will be:
12 1

Answer 1

第一个3和5输入是矩阵的大小3 x 3和5 x 5不应该被计算为加法

按照rule ，在穿越时不允许左转或向上移动，下面是一个简单的right direction和bottom direction遍历

12表示1 + 2 + 3 + 3 + 3次应该是 1，因为只有在一条路径中才能达到这个值

15表示3 + 1 -1 + 4 + 1 + 2 + 2 + 2 + 1次应该是 1，因为只有在路径中才能达到这个值

您需要编写2 x 2内核循环，它将找到 2 个最大的和数并确定流的方向，然后沿着该方向跳转并选择另一个2 x 2并继续循环，无需随机方向

但是，这里有一个技巧，如果您得到 2 个大数字，则可能需要遵循第二条路径

要实现第二条路径，您可以通过在单个循环中处理两个方向来进行double iteration或single iteration ，这是两个方向的简单示例

1 1 0 0 0
2 1 1 0 0
0 2 1 0 0
0 2 1 1 1
0 2 2 2 1

这只是我提供的一个随机解决方案，但找到每个 2x2 矩阵的权重并使用基于树的遍历、卷积核......等应该是最好的方法

Answer 2

这个答案是我在这里写的“唯一路径”问题的算法的修改：试图解决“唯一路径”问题，但得到了错误的答案。 另一个挑战具有相同的约束，您只能向下和向右移动，这就是类似算法起作用的原因。

在这种情况下，我们可以从左上角开始。 我们需要保持2个阵列，一个用于sum对于一个给定的细胞实现的，以及一个用于count的路径来获取总和。 我们还需要两个变量来表示可实现的最高总和/计数（ maxSum和maxCount ）。 所有这些都被初始化为 0。

对于每个单元格，这里有 3 个“路径”，我们计算每个路径的总和/计数（如果可能），其中row是正在处理的当前行的矩阵值数组：

• 从上面：
  sum / count数值当前是前一行的累计值。 由于sum / count值被初始化为 0，因此即使在处理第一行时也可以使用它们。

   sumAbove = sum[col] + row[col] countAbove = count[col]

• 从左边开始：
  sum / count值当前是当前行的前一个单元格的累积值，因为我们只是在从左到右迭代时更新了它。

   sumLeft = sum[col - 1] + row[col] or row[col] if col == 0 countLeft = count[col - 1] or 0 if col == 0

• 从这里开始：

   sumStart = row[col] countStart = 1

然后我们找到三者的最高和，并将新的sum[col]设置为该值。 新的count[col]值将是总和为最大值的计数的总和，例如，如果所有 3 个总和都相同，则count[col] = countAbove + countLeft + countStart 。

如果新的sum[col]高于maxSum ，那么我们将maxSum / maxCount更新为这些新值。 如果新的sum[col]等于maxSum ，我们将新的count[col]到maxCount 。

让我们以下面的矩阵为例：

 3  1 -4  1  3
-6 -1  4 -1 -4
 1  1  1  1  1
-1  2  2  1  1
12 -5  1  1  0

我们从全 0 开始。

sum = { 0, 0, 0, 0, 0 }, count = { 0, 0, 0, 0, 0 }, maxSum = 0, maxCount = 0

处理第一行：

row: { 3, 1, -4, 1, 3 }
bestPath: { start, left, left, left/start, left }
sum = { 3, 4, 0, 1, 4 }, count = { 1, 1, 1, 2, 2 }, maxSum = 4, maxCount = 2

对于前三个，有一条路径可以得到这些总和，即从0,0开始。 对于最后两个，有两条路径可以得到这些总和，即从0,0或3,0 (col,row) 开始。 为了澄清这一点，我们展示了哪条路径通向标记为bestPath的新值。

处理第二行：

row: { -6, -1, 4, -1, -4 }
bestPath: { above, above, left, left, left }
sum = { -3, 3, 7, 6, 2 }, count = { 1, 1, 1, 1, 1 }, maxSum = 7, maxCount = 1

处理第三行：

row: { 1, 1, 1, 1, 1 }
bestPath: { start, above, above, above, above }
sum = { 1, 4, 8, 7, 3 }, count = { 1, 1, 1, 1, 1 }, maxSum = 8, maxCount = 1

处理第四行：

row: { -1, 2, 2, 1, 1 }
bestPath: { above, above, above, left, left }
sum = { 0, 6, 10, 11, 12 }, count = { 1, 1, 1, 1, 1 }, maxSum = 12, maxCount = 1

处理第五行：

row: { 12, -5, 1, 1, 0 }
bestPath: { start/above, left, above, above/left, above/left }
sum = { 12, 7, 11, 12, 12 }, count = { 2, 2, 1, 2, 3 }, maxSum = 12, maxCount = 9

最后结果：

12 9

使用 N x N 矩阵，此代码具有出色的O(m)时间复杂度，其中 m = N²，即矩阵中的单元格数量，以及O(N)又名O(sqrt m)存储复杂度。

Answer 3

这是使用python的实现代码。 两个矩阵用于测试。

def findMaximumPath(mat): 
    rows = cols = len(mat)
    count_list = []

    for i in range(rows):
        summ = 0
        mat_index = [rows-1, cols-1]
        curr_index = [0, i]
        summ = mat[curr_index[0]][curr_index[1]]

        while curr_index[0] != rows-1 and curr_index[1] != cols-1:
            if mat[curr_index[0]][curr_index[1]+1] > mat[curr_index[0]+1][curr_index[1]]:
                   curr_index[1] = curr_index[1] + 1
            else:
                   curr_index[0] = curr_index[0] + 1        

            summ += mat[curr_index[0]][curr_index[1]]
            #print(str(curr_index) + " Sum: " + str(summ))


        if curr_index[0] != rows-1 and curr_index[1] == cols-1:
            for i in range(curr_index[0]+1, rows):
                summ += mat[i][cols-1]
                #print(str(i) + "    Sum1: " +str(summ))

        if curr_index[0] == rows-1 and curr_index[1] != cols-1:
            for i in range(curr_index[1]+1, cols):
                summ += mat[rows-1][i]
                #print(str(i) + "    Sum2: " +str(summ))


        count_list.append(summ)

    max_sum = max(count_list)
    count = 0
    for element in count_list:  
        if(element == max_sum): 
            count+= 1

    print(count_list)
    print("Maximum Sum: " + str(max_sum))
    print("Number of Occurrences: " + str(count) + "\n")


mat1 = ([[3, 1, -2, 1, 1],
        [-6, -1, 4, -1, -4],
        [1, 1, 1, 1, 1],
        [2, 2, 2, 2, 2],
        [1, 1, 1, 1, 1]]) 

mat2 = ([[1, 1, 1],
        [2, 2, 2],
        [3, 3, 3]])

findMaximumPath(mat1)

findMaximumPath(mat2)

输出：矩阵 1：[15, 12, 10, 2, 1] 最大和：15 出现次数：1

矩阵 2：[12, 9, 6] 最大和：12 出现次数：1