代码随想录算法训练营第四十二天| 494. 目标和、474. 一和零、52. 携带研究材料（第七期模拟笔试）、518. 零钱兑换 II

最新推荐文章于 2024-07-14 19:56:17 发布

dreamtang

最新推荐文章于 2024-07-14 19:56:17 发布

阅读量653

点赞数 27

文章标签：算法

本文链接：https://blog.csdn.net/dreamtang/article/details/139738439

版权

[LeetCode] 494. 目标和
 [LeetCode] 494. 目标和文章解释

[LeetCode] 494. 目标和视频解释

题目：

给你一个非负整数数组 nums 和一个整数 target 。

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

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

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

示例 1：
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：
输入：nums = [1], target = 1
输出：1
提示：

1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

[LeetCode] 494. 目标和

自己看到题目的第一想法

不会～那么多加减号，怎么和动态规划联系起来的！

看完代码随想录之后的想法

这都不会？

首先假设存在两组数，一组没有做任何修改，一组全部变成负数，这两组数的和为 x 和 -y，假设存在这样两组数使得 x - y = target, 则存在隐含关系 x + y = sum

因此 x - y + x + y = target + sum, 因此 x = (target + sum)/2，这里 x 一定是整数，所以 target + sum 一定要是偶数，同时 target 如果为负数的话，绝对值必须小于 sum.

// 一维数组版本
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        // 因为 sum 一定为正数, 如果 target + sum 小于 0， 说明 nums 所有数字取反后求和都无法等于 target
        if (target + sum < 0) {
            return 0;
        }
        sum += target;
        if (sum % 2 == 1) {
            return 0;
        }
        target = sum/2;
        // dp[i] 表示使用下标为 0～i 的数字，和为 i 的组合个数
        int[] dp = new int[target + 1];
        // 递推公式：dp[j] = dp[j] + dp[j - nums[i]];
        // 初始化
        dp[0] = 1;// 用下标为 0 的数字， 和为 0 的组合个数为1， 即空组合 []
        // 遍历顺序：
        for (int i = 0; i < nums.length; i++) {
            for (int j = target; j >= nums[i]; j--) {
                dp[j] = dp[j] + dp[j - nums[i]];
            }
        }
        // 模拟 dp：无
        return dp[target];
    }
}

// 二维数组版本
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        // 因为 sum 一定为正数, 如果 target + sum 小于 0， 说明 nums 所有数字取反后求和都无法等于 target
        if (target + sum < 0) {
            return 0;
        }
        sum += target;
        if (sum % 2 == 1) {
            return 0;
        }
        target = sum/2;
        // dp[i][j] 表示使用下标为 0～i 的数字，和为 j 的组合个数
        int[][] dp = new int[nums.length][target + 1];
        // 递推公式：dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
        // 初始化: 用下标为 0 的数字，组成和为 0 的组合的个数为1， 即空组合 []
        //     初始化第一行，nums[0] 如果小于等于 target， 则 dp[0][nums[0]] = 1
        //     同时 dp[0][0]++， 因为空组合也算
        //     初始化真的很重要，感觉是决定动态规划的核心思考之一

        // 这里很重要，如果 nums[0] = 0 的话， dp[0][0] 需要赋值为1， 同时 dp[0][0] 位置空组合也算一个, 因此要再加 1
        // 活着换一个思考， dp[0][0] 永远赋值为 1， dp[0][nums[0]] = dp[0]
        if (nums[0] <= target) {
            dp[0][nums[0]] = 1;
        }
        dp[0][0]++;
        // 遍历顺序：
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j <= target; j++) {
                if (nums[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
                }
            }
        }
        // 模拟 dp：无
        return dp[nums.length - 1][target];
    }
}

自己实现过程中遇到哪些困难

那是真的有点多了。。。二维数组更根本想不出来哪里出问题了。后来发现是初始化的问题，但是初始化的逻辑还挺绕的。

