两题都挺有难度，第一次做，硬想很难想出来。

343.整数拆分

题目链接：343.整数拆分

难度指数：😀😐😕😟

题目思路：（动规五部曲）

1️⃣ 确定dp数组以及下标的含义

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

2️⃣ 确定递推公式

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

3️⃣ dp数组如何初始化

有的题解里会给出dp[0] = 1，dp[1] = 1的初始化，拆分0和拆分1的最大乘积是无解的。

(初始化dp[0]、dp[1] 没意义❌)

我们只初始化 dp[2] = 1 ，从 dp[i] 的定义来说，拆分数字2，得到的最大乘积是1

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

细节部分： 枚举 j 的时候，是从1开始的。 i 是从3开始，这样 dp[i - j] 就是 dp[2] 正好可以通过我们初始化的数值求出来。

 for (int i = 3; i <= n ; i++) {
     for (int j = 1; j < i - 1; j++) {
         dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
     }
 }

5️⃣ 举例推导dp数组

AC代码： （核心代码模式）

 class Solution {
 public:
     int integerBreak(int n) {
         //确定dp数组以及下标的含义
         vector<int> dp(n + 1);
         //dp数组的初始化
         dp[2] = 1;  //只初始化dp[2]
         //遍历顺序
         for (int i = 3; i <= n; i++) {
             for (int j = 1; j < i - 1; j++) {
                 dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
             }
         }
         //举例推导dp数组
         return dp[n];
     }
 };

思考：如何打印dp数组？

↓↓↓↓

打印dp数组：

 class Solution {
 public:
     int integerBreak(int n) {
         //确定dp数组以及下标的含义
         vector<int> dp(n + 1);
         //dp数组的初始化
         dp[2] = 1;  //只初始化dp[2]
         //遍历顺序
         for (int i = 3; i <= n; i++) {
             for (int j = 1; j < i - 1; j++) {
                 dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
             }
             cout << dp[i] << endl;  //打印dp数组
         }
         return dp[n];
     }
 };

stdout：2 4 6 9 12 18 27 36

✔

96.不同的二叉搜索树

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

难度指数：😀😐😕😟🥴

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]

题目思路：（动规五部曲）

1️⃣ 确定 dp数组 以及 下标 的含义

dp[i] ：1 ~ i 为节点组成的二叉搜索树的个数 dp[i]。

2️⃣ 确定递推公式

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

j - 1 为 j 为头结点左子树节点数量， i - j 为以 j 为头结点右子树节点数量

3️⃣ dp数组如何初始化

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

空节点也是一棵二叉树，也是一棵二叉搜索树。

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

因此，初始化 dp[0] = 1

4️⃣ 确定遍历顺序

节点数为 i 的状态是依靠 i 之前节点数的状态。

那么遍历 i 里面每一个数作为头结点的状态，用 j 来遍历。

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

5️⃣ 举例推导dp数组

AC代码： （核心代码模式）

 class Solution {
 public:
     int numTrees(int n) {
         //确定dp数组以及下标的含义
         vector<int> dp(n + 1);
         //dp数组的初始化
         dp[0] = 1;
         //遍历顺序
         for (int i = 1; i <= n; i++) {  //遍历i里面每一个数作为头结点的状态
             for (int j = 1; j <= i; j++) {  //用j来遍历
                 //递推公式
                 dp[i] += dp[j - 1] * dp[i - j];
             }
         }
         //举例推导dp数组
         return dp[n];
     }
 };

打印dp数组：

 class Solution {
 public:
     int numTrees(int n) {
         //确定dp数组以及下标的含义
         vector<int> dp(n + 1);
         //dp数组的初始化
         dp[0] = 1;
         //遍历顺序
         for (int i = 1; i <= n; i++) {  //遍历i里面每一个数作为头结点的状态
             for (int j = 1; j <= i; j++) {  //用j来遍历
                 //递推公式
                 dp[i] += dp[j - 1] * dp[i - j];
             }
             cout << dp[i] << endl;  //打印dp数组
         }
         //举例推导dp数组
         return dp[n];
     }
 };

stdout：1 2 5 14 42