代码随想录第三十六天| 1049.最后一块石头的重量II 494.目标和 474.一和零-优快云博客

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

题目描述

有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。粉碎的结果如下：

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

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

力扣题目链接：最后一块石头的重量 II

解题思路

这个问题可以通过转化为背包问题来解决。目标是找到一个子集，使得这个子集的重量尽可能接近所有石头总重量的一半。这样，在粉碎过程中，可以使得最后剩下的石头重量最小。

计算石头总重量：首先计算所有石头的总重量。
确定目标和：如果总重量是奇数，目标和为 (sum-1)/2；如果是偶数，目标和为 sum/2。
初始化动态规划数组：创建一个动态规划数组 dp，其中 dp[j] 表示背包容量为 j 时，能够装入的最大价值。
动态规划填表：遍历每个石头，并更新动态规划数组。对于每个石头 stones[i]，从目标值 target 开始向下遍历到 stones[i]，更新 dp[j] 为 max(dp[j], dp[j-stones[i]] + stones[i])。
计算结果：最后返回总重量减去两倍的目标和，即 sum - 2*dp[target]，这表示最后一块石头的最小可能重量。

以下是实现该解法的代码：

class Solution {
    public int lastStoneWeightII(int[] stones) {
		int target = 0;
		int sum = 0;
		for(int i=0;i<stones.length;i++){
			sum = sum + stones[i];
		}
		if(sum % 2 != 0){
			target = (sum-1)/2;
		}else{
			target = sum/2;
		};
		int[] dp = new int[target+1];

		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 - 2*dp[target];

    }
}

494. 目标和

题目描述

力扣题目链接：目标和

难度：中等

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 - 中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

解题思路

求和与判断：首先计算数组所有元素的和 sum，如果 sum 小于 target 的绝对值，或者 (sum + target) 不是偶数，则直接返回 0，因为不可能通过加减操作得到目标数 S。
转换问题：将问题转换为寻找一个子集，使得子集中元素的和为 (sum + target) / 2。这是因为假设 P 是加号集合，N 是减号集合，则有 sum(P) - sum(N) = target，即 sum(P) = (sum + target) / 2。
动态规划：使用动态规划求解子集和问题。定义 dp[j] 为填满容量为 j 的背包有 dp[j] 种方法。初始化 dp[0] = 1，因为有一种方法什么都不装。对于每个数字 nums[i]，更新 dp 数组，对于每个容量 j 从 target 到 nums[i]，dp[j] 应该加上 dp[j - nums[i]]。
返回结果：最终 dp[target] 即为所求的方法数。

代码实现

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

474. 一和零

题目描述

力扣题目链接：一和零

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

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

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

解题思路

动态规划定义：定义 dp[i][j] 为最多有 i 个 0 和 j 个 1 的情况下，能够组成的最大子集的大小。
初始化：dp 数组初始化为 0，因为至少可以组成一个大小为 0 的子集。
遍历字符串数组：对于每个字符串，计算其中 0 和 1 的数量。
更新动态规划数组：使用倒序遍历的方式更新 dp 数组，确保每个字符串只被使用一次。对于每个字符串，如果当前剩余的 0 和 1 的数量足够，则尝试将当前字符串加入子集，并更新 dp[i][j]。
返回结果：最终 dp[m][n] 即为所求的最大子集的大小。

代码实现

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        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];
    }
}