DP(2) | Java | LeetCode 62, 63, 343, 96 做题总结

62.不同路径

• 我的代码（报错）
  写的过程中感到很迷惑的点：①二维数组和这道题目的对应弄不清除，m n的初始化 是 dp[m][n] 还是 dp[n][m] ②

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

/*
自己解题的时候思考过程

n-1 : 往右走的次数
m-1 : 往下走的次数 

dp[i][j]到当前的位置，有几种方法
dp[0][0] 0
dp[0][1] 1
dp[1][0] 1
dp[1][1] 2
dp[i][j] 的前一个状态是，(1)他的左边dp[i-1][j]，或者(1)dp[i-1][j-1]
dp[i][j] = dp[i-1][j] + dp[i-1][j-1];

 */

初始化出错，这里初始化要覆盖到整个左列 和 横排

// 第0列，dp[i][0] 表示到当前的位置，有几种方法，这一列都是只有一种
 for (int i = 0; i < m; i++) {
  dp[i][0] = 1;
 }
 
// 第0行，dp[0][i] 表示到当前的位置，有几种方法，这一行都是只有一种
 for (int i = 0; i < n; i++) {
     dp[0][i] = 1;
 }

JAVA二维数组存储示意图：

• 思考过程
  (1) 确定dp数组以及下标的含义：到当前的位置[i][j]，有几种方法 dp[i][j]
  (2) 确定递推公式 dp[i][j] = dp[i-1][j] + dp[i][j-1];
  (3) dp数组如何初始化 本题就栽在这一步了，其实是要for循环 初始化一列和一排的
  (4) 确定遍历顺序 从前到后
  (5) 举例推导dp数组
  (6) 打印 dp 数组

• ac

class Solution {
    public int uniquePaths(int m, int n) {
        int[][]dp = new int[m][n];

        for(int i=0; i<m; i++) {
            dp[i][0] = 1;
        }
        
        for(int i=0; i<n; i++) {
            dp[0][i] = 1;
        }

        for(int i=1; i<m; i++) {
            for(int j=1; j<n; j++) {
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }

        return dp[m-1][n-1];
    }
}

java

求二维数组长度

int m = obstacleGrid.length;
int n = obstacleGrid[0].length;

20241020重做 错误分析

错误分析：dp含义，但是dp数组定义的时候就有问题， 题目问的是m*n的矩阵，也就是矩阵的行列数已经定义好了，如果按照下面的代码，那矩阵是(m+1)*(n+1)

dp初始化也出错了，dp[0][0] =1

63. 不同路径 II

• 推导公式 dp[i][j] = dp[i-1][j] + dp[i][j-1];
  如果[i][j]有障碍，本来就走不了。
  if(obs[i][j] == 0) dp[i][j] = dp[i-1][j] + dp[i][j-1];

• 初始化
  如果第一行或者第一列有一个障碍物，那么后面的都要初始化为0

• 出错

java.lang.ArrayIndexOutOfBoundsException: Index -1 out of bounds for length 3
  at line 22, Solution.uniquePathsWithObstacles
  at line 56, __DriverSolution__.__helper__
  at line 86, __Driver__.main

因为dp从[1][1]走起

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;

        int[][]dp = new int[m][n];
        if(obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) {
            return 0;
        } 
        //初始化
        for(int i=0; i<m && obstacleGrid[i][0]!=1; i++) {
            dp[i][0] = 1;
            //中途如果有obstacleGrid[i][0]!=0，那就暂停循环，Java初始化都赋了0
        }

        //初始化
        for(int j=0; j<n && obstacleGrid[0][j]!=1; j++) {
            dp[0][j] = 1;
        }
        for(int i=1; i<m; i++) { //这里写了0是错误的
            for(int j=1; j<n; j++) {
                dp[i][j] = (obstacleGrid[i][j]==0?(dp[i][j-1]+dp[i-1][j]):0);
            }
        }
        return dp[m-1][n-1];
    }
}

//我的思考
// obstacleGrid[i][j] = 1 此处有障碍物，走不了
// obstacleGrid[i][j] = 0
// dp[i][j] = dp[i-1][j] + dp[i][j-1]
// 如果 obstacleGrid[i-1][j] = 1，前一种状态就不能是dp[i-1][j]，dp[i][j] = dp[i][j-1]
// 如果 obstacleGrid[i][j-1] = 1，前一种状态就不能是dp[i][j-1]，dp[i][j] = dp[i-1][j]

20241021重做 正确

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int[][]dp = new int[obstacleGrid.length][obstacleGrid[0].length];
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;

        //碰到obstacleGrid[i][j]=1要清零？
        for(int i=0; i<m; i++) {
            if(obstacleGrid[i][0]!=1) {
                dp[i][0] = 1;
            } else {
                dp[i][0] = 0;
                break;
            }
        }

        for(int j=0; j<n; j++) {
            if(obstacleGrid[0][j]!=1) {
                dp[0][j] = 1;
            } else {
                dp[0][j] = 0;
                break;
            }
        }

        for(int i=1; i<m; i++) {
            for(int j=1; j<n; j++) {
                if(obstacleGrid[i][j]!=1) {
                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                } else {
                    continue;
                }
            }
        }
        return dp[obstacleGrid.length-1][obstacleGrid[0].length-1];
    }
}

343. 整数拆分

没啥思路

力扣解题思路
① 尽可能拆成相同的数字，当所有拆分出的数字相等时，乘积最大。② 最优拆分数字为 3 。

• 数学方法

class Solution {
    public int integerBreak(int n) {
        if(n <= 3) return n - 1;
        int a = n / 3, b = n % 3;
        if(b == 0) return (int)Math.pow(3, a); 
        //b=0的 意思是 n中有a个3
        if(b == 1) return (int)Math.pow(3, a - 1) * 4;
        return (int)Math.pow(3, a) * 2;
    }
}

public static double pow(double x, double y) x的y次幂

• 动态规划？
  有点没看懂

1021重做

看不懂数学方法了hhh

96. 不同的二叉搜索树

20241021

二叉搜索树(Binary Search Tree) = 二叉排序树，左子树若存在，值小于根节点，右子树若存在，值大于根节点。

dp[i] i个节点能组合成多少种不同二叉搜索树
dp[i] = 以1为头节点的所有BST， 以2为头节点的所有BST， 以3为头节点的所有BST······以 i 为头节点的所有BST。
dp[i] += dp[j-1]✖dp[i-j] (j=1```i)

初始化：
dp[0] = 1 ，0个节点1个空二叉树
dp[1] = 1
dp[2] = 2

遍历顺序：从小到大

没有理解J变量存在的意义：所以出错了，这段代码是错的。虽然只需要把int j=2改成int j=1，但是意思非常不同。j=1是以1为根节点时，这n个节点的BST树。

class Solution {
    public int numTrees(int n) {
        int[] dp = new int [n+1];
        dp[0] = dp[1] = 1;
        for(int i=2; i<=n; i++) {
            for(int j=2; j<=i; j++) {
                dp[i] += dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
}