代码随想录刷题day29

1、不同的二叉搜索树

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

感悟:通过举例推导,n=1,只有一颗二叉搜索树;n=2,有两颗;n=3,有5颗,且可以看出,是在n=2的前提上演变过来的。得出递归公式:dpi += dp以j为头结点左子树节点数量 * dp以j为头结点右子树节点数量,即:dpi += dpj - 1 * dpi - j;

java 复制代码
class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        //dp[1] = 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];
    }
}

2、分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。

感悟:典型的0-1背包问题,数组元素的和是固定的,所以背包容量是sum/2,看是否有能刚好装满背包的元素。0-1背包问题的递推公式:dpj = max(dpj, dpj - weight\[i] + valuei);当dptarget=target时,表示找到了能装满背包的元素。

注意:动态数组使用一维数组时,第二层循环需要倒序,不然可能会把某个元素放入多次;

java 复制代码
class Solution {
    public boolean canPartition(int[] nums) {
        int target = 0;
        for(int n :nums){
            target += n;
        }
        if(target % 2 >0) return false;
        int m = target/2;
        int[] dp = new int[m+1];
        for(int i=0;i<nums.length-1;i++){
            for(int j=m;j>0 && j>=nums[i];j--){
                dp[j] = Math.max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        return dp[m] == m;
    }
}

3、最后一块石头的重量II

有一堆石头,用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合,从中选出任意两块石头 ,然后将它们一起粉碎。假设石头的重量分别为 x 和 y,且 x <= y。那么粉碎的可能结果如下:

  • 如果 x == y,那么两块石头都会被完全粉碎;
  • 如果 x != y,那么重量为 x 的石头将会完全粉碎,而重量为 y 的石头新重量为 y-x。

最后,最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下,就返回 0。

感悟:和上题类似,当两块石头尽可能接近时,可以获得最小的重量。

java 复制代码
class Solution {
    public int lastStoneWeightII(int[] stones) {
        if(stones == null || stones.length == 0) return 0;
        int len = stones.length;
        int sum = 0;
        for(int n : stones){
            sum += n;
        }
        int m = sum/2;
        int[] dp = new int[m+1];
        for(int i=0;i<len;i++){
            for(int j=m;j>=stones[i];j--){
                dp[j] = Math.max(dp[j],dp[j-stones[i]]+stones[i]);
            }
        }
        return sum-2*dp[m];
    }
}

4、目标和

给你一个非负整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 '+' 或 '-' ,然后串联起所有整数,可以构造一个 表达式 :

  • 例如,nums = [2, 1] ,可以在 2 之前添加 '+' ,在 1 之前添加 '-' ,然后串联起来得到表达式 "+2-1" 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

感悟:整个数组分成left、right两部分,left+right=sum,left-right=target,所以left = (sum+target)/2,又转化为0-1背包问题了。用二维数组时,能更清晰的推导出转移方程。

归纳总结如下:

  • 不放物品i:即背包容量为j,里面不放物品i,装满有dpi - 1j中方法。

  • 放物品i: 即:先空出物品i的容量,背包容量为(j - 物品i容量),放满背包有 dpi - 1j - 物品i容量 种方法。

本题中,物品i的容量是numsi,价值也是numsi。

递推公式:dpij = dpi - 1j + dpi - 1j - nums\[i];

java 复制代码
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        int len = nums.length;
        for(int n : nums){
            sum += n;
        }
        if((sum+target)%2 == 1) return 0;
        if((sum+target) < 0) return 0;
        int left = (sum+target)/2;
        int[] dp = new int[left+1];
        dp[0] = 1;
        for(int i=0;i<len;i++){
            for(int j=left;j>=nums[i];j--){
                dp[j] += dp[j-nums[i]];
            }
        }
        return dp[left];
    }
}

5、一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度,该子集中 最多 有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素,集合 x 是集合 y 的 子集 。

感悟:本题稍有点特殊,背包有两个维度,0和1分别是一个维度。递推公式:dpij = max(dpij, dpi - zeroNumj - oneNum + 1);

java 复制代码
class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        if(strs.length == 0) return 0;
        int[][] dp = new int[m+1][n+1];
        for(String s:strs){
            int zeroNum = 0,oneNum = 0;
            for(char c:s.toCharArray()){
                if(c == '0'){
                    zeroNum++;
                }else{
                    oneNum++;
                }
            }
            for(int i=m;i>=zeroNum;i--){
                for(int j=n;j>=oneNum;j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i-zeroNum][j-oneNum]+1);
                }
            }
        }
        return dp[m][n];
    }
}

总结:0-1背包问题,当递推公式不好直接看出来时,可以先尝试使用二维数组去推理。

0-1背包的递推公式推理过程抽象化如下:

  • 不放物品i:背包容量为j,里面不放物品i的最大价值是dpi - 1j。

  • 放物品i:背包空出物品i的容量后,背包容量为j - weighti,dpi - 1j - weight\[i] 为背包容量为j - weighti且不放物品i的最大价值,那么dpi - 1j - weight\[i] + valuei (物品i的价值),就是背包放物品i得到的最大价值

递归公式: dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

相关推荐
青少儿编程课堂6 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:中国剩余定理解析
c++·python·算法·bfs·信息学竞赛
罗西的思考18 小时前
【轻量化复刻大模型 / KIMI K3】Muon 优化器及 训练系统
人工智能·算法·机器学习
ashiho19 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
数据工匠老o20 小时前
数据库没死,业务卡住了:行锁等待、元数据锁、长事务的排查路径
数据库·算法·架构
黑客笔记20 小时前
安全态势感知中的资产失陷排名思考
人工智能·算法·网络安全
青少儿编程课堂1 天前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:扫描线与线段树求矩形面积并解析
c++·python·算法·bfs·信息学竞赛
电科_银尘1 天前
【大模型算法与工程 09】SGD、Momentum与AdamW:优化器如何选择
人工智能·算法
货拉拉技术1 天前
视觉底座:货拉拉OCR的进阶之路
算法
__underline__1 天前
冷门Python知识点005篇:list.sort( )的排序稳定性,是用0字节额外内存实现的
python·算法