背包问题

思路

• 目标是让石头分割成尽量相等的两堆 等和数组
• 背包容量是sum/2 , 问题是选哪些元素可以使得背包最满
• 设dp[i][j] 表示背包容量是j , 前面[..i]物品能装的最大体积
  dp[i][j] = dp[i-1][j] when 不放第i件物品
  dp[i][j] = dp[i][j-nums[i]] + nums[i] when 放第i件物品
  so dp[i][j] = max(dp[i-1][j] , dp[i][j-nums[i]] + nums[i])
• 举例验证
  e.g [2,7,4,1,8,1] bag= 23/2=11
  0 1 2 3 4 5 6 7 8 9 10 11
  0 0 0 2 2 2 2 2 2 2 2 2 2
  1 0 0 2 2 2 2 2 7 7 9 9 9
  2
  3
  4
  5

代码 1 调试用

class Solution {
public:
    int lastStoneWeightII(vector<int>& nums) {
    //   [2,4,7] -->[2,7] -->5
    //   [2,7,4] -->[5,4] -->1
 
    //output 
    // 0 0 2 2 2 2 2 2 2 2 2 
    // 0 0 2 2 2 2 2 7 7 9 9 
    // 0 0 2 2 4 4 6 7 8 9 10 
    // 0 1 2 3 4 5 6 7 8 9 10 
    // 0 1 2 3 4 5 6 7 8 9 10 
    // 0 1 2 3 4 5 6 7 8 9 10 
    int tsum=0;
    for(const auto & t: nums)
    {
        tsum+=t;
    }
    int bag= tsum/2;
    int sizeOfThings= nums.size();
    auto dp= std::vector<std::vector<int> > (sizeOfThings, std::vector<int>(bag+1,0));
    for(int j=0;j<=bag;j++)
    {
        if(j>=nums[0] ) dp[0][j]= nums[0];
    }
    for(int i=1;i<sizeOfThings;i++)
    {
        for(int j=0;j<=bag; j++)
        {
           if(j>=nums[i]) 
           {
               dp[i][j] = std::max( dp[i-1][j] , nums[i] + dp[i][j-nums[i]]);
           }else  
           {
               dp[i][j] = dp[i-1][j];
           }
        }
    }
      
     for(auto vec: dp)
     {
         for(auto x: vec) std::cout << x << " ";
         std::cout << std::endl;
     }
   //  (tsum- dp[end][end] )- dp[end][end]

     return tsum - 2* dp[sizeOfThings-1][bag];
    }
}; 

代码2 实际优化后代码

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001, 0);
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) sum += stones[i];
        int target = sum / 2;
        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];
    }
};

题目描述

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例：

输入：[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]，这就是最优值。

提示：

1 <= stones.length <= 30
1 <= stones[i] <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/last-stone-weight-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。