最后一块石头的重量II
1049. 最后一块石头的重量 II - 力扣（LeetCode）
考虑昨天的能否将一个数组分为两个和相等的子集，本题有类似的思路，即将左右分为左右两个和相近的子集，然后返回其差值，这里使用动态规划的话。
DP数组含义，dpj表示能够达到的总重量为j的石头的最大重量
背包容量从0到1501（根据题目要求变化）
dpj = max(dpj, dpj-nums\[i] + numsi)，j为重量，i为石头的选择与否。
遍历顺序同样物品遍历在外，背包遍历在内层，且内层倒序遍历。
最后考虑对最后一块石头重量的返回。考虑到dpj为其中一个子集所能抵达的最大重量，则另外一个子集的重量为总重量减去子集1的重量，要得到最后一块石头的重量，为两个子集和的相减值，最后的结果可以表示为sum -= 2*dpj。
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的一半。
使用动态规划算法来解决这个问题。
此时的dpj表示的是要装满容量为j的背包共有dpj种方式。
dpj：装满容量为j的背包有dpj种方式。
dpj的推导公式，这里需要牢记 dpj表示的是装满容量为j的背包的所有方式数量，所以dpj与dpj-nums\[j]相关。即总容量为5，我们有一个质量为1的物品，则应该有dp4种方法能够得到5（1+4 = 5），若我们有一个质量为2的物品，应该有dp3种方法能够得到5（2+3 = 5 考虑之前的爬楼梯的题目），依次向下推，则dp5 = dp4 + dp3 + dp2 + dp1 + dp0。
dpj += dpj-nums\[i]，此处为累加
dp0本应为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数组，背包中最多有多少个物品，dpij即表示最多背的物品个数，即最后返回值为dpmn。
dpij = max(dpij-1,dpij) x和y分别表示物品i中有x个0，y个1，此处max中的dpij参考之前背包问题的滚动数组，做了压缩。
对dp数组进行初始化，dp00 = 0，其余值也全赋值为0。同样参考之前背包问题的滚动数组，dpij的值在每次遍历过程中会被覆盖。
遍历顺序，先遍历物品，再遍历背包，且背包要倒序遍历。
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)。