最后一块石头的重量II
1049. 最后一块石头的重量 II - 力扣(LeetCode)
考虑昨天的能否将一个数组分为两个和相等的子集,本题有类似的思路,即将左右分为左右两个和相近的子集,然后返回其差值,这里使用动态规划的话。
DP数组含义,dp[j]表示能够达到的总重量为j的石头的最大重量
背包容量从0到1501(根据题目要求变化)
dp[j] = max(dp[j], dp[j-nums[i]] + nums[i]),j为重量,i为石头的选择与否。
遍历顺序同样物品遍历在外,背包遍历在内层,且内层倒序遍历。
最后考虑对最后一块石头重量的返回。考虑到dp[j]为其中一个子集所能抵达的最大重量,则另外一个子集的重量为总重量减去子集1的重量,要得到最后一块石头的重量,为两个子集和的相减值,最后的结果可以表示为sum -= 2*dp[j]。
cpp
class Solution {
public:
int lastStoneWeightII(vector<int>& stones) {
// 创建一个长度为1501,全0的数组dp,用于动态规划
// dp[j]表示能够达到的总重量为j的石头的最大重量
vector<int> dp(1501, 0);
int sum = 0;
// 计算stones数组中所有石头的总重量
for (auto x : stones) {
sum += x;
}
// 计算目标和,即分割后两堆石头的总重量应该接近sum/2
const int target = sum / 2;
for (int i = 0; i < stones.size(); i++) {
// 从大到小遍历目标和及其以下的值
for (int j = target; j >= stones[i]; j--) {
// 更新dp[j],选取当前石头和不选取当前石头,取两种情况的最大值
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
// 最终结果为sum - dp[target]的两倍,因为dp[target]是接近sum/2的最大重量
// 所以sum - dp[target]是另一堆石头的重量,两堆石头碰撞后剩下的最小重量就是它们的差
return sum - 2 * dp[target];
}
};
算法的时间复杂度为O(n^2),空间复杂度为O(n)。
目标和
动态规划之背包问题,装满背包有多少种方法?| LeetCode:494.目标和_哔哩哔哩_bilibili
得到目标和,需要在数字前面添加加号和减号,即存在两个数组我们假定为left数组和right数组,left数组中元素前全为加号,right数组中元素前全为减号。目标和为target,元素的所有和为sum。
sum_left + sum_right = target;
sum_left - sum_right = sum;
sum_left = (target + sum)/2,即我们能够得到left数组的和为target和元素和sum的一半。
使用动态规划算法来解决这个问题。
此时的dp[j]表示的是要装满容量为j的背包共有dp[j]种方式。
dp[j]:装满容量为j的背包有dp[j]种方式。
dp[j]的推导公式,这里需要牢记 dp[j]表示的是装满容量为j的背包的所有方式数量,所以dp[j]与dp[j-nums[j]]相关。即总容量为5,我们有一个质量为1的物品,则应该有dp[4]种方法能够得到5(1+4 = 5),若我们有一个质量为2的物品,应该有dp[3]种方法能够得到5(2+3 = 5 考虑之前的爬楼梯的题目),依次向下推,则dp[5] = dp[4] + dp[3] + dp[2] + dp[1] + dp[0]。
dp[j] += dp[j-nums[i]],此处为累加
dp[0]本应为0,但这里若初始为0,则所有dp均为0,所以初始化为1,非0下标初始化为0。
遍历顺序物品遍历在外,背包遍历在内层,且内层倒序遍历。
cpp
class Solution {
public:
int findTargetSumWays(vector<int>& nums, int target) {
int sum = 0;
// 计算数组nums中所有数字的和
for (auto x : nums) {
sum += x;
}
// 如果(target + sum)是奇数,那么不可能通过添加+或-得到target,因为每添加一个-,总和就会减少两倍
if ((target + sum) % 2 == 1) {
return 0;
}
// 如果target的绝对值大于sum,那么也不可能得到target,leetcode有反例[100] target -200
if (abs(target) > sum) {
return 0;
}
// 计算我们需要的正数总和left
const int left = (sum + target) / 2;
// 初始化动态规划数组dp,大小为left+1,初值都为0,dp[j]表示总和为j的方法数
vector<int> dp(left + 1, 0);
// 总和为0的方法只有1种,即不选择任何数字
dp[0] = 1;
// 遍历数组nums中的每个数字
for (int i = 0; i < nums.size(); i++) {
// 从大到小遍历left及其以下的值
for (int j = left; j >= nums[i]; j--) {
// 更新dp[j],考虑选择当前数字和不选择当前数字的情况
dp[j] += dp[j - nums[i]];
}
}
// 返回总和为left的方法数,即dp[left]
return dp[left];
}
};
算法的时间复杂度为O(n^2),空间复杂度为O(n)。
一和零
本题还是一个01背包问题,虽然有两个维度。具体参考如下网站
动态规划之背包问题,装满这个背包最多用多少个物品?| LeetCode:474.一和零_哔哩哔哩_bilibili
我们需要装满m个0,n个1的背包,共2个维度,需要一个二维的dp数组,背包中最多有多少个物品,dp[i][j]即表示最多背的物品个数,即最后返回值为dp[m][n]。
dp[i][j] = max(dp[i][j-1],dp[i][j]) x和y分别表示物品i中有x个0,y个1,此处max中的dp[i][j]参考之前背包问题的滚动数组,做了压缩。
对dp数组进行初始化,dp[0][0] = 0,其余值也全赋值为0。同样参考之前背包问题的滚动数组,dp[i][j]的值在每次遍历过程中会被覆盖。
遍历顺序,先遍历物品,再遍历背包,且背包要倒序遍历。
cpp
class Solution {
public:
int findMaxForm(vector<string>& strs, int m, int n) {
// 初始化动态规划数组dp,大小为(m+1) x (n+1),初值都为0
// dp[i][j]表示最多能组成多少个只包含0和1的字符串,且0的数量不超过i,1的数量不超过j
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
// 遍历数组strs中的每个字符串
for (string str : strs) {
int zero_count = 0; // 记录当前字符串中0的数量
int one_count = 0; // 记录当前字符串中1的数量
// 遍历当前字符串中的每个字符
for (auto c : str) {
if (c == '0') {
zero_count++;
} else {
one_count++;
}
}
// 从大到小遍历m和n,更新dp数组
for (int i = m; i >= zero_count; i--) {
for (int j = n; j >= one_count; j--) {
// 更新dp[i][j],考虑选择当前字符串和不选择当前字符串的情况
dp[i][j] = max(dp[i - zero_count][j - one_count] + 1, dp[i][j]);
}
}
}
// 返回最多能组成只包含0和1的字符串的数量,即dp[m][n]
return dp[m][n];
}
};
算法的时间复杂度为O(m*n*k),k为strs的长度,外层遍历str数组中的每个字符串,共有strs.size()次迭代,k为strs数组的总长度,为strs.size()*每个数组中元素的平均长度L。
空间复杂度考虑需要维护一个二维dp数组,为O(m*n)。