初始化感觉是个大学问，但是确实不是太容易想明白。但是要知道，动态规划的起点都是从初始化开始的，初始化不对，后面的逻辑都无法自洽的！

[LeetCode] 474. 一和零
 [LeetCode] 474. 一和零文章解释

[LeetCode] 474. 一和零视频解释

题目：

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

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

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

示例 1：
输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
示例 2：
输入：strs = ["10", "0", "1"], m = 1, n = 1
输出：2
解释：最大的子集是 {"0", "1"} ，所以答案是 2 。
提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 '0' 和 '1' 组成
1 <= m, n <= 100

[LeetCode] 474. 一和零

自己看到题目的第一想法

[m][n] 要看成背包里的容量。

套用公式！

但是确实想不明白。

看完代码随想录之后的想法

[m][n] 作为容量，因为是01背包问题，在遍历物品的循环中，对容量从后往前遍历即可。这句话现在说着轻松，两天后看一定又是一头雾水。

// 三维数组版本: 效率很低
class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][][] dp = new int[strs.length][m + 1][n + 1];
        int zeroCount = 0;
        int oneCount = 0;
        for (int i = 0; i < strs[0].length(); i++) {
            if (strs[0].charAt(i) == '0') {
                zeroCount++;
            } else {
                oneCount++;
            }
        }
        for (int i = zeroCount; i <= m; i++) {
            for (int j = oneCount; j <= n; j++) {
                dp[0][i][j] = 1;
            }
        }
        for (int i = 1; i < strs.length; i++) {
            zeroCount = 0;
            oneCount = 0;
            for (int charIndex = 0; charIndex < strs[i].length(); charIndex ++) {
                if (strs[i].charAt(charIndex) == '0') {
                    zeroCount++;
                } else {
                    oneCount++;
                }
            }

            // 这里 j 和 k 表示的是字符的容量
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n; k++) {
                    if (j < zeroCount || k < oneCount) {
                        dp[i][j][k] = dp[i - 1][j][k];
                        continue;
                    }
                    // 因为要求的是能放的最大字符串个数
                    // 因此这里要对比一下， 不把自己放进去以及把自己放进去后，哪个组合里的字符串个数更大 
                    dp[i][j][k] = Math.max(dp[i - 1][j][k], dp[i - 1][j - zeroCount][k - oneCount] + 1);
                }
            }
        }
        return dp[dp.length - 1][m][n];
    }
}

// 二维数组版本
// 效率高很多，毕竟少操作了非常多 二维数组！！！
class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        int zeroCount = 0;
        int oneCount = 0;
        for (String str : strs) {

            zeroCount = 0;
            oneCount = 0;

            for (int i = 0; i < str.length(); i++) {
                if (str.charAt(i) == '0') {
                    zeroCount++;
                } else {
                    oneCount++;
                }
            }

            for (int i = m; i >= zeroCount; i--) {
                for (int j = n; j >= oneCount; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroCount][j - oneCount] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

自己实现过程中遇到哪些困难

那可真是多到说不清楚了。这两天难度确实挺高的，脑子有点迷糊了。

[KamaCoder] 52. 携带研究材料（第七期模拟笔试）

[KamaCoder] 52. 携带研究材料（第七期模拟笔试）文章解释

[KamaCoder] 52. 携带研究材料（第七期模拟笔试）

自己看到题目的第一想法

无。

看完代码随想录之后的想法

和01背包几乎相同，只是遍历顺序不同。

但是！！！二维数组实现的时候，初始化以及递增方式都发生了变化！

// 二维数组版本
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Integer materialCount = null;
        Integer packageCapacity = null;
        int[] weights = null;
        int[] values = null;
        int count = 0;
        while (scanner.hasNext()) {
            if (materialCount == null) {
                String materialCountStr = scanner.nextLine();
                String[] materialCounts = materialCountStr.split(" ");
                materialCount = Integer.parseInt(materialCounts[0]);
                packageCapacity = Integer.parseInt(materialCounts[1]);
            } else {
                if (weights == null) {
                    weights = new int[materialCount];
                    values = new int[materialCount];
                }
                String weightAndValueStr = scanner.nextLine();
                String[] weightAndValues = weightAndValueStr.split(" ");
                weights[count] = Integer.parseInt(weightAndValues[0]);
                values[count++] = Integer.parseInt(weightAndValues[1]);
            }
        }

        int[][] dp = new int[materialCount][packageCapacity + 1];
        // 初始化
        for (int i = weights[0]; i <= packageCapacity; i++) {
            dp[0][i] = dp[0][i - weights[0]] + values[0];
        }
        for (int i = 1; i < weights.length; i++) {
            for (int j = 0; j <= packageCapacity; j++) {
                if (weights[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                    continue;
                }
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - weights[i]] + values[i]);
            }
        }
        System.out.println(dp[dp.length - 1][packageCapacity]);
    }
}

