【动态规划】力扣64：最小路径扣

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
说明：每次只能向下或者向右移动一步。
示例：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

创建二维数组 dp，与原始网格的大小相同，dp[i][j] 表示从左上角出发到 (i, j) 位置的最小路径和。显然，dp[0][0]=grid[0][0]。对于 dp 中的其余元素，通过以下状态转移方程计算元素值。
4种情况：

当左边和上边均为矩阵边界即 i=0 且 j=0 时，dp[0][0]=grid[0][0]，即起点。
当只有上边时矩阵边界即 i>0 且 j=0 时，dp[i][0]=dp[i−1][0]+grid[i][0]。
当只有左边时矩阵边界即 i=0 且 j>0 时，dp[0][j]=dp[0][j−1]+grid[0][j]。
当没有矩阵边界即 i>0 且 j>0 时，dp[i][j]=min(dp[i−1][j],dp[i][j−1])+grid[i][j]。
最后得到 dp矩阵右下角值即 dp[m−1][n−1] 的值即为从网格左上角到网格右下角的最小路径和。

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0]) # 行列分别为m、n
        if grid == 0:
            return 0
        dp = [[0] * n for _ in range(m)] # 初始化二维数组，也可以是 dp = [[0] * n] * m
        dp[0][0] = grid[0][0]
        for i in range(1, m):
            dp[i][0] = dp[i -1][0] + grid[i][0]
        for j in range(1, n):
            dp[0][j] = dp[0][j - 1] + grid[0][j]
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j]
        return dp[m - 1][n - 1]

时间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。需要对整个网格遍历一次，计算 dp 的每个元素的值。
空间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。创建一个二维数组 dp，和网格大小相同。

其实我们完全不需要建立 dp 矩阵浪费额外空间，直接遍历 grid[i][j] 修改即可。这是因为：grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j] ；原 grid 矩阵元素中被覆盖为 dp 元素后（都处于当前遍历点的左上方），不会再被使用到。

class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m, n = len(grid), len(grid[0]) # 行列分别为m、n
        if grid == 0:
            return 0
        for i in range(m):
            for j in range(n):
                if i == 0 and j == 0:
                    continue
                elif i == 0:
                    grid[i][j] = grid[0][j - 1] + grid[0][j]
                elif j == 0:
                    grid[i][j] = grid[i - 1][0] + grid[i][0]
                else:
                    grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
        return grid[m - 1][n - 1]