第四十一天 | 62.不同路径 63.不同路径|| 343.整数拆分 96.不同的二叉搜索树

题目：62.不同路径

1.二维dp数组dp[i][j]含义：到达（i，j）位置有dp[i][j]种方法。

2.动态转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

3.初始化：dp[0][j] = 1, dp[i][0] = 1 （第一行第一列都为1）

4.遍历顺序：从上向下，从左往右

5.打印dp

二维数组怎么定义？

代码如下：

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

题目：63.不同路径||

思路：

1.dp数组及含义：到达（i，j）位置有dp[i][j]种方法。

2.状态转移方程：dp[i][j] = dp[i - 1][j] + dp[i][j - 1]（遇到空位置才进行计算）

3.初始化：dp[0][j] = 1, dp[i][0] = 1 （第一行第一列都为1）。当遇到障碍后停止。

4.遍历顺序：从上向下，从左往右

5.打印dp

代码如下：

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        vector<vector<int>> dp(obstacleGrid.size(), vector<int>(obstacleGrid[0].size(), 0));
        for(int i = 0; i < obstacleGrid.size() && obstacleGrid[i][0] == 0; i++){
            dp[i][0] = 1;
        }
        for(int j = 0; j < obstacleGrid[0].size() && obstacleGrid[0][j] == 0; j++){
            dp[0][j] = 1;
        }
        for(int i = 1; i < obstacleGrid.size(); i++){
            for(int j = 1; j <obstacleGrid[0].size(); j++){
                if(obstacleGrid[i][j] == 0){
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[obstacleGrid.size() - 1][obstacleGrid[0].size() - 1];
    }
};

题目：343.整数拆分

关键在于理解递推公式。（考虑好有几个需要比较的情况）

什么时候乘积最大？拆成尽可能相等的数

思路：

1.dp含义：数i经过拆分后，得到最大的乘积dp[i]

2.状态转移方程（dp[i] 是依靠 dp[i - j]的状态）：

递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

        1)有两种拆分方式：一是i * (i - j)直接相乘（把 i 拆成两个数）；

                                    二是 j * dp[i - j]（把 i 拆成三个数及以上）         

        2)在递推公式推导的过程中，每次计算dp[i]，取最大的而已

                因为在第二层循环中会不断得到新的dp[i]，用本轮for循环得到的dp[i]与之前得到的最大的dp[i]作比较，取更大的。

3.初始化：

拆分0和拆分1的最大乘积是多少？

这是无解的。

这里我只初始化dp[2] = 1，从dp[i]的定义来说，拆分数字2，得到的最大乘积是1，这个没有任何异议！确定遍历顺序，先来看看递归公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

4.确定遍历顺序：从前到后

确定遍历顺序，先来看看递归公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));

dp[i] 是依靠 dp[i - j]的状态，所以遍历i一定是从前向后遍历，先有dp[i - j]再有dp[i]。

5.打印dp数组：

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

题目：96.不同的二叉搜索树

思路：

1.dp数组含义：含有 i 个节点的二叉搜索树共有dp[i]种

2.状态转移方程：

dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量

有2个元素的搜索树数量就是dp[2]。

有1个元素的搜索树数量就是dp[1]。

有0个元素的搜索树数量就是dp[0]。

所以dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

所以递推公式：dp[i] += dp[j - 1] * dp[i - j]; ，j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量

3.初始化：

初始化，只需要初始化dp[0]就可以了，推导的基础，都是dp[0]。

那么dp[0]应该是多少呢？

从定义上来讲，空节点也是一棵二叉树，也是一棵二叉搜索树，这是可以说得通的。

从递归公式上来讲，dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量] 中以j为头结点左子树节点数量为0，也需要dp[以j为头结点左子树节点数量] = 1， 否则乘法的结果就都变成0了。

4.遍历顺序：左往右

5.打印dp

容易犯得典型错误：

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;      //易错：空二叉树也是二叉搜索树
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3; i <= n; i++){      //统计以1，2,...,n为结点有多少种不同的二叉树
            for(int j = 1; j <= i; j++){     //统计以1，2,...,i为头结点，同时共n个节点，有多少种不同的二叉树
                dp[i] += dp[j - 1] * dp[i - j]; 
            }
        }
        return dp[n];
    }
};

在初始化时赋值dp[2]等于0，如果题目中n = 1,则会越界。

这一点很容易犯错

其实经常会有一个困惑，到底初始化时要初始前多少个呢？（手动模拟一下）

正确代码如下：

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

其实只用定义dp[0] = 0，dp[1]往后都是可以动态规划循环推出来的。