力扣64.最小路径和

 64. 最小路径和

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

输入:

[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小

思路一：动态规划

这是一道典型的动态规划题
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)

注意，

因为这题求的最小值，所以不能用开辟 (ows+1)*(cols+1)个空间来代替边界初始化, 因为在在边界处 Math.min(dp[i-1][j], dp[i][j-1]) 肯定等于0， 那d[i][0]或者dp[0][j]肯定等于grid[i][j]， 这是明显错误的。

class Solution {
    public int minPathSum(int[][] grid) {
        // 动态规划，dp[i][j]表示从起点到达(i,j)经过的路径最小和
        if(grid == null || grid.length == 0 || grid[0].length == 0){
            return 0;
        }
        int rows = grid.length;
        int cols = grid[0].length;
        int[][] dp = new int[rows+1][cols+1];
        for(int i = 1; i <= rows; i++){
            for(int j = 1; j <= cols; j++){
                dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i-1][j-1];
            }
        }
        return dp[rows][cols];
    }
}

但是这题求的是最大值，那么是可以这样做来简化代码的。

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

 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-1]在dp[j]之前就已经计算出来，已经包含了grid[i][j-1], 所以是没有问题的。dp[j]（等式左边的dp[j]）就相当于是上面的dp[i-1][j], dp[j-1]就相当于上面的dp[i][j-1],  

所以dp[j] = Math.min(dp[j], dp[j-1]) + grid[i][j];这时候没问题的。

边界值
dp[j] = dp[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/