LeetCode 64. 最小路径和

64. 最小路径和

题目描述

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

解题思路

思路一： 动态规划

1. 状态定义

设 dp 为大小 m×n 矩阵，其中 dp[i][j] 的值代表直到走到 (i,j)的最小路径和。

2. 转移方程

• 网格的第一行的每个元素只能从左方元素开始向右移动到达，网格的第一列的每个元素只能从上方元素开始向下移动到达，此时的路径是唯一的，因此每个元素对应的最小路径和即为对应的路径上的数字总和；
• 对于不在第一行和第一列的元素，可以从其上方相邻元素向下移动一步到达，或者从其左方相邻元素向右移动一步到达，元素对应的最小路径和等于其上方相邻元素与其左方相邻元素两者对应的最小路径和中的最小值加上当前元素的值；

状态转移方程：

• 当i = 0, j = 0 时，即起点， dp[i][j] = grid[i][j];
• 当 i = 0 且 j > 0 时，即第一行， dp[0][j] = dp[0][j - 1] + grid[0][j];
• 当 i > 0 且 j = 0 时，即第一列， dp[i][0] = dp[i − 1][0] + grid[i][0];
• 当 i > 0 且 j > 0 时， dp[i][j]=min(dp[i − 1][j], dp[i][j − 1]) + grid[i][j];

3. 初始状态

dp[0][0] = grid[0][0];
for (let i = 1; i < rowLen; i++) {
    dp[i][0] = dp[i - 1][0] + grid[i][0];
}
for (let j = 1; j < colLen; j++) {
    dp[0][j] = dp[0][j - 1] + grid[0][j];
}

4. 返回值
返回 dp 矩阵右下角值，即走到终点的最小路径和

实现代码如下：

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function(grid) {
    let rowLen = grid.length, 
        colLen = grid[0].length,
        dp = Array.from(Array(rowLen), () => Array(colLen)); 

    dp[0][0] = grid[0][0];
    for (let i = 1; i < rowLen; i++) {
        dp[i][0] = dp[i - 1][0] + grid[i][0];
    }
    for (let j = 1; j < colLen; j++) {
        dp[0][j] = dp[0][j - 1] + grid[0][j];
    }
    for (let i = 1; i < rowLen; i++) {
        for (let j = 1; j < colLen; j++) {
            dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
        }
    }
    return dp[rowLen - 1][colLen - 1]; 
};

• 时间复杂度：O(mn)，其中 m 和 n 分别是网格的行数和列数。需要对整个网格遍历一次，计算 dp 的每个元素的值。

• 空间复杂度：O(mn)

空间复杂度优化
每次只存储上一行的 dp 值，则可以将空间复杂度优化到 O(n)

/**
 * @param {number[][]} grid
 * @return {number}
 */
var minPathSum = function(grid) {
    let rowLen = grid.length, 
        colLen = grid[0].length,
        dp = Array(colLen); 

    dp[0] = grid[0][0];
    // 初始化dp数组
    for (let i = 1; i < colLen; i++) {
        dp[i] = grid[0][i] + dp[i - 1];
    }
    
    // 维护dp数组
    for (let i = 1; i < rowLen; i++) {
        dp[0] = dp[0] + grid[i][0]; 
        for (let j = 1; j < colLen; j++) {
            dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
        }
    }
    return dp[colLen - 1]; 
};

参考资料

https://leetcode.cn/problems/minimum-path-sum/solution/zui-xiao-lu-jing-he-by-leetcode-solution/