01背包、完全背包

本文主要使用一维数组进行使用

意思：

01背包：代表物品只有两种状态，只能使用一次。如，dp[i] = max(dp[i], dp[i - wight[j]] + value[j]) 代表容量为i所获得的最大利润。

完全背包：一个物品可以使用无限次

 

技巧：

1.如果是0-1背包，即数组中的元素不可重复使用，nums放在外循环，target在内循环，且内循环倒序；（原因：倒序，后一个状态只依赖前一个状态，而nums是有顺序的，故只使用了一次）
2.如果是完全背包，即数组中的元素可重复使用，nums放在外循环，target在内循环。且内循环正序。
3.如果组合问题需考虑元素之间的顺序，需将target放在外循环，将nums放在内循环。（有顺序，按照目标target大小进行遍历），不考虑顺序时，nums放到外环。

 

基础模版：

常见的背包问题有1、组合问题。2、True、False问题。3、最大最小问题（最大和最小问题只需要修改数组中的默认值）。

模板1:

//01背包，最大值
dp[0] = 0
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]);
    }
}

//完全背包，最大值
dp[0] = 0
for (int i = 0; i < nums.size(); i++) {
    for (int j = nums[i]; j <= target; j++) {
        dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
    }
}

//01背包，组合问题（后一个状态依赖于前一个状态，多种前置状态带来不同组合数）
dp[0] = 1（组合数）
for (int i = 1; i <= target; i++) {
    for (int j = 0; j < nums.size(); j++) {
        dp[j] = dp[j] + dp[j - nums[i]];
    }
}

//01背包，能否得到一个状态（只要有一个状态到达即可）
dp[0] = 1
for (int i = 0; i < nums.size(); i++) {
    for (int j = target; j >= nums[i]; j--) {
        dp[j] = dp[j] || dp[j - nums[i]];
    }
}

1、组合问题：
377. 组合总和 Ⅳ

完全背包常用模板（dp[i] = max(dp[i], dp[i - wight[j]] + value[j])），获取能得到组合数的最大值，本文题目是获取组合数，故使用组合模板

int combinationSum4(vector<int>& nums, int target) {
    //unsigned long long解case
    vector<unsigned long long> dp(target + 1, 0);
    dp[0] = 1;
    for (int i = 0; i <= target; i++) {
        for (int j = 0; j < nums.size(); j++) {
            if (nums[j] <= i) {
                dp[i] = dp[i] + dp[i - nums[j]];
            }
        }
    }
    return dp[target];
}

494. 目标和（未刷）

518. 零钱兑换 II

组合无序，故将nums放到外循环

int change(int amount, vector<int>& coins) {
    vector<int> dp(amount + 1, 0);
    dp[0] = 1;
    for (int j = 0; j < coins.size(); j++) {
        for (int i = coins[j]; i <= amount; i++) {
            dp[i] += dp[i - coins[j]];
        }
    }
    return dp[amount];
}

2、True、False问题：
139. 单词拆分（未刷）
416. 分割等和子集

bool canPartition(vector<int>& nums) {
    int sum = 0;
    for (int i = 0; i < nums.size(); i++) {
        sum += nums[i];
    }
    if (sum % 2) {
        return false;
    }
    sum = sum / 2;
    vector<int> dp(sum + 1, 0);
    dp[0] = 1;

    for (int i = 1; i < nums.size(); i++) {
        for (int j = sum; j >= 0; j--) {
            if (j >= nums[i]) {
                dp[j] = dp[j] || dp[j - nums[i]];
            }
        }
    }
    if (dp[sum]) {
        return true;
    }
    return false;
}

我给转化到最大值

bool canPartition(vector<int>& nums) {
    int sum = 0;
    for (int i = 0; i < nums.size(); i++) {
        sum += nums[i];
    }
    if (sum % 2) {
        return false;
    }
    sum = sum / 2;
    vector<int> dp(sum + 1, 0);
    dp[0] = 0;

    for (int i = 1; i < nums.size(); i++) {
        for (int j = sum; j >= 0; j--) {
            if (j >= nums[i]) {
                dp[j] = max(dp[j],  dp[j - nums[i]] + nums[i]);
            }
        }
    }
    if (dp[sum] == sum) {
        return true;
    }
    return false;
}

3、最大最小问题：
474. 一和零（未刷）
322. 零钱兑换

int coinChange(vector<int>& coins, int amount) {
    vector<long> dp(amount + 1, INT_MAX);
    dp[0] = 0;
    for (int j = 0; j < coins.size(); j++) {
        for (int i = 1;i <= amount; i++) {
            if (i >= coins[j]) {
                dp[i] = min(dp[i - coins[j]] + 1, dp[i]);
            }
        }
    }
    if (dp[amount] != INT_MAX) {
        return dp[amount];
    }
    return -1;
}

 

参考：

https://leetcode-cn.com/problems/combination-sum-iv/solution/377-zu-he-zong-he-ivdong-tai-gui-hua-xia-kbo0/

https://leetcode-cn.com/problems/combination-sum-iv/solution/xi-wang-yong-yi-chong-gui-lu-gao-ding-bei-bao-wen-/