动态规划day35|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

提示：

• 1 <= stones.length <= 30
• 1 <= stones[i] <= 100

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]*2;
    }
};

本题的思路即等效转换是最难的，里面使用背包的过程反而不难，只要注意一下dp数组初始化的大小就行了

等效转换思路：本题属于优化类问题，我们可以联想到01背包。我们把整个集合平分成2份，保证2份的各自的元素和几乎相等或者说是和最为接近的两个子集。这样这两个子集一旦相减，最后的结果也就等效于最后一个石头的最小重量了。

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

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((sum+target)%2==1)
        return 0;
        if(abs(target)>sum)
        return 0;
        int bagSize=(sum+target)/2;
        vector<vector<int>> dp(nums.size(),vector<int>(bagSize+1,0));
        dp[0][0]=1;
        if(bagSize>=nums[0])
        dp[0][nums[0]]=1;
        int zeroNum=0;
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]==0)
            zeroNum++;
            dp[i][0]=(int)pow(2.0,zeroNum);
        }
        for(int i=1;i<nums.size();i++)
            for(int j=1;j<=bagSize;j++)
                if(j<nums[i]) 
                dp[i][j]=dp[i-1][j];
                else
                dp[i][j]=dp[i-1][j]+dp[i-1][j-nums[i]];
        return dp[nums.size()-1][bagSize];
    }
};

使用二维背包，更容易理解一些

难点：

• 等效转换：将原集合分成两个子集，代表一正一负，二者相加是sum，相减是target，由此可得出正子集的和为（sum+target）/2。所以将问题转化为：在原来的集合中找，使得他们相加为（sum+target）/2，问这有多少种情况。这样的话我们就可以用01背包了：背包容量为（sum+target）/2，在这群物品里面任意挑，装满背包的方法有多少种？
• 和最大价值和问题的比较：这种背包思路和以往的不一样，不讨论物品的价值。之前是不求装满，但求价值和最大；而这里是必须要装满背包，然后求出有多少种装满的方法。最大价值和的问题里面可能出现重量小但是价值大或者重量大但是价值小的情况，所以在决定放不放的时候我们需要进行比较（即max方法），每次都是得出最优的dp [i] [j]，然后动态规划下去；而这里求的是装满背包的方法数问题，问题来了，既然dp数组的含义都不一样，那我们为什么可以套用01背包的框架呢？这就是涉及到背包的本质了。
• 背包的本质：背包问题，本质上就是在一个数组内求特定和问题。只要我们需要在一个数组内求特定和，那么这个特定和就是背包容量，背包内的元素都是在这个数组里面找的。只要满足这个情境，就可以套用01背包的框架！但是不是死板的，需要灵活理解。而且这个仅仅是解决问题的基础，还要根据不同题目做出变化
• 尽管都是背包，但dp数组的意义是不断变化的。意义不同，递推公式就不同。但是任然保留了主体框架不变。这里的求方法数，肯定是需要加在一起的，而不是去最大值：dp [i] [j]=dp [i-1] [j]+dp[i-1] [j-nums[i]];

易错点：

• 剪枝：

if((sum+target)%2==1)
        return 0;
        if(abs(target)>sum)
        return 0;

当这个和不是整数或者大于sum时都不行

• 横向初始化：dp [0] [0]=1; 只有当容量恰好等于nums[i]时，即dp [0] [nums[0]]=1;(此时最大容量>=nums[0])，其他都为0

• 竖向初始化：即dp [i] [0]，显然为1。但是，当nums[i]为0时，我们就需要另外考虑了，即：

for(int i=0;i<nums.size();i++)
          {
              if(nums[i]==0)
              zeroNum++;
              dp[i][0]=(int)pow(2.0,zeroNum);
          }

有几个0，那么就有2的几次方个方法

• 返回值；我们要知道dp数组的含义：装满背包的方法数，所以只要输入我们要求的背包容量、物品数，然后直接返回dp即可，即：

  return dp[nums.size()-1][bagSize];

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

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1,0));
        for(string str:strs)
        {
            int x=0,y=0;
            for(char c:str)
            {   
                if(c=='0') x++;
                else y++;
            }
            for(int i=m;i>=x;i--)
                for(int j=n;j>=y;j--)
                    dp[i][j]=max(dp[i][j],dp[i-x][j-y]+1);
        }
        return dp[m][n];
    }
};

虽然是二维数组，本质上还是一维背包，只不过背包有两个维度的控制。需要注意的是，dp数组的含义是背包内元素的个数。