算法日记day 35（动归之分割等和子集|最后一块石头的重量2）

一、分割等和子集

题目：

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

示例 1：

输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：

输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

思路：

可以用0-1背包的思路去思考问题，首先对数组中所有元素的总和取半，对第一层循环遍历数组，第二层循环对加入的值比较，取一个放入或者是不放入之间的最大值，每循环一次判断是否达到了对应取半的值，如果达到了，说明剩下的值与其相等，返回true

代码：

public boolean canPartition(int[] nums) {
    int n = nums.length;
    
    // 如果数组为空或长度为0，无法分割为两个相等的子集
    if (nums == null || nums.length == 0)
        return false;
    
    // 计算数组元素的总和
    int sum = 0;
    for (int i : nums) {
        sum += i;
    }
    
    // 如果总和为奇数，则无法分割为两个相等的子集
    if (sum % 2 == 1)
        return false;
    
    // 计算每个子集的目标和（总和的一半）
    int target = sum / 2;
    
    // 创建动态规划数组，dp[j] 表示是否可以达到和 j
    int[] dp = new int[target + 1];
    
    // 遍历每个数组元素
    for (int i = 0; i < n; i++) {
        // 从目标和开始，倒序遍历，以避免使用当前元素多次
        for (int j = target; j >= nums[i]; j--) {
            // 更新 dp[j]，如果可以通过当前元素 nums[i] 达到和 j
            dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
        }
        // 如果已经可以达到目标和，直接返回 true
        if (dp[target] == target)
            return true;
    }
    
    // 返回 dp[target] 是否等于目标和，来确定是否可以分割成两个相等的子集
    return dp[target] == target;
}

1. 基本检查：

   • 确保数组 nums 不为空且长度大于 0。

2. 总和计算：

   • 计算数组 nums 的总和 sum。

3. 奇数检查：

   • 如果总和是奇数，无法将其分割成两个相等的子集，直接返回 false。

4. 目标值设定：

   • 计算目标值 target，即总和的一半。

5. 动态规划数组初始化：

   • 使用 dp 数组，其中 dp[j] 表示是否可以用数组中的元素组成和为 j 的子集。

6. 动态规划更新：

   • 遍历数组中的每个元素，从 target 向下更新 dp 数组。
   • 对于每个元素 nums[i]，更新 dp[j]，表示是否可以达到和 j。

7. 检查目标和：

   • 如果在遍历过程中，dp[target] 达到目标和，则返回 true。

8. 最终结果：

   • 返回 dp[target] 是否等于目标和，决定是否可以分割数组成两个和相等的子集。

二、最后一块石头的重量2

题目：

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

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

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

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

示例 1：

输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

示例 2：

输入：stones = [31,26,33,21,40]
输出：5

思路：

 首先定义dp数组，这里的dp数组表示容量为 j 的背包可容的最大重量为dp[j]，与分割等和子集类似，也需要取数组总和的一半，这样才能保证取到的两部分石头相撞后的数值一定最小，这里明确总和为sum，取整数半为target，那么其最小剩余的重量就为 (sum-target)-target，递推表达式为

                                               dp[j] = max(dp[j]，dp[j-stone[i]]+stone[i])

代码：

public int lastStoneWeightII(int[] stones) {
    int n = stones.length;
    
    // 如果数组为空或长度为0，则返回0
    if (stones == null || stones.length == 0)
        return 0;
    
    // 计算所有石头的总重量
    int sum = 0;
    for (int i : stones) {
        sum += i;
    }
    
    // 目标是总重量的一半
    int target = sum / 2;
    
    // 创建动态规划数组 dp，dp[j] 表示能否通过选择一些石头获得重量 j
    int[] dp = new int[target + 1];
    
    // 遍历每个石头
    for (int i = 0; i < n; i++) {
        // 从目标重量向下遍历，以避免重复使用同一个石头
        for (int j = target; j >= stones[i]; j--) {
            // 更新 dp[j]，如果通过当前石头 stones[i] 能达到重量 j
            dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
        }
    }
    
    // 返回最终结果：总重量减去两倍的 dp[target]，即为最后剩余的石头重量
    return sum - dp[target] - dp[target];
}

1. 基础检查：

   • 确保数组 stones 不为空且长度大于 0。

2. 总和计算：

   • 计算所有石头的总重量 sum。

3. 目标值设定：

   • 目标值 target 是总重量的一半。

4. 动态规划数组初始化：

   • 使用 dp 数组，dp[j] 表示是否可以通过选择一些石头组成重量 j。

5. 动态规划更新：

   • 遍历每个石头 stones[i]，从目标值 target 向下更新 dp 数组，确保每个石头只被使用一次。

6. 结果计算：

   • 最终结果是 sum - dp[target] - dp[target]，其中 dp[target] 是最接近目标值的重量，两倍的 dp[target] 代表了通过选择这些石头可以达到的最大重量。剩余的就是最后剩余的石头重量。

今天的学习就到这里