算法学习|动态规划 LeetCode 416. 分割等和子集

动态规划

  • 一、二维dp数组实现01背包
    • 思路
    • 实现代码
  • 二、一维dp数组实现01背包问题
    • 思路
    • 实现代码
  • 三、分割等和子集
    • 思路
    • 实现代码

0 - 1背包:n种物品,每种物品只有一个
完全背包:n种物品,每种物品有无数个
多重背包:n种物品,每种物品的数量各不相同

一、二维dp数组实现01背包

算法学习|动态规划 LeetCode 416. 分割等和子集_第1张图片

思路

1.dp[i][j] : [0,i]的物品里任取,放进容量为j的背包,价值总和最大是多少
2.递推公式:dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])
不放物品i:dp[i - 1][j]
放物品i: dp[i - 1][j - weight[i]] + value[i]
3.初始化: dp[i][0] = 0 当j >= weight[0]时,dp[0][j] = value[0]
4.遍历顺序:二维dp数组实现的背包问题 先遍历物品,再遍历背包(顺序可颠倒)

实现代码

void test_2_wei_bag_problem1() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagweight = 4;

    // 二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
            if (j < weight[i]) dp[i][j] = dp[i - 1][j];
            else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

        }
    }

    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    test_2_wei_bag_problem1();
}

二、一维dp数组实现01背包问题

滚动数组:把上一层的数据拷贝下来
算法学习|动态规划 LeetCode 416. 分割等和子集_第2张图片

思路

1.dp[j]:容量j的背包所装的最大价值为dp[j]
2.递推公式:dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
3.初始化:dp[0] = 0 dp数组全部初始化为0,如果初始化其他数的话,递推时会被初始值覆盖
4.遍历顺序:倒序遍历(保证每个物品只被添加一次),先遍历物品再遍历背包
正序遍历:
dp[1] = dp[1 - 1] + 15 = 15
dp[2] = dp[2 - 1] + 15 = 30 (物品0被添加了两次)
倒序遍历:
dp[2] = dp[2 - 1] + 15 = 15
dp[1] = dp[1 - 1] + 15 = 15

实现代码

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;
    // 初始化
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}

三、分割等和子集

给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
注意: 每个数组中的元素不会超过 100 数组的大小不会超过 200

思路

能不能装满容量为11的背包
1.dp[j]:容量j的背包所装的最大价值为dp[j]
2.递推公式:dp[j] = max(dp[j], dp[j - numbers[i]] + numbers[i])
3.初始化:dp[0] =0,非零下标的dp数组初始化为0
4.遍历顺序:先遍历物品,再遍历背包(倒序)

实现代码

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        // dp[i]中的i表示背包内总和
        // 题目中说:每个数组中的元素不会超过 100,数组的大小不会超过 200
        // 总和不会大于20000,背包最大只需要其中一半,所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) {
            for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入,所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和target
        if (dp[target] == target) return true;
        return false;
    }
};

你可能感兴趣的:(#,算法学习,算法,leetcode,动态规划,c++,学习)