代码随想录算法训练营Day42 | 0-1背包问题，416. 分割等和子集 | Day 13 复习

动态规划：0-1背包理论基础 二维

文章链接  |  视频链接

01 背包

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

二维dp数组01背包

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。 

有两个方向推出来dp[i][j]，

• 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。(其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。)
• 放物品i：由dp[i - 1][j - weight[i]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值

所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

01背包问题 一维

文章链接  |  视频链接

一维dp数组（滚动数组）

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]

416. 分割等和子集

文章链接  |  题目链接  |  视频链接

C++解法

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for (int num : nums){
            sum += num;
        }
        if (sum % 2 == 1) return false;
        int target = sum / 2;
        vector<int> dp(target+1, 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]);
            }
        }
        if (dp[target] == target){
            return true;
        } else {
            return false;
        }
    }
};

Python解法

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        num_sum = sum(nums)
        if num_sum % 2 == 1:
            return False
        target = num_sum // 2
        dp = [0] * (target+1)
        for i in range(0, len(nums)):
            for j in range(target, nums[i]-1, -1):
                dp[j] = max(dp[j], dp[j-nums[i]]+nums[i])
        if dp[target] == target:
            return True
        else:
            return False

Day 13 复习

239. 滑动窗口最大值

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        deque<int> queue;

        for (int i = 0; i < k; i++){
            while (!queue.empty() && nums[i] > queue.back()){
                queue.pop_back();
            }
            queue.push_back(nums[i]);
        }

        result.push_back(queue.front());

        for (int i = k; i < nums.size(); i++){
            if (nums[i - k] == queue.front()){
                queue.pop_front();
            }
            while (!queue.empty() && nums[i] > queue.back()){
                queue.pop_back();
            }
            queue.push_back(nums[i]);
            result.push_back(queue.front());
        }

        return result;
    }
};

347.前 K 个高频元素

class Solution {
public:
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for (int i = 0; i < nums.size(); i++){
            map[nums[i]]++;
        }
        priority_queue <pair<int, int>, vector<pair<int, int>>, mycomparison> pq;
        
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pq.push(*it);
            if (pq.size() > k) {
                pq.pop();
            }
        }
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pq.top().first;
            pq.pop();
        }
        return result;
    }
};