玩转动态规划 lee64 最小路径和 从左上到右下

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

思路 我的想法和三角形那个类似

我的代码：

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid.length==0|| grid==null) return 0;
        int[][] dp=new int[grid.length][grid[0].length];
        for(int i=grid.length-1;i>=0;i--){
            for(int j=0;j<grid[i].length;j++){
                dp[i][j]= Math.min( dp[i+1][j], dp[i][j+1] ) + grid[i][j];
            }
        }
        return dp[0][0];
    }
}

发现总报越界错误
因为 如果在边境，可能向左向上越界
所以要不同情况不同判断

分为四种情况

1. i是边界 j是
2. i不是 j是
3. i是 j不是
4. i不是 j不是

二维数组代码如下

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid.length==0|| grid==null) return 0;
        int[][] dp=new int[grid.length][grid[0].length];
        for(int i=grid.length-1;i>=0;i--){
            for(int j=grid[0].length-1; j>=0; j--){
                if( j != grid[0].length-1 && i!=grid.length-1){
                    dp[i][j]= Math.min( dp[i+1][j], dp[i][j+1] ) + grid[i][j];
                }
                else if(i==grid.length-1 && j!=grid[0].length-1){
                    dp[i][j]=grid[i][j]+dp[i][j+1];
                }
                else if(i!=grid.length-1 && j==grid[0].length-1){
                    dp[i][j]=grid[i][j]+dp[i+1][j];
                }
                else
                    dp[i][j]=grid[i][j];
                
            }
        }
        return dp[0][0];
    }
}
/*

我自己写的：

class Solution {
    public int minPathSum(int[][] grid) {
        
        int rows=grid.length;
        int cols=grid[0].length;
        if(rows==0 || cols==0) return 0;
        int[][] dp = new int[rows][cols];
   //     dp[0][0]=0;
        for(int i=0;i<rows;i++){  // 怎样处理越界问题？分情况
            for(int j=0;j<cols;j++){
                if(i==0 && j==0){
                     dp[i][j]=grid[i][j];
                  
                }
                else if( i==0 && j!=0 ){
                     dp[0][j]=dp[0][j-1]+grid[0][j];
                   
                }
                else if(j==0 && i!=0){
                    dp[i][0]=dp[i-1][0]+grid[i][0];
                    
                }
                else {
                    dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j])+grid[i][j];
                }
            }    
        }
        return dp[rows-1][cols-1];
    }
}

同理 一维数组

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid.length==0|| grid==null) return 0;
        int[] dp=new int[grid[0].length];
        for(int i=grid.length-1;i>=0;i--){
            for(int j=grid[0].length-1; j>=0; j--){
                if( j != grid[0].length-1 && i!=grid.length-1){
                    dp[j]= Math.min( dp[j], dp[j+1] ) + grid[i][j];
                }
                else if(i==grid.length-1 && j!=grid[0].length-1){
                    dp[j]=grid[i][j]+dp[j+1];
                }
                else if(i!=grid.length-1 && j==grid[0].length-1){
                    dp[j]=grid[i][j]+dp[j];
                }
                else
                    dp[j]=grid[i][j];
                
            }
        }
        return dp[0];
    }
}

不需要额外空间 在原数组上存储

就把dp换成grid即可