如何用动态规划解决这个问题？

Question

说明：老鼠可以向上或向右移动

输入：

• 第一行包含桌子大小 n 的数量和奶酪的数量 m。
• 从下一行开始，给出奶酪的 x、y 位置

输出：

• 最多吃多少奶酪

示例 1：

• 输入：1 1 1
• 输出：1 1

示例 2：

• 输入：

3 2
1 2
3 1

• 输出：1

示例 3：

• 输入：

5 5
2 3
3 2
4 3
4 5
5 2

• 输出：3

如何用 python 解决？ 我试过了

def maxAverageOfPath(table, N): 
    dp = [[0 for i in range(N)] for j in range(N)] 
    dp[0][0] = table[0][0] 
    # Initialize first column of total table(dp) array 
    for i in range(0, N): 
        dp[i][0] = 0


    for j in range(0, N): 
        dp[0][j] = 0

    for i in range(0, N): 
        for j in range(0, N):
            print(i, j)
            if i == N-1 and j == N-1:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
                continue
            if i == N-1 :
                dp[i][j] = table[i][j + 1]
                continue

            if j == N-1 :
                dp[i][j] = table[i + 1][j]
                continue
            dp[i][j] = max(table[i + 1][j], table[i][j + 1])

    return dp

但是失败了……

Answer 1

对于动态编程，您需要一个边缘条件和一种在您现在所处的位置得分的方法。在那之后，它或多或少是聪明的蛮力。聪明的部分来自记忆，所以你不会重复工作。

下面是 python 的基本递归方法，它执行以下操作：

• 将奶酪表组织为一组冷冻元组。这可以进行哈希处理以供记忆，并且您可以在恒定时间内确定集合中的位置。

• 为结束创建一个边缘条件（当两个坐标都是 N 时）和一个当您离开地图时的边缘条件 - 只返回 0。

• 使用lru_cache 来记忆。您可以自己轻松实现。

---

from functools import lru_cache

def hasCheese(table, location):
    ''' Helper function just to improve readability '''
    return 1 if location in table else 0

@lru_cache()
def maxC(table, N, location = (0, 0)):  

    # edge conditions final square and off the grid:  
    if location[0] == N and location[1] == N:
        return hasCheese(table, location)
    if any(l > N for l in location):
        return 0

    # recursion
    score_here = hasCheese(table, location)
    return max(score_here + maxC(table, N, (location[0] + 1, location[1])),
               score_here + maxC(table, N, (location[0], location[1] + 1))
              )

t = frozenset([(2, 3), (3, 2), (4, 3), (4, 5), (5, 2)])
N = 5

print(maxC(t, N))
# prints 3

如果您想使用矩阵以自上而下的方式执行此操作，则需要非常小心，您始终拥有先前的索引集。这样做更容易出错，因为您需要获得正确的索引和顺序。当您将其设置为两个嵌套递增循环时，这意味着下一个值始终是当前单元格加上两个单元格的最大值减去一个单位 - 您应该始终在矩阵中向后看。当您期待此内容时，尚不清楚您正在尝试做什么：

 dp[i][j] = table[i][j + 1]

因为j+1尚未确定。

由于奶酪坐标是 1 索引的，一个简单的方法是让您的矩阵索引为零并且大小为 N+1。然后，当您在 1 开始 for 循环时，您始终可以查看并查看较低的索引，而不会低于矩阵，并避免大量 if/else 逻辑。例如：

def hasCheese(table, location):
    ''' Helper function just to improve readability '''
    return 1 if location in table else 0

def maxAverageOfPath(table, N): 
    # matrix is sized one unit bigger
    dp = [[0 for i in range(N+1)] for j in range(N+1)] 

    # iterate 1-5 inclusive
    for i in range(1, N+1): 
        for j in range(1, N+1):
            # because the zeroth row and column are already zero, this works without undershooting the table
            dp[i][j] = hasCheese(table, (i, j)) + max(dp[i][j-1], dp[i-1][j])
    # solution is in the corner
    return dp[N][N]

t = {(2, 3), (3, 2), (4, 3), (4, 5), (5, 2)}
N  = 5

print(maxAverageOfPath(t, N)) #3

完成后，您的矩阵将如下所示：

[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 1, 1]
[0, 0, 1, 1, 1, 1]
[0, 0, 1, 2, 2, 3]
[0, 0, 2, 2, 2, 3]

你的起点是从右上角开始的 (1, 1)，你的答案是左下角。

Answer 2

在每个点上，您都有两个进一步的选择：

1. 数组[行] [col+1]
2. 数组 [row+1] [col]

因为我们必须找出一条涉及最大奶酪的路径。 可以通过像下面这样重复数组来解决相同的问题：

解决方案 =>

array [i] [j] + Max(Recur(array [i] [j+1]), Recur(array [i+1] [j]));