代码随想录41天|0-1背包问题、一维dp数组0-1背包问题、416. 分割等和子集

0-1背包问题

①dp[i][j]数组含义：容量为j的背包随机在前i个物品中取可以取得的最大值。

②初始化：dp[i][0]代表容量为0的背包可以取得的最大价值，无法装东西，其结果必然是0；dp[0][j]初始化只看第0个物品放进去或者不放进去的最大价值，当背包容量（j < weight[0]）小于第0个物品重量时其结果为0，其余的初始化为第0个物品的价值，其余值可以随机初始化。

③递推公式：针对容量为j的背包，在处理第i个物品时有两种选择，选择最大的就可以。

I. 不放第i个物品取得的最大值,即在处理第i-1个物品时可以取得的最大value值dp[i-1][j]

II.放第i个物品取得的最大值：如果想要放置第i个物品背包首先要能空出放置第i个物品的质量，此时背包其余部分容量为j-weight[i]，而dp[i-1][j-weight[i]]是剩余部分在前i-1个物品里可以取得的最大值，则当前可以取得最大值为dp[i-1][j-weight[i]] + value[i].

④遍历顺序：dp[i][j]的取值完全由dp[0 ~ i-1][0 ~ j-1]来决定，因此从小到大遍历的话先遍历物品还是先遍历容量无所谓，但是如果从大到小遍历容量的话必须先遍历物品（一维dp数组0-1背包问题）。

int backPackSolution(const std::vector<int>& weight, const std::vector<int>& value, size_t capacity) {
    std::vector< std::vector<int> > dp(weight.size(), std::vector<int>(capacity + 1, 0));
    for (std::vector<int>::size_type i = 0; i < capacity + 1; i++) {
        if (i >= weight[0]) dp[0][i] = value[0];
    }
    for (std::vector<int>::size_type i = 1; i < weight.size(); i++) {
        for (std::vector<int>::size_type j = 1; j < capacity + 1; j++) {
            if (weight[i] > j) continue;
            else dp[i][j] = std::max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }
    return dp[weight.size() - 1][capacity];
}

优化：一维dp数组

int backPackSolution1D(std::vector<size_t>& weight, std::vector<unsigned int>& value, size_t capacity) {
    std::vector<unsigned int> dp(capacity + 1, 0);
    for (std::vector<unsigned int>::size_type i = weight[0]; i <= capacity; i++) {
        dp[i] = value[0];
    }

    for (std::vector<unsigned int>::size_type i = 1; i < value.size(); i++) {
        for (size_t j = capacity; j >= weight[i]; j--) { //这里边界条件很巧妙
            dp[j] = std::max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    return dp.back();
}

416. 分割等和子集 - 力扣（Leetcode）

暴力超时的回溯

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(int num : nums) { sum += num; }
        if (sum % 2 == 1) return false;
        sum /= 2;
        int curSum = 0;
        return backtracking(nums, 0, sum, curSum);
    }

    bool backtracking(vector<int>& nums, vector<int>::size_type startIndex, const int& sum, int& curSum) {
        if(curSum == sum) return true;
        else if(curSum > sum) return false;

        for(vector<int>::size_type i = startIndex; i < nums.size(); i++) {
            curSum += nums[i];
            if(backtracking(nums, i + 1, sum, curSum)) return true;
            curSum -= nums[i];
        }
        return false;
    }
};

动态规划：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for(int num : nums) { sum += num; }
        if((sum & 1) == 1) return false;
        sum = sum >> 1;
        if(nums[0] > sum) return false;
        else if(nums[0] == sum) return true;
        vector<int> dp(sum + 1, 0);
        for(vector<int>::size_type i = nums[0]; i < dp.size(); i++) {
            dp[i] = nums[0];
        }
        for(vector<int>::size_type i = 1; i < nums.size(); i++) {  
            if(nums[0] > sum) return false;
            else if(nums[0] == sum) return true;
            for(vector<int>::size_type j = dp.size() - 1; j > 0; j--) {
                if (nums[i] > j) continue;
                else dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
                if(dp[j] == sum) return true;
            }
        }
        return false;
    }
};