算法训练营Day43 第九章 动态规划 part5

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

        这道题的思路是：将这组石头分成大小相近的两组，两组石头之差就是本题结果了。然后，就可以把这道题变成一道01背包问题，背包的容量就是本组石头总重量的一半（向下取整）。可以理解为，重量与价值是相同的，找出这个背包能放入石头最大价值。

代码如下：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for(int i : stones) sum += i;
        int bagWeight = sum / 2;
        vector<int> dp(bagWeight + 1);
        for(int i = 0; i < stones.size(); i++) {
            for(int j = bagWeight; j >= stones[i]; j--) {
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        int littleGroup = dp[bagWeight];
        int bigGroup = sum - littleGroup;
        return bigGroup - littleGroup;
    }
};

第二题: 494. 目标和 

        这道题我考虑到了回溯算法，将这道题转换成从nums数组中找出和为x的子集个数，代码如下所示：

class Solution {
public:
    int sum = 0;
    int result = 0;

    void backtracking(vector<int>& nums, int x, int startIndex) {
        if(sum == x) {
            result++;
            //return; //不能直接return,后面可能还有元素0
        }
        if(sum > x) return;
        for(int i = startIndex; i < nums.size(); i++) {
           sum += nums[i];
           backtracking(nums, x, i + 1);
           sum -= nums[i]; 
        }
        return;
    }

    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        vector<int> dp(n + 1);
        int sum_nums = 0;
        for(int i : nums) sum_nums += i;
        int tmp = sum_nums + target;
        if(tmp % 2) return 0;
        int x = tmp / 2;
        //从数组nums中找出和为x的子数组，一共有多少个
        backtracking(nums, x, 0);
        return result;
    }
};

        回溯算法能够解决这道题，但算法复杂度较高，还可以使用动态规划的方法来解题。思路是：将数组元素分成两组，两组之和分别为left和right，其中left + right = sum; left - right = target。求出left和right，这样问题就转化成背包容量为left，从数组中能找出多少个恰好满足和为left的子集。这样就转化为一道01背包问题，背包容量为left，求恰好能装满背包的情况有多少种？

        令dp[j]表示容量为j的背包，能装多少种不同下标的元素。只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法，然后累加起来就好了。初始化也有一个坑，dp[0]到底是0还是1呢？我们带入一下就好了，当数组为[0]，并且target也为0时，此时bagSize也是0，但结果很明显是1，所以应当把dp[0]初始化为1。

代码如下：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int S) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(S) > sum) return 0; // 此时没有方案
        if ((S + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (S + sum) / 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];
    }
};

第三题： 474.一和零

        这道题得用三维数组来解题，先写出三维数组的方法有利于理解处理的过程。总体思路还是01背包问题。三维数组解法的代码如下所示：

class Solution {
public:
    int getNums(string& s, char c) {
        int result = 0;
        for(char a : s) {
            if(a == c) result++;
        }
        return result;
    }

    int findMaxForm(vector<string>& strs, int m, int n) {
        int size = strs.size();
        //dp[i][m][n]表示从前i个元素中选取时，含有m个0，n个1的最大子集数量
        vector<vector<vector<int>>> dp(size + 1, vector<vector<int>> (m + 1, vector<int>(n + 1, 0)));
        for(int i = 1; i < size + 1; i++) {
            int zeros = getNums(strs[i-1], '0');
            int ones = getNums(strs[i-1], '1');
            for(int j = 0; j < m + 1; j++) {
                for(int k = 0; k < n + 1; k++) {
                    dp[i][j][k] = dp[i-1][j][k];
                    if(j >= zeros && k >= ones) {
                        dp[i][j][k] = max(dp[i][j][k], 1 + dp[i-1][j-zeros][k-ones]);
                    }
                }
            }
        }
        return dp[size][m][n];
    }
};

可以优化成二维数组的形式，代码如下：

class Solution {
public:
    int getNums(string& s, char c) {
        int result = 0;
        for(char a : s) {
            if(a == c) result++;
        }
        return result;
    }

    int findMaxForm(vector<string>& strs, int m, int n) {
        int size = strs.size();
        //dp[m][n]表示含有m个0，n个1的最大子集数量
        vector<vector<int>> dp(m + 1, vector<int> (n + 1));
        for(int i = 1; i < size + 1; i++) {
            int zeros = getNums(strs[i-1], '0');
            int ones = getNums(strs[i-1], '1');
            for(int j = m; j >= zeros; j--) {
                for(int k = n; k >= ones; k--) {
                    if(j >= zeros && k >= ones) {
                        dp[j][k] = max(dp[j][k], 1 + dp[j-zeros][k-ones]);
                    }
                }
            }
        }
        return dp[m][n];
    }
};

        Day43打卡！！！