day 43|● 1049. 最后一块石头的重量 II ● 494. 目标和 ● 474.一和零

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

有一堆石头，用整数数组 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

解：

//本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成0,1背包问题了。
//最后一块石头的重量 等价于 两个数组之差要最接近 等价于 计算在sum/2时的两个数组相减 变为石头的最小重量
class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
    int sum=0;
    for(int i=0;i<stones.size();i++)
    {
        sum +=stones[i];
    }

    int target=sum/2;
    vector<int> dp(1501,0);
    for(int i=0;i<stones.size();i++)
    {
        for(int j=target;j>=stones[i];j--)
        {
            dp[j]=max(dp[j],dp[j-stones[i]]+stones[i]);
        }
    }
    return (sum-dp[target]-dp[target]);
    }
};

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

解：

//转化为背包问题，满容量时，装满背包有多少种方法
//设容量为j，dp[j]为容量为j时有多少种方法。
//dp[0]=1
class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
    int sum=0;
    for(int i=0;i<nums.size();i++)
    {
        sum+=nums[i];
    }
     if (abs(target) > sum) return 0; // 此时没有方案
    if((sum+target)%2!=0) return 0;
    int left=(sum+target)/2; //left设为容量，当left为满时，总共有多少种方法。
    vector<int> dp(left+1,0);
    dp[0]=1;
    for(int i=0;i<nums.size();i++)
    {
        for(int j=left;j>=nums[i];j--)
        {
            dp[j] += dp[j-nums[i]];
        }
    }
    return dp[left];
    }
};

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 。

解：

//你的思路没错，递归公式也没错，就按照0-1背包的写法逐个遍历就行！！！
class Solution {
public:
    int compute(string &str)
    {
        int j1=0;
        for(int i=0;i<str.size();i++)
        {
            if(str[i]=='0') j1++;
        }
        return j1;
    }

    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(int i=0;i<strs.size();i++)
        {
            int j1 = compute(strs[i]);
            int j2 = strs[i].size()-j1;
            for(int g=m;g>=j1;g--)
            {
                for(int k=n;k>=j2;k--)
                {
                    dp[g][k]=max(dp[g][k],dp[g-j1][k-j2]+1);
                }
            }
        }
        return dp[m][n];
    }
};