代码随想录算法训练营第五十一天 | LeetCode 198、213、337

---

前言

LeetCode题目：LeetCode 198、213、337
Takeaway：背包问题，打家劫舍系列问题

---

一、198

内层循环不一定直接是物品，也可以是用来取物品的变量，如本题的 j - i

class Solution {
public:
    int rob(vector<int>& nums) {
        //边界处理
        if(nums.size() == 1) {
            return nums[0];
        }

        //定义DP数组，DP含义是偷盗第 i 个屋子，最多能拿多少钱
        vector<int> dp(nums.size()+1);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);

        //偷第 i 个屋子，和不偷第 i 个屋子
        for(int i=2; i<nums.size(); i++){
            dp[i] = max(dp[i-1], dp[i-2]+nums[i]);
        }

        return dp[nums.size()-1];
    }
};

---

二、213

这题就是分情况DP，最后整合一下就可以了。

class Solution {
public:
    int rob(vector<int>& nums) {

        if(nums.size() == 1){
            return nums[0];
        }
        if(nums.size() == 2){
            return max(nums[0], nums[1]);
        }

        //定义DP数组，DP数组的含义是，走到第 i 家，最多可以偷到多少钱
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for(int i=2; i<=nums.size()-2; i++){
            dp[i] = max(dp[i-1], dp[i-2]+nums[i]);
        }
        int ans1 = dp[nums.size()-2];

        vector<int> dp2(nums.size());
        dp2[1] = nums[1];
        dp2[2] = max(nums[1], nums[2]);
        for(int i=3; i<=nums.size()-1; i++){
            dp2[i] = max(dp2[i-1], dp2[i-2]+nums[i]);
        }
        int ans2 = dp2[nums.size()-1];

        return max(ans1, ans2);
    }
};

---

三、337

树型DP，具体内容看注释就可以了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    vector<int> traverse(TreeNode* root) {
        // 递归出口：子树为空
        if(root == NULL){
            return vector<int>{0, 0};
        }

        // 遍历左子树
        vector<int> left = traverse(root->left);

        // 遍历右子树
        vector<int> right = traverse(root->right);

        // 接下来进行单层的递归处理
        // 选择拿当前元素，那么左右子节点全都不可能拿了
        int val1 = root->val + left[0] + right[0];
        // 选择不拿当前元素，那么左右孩子就跳拿与不拿的最大值就好了
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }

    int rob(TreeNode* root) {
        vector<int> result = traverse(root);
        return max(result[0], result[1]);
    }
};

---

总结

背包问题结束，今天的题是打家劫舍类型的，难一点的就是分情况DP并且组合，以及树型DP。