Day41【动态规划】343.整数拆分、96.不同的二叉搜索树

最新推荐文章于 2024-05-30 16:17:47 发布

林沐华

最新推荐文章于 2024-05-30 16:17:47 发布

阅读量64

点赞数

分类专栏：代码随想录文章标签：动态规划算法 c++ leetcode 数据结构

本文链接：https://blog.csdn.net/qq_41657851/article/details/130668215

版权

代码随想录专栏收录该内容

53 篇文章 0 订阅

订阅专栏

343.整数拆分

力扣题目链接/文章讲解

视频讲解

1、确定 dp 数组下标及值的含义

dp[i]：下标 i 表示对数字 i 拆分成两个及以上的正整数，dp[i] 的值表示拆分数字 i 可以得到的最大乘积为 dp[i]

2、确定递推公式

想要得到 dp[i]，也就是说要对数字 i 进行拆分。我们思考一下怎么对 i 进行拆分？

其实可以分析第一个拆出来的数 j，从 1 开始遍历 j，然后有两种渠道得到 dp[i]

一个是 j * (i - j) 直接相乘，即拆分出两个数

一个是 j * dp[i - j]，相当于是进一步拆分 (i - j)，即拆分出三个数及以上

那么从 1 遍历 j，比较 (i - j) * j和dp[i - j] * j 取最大的。递推公式：dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j))

3、dp 数组初始化

严格从 dp[i] 的定义来说，dp[0], dp[1] 就不应该初始化，也就是没有意义的数值（因为要拆分成两个及以上的正整数，0 和 1 没办法拆）

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

然后我们从 dp[3] 开始遍历更新数组

4、确定遍历顺序

从左向右遍历填充 dp 数组

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[0] 和 dp[1] 没有意义

因此我们初始化了 dp[2]，从 dp[3] 开始更新 dp 数组

此外，因为出现了 dp[i - j]，因此要保证 i - j > 1，故内层循环中 j < i - 1

5、打印 dp 数组

代码如下

class Solution {
public:
    int integerBreak(int n) {
        //1.定义dp数组及含义：dp[i]表示将数字i拆成两个以上正整数可能取到的乘积最大值
        vector<int> dp(n + 1, 0);
        
        //2.递推公式
        //假如把i拆成两个数，假设拆成i * j，可能取到最大
        //假如把i拆成三个及以上的数，最大的一定是j * dp[i - j]的时候最大
        //因此，每固定一个i，需要遍历拆分出来的其中一个数j，找最大dp[i] = max(j * (i - j), j * dp[i - j])
        //3.初始化：dp[2] = 1 从dp[3]开始填dp数组
        dp[2] = 1;
        for (int i = 3; i <= n; ++i)
            for (int j = 1; j < i - 1; ++j) //从1开始遍历拆出来的第一个数j
                {
                    dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));
                    //内层max是取拆出来有j的情况下，拆两个数或是三个及以上数这两种拆分方案中的最大值
                    //外层max是考虑所有j的情况找最大值
                    //因为用到max dp[i]，最好一开始把dp[i]初始化为一个小值
                }
        return dp[n];
    }
};

本题递归公式是关键！

96.不同的二叉搜索树

力扣题目链接/文章讲解

视频讲解

1、确定 dp 数组下标及值的含义

dp[i]：下标 i 表示节点值从 1 到 i 组成二叉搜索树，dp[i] 的值表示 1 到 i 为节点组成的二叉搜索树的个数为 dp[i]

2、确定递推公式

以 n = 3 为例

当1为头结点的时候，其右子树有两个节点，右子树节点的不同布局数量为 dp[2]

当2为头结点的时候，其左右子树都只有一个节点，左子树或右子树节点的不同布局数量为 dp[1]

当3为头结点的时候，其左子树有两个节点，左子树节点的不同布局数量为 dp[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 为头结点右子树节点数量，j 表示用于当头节点的数值，j 从 1 遍历到 i

3、确定初始条件

dp[0] = 1，因为，递推公式中，当 j = 1 时，元素 1 为头结点搜索树的数量 = 左子树有 0 个元素的搜索树数量 * 右子树有 i - 1 个元素的搜索树数量，即 dp[0] * dp[i - 1]，此时 dp[0] 应该为 1，否则乘法的结果就变成 0 了

所以初始化dp[0] = 1

剩余的 dp 应该初始化为 0，方便我们在计算每个 dp 值的时候做累加操作

4、确定遍历顺序

从递归公式：dp[i] += dp[j - 1] * dp[i - j] 可以看出，节点数为 i 的状态是依靠 i 之前节点数的状态，因此从左向右遍历，保证 dp[i] 之前的数值是已经被更新过的正确数值

5、打印 dp 数组验证

代码如下

class Solution {
public:
    int numTrees(int n) {
        //1、定义dp数组下标及值含义：下标i表示从1到i组成二叉搜索树，dp[i]的值表示1到i组成的二叉搜索树个数
        vector<int> dp(n + 1, 0);
        //2、确定递推公式：dp[i] += dp[j - 1] * dp[i - j]，即考虑1到i所有的节点都可能为头节点的情况，统计所有情况
        //3、确定初始化：dp[0] = 1，其他初始化为0方便累加
        dp[0] = 1;
        //4、确定遍历顺序：从左向右
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= i; ++j)    // 从1开始遍历每个节点都可能为头节点的情况
                dp[i] += dp[j - 1] * dp[i - j];
        }
        //5、打印 dp 数组验证，略
        return dp[n];
    }
};