代码随想录刷题第43天|LeetCode1049最后一块石头的重量II，LeetCode494目标和，LeetCode474一和零

1、LeetCode1049最后一块石头的重量II

题目链接：1049、最后一块石头的重量II

尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小。

容量为sum/2的背包最多可以装多少重量的石头，先求dp[sum/2]。

最后两边相差 sum - dp[target] - dp[target]。

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

2、LeetCode494目标和

题目链接：494、目标和

本题要如何使表达式结果为target，

既然为target，那么就一定有 left组合 - right组合 = target。

left + right = sum，而sum是固定的。right = sum - left

公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2 。

target是固定的，sum是固定的，left就可以求出来。

此时问题就是在集合nums中找出和为left的组合。

1、dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法；

2、 dp[j] += dp[j - nums[i]];

已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。

已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。

已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包

已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包

已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包

3、初始化：dp[0] = 1;

4、遍历顺序：先遍历物品，再遍历背包，背包倒序遍历。

5、举例推导。

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 < abs(target)) return 0;
        if ( (sum + target) % 2 == 1) return 0;

        int bagsize = (sum + target) / 2;
        vector<int> dp(bagsize+1, 0);
        dp[0] = 1;

        for (int i = 0; i < nums.size(); i++)
        {
            for (int j = bagsize; j >= nums[i]; j--)
            {
                dp[j] += dp[j - nums[i]];
            }
        }

        return dp[bagsize];

    }
};

3、LeetCode474一和零

题目链接：474、一和零

本题中strs 数组里的元素就是物品，每个物品都是一个！

而m 和 n相当于是一个背包，两个维度的背包。

1、dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

2、dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

3、初始化：dp数组初始化为0。

4、遍历顺序：先遍历物品strs，再遍历两个背包，背包倒叙遍历。

5、举例推导。

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 zeroNum = 0;
            int oneNum = 0;
            for (char c : str)
            {
                if (c == '0') zeroNum++;
                else
                {
                    oneNum++;
                }
            }

            for (int i = m; i >= zeroNum; i--)
            {
                for (int j = n; j >= oneNum; j--)
                {
                    dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }

        return dp[m][n];


    }
};