二维dp01

62.不同路径

dp[i][j]：考虑到达位置[i,j]的不同路径数；

代码如下：

1.可以分条件讨论

2.由于只能向下或是向右移动，所以0行和0列的不同路径只有1条。直接写出dp值。

class Solution {
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n];
        dp[0][0] = 1;
        for(int i=0; i<m; i++){
            dp[i][0]=1;
        }
        for(int j=0; j<n; j++){
            dp[0][j]=1;
        }
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                // if(i>0 && j>0){
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                // }else if(i>0){
                //     dp[i][j] = dp[i-1][j];
                // }else if(j>0){
                //     dp[i][j]=dp[i][j-1];
                // }
            }
        }
        return dp[m-1][n-1];
    }
}

64.最小路径和

dp[i][j]：考虑到位置[i,j]的最小值

位置依赖于上方和左方，空间压缩为一维dp，从上到小，从左到右更新

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

class Solution {
    public int minPathSum(int[][] grid) {
        /**
        严格位置依赖的DP+空间压缩技巧
        整个大过程就是从上到小不停更新一维数组
        其中更新一维数组的小过程就是从左到右
         */
        int n = grid[0].length;
        int m = grid.length;
        // 用一个一维数组动态更新来记录想象中的二维缓存表
        int[] dp = new int[n];
        // 记录想象表的第0行，就是由grip表第0行从左往右计算得到
        dp[0]=grid[0][0];
        for(int j= 1; j<n; j++){
            dp[j]=dp[j-1]+grid[0][j];
        }
        // 从上到下的大过程
        for(int i = 1; i<m;i++){
            // 0位置的更新
            dp[0]+=grid[i][0];
            // 从左到右的小过程
            for(int j=1; j<n;j++){
                // 当前位置的值取决于左边和上边的最小值
                dp[j]=grid[i][j]+Math.min(dp[j-1],dp[j]);
            }
        }
        return dp[n-1];
    }
}