力扣64.最小路径和

 64. 最小路径和

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

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

输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-path-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路一：动态规划

这是一道典型的动态规划题
dp[i][j]表示从起点到达(i, j)位置的最小路径和，

状态转移方程

dp[i][j] = Math.min(dp[i - 1][j],dp[i][j-1]) + m[i][j];

边界值
dp[i][0] = dp[i-1][0] + m[i][0]
dp[0][j] = dp[0][j-1] + m[0][j]

class Solution {
    public int minPathSum(int[][] grid) {

        if(grid == null || grid.length == 0){
            return Integer.MAX_VALUE;
        }
        int rlen = grid.length;
        int clen = grid[0].length;
        int[][] dp = new int[rlen][clen];
        // 初始化边界值
        dp[0][0] = grid[0][0];
        for(int i = 1; i < rlen; i++){
            dp[i][0] = dp[i-1][0] + grid[i][0];
        }
        for(int j = 1; j < clen; j++){
            dp[0][j] = dp[0][j-1] + grid[0][j];
           
        }

        for(int i = 1; i < rlen; i++){
            for(int j = 1; j < clen; j++){
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[rlen - 1][clen - 1];
    }
}

力扣测试时间为3ms, 空间为42.3MB

复杂度分析：

时间复杂度为O(n*m)

空间复杂度也是O(mn)

思路二：利用一维数组进行动态规划

 dp数组大小等于矩阵的列的数目

状态转移方程

dp[j] = dp[0] + grid[i][j]; (j == 0)
dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j]; (j != 0)

边界值
dp[j] = dp[0][j-1] + grid[0][j]; // 初值

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid == null || grid.length == 0){
            return Integer.MAX_VALUE;
        }
        int rlen = grid.length;
        int clen = grid[0].length;
        int[] dp = new int[clen];
        // 初始化边界值
        dp[0] = grid[0][0];
        
        for(int j = 1; j < clen; j++){
            dp[j] = dp[j-1] + grid[0][j];
        }

        for(int i = 1; i < rlen; i++){
            for(int j = 0; j < clen; j++){
                if(j == 0){
                    dp[j] = dp[0] + grid[i][j];     // 每行第0列元素
                }else{
                    dp[j] = Math.min(dp[j-1], dp[j]) + grid[i][j];
                }
            }
        }
        return dp[clen - 1];
    }
}

力扣测试时间2ms, 空间为41.9MB

复杂度分析：

时间复杂度为O(nm)

空间复杂度为O(n), n为列的数目

思路三：无额外空间的动态规划

 由于每个grid[i][j]只使用一次，所以完全可以用grid[i][j]来作为dp数组

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid == null || grid.length == 0){
            return Integer.MAX_VALUE;
        }
        int rlen = grid.length;
        int clen = grid[0].length;
        
        // 初始化边界值
        for(int i = 1; i < rlen; i++){
            grid[i][0] = grid[i-1][0] + grid[i][0];
        }
        for(int j = 1; j < clen; j++){
            grid[0][j] = grid[0][j-1] + grid[0][j];
           
        }

        for(int i = 1; i < rlen; i++){
            for(int j = 1; j < clen; j++){
                grid[i][j] = Math.min(grid[i-1][j], grid[i][j-1]) + grid[i][j];
            }
        }
        return grid[rlen - 1][clen - 1];
    }
}

力扣测试时间为4ms, 空间为42.5MB

复杂度分析：

时间复杂度为O(nm)

空间复杂度为O(1)

思路参考：

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