代码随想录算法训练营第36天 | LeetCode1049.最后一块石头的重量II、LeetCode494.目标和、LeetCode474.一和零-CSDN博客

本文链接：https://blog.csdn.net/m0_68237332/article/details/141884199

LeetCode494.目标和

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

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

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

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

思路：本题可以转换为在给定背包容量的情况下，找到将背包容量填充满的方案有多少。

那么如何转换呢？

首先我们假设将元素分为了两个子集，一个left,一个right，那么不管符号加在哪里，left+right=sum(sum为nums数组元素总和)，这是始终成立的；现在我们假设在right上加上了负号，那么就有left-right=target，于是两个式子联立求解，有left=(sum+target)/2，sum可以求，是固定值，target也是固定值，题目中给定，所以相当于就将left的值给固定下来了，也就是left的值就为固定的背包容量了。

于是现在题目就转换成了背包容量固定，我们想要将其填满，因为填满就相当于有了一种方案（注意这里同样将nums[i]的大小当作了所占空间大小以及所拥有的价值），所以现在问题就明晰起来了。

我们创建dp[i][j]二维数组，表示在0到i个物品中，容量为j时将其装满的方案数，那么递归方程如何求呢，可以画个图，使用力扣中的测试用例，填充dp数组，可以比如nums[1,1,1,1,1]，target=3，以求dp[2][2]为例，当容量为2的时候，如果没有装第2个物品，那么它的方案数就等于从0到1的物品，容量为2是的方案数，即dp[1][2]的方案数；当容量为2，装了第2个物品，那么就等于0到1的物品，容量为j-nums[2]时的方案数，因为这时空出来放入nums[2]大小的空间。能够将第2个物品放入。

于是乎，dp[2][2]=dp[1][2]+dp[1][1]，所以抽象出来，递推公式为dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i]]，但是要注意这里是在j>=nums[i]时才能这样更新，如果是小于的话，那么就直接dp[i][j]=dp[i-1][j]。

初始赋值的话对于dp[0][j]的元素，只有当j=nums[0]时，赋值为1，因为其他大小要么装不满，要么装不下，所以赋值为1即可。对于dp[i][0]的元素，也就是容量为0，一般来说就是不放物品，这也算一种方案数，所以统一赋值为1，但是因为题目中说nums[i]>=0，也就是可能为0，所以需要记录下0的个数，相应的元素赋值也成了求这些0元素的子集数量，所以从这个角度看，不放任何物品时，相当于就是一个空集，这样也合理。

    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;//求总和
        for(int i = 0; i < nums.size(); i ++) sum += nums[i];
        //这里的(sum+target)/2是这样推导而来的，首先假设nums中的元素分为两个子集
        //left为左边子集的和,right为右边子集的和,那么可以知道left+right=sum，并且可以有left-right=target
        //那么两式合并，即可得到左边子集left=(sum+target)/2
        if((sum + target) % 2 == 1) return 0;//这里sum+target为奇数，无法找到和为其一半的子集和，直接返回0
        if(abs(target) > sum) return 0;

        int N = (sum + target) / 2;
        vector<vector<int>> dp(nums.size(), vector<int>(N + 1, 0));//dp[i][j]表示0到i个物品中，将j个空间容量填满的方案数目
        if(N >= nums[0]) dp[0][nums[0]] = 1;//初始化，能够将第一个物品填满的只能是容量为nums[0]空间大下的容量，其他的要么填不满，要么就是填不下
        int count_zero = 0;
        for(int i = 0; i < nums.size(); i ++){
            if(nums[i] == 0) count_zero ++;
            dp[i][0] = (int)pow(2, count_zero);//这里其实就是在对最左边的一列进行初始化
            //因为背包容量为0，所以方案数初始化均可都为1，因为不放任何物品也是一种方法，
            //但是因为nums[i]可以为0，所以需要统计0元素的数量，而这个位置的初始化就有了所有0元素在一起组成集合的子集数量
            //子集数量有多少，那么就代表这里能够有多少种放入的情况，所以这里的不放任何物品可以看成是子集中的空集，这样就便于理解了
        }

        for(int i = 1; i < nums.size(); i ++){
            for(int j = 0; j < N + 1; j ++){
                //这里依然将nums[i]的值作为物品所占容量大小以及价值大小
                if(j < nums[i]) dp[i][j] = dp[i - 1][j];//当容量不够时，就等于不加i这个物品时，从0到i-1物品容量为j时的方案数
                else dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];//容量足够时就需要将前面0到i-1物品，容量为时的方案数加上0到i个物品并且留出i物品空间时的方案数
            }
        }
        return dp[nums.size() - 1][N];
    }