// 一维数组版本
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Integer materialCount = null;
        Integer packageCapacity = null;
        int[] weights = null;
        int[] values = null;
        int count = 0;
        while (scanner.hasNext()) {
            if (materialCount == null) {
                String materialCountStr = scanner.nextLine();
                String[] materialCounts = materialCountStr.split(" ");
                materialCount = Integer.parseInt(materialCounts[0]);
                packageCapacity = Integer.parseInt(materialCounts[1]);
            } else {
                if (weights == null) {
                    weights = new int[materialCount];
                    values = new int[materialCount];
                }
                String weightAndValueStr = scanner.nextLine();
                String[] weightAndValues = weightAndValueStr.split(" ");
                weights[count] = Integer.parseInt(weightAndValues[0]);
                values[count++] = Integer.parseInt(weightAndValues[1]);
            }
        }

        int[] dp = new int[packageCapacity + 1];
        // 初始化
        for (int i = 0; i < weights.length; i++) {
            for (int j = weights[i]; j <= packageCapacity; j++) {
                dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
            }
        }
        System.out.println(dp[packageCapacity]);
    }
}

自己实现过程中遇到哪些困难

无

[LeetCode] 518. 零钱兑换 II
[LeetCode] 518. 零钱兑换 II 文章解释

[LeetCode] 518. 零钱兑换 II 视频解释

[LeetCode] 518. 零钱兑换 II

自己看到题目的第一想法

无

看完代码随想录之后的想法

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];// 背包容量为 amount 的全面背包问题
        dp[0] = 1;
        for (int i = 0; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] = dp[j] + dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
}

class Solution {
    public int change(int amount, int[] coins) {
        int[][] dp = new int[coins.length][amount + 1];// 背包容量为 amount 的全面背包问题
        dp[0][0] = 1;
        for (int i = coins[0]; i <= amount; i++) {
            dp[0][i] = dp[0][i - coins[0]];
        }
        for (int i = 1; i < coins.length; i++) {
            for (int j = 0; j <= amount; j++) {
                if (coins[i] > j) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i]];
                }
            }
        }
        return dp[coins.length - 1][amount];
    }
}

自己实现过程中遇到哪些困难

啊这初始化真是不好搞。。。按字面意思很难确定，最终还是要回归到算数逻辑的本质上来。。。背包问题通过 dp 定义来推导递归公式，对于初始化有一定的误导性，自己需要意识到这一点。但是 dp 的定义依旧很重要，只是在初始化时要回归到算数的本质上来。

dreamtang

关注

27
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第四十二天| 494. 目标和、474. 一和零、52. 携带研究材料（第七期模拟笔试）、518. 零钱兑换 II

给你一个非负整数数组nums和一个整数target。向数组中的每个整数前添加'+'或'-'，然后串联起所有整数，可以构造一个2'+'1'-'"+2-1"返回可以通过上述方法构造的、运算结果等于target的不同的数目。5一共有 5 种方法让最终目标和为 3。1。
复制链接

扫一扫