7. leetcode (Dynamic Programming - Backpack)

knapsack problem

1.01 backpack

//1.01背包问题

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
    
    
public:
    void bag_problem() {
    
    
        vector<int> weight{
    
    1, 3, 4};
        vector<int> value{
    
    15, 20, 30};
        int bagweight = 4;
        
        //weight.size()物品个数，bagweight背包容量
        vector<vector<int>> dp(weight.size() + 1, vector<int>(bagweight + 1, 0));

        //初始化
        for (int j = weight[0]; j <= bagweight; j++) {
    
    
            dp[0][j] == value[0];
        }
        
        //遍历物品
        for (int i = 1; i < weight.size(); i++) {
    
    
            //遍历背包容量
            for (int j = 0; j <= bagweight; j++) {
    
    
                //当放第i件物品时，背包未满
                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] << "\n";

    }    
};

int main() {
    
    
    Solution s;
    s.bag_problem();

    return 0;
}

2. One-dimensional dp array

//2. 一维dp数组

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
    
    
public:
    void bag_problem1() {
    
    
        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] << "\n";
    }
};

int main() {
    
    
    Solution s;
    s.bag_problem1();

    return 0;
}

3.leetcode 416 segmentation and subset

//3.leetcode 416. 分割等和子集

class Solution {
    
    
public:
    bool canPartition(vector<int>& nums) {
    
    
        int sum = 0;

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

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

4. Leetcode 1049 The Weight of the Last Stone II

// 4. leetcode 1049. 最后一块石头的重量 II

class Solution {
    
    
public:
    int lastStoneWeightII(vector<int>& stones) {
    
    
        vector<int> dp(15001, 0);
        int sum = 0;

        for (int i = 0; i < stones.size(); i++) {
    
    
            sum += stones[i];
        }
        int target = sum / 2;

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

//外循环stones 内循环target = sum / 2倒序
class Solution {
    
    
public:
    int lastStoneWeightII(vector<int>& stones) {
    
    
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int target = sum / 2;

        vector<int> dp(target + 1);
        for (int stone : stones) {
    
    
            for (int i = target; i >= stone; i--) {
    
    
                dp[i] = max(dp[i], dp[i - stone] + stone);
            }
        }
        return sum - 2 * dp[target];
    }
};

5. leetcode 494 goals and

// 5. leetcode 494. 目标和
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 (abs(target) > sum) return 0;  // 此时没有方案
        if ((target + sum) % 2 == 1) return 0; //此时没有方案
        int bagSize = (target + 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];
    }
};

6. leetcode 474 one and zero

// 6. leetcode 474 一和零

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 oneNum = 0, zeroNum = 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];    
        
    }
};

7. Complete Backpack

//完全背包

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Solution {
    
    
public:
    void completePack() {
    
    
        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 =weight[i]; j <= bagweight; j++) {
    
    
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
            }
        }
        cout << dp[bagweight] << "\n";
    }
};

int main() {
    
    

    Solution s;
    s.completePack();

    return 0;
}

8. leetcode 518 change II

//2. leetcode 518 零钱兑换 II

class Solution {
    
    
public:
    int change(int amount, vector<int>& coins) {
    
    
        vector<int> dp(amount + 1, 0);
        dp[0] = 1;

        for (int i = 0; i < coins.size(); i++) {
    
    
            for (int j = coins[i]; j <= amount; j++) {
    
    
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
};

9. Leetcode 377 Combination Sum IV

//3. leetcode 377. 组合总和 Ⅳ 
class Solution {
    
    
public:
    int combinationSum4(vector<int>& nums, int target) {
    
    
        vector<int> dp(target + 1, 0);
        dp[0] = 1;

        for (int i = 0; i <= target; i++) {
    
       //遍历背包
            for (int j = 0; j < nums.size(); j++) {
    
      //遍历物品
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {
    
    
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
};

10. leetcode 279 perfect square number

//4. leetcode 279 完全平方数

class Solution {
    
    
public:
    int numSquares(int n) {
    
    
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;

        for (int i = 0; i <= n; i++) {
    
    
            for (int j = 1; j * j <= i; j++) {
    
    
                dp[i] = min(dp[i], dp[i - j*j] + 1);
            }
        }
        return dp[n];
    }
};

11. leetcode 139 word splitting

//5. leetcode 139. 单词拆分

class Solution {
    
    
public:
    bool wordBreak(string s, vector<string>& wordDict) {
    
    
        unordered_set<string> wordset(wordDict.begin(), wordDict.end());
        vector<bool> dp(s.size() + 1, false);
        dp[0] = true;

        for (int i = 1; i <= s.size(); i++) {
    
      //遍历背包
            for (int j = 0; j < i; j++) {
    
        //遍历物品
                string word = s.substr(j, i - j);  //substr（起始位置，截取的个数）
                if (wordset.find(word) != wordset.end() && dp[j]) {
    
    
                    dp[i] = true;
                }
            }
        }
        return dp[s.size()];
    }
};