Leetcode64. Minimum Path Sum

Leetcode64. Minimum Path Sum

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.
Note: You can only move either down or right at any point in time.

Example:

Input:
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
Output: 7
Explanation: Because the path 1→3→1→1→1 minimizes the sum.

解法 动态规划

第 1 步：定义状态

设dp为m x n的矩阵，dp[i][j]表示到达点(i,j)的最小路径和。

第 2 步：思考状态转移方程

题目要求，只能向右或向下走，换句话说，当前单元格(i,j) 只能从左方单元格(i−1,j) 或上方单元格(i,j−1) 走到，因此只需要考虑矩阵左边界和上边界。

走到当前单元格 (i,j) 的最小路径和 = “从左方单元格 (i−1,j) 与 从上方单元格 (i,j−1) 走来的两个最小路径和中较小的 ” + 当前单元格值 grid[i][j] 。具体分为以下 4 种情况：

• 当左边与上边都不是矩阵边界时：$i\ne 0,j\ne 0,dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i,j]$
• 当只有左边是矩阵边界时，只能从上面来：$i=0,j\ne 0,dp[i][j]=dp[i][j-1]+grid[i,j]$
• 当只有上边是矩阵边界时，只能从左边来：$i\ne 0,j=0,dp[i][j]=dp[i-1][j]+grid[i,j]$
• 当左边和上边都是矩阵边界时：$i=0,j=0,dp[i,j]=grid[i,j]$

第 3 步：思考初始值

初始化dp[m,n]为0。

第 4 步：思考输出

输出dp矩阵的右下角值。

第5部：思考状态压缩

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

• 时间复杂度：
• 空间复杂度：

Java

class Solution {
    public int minPathSum(int[][] grid) {
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[0].length; j++) {
                if(i == 0 && j == 0) continue;
                else if(i == 0)  grid[i][j] = grid[i][j - 1] + grid[i][j];
                else if(j == 0)  grid[i][j] = grid[i - 1][j] + grid[i][j];
                else grid[i][j] = Math.min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j];
            }
        }
        return grid[grid.length - 1][grid[0].length - 1];
    }
}

Python

class Solution:
    def minPathSum(self, grid: [[int]]) -> int:
        for i in range(len(grid)):
            for j in range(len(grid[0])):
                if i == j == 0: continue
                elif i == 0:  grid[i][j] = grid[i][j - 1] + grid[i][j]
                elif j == 0:  grid[i][j] = grid[i - 1][j] + grid[i][j]
                else: grid[i][j] = min(grid[i - 1][j], grid[i][j - 1]) + grid[i][j]
        return grid[-1][-1]