我在代码随想录|写代码Day34 | 动态规划| 96.不同的二叉搜索树, 416. 分割等和子集,1049.最后一块石头的重量II

🔥博客介绍`： 27dCnc

🎥系列专栏： <<数据结构与算法>> << 算法入门>> << C++项目>>

🎥 当前专栏: <<数据结构与算法>>

专题 : 数据结构帮助小白快速入门算法
👍👍👍👍👍👍👍👍👍👍👍👍
☆*: .｡. o(≧▽≦)o .｡.:*☆

❤️感谢大家点赞👍收藏⭐评论✍️

学习目标：

今日学习打卡

• ACM题解

---

学习时间：

• 周一至周五晚上 7 点—晚上9点
• 周六上午 9 点-上午 11 点
• 周日下午 3 点-下午 6 点

---

学习内容：

1. 不同的二叉搜索树
2. 分割等和子集
3. 最后一块石头的重量II

---

内容详细：

96.不同的二叉搜索树

知识点: 树 树上动态规划

树上动态规划

1. 确定dp数组（dp table）以及下标的含义
   dp[i] ： 1到i为节点组成的二叉搜索树的个数为dp[i]。

也可以理解是i个不同元素节点组成的二叉搜索树的个数为dp[i] ，都是一样的。

以下分析如果想不清楚，就来回想一下dp[i]的定义

确定递推公式
在上面的分析中，其实已经看出其递推关系， dp[i] += dp[以j为头结点左子树节点数量] * dp[以j为头结点右子树节点数量]

j相当于是头结点的元素，从1遍历到i为止。

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

2. dp数组如何初始化
   初始化，只需要初始化dp[0]就可以了，推导的基础，都是dp[0]。

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

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

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

所以初始化dp[0] = 1

3. 确定遍历顺序
   首先一定是遍历节点数，从递归公式：dp[i] += dp[j - 1] * dp[i - j]可以看出，节点数为i的状态是依靠 i之前节点数的状态。

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

class Solution {
public:
    int numTrees(int n) {
        vector<int>dp(n+2,0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[i - j] *dp[j - 1];
            }
        }
        return dp[n];
    }
};
//递归五部曲
//1.确定参数涵义
//2.初始化
//3.递归方程
//4.确定遍历顺序
//5.举例推导dp数组

416. 分割等和子集

题解: 动态规划

思路

代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int target = 0;
        for (auto i : nums) {
            target += i;
        }
        //不能将数据分为俩半,说明无法找到使得两个子集的元素和相等。
        if (target % 2 == 1) return false;
        target/=2;
        //确定dp数组涵义
        int dp[2*target];
        //初始化dp数组
        memset(dp,0,sizeof dp);
        //dp数组遍历
        for (int i = 1; i < nums.size(); i++) {
            for (int j = target; j >= nums[i]; j--) {
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        //判断返回值
        if ( dp[target] == target) return true;
        else return false;
    }
};

1049.最后一块石头的重量II

题目: 动态规划

核心代码

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

for (int i = 0; i < stones.size(); i++) { // 遍历物品
    for (int j = target; j >= stones[i]; j--) { // 遍历背包
        dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
    }
}

• 推导递推公式

最后dp[target]里是容量为target的背包所能背的最大重量。

那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。

在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。

那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = 0;
        sort(stones.begin(),stones.end());
        vector<int>dp(15001,0);
        for (auto& x : stones) {
            sum += x;
        } 
        int ans = sum;
        sum /= 2;
        for (int i = 0; i < stones.size(); i++) {
            for (int j = sum;j >= stones[i]; j--) {
                dp[j] = max(dp[j],dp[j - stones[i]] + stones[i]);
            }
        }
        return ans - dp[sum] - dp[sum];
    }
};

---

学习产出：

• 技术笔记 2 遍
• CSDN 技术博客 3 篇
• 习的 vlog 视频 1 个