【动态规划】-【基础题目02】-62不同路径，343整数拆分，96不同的二叉搜索树

本博客写动态规划第二波基础题目，分别为：

（1）定义二维向量：

vector<vector<int>> dp(m, vector<int>(n, 0));

（2）滚动数组解决二维动态规划问题；时空复杂度一般为O(mn)，空间可以压缩为O(n)。

（3）整数拆分的递推公式；还有数学方法

（4）二叉搜索树的定义；

（5）需要注意，每个题目都会有n的取值范围，如果你的初始化循环开始的数字超过了n，就要加if判断语句，直接输出你的初始化值，不然会出错。

目录

62.不同路径

63. 不同路径 II

343. 整数拆分

96.不同的二叉搜索树

---

62.不同路径

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

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

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

示例 1：

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

思路：

比较好了解，直接写过程：

（1）递推公式：dp[i][j]=dp[i-1][j]+dp[i][j-1]

（2）初始化：第一行和第一列都为1，只有一种走法；

代码：

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        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++)
                dp[i][j]=dp[i-1][j]+dp[i][j-1];
        return dp[m-1][n-1];
    }
};

上面时空复杂度都为O(mn)。为了节省空间，也可以使用一维数组，即滚动数组，

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. 向下 -> 向下 -> 向右 -> 向右

思路：

现在有了障碍物，不过整体的思路还是没变，需要注意，初始化时，第一行和第一列还是都为1，但要是遇到障碍物，后面的都为0。递推公式时，只有当前位置是空位置时，才等于原来的递推，同时注意所有图中的障碍物的dp都为0。

代码：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m=obstacleGrid.size();
        int n=obstacleGrid[0].size();
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i=0;i<m&&obstacleGrid[i][0]!=1;i++)
            dp[i][0]=1;
        for(int j=0;j<n&&obstacleGrid[0][j]!=1;j++)
            dp[0][j]=1;
        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];
        return dp[m-1][n-1];
    }
};

343. 整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

示例 1:

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

示例 2:

• 输入: 10
• 输出: 36
• 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
• 说明: 你可以假设 n 不小于 2 且不大于 58。

思路：

五步法进行分析：

（1）数组及下标含义：dp[i]表示对于数字 i 拆分它的最大乘积；

（2）递推公式

首先最容易想到的就是dp[i]=max（dp[1]*dp[i-1]，dp[2]*dp[i-2]，dp[3]*dp[i-3]，……）。

但是需要注意，上述拆分法是强制将该数拆成四个以上的数了。

所以我们应该只拆分一个，即最小拆分两个，然后拆分三个及以上，所以递推公式就为：

dp[i]= max（dp[i]，max（（i-j）*j，dp[i-j]*j ），前者是拆分成2个，后者是拆分成2个以上。至于为什么 j 不拆分，因为遍历的时候已经拆分过了，此处dp[i-j]*j，dp[j]*(i-j)以及dp[i-j]*dp[j]是一样的结果。

代码：

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n+1,1);
        dp[0]=0;
        dp[1]=0;
        dp[2]=1; //注意输入范围是从2开始
        for(int i=3;i<=n;i++)
            for(int j=1;j<i;j++)
            dp[i]=max(dp[i],max((i-j)*j,dp[i-j]*j));
        return dp[n];
    }
};

96.不同的二叉搜索树

给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

示例:

#思路

 五步法：

首先需要看一下二叉搜索树的定义：左子树上所有节点的值均小于根节点，右子树均大于根节点。

（1）数组下标及含义：dp[i]表示节点为 i 时，二叉搜索树的个数；

（2）递推公式：

由于左子树的值均小于根节点，右子树均大于根节点。

那么对于当前节点n，其可能有：1：左0右dp[n-1]；2：左dp[1]右dp[n-2]；3：左dp[2]右dp[n-3]。

右边是2~n或者3~n，等价于dp[n-1]等。

所以递推公式为：dp[i]=（ dp[0]+dp[n-1] ）+ （ dp[1]+dp[n-2]  + ……+ （ dp[n-1]+dp[0] ）

（3）初始化：dp[1]=1，dp[2]=2；

（4）遍历顺序：从小到大

代码：

class Solution {
public:
    int numTrees(int n) {
        if(n<=2)
            return n;
        vector<int> dp(n+1,0);
        dp[0]=1;
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=n;i++)
            for(int j=1;j<=i;j++)
                dp[i]+=dp[j-1]*dp[i-j];
        return dp[n];
    }
};