扫清 LeetCode 64 号难题：徒步抵达终点，踏上铺满最小路径和的征程

前端

2023-11-24 23:51:21

引子：初识 LeetCode 64 号难题

LeetCode 64 号难题，又称“最小路径和”，向我们抛出了一个颇具挑战性的任务：给定一个包含非负整数的二维网格，如何找到一条从左上角到右下角的路径，使得沿途经过的数字之和最小？

这不仅考验了我们的算法思维，也对我们的编程技巧提出了要求。为此，我们将携手探索动态规划这一强大工具，以其为武器征服 LeetCode 64 号难题。

一、动态规划：铺平通往终点的道路

动态规划是一种自底向上的求解方法，它将复杂问题分解成一系列子问题，逐一求解，最终得到整个问题的答案。对于 LeetCode 64 号难题，我们可以将网格划分为一个个子网格，并计算出从每个子网格的左上角到右下角的最小路径和。

1. 子问题的定义：

令 dp[i][j] 表示从网格的左上角 (0, 0) 到 (i, j) 的最小路径和。

2. 子问题的递推关系：

dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

3. 边界条件：

当 i = 0 时，dp[i][j] = dp[0][j-1] + grid[0][j]
当 j = 0 时，dp[i][j] = dp[i-1][0] + grid[i][0]

4. 求解过程：

根据递推关系和边界条件，我们可以逐步计算出从左上角到每个子网格的最小路径和，最终得到从左上角到右下角的最小路径和。

二、实例解析：步步为营，攻克难题

为了加深对动态规划的理解，让我们以一个实例来具体解析 LeetCode 64 号难题的求解过程。

给定网格：

[[1, 3, 1],
 [1, 5, 1],
 [4, 2, 1]]

1. 初始化：

dp[0][0] = grid[0][0] = 1

2. 计算子网格的最小路径和：

dp[1][0] = min(dp[0][0], dp[1][0]) + grid[1][0] = min(1, ∞) + 3 = 3
dp[0][1] = min(dp[0][0], dp[0][1]) + grid[0][1] = min(1, ∞) + 1 = 2
dp[1][1] = min(dp[1][0], dp[1][1]) + grid[1][1] = min(3, 2) + 5 = 7
dp[2][0] = min(dp[2][0], dp[1][0]) + grid[2][0] = min(∞, 3) + 4 = 7
dp[2][1] = min(dp[2][0], dp[2][1]) + grid[2][1] = min(7, ∞) + 2 = 9
dp[2][2] = min(dp[2][1], dp[2][2]) + grid[2][2] = min(9, 7) + 1 = 8

3. 最终结果：

从左上角到右下角的最小路径和为 dp[2][2] = 8。

三、代码实现：LeetCode 64 号难题的编程实践

def minPathSum(grid):
    m, n = len(grid), len(grid[0])
    dp = [[0 for _ in range(n)] for _ in range(m)]

    dp[0][0] = grid[0][0]

    # 初始化第一行
    for j in range(1, n):
        dp[0][j] = dp[0][j-1] + grid[0][j]

    # 初始化第一列
    for i in range(1, m):
        dp[i][0] = dp[i-1][0] + grid[i][0]

    # 计算子网格的最小路径和
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]

    return dp[m-1][n-1]


# 测试用例
grid = [[1, 3, 1],
       [1, 5, 1],
       [4, 2, 1]]

print(minPathSum(grid))  # 输出：8