代码随想录算法训练营_day36

最新推荐文章于 2024-10-25 13:33:57 发布

kennyS_ss

最新推荐文章于 2024-10-25 13:33:57 发布

阅读量1k

点赞数 10

分类专栏：代码随想录算法训练营文章标签：算法

本文链接：https://blog.csdn.net/qq_43745961/article/details/141890625

版权

代码随想录算法训练营专栏收录该内容

33 篇文章 0 订阅

订阅专栏

题目信息 1049. 最后一块石头的重量 II

题目链接: https://leetcode.cn/problems/last-stone-weight-ii/description/
题目描述:
有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

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

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

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

解题思路

如果对背包问题不都熟悉先看这两篇：

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成01背包问题了。

是不是感觉和昨天讲解的416. 分割等和子集 (opens new window)非常像了。

本题物品的重量为stones[i]，物品的价值也为stones[i]。

对应着01背包里的物品重量weight[i]和物品价值value[i]。

接下来进行动规五步曲：

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

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]。

可以回忆一下01背包中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。

相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”

确定递推公式

01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

一些同学可能看到这dp[j - stones[i]] + stones[i]中又有- stones[i] 又有+stones[i]，看着有点晕乎。

大家可以再去看 dp[j]的含义。

dp数组如何初始化

既然 dp[j]中的j表示容量，那么最大容量（重量）是多少呢，就是所有石头的重量和。

因为提示中给出1 <= stones.length <= 30，1 <= stones[i] <= 1000，所以最大重量就是30 * 1000 。

而我们要求的target其实只是最大重量的一半，所以dp数组开到15000大小就可以了。

当然也可以把石头遍历一遍，计算出石头总重量然后除2，得到dp数组的大小。

我这里就直接用15000了。

接下来就是如何初始化dp[j]呢，因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会初始值所覆盖。

代码为：

vector<int> dp(15001, 0);

确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中就已经说明：如果使用一维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数组

举例，输入：[2,4,1,1]，此时target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：

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

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

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

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

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

代码实现

public int lastStoneWeightII(int[] stones){  
    if (stones == null || stones.length == 0){  
        return 0;  
    }  
    int sum = 0;  
    int target = 0;  
    for (int stone : stones){  
        sum += stone;  
    }  
    target = sum / 2;  
    int[] dp = new int[1501];  
    for (int i = 0;i < stones.length;i++){  
        for (int j = target;j >= stones[i];j--){  
            dp[j] = Math.max(dp[j],dp[j - stones[i]] + stones[i]);  
        }  
    }  
    return sum - dp[target] - dp[target];  
}

题目信息 494. 目标和

题目链接: https://leetcode.cn/problems/target-sum/description/
题目描述:
给你一个非负整数数组 nums 和一个整数 target 。

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

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

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

解题思路

动态规划（一维dp数组）

将二维dp数组压缩成一维dp数组，我们在 01背包理论基础（滚动数组） (opens new window)讲过滚动数组，原理是一样的，即重复利用每一行的数值。

既然是重复利用每一行，就是将二维数组压缩成一行。

dp[i][j] 去掉行的维度，即 dp[j]，表示：填满j（包括j）这么大容积的包，有dp[j]种方法。

确定递推公式

二维DP数组递推公式： dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];

去掉维度i 之后，递推公式：dp[j] = dp[j] + dp[j - nums[i]] ，即：dp[j] += dp[j - nums[i]]

这个公式在后面在讲解背包解决排列组合问题的时候还会用到！

dp数组如何初始化

在上面二维dp数组中，我们讲解过 dp[0][0] 初始为1，这里dp[0] 同样初始为1 ,即装满背包为0的方法有一种，放0件物品。

确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中，我们系统讲过对于01背包问题一维dp的遍历。

遍历物品放在外循环，遍历背包在内循环，且内循环倒序（为了保证物品只使用一次）。

举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], target: 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

dp数组状态变化如下：

代码实现

public int findTargetSumWays(int[] nums, int target) {  
    int sum = 0;  
  
    if (Math.abs(target) > sum) return 0;  
    if ((target + sum) % 2 != 0) return 0;  
  
    int bagSize = (target + sum) / 2;  
    int[] dp = new int[bagSize + 1];  
    dp[0] = 1;  
  
    for (int i = 0;i < nums.length;i++){  
        for (int j = bagSize;j >= nums[i];j--){  
            dp[j] += dp[j - nums[i]];  
        }  
    }  
    return dp[bagSize];  
}

题目信息 474. 一和零

题目链接: https://leetcode.cn/problems/ones-and-zeroes/
题目描述:
给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

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

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

解题思路

其实本题并不是多重背包，再来看一下这个图，捋清几种背包的关系

416.分割等和子集1

多重背包是每个物品，数量不同的情况。

本题中strs 数组里的元素就是物品，每个物品都是一个！

而m 和 n相当于是一个背包，两个维度的背包。

理解成多重背包的同学主要是把m和n混淆为物品了，感觉这是不同数量的物品，所以以为是多重背包。

但本题其实是01背包问题！

只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

开始动规五部曲：

确定dp数组（dp table）以及下标的含义

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

确定递推公式

dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

然后我们在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。

dp数组如何初始化

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中已经讲解了，01背包的dp数组初始化为0就可以。

因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中，我们讲到了01背包为什么一定是外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

那么本题也是，物品就是strs里的字符串，背包容量就是题目描述中的m和n。

代码如下：

for (string str : strs) { // 遍历物品
    int oneNum = 0, zeroNum = 0;
    for (char c : str) {
        if (c == '0') zeroNum++;
        else oneNum++;
    }
    for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
        for (int j = n; j >= oneNum; j--) {
            dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
        }
    }
}

有同学可能想，那个遍历背包容量的两层for循环先后循序有没有什么讲究？

没讲究，都是物品重量的一个维度，先遍历哪个都行！

举例推导dp数组

以输入：[“10”,“0001”,“111001”,“1”,“0”]，m = 3，n = 3为例

最后dp数组的状态如下所示：

474.一和零

代码实现

public int findMaxForm(String[] strs, int m, int n) {  
    //dp[i][j]表示i个0和j个1时的最大子集  
    int[][] dp = new int[m + 1][n + 1];  
    int oneNum, zeroNum;  
    for (String str : strs) {  
        oneNum = 0;  
        zeroNum = 0;  
        for (char ch : str.toCharArray()) {  
            if (ch == '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];  
}