总和小于或等于给定数字的二维数组中的最大成本值

Question

给定一个二维数组和一个数字K 。

问题：我们有一个矩阵cost[][] ，矩阵的每个单元格代表遍历该单元格的成本。 我们从左上角(0,0)开始，我们必须到达最后一个单元格（右下角）。 我必须写一个 function 来返回到达(m,n)的最大成本路径的成本，而不超过数字K 。

到达(m, n)的路径的总成本是该路径上所有成本的总和（包括源和目的地），总和应小于或等于K 我们只能向下、向右或向右斜向下移动。

如果我们找不到最大和小于或等于K的路径，则返回-1并且矩阵的值不能为负

解决方案：我尝试了很多代码，但没有一个返回我预期的结果。

我的第一个解决方案是将二维数组转换为一个简单的数组并应用背包算法，但它不起作用，因为逻辑上没有遵循路径。 （练习的逻辑随着这个想法消失了）

我也尝试了一个递归公式，但它没有用。 我得到一个错误“最大递归深度”。 当我解决这个递归问题时，我的算法没有考虑到不超过数量的约束。

我不需要代码，我只想要一些解释能够解决问题（尤其是数学公式）。 谢谢

例子：

    if we had this 3*3 matrix:
    cost[][] = {{2,3,1}, {6,1,9},{8,2,3}}
    and k = 7

答案应该是6:(0,0)->(1,1)->(3,3)

Answer 1

如果我们将其视为在从结束到开始的过程中减去成本时寻找最小的剩余非负量级，那么简单的递归可能类似于以下内容。 记忆递归有时比k的全维迭代更适合，因为许多输入可以产生特殊的和集。

 function g(m, K, i, j, k, memo){ if (k < 0 || i < 0 || j < 0) return K + 1; if (i == 0 && j == 0) return k >= m[i][j]? k - m[i][j]: K + 1; const key = String([i, j, k]); if (memo.hasOwnProperty(key)) return memo[key]; return memo[key] = Math.min( g(m, K, i-1, j, k - m[i][j], memo), g(m, K, i, j-1, k - m[i][j], memo), g(m, K, i-1, j-1, k - m[i][j], memo) ) } function f(m, k){ return k - g(m, k, m.length-1, m[0].length-1, k, {}); } var m = [ [2,3,1], [6,1,9], [8,2,3] ]; var k = 7; console.log(f(m, k));

Answer 2

假设dp[i][j]是 go 到位置(i,j)的成本，那么成本取决于从当前位置到达其先前位置的成本：

• 对角线右下(i-1,j-1)
• 或向下一列(i-1,j)
• 或对(i, j-1) 。

现在方程可以写成：

dp[i][j] = -1
if ( cost[i][j] < K ):
    dp[i][j] = if ( dp[i-1][j-1] != -1 and cost[i][j] + dp[i-1][j-1] <= K ) :
                  dp[i][j] = cost[i][j] + dp[i-1][j-1]

               if ( dp[i-1][j] != -1 and cost[i][j] + dp[i-1][j] <= K ) :
                  dp[i][j] = max( dp[i][j], cost[i][j] + dp[i-1][j] )

               if ( dp[i][j-1] != -1 and cost[i][j-1] + dp[i][j-1] <= K):
                  dp[i][j] = max( dp[i][j], cost[i][j] + dp[i][j-1] )

使用这些，您可以构建一个自下而上的dp数组，您的答案将是dp[m][n]其中mxn是二维数组的大小。