时间复杂度：O(m*n)

空间复杂度：O(m*n)

当然也可以使用一维滚动数组来优化一下空间复杂度，注意这里的两层for循环中的遍历顺序，不能弄反，否则会出错。

    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;//求总和
        for(int i = 0; i < nums.size(); i ++) sum += nums[i];
        if((sum + target) % 2 == 1) return 0;
        if(abs(target) > sum) return 0;

        int N = (sum + target) / 2;
        vector<int> dp(N + 1, 0);//dp[j]表示将j个空间容量填满的方案数目
        dp[0] = 1;//初始化，容量为0时的方案就是不放任何物品，方案数为1

        for(int i = 0; i < nums.size(); i ++){
            for(int j = N; j >= nums[i]; j --){
                dp[j] = dp[j] + dp[j - nums[i]];
                //可以简写成dp[j] += dp[j - nums[i]]
            }
        }
        return dp[N];
    }

时间复杂度：O(m*n)

空间复杂度：O(m)

LeetCode474.一和零

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

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

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

思路：这里可以转化为给定背包容量，然后求最多能够装入多少的物品数量。

但是这里的背包容量是二维的，所以有dp[i][j]表示最多为i个0，j个1的条件下，最大的子集数量。

我们这里是采用的背包的一维滚动数组的形式（只不过背包容量为二维，所以需要维护二维的数组），那么如何更新数组呢，dp[i][j]可以使用前面的已经遍历过的字符串的结果进行更新，也就是说，dp[i][j]=dp[i-count_zero][j-count_one]+1，这里是说dp[i][j]的数量就等于目前i个0减去当前字符串的0的个数、目前j个1减去当前字符串的1的个数的情况下的最大子集数量，加上把当前这个字符串加入其中的数量，所以这里有个加1。

当然了，dp[i][j]如果本身比dp[i-count_zero][j-count_one]+1大，那就取dp[i][j]，所以递推公式就是dp[i][j]=max(dp[i][j],dp[i-count_zero][j-count_one]+1)。

初始赋值直接赋值为0即可，不会出现初始值将已有价值覆盖的情况。

同时这里还是需要强调大的两层for循环的顺序（实际本题有三层循环，第二层和第三层循环可以交换位置，相当于一个整体，进行背包容量的遍历），首先是遍历物品，然后是遍历容量，同时在遍历容量的时候一定是倒序的。

    int findMaxForm(vector<string>& strs, int m, int n) {
        //这里需要记录两个维度的背包容量，一个是装0字符的，一个是装1字符的
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));//dp[i][j]表示最多i个0、j个1的条件下最大的子集个数
        for(int i = 0; i < strs.size(); i ++){
            int count_zero = 0;//记录元素中0字符的数量
            int count_one = 0;//记录元素中1字符的数量
            for(char ch: strs[i]){
                if(ch == '0') count_zero ++;
                else count_one ++;
            }
            for(int j = m; j >= count_zero; j --){
                for(int k = n; k >= count_one; k --){
                    dp[j][k] = max(dp[j][k], dp[j - count_zero][k - count_one] + 1);//这里的加1代表满足条件的子集个数加1
                }
            }
        }
        return dp[m][n];
    }