Day36:动态规划 LeedCode 62.不同路径 63. 不同路径 II 343. 整数拆分 96.不同的二叉搜索树

62. 不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

示例 2：

输入：m = 3, n = 2
输出：3
解释：
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右
3. 向下 -> 向右 -> 向下

示例 3：

输入：m = 7, n = 3
输出：28

示例 4：

输入：m = 3, n = 3
输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 109

思路:

动规五部曲：

1.确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2.确定递推公式

想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。

那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。

3.dp数组的初始化

如何初始化呢，首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。

所以初始化代码为：

for (int i = 0; i < m; i++) dp[i][0] = 1;
for (int j = 0; j < n; j++) dp[0][j] = 1;
4.确定遍历顺序

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

5.举例推导dp数组

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];

    }
}

---

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
输出：2
解释：3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径：
1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]]
输出：1

提示：

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

思路:

思路与上题一致,区别在于有障碍物的位置dp[i][j]=0;

动规五部曲：

1.确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2.确定递推公式

想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

此时在回顾一下 dp[i - 1][j] 表示啥，是从(0, 0)的位置到(i - 1, j)有几条路径，dp[i][j - 1]同理。

那么很自然，dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为dp[i][j]只有这两个方向过来。

3.dp数组的初始化

如何初始化呢，首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。有障碍物的位置为0,注意第一行和一列中,某个位置有障碍物,则该行/列的后面的路径就为0

所以初始化代码为：尤其注意初始化位置是否有障碍物

   //初始化
    for(int i=0;i<obstacleGrid.length&&obstacleGrid[i][0]==0;i++){
       dp[i][0]=1;
     }
    for(int j=0;j<obstacleGrid[0].length&&obstacleGrid[0][j]==0;j++){
            dp[0][j]=1;
        }
4.确定遍历顺序

dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j]都是从其上方和左方推导而来，那么从左到右一层一层遍历就可以了。

5.举例推导dp数组

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m=obstacleGrid.length;
        int n=obstacleGrid[0].length;
         int[][] dp= new int[m][n];
         for(int i=0;i<m;i++){
            Arrays.fill(dp[i],0);
         }
         if(obstacleGrid[0][0]==0)
         dp[0][0]=1;
         for(int i=1;i<m;i++){
            if(obstacleGrid[i][0]==0)
            dp[i][0]=dp[i-1][0];
         }
         for(int i=1;i<n;i++){
            if(obstacleGrid[0][i]==0)
            dp[0][i]=dp[0][i-1];
         }
         for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                if(obstacleGrid[i][j]==0){
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
            }
         }
         return dp[m-1][n-1];
    }
}

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
     int[][] dp=new int[obstacleGrid.length][obstacleGrid[0].length];
     for(int i=0;i<dp.length;i++){
        Arrays.fill(dp[i],0);
     }
     //初始化
    for(int i=0;i<obstacleGrid.length&&obstacleGrid[i][0]==0;i++){
       dp[i][0]=1;
     }
    for(int j=0;j<obstacleGrid[0].length&&obstacleGrid[0][j]==0;j++){
            dp[0][j]=1;
        }
        //遍历
    for(int i=1;i<obstacleGrid.length;i++){
            for(int j=1;j<obstacleGrid[0].length;j++){
                if(obstacleGrid[i][j]==1){
                    continue;
                }
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[obstacleGrid.length-1][obstacleGrid[0].length-1];
    }
}

---

343. 整数拆分

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回 你可以获得的最大乘积 。

示例 1:

输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。

示例 2:

输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

提示:

• 2 <= n <= 58

思路:

1.确定dp数组（dp table）以及下标的含义

dp[i]分拆数字i，可以得到的最大乘积为dp[i]。

2.确定递推公式

dp[i]=max(dp[i],j*(i-j),j*dp[i-j])

j*(i-j):拆分成两个数之间相乘

j*dp[i-j]:拆分成两个及两个以上

为什么j不拆分?

从1遍历到j,相当于j已经被拆分过了

3.dp数组如何初始化

dp[2]=1:2拆分成1*1=1

0,1无法拆分,不对dp[0],dp[1]初始化

所以后面我们遍历时需要满足i-j>=2

4.确定遍历顺序

dp[i]=max(dp[i],j*(i-j),j*dp[i-j])

由地推公式可知,从左往右遍历

5.举例推导dp数组

class Solution {
    public int integerBreak(int n) {
     int[] dp=new int[n+1];
     dp[2]=1;
     //dp[i]=Max(dp[i],j*(i-j),j*dp[i-j])
     for(int i=3;i<=n;i++){
   for(int j=1;j<i;j++){
    dp[i]=Math.max(dp[i],Math.max(j*dp[i-j],j*(i-j)));
   }
     }
     return dp[n];
    }
}

---

96. 不同的二叉搜索树

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。

示例 1：

输入：n = 3
输出：5
示例 2：

输入：n = 1
输出：1
思路:

由图可知

当n=3时:

头结点为1,左子结点个数为0,右子节点个数为2  

头结点为2,左子结点个数为1,右子节点个数为1  

头结点为3,左子结点个数为2,右子节点个数为0  

 1.确定dp数组（dp table）以及下标的含义

dp[i]表示有i个结点时,有多少不互相同的二叉树

2.确定递推公式

如图

dp[3]=d[0]*dp[2]+dp[1]*dp[1]+dp[2]*dp[0]

故dp[i]+=dp[j-1]*dp[i-j]

j-1:左子结点个数

i-j:右子节点个数

3.dp数组如何初始化

dp[0]=1;

4.确定遍历顺序

由dp[i]+=dp[j-1]*dp[i-j]可知:dp[i]是根据之前状态得到的

5.举例推导dp数组

class Solution {
    public int numTrees(int n) {
     int[] dp= new int[n+1];//dp[i]表示有i个结点时,有多少不互相同的二叉树
     dp[0]=1;
     for(int i=1;i<=n;i++){
      for(int j=1;j<=i;j++){//j表示根节点为j
        dp[i]+=dp[i-j]*dp[j-1];
      }
     }
     return dp[n];
    }
}