代码随想录算法训练营第三十五天|343. 整数拆分，96.不同的二叉搜索树

343. 整数拆分 - 力扣（LeetCode）

给定一个正整数 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。

思路：动态规划。

解决：确定五步曲：

        1.确定dp[i]的含义；

        dp[i]在这里指拆分i获得的最大乘积。

        2.确定递推公式；

        举例确定递推公式，当n=5时，开始拆分，那么dp[5]怎么遍历出来？

        从1开始遍历，dp[5]=1*4,但这里4又可以继续拆分，dp[4]也是一个乘积最大的结果；

        所以就需要比较1*4和1*dp[4]的大小，转化成公式就是dp[i]=max(j*i-j，j*dp[i-j])。

                但是没有结束, 只是完成了当前i的遍历！

        由于i也是从1遍历到n,所以每次都需要更新当前的乘积最大的结果，转化公式就是

                                dp[i]=max(max(j*i-j，j*dp[i-j])，dp[i])。

        3.确定dp初始化；

        由于1和0拆分有点牵强，所以拆分从dp[2]开始，dp[2]=1。

        4.确定遍历顺序；

        i在从小递增到n,所以拆分也是从小到达拆分，遍历顺序也是从前向后。

        5.举例推导dp数组。

        例子2，n=10

         1 2 3 4 5 6 7 8 9 10

dp[i]  1 1 2 4 6 9 12 16 27 36

代码：这里j不需要完全遍历到最后，因为一个数拆分，拆开的数离得越近，乘积越大，j遍历到i的一半就可以。

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

96. 不同的二叉搜索树 - 力扣（LeetCode）

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

示例 1：

输入：n = 3
输出：5

示例 2：

输入：n = 1
输出：1

思路：动态规划。

解决：确定五步曲：

        1.确定dp[i]的含义；

        ​​​​​​​dp[i]表示n个节点组成的互不相同二叉搜索数的个数。

        2.确定递推公式；

        从例子3来看，有5个二叉搜索树，两个以1为头节点，两个以3为头节点，一个以2为头节点。

        以1为头节点，剩下2，3两个节点都在右子树上，所以以1为头节点，加上两个节点组成的二叉搜索数就等于dp[2]；转化成公式：dp[0]+dp[2]；

        以3为头节点，剩下1，2两个节点都在右子树上，所以以3为头节点，加上两个节点组成的二叉搜索数就等于dp[2]，和以1开头一样；转化成公式：dp[2]+dp[0]；

         以2为头节点，剩下1在左子树上，剩下3在右子树上，所以以2为头节点，和左右子树组成的二叉搜索数的个数：dp[1]+dp[1]；

不难总结出：

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

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

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

所以当n继续变大时，同样可以按不同元素作为头节点来统计剩下左右子树的搜索树数量。

        ​​​​​​​那么公式等于dp[i]=dp[j]*dp[i-j]。

       但上述公式并不对，首先dp[j]这里j不能等于i，其次dp[i-j]这里i-j又可以等于0；这就对j的初始值有要求，那就让j从1开始，公式就变成dp[i]=dp[j-1]*dp[i-j]。

        3.确定dp初始化；

        上一步分析到j从1开始，但是dp[j-1]可能等于dp[0]，所以我们初始化就是dp[0]=1，这样dp[1]=dp[0]*dp[0]=1；这里非常巧妙，初始化从0开始。

        4.确定遍历顺序；

        遍历顺序就是随着数字变大，组合树的数量就越来越多，所以是从前向后遍历。

        5.举例推导dp数组。

        n=5

         0 1 2 3 4 5 

dp[i]  1 1 2 5 14 42

代码：

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