day40|198.打家劫舍，213.打家劫舍II，337.打家劫舍III

最新推荐文章于 2024-08-16 10:27:08 发布

bindloy

最新推荐文章于 2024-08-16 10:27:08 发布

阅读量192

点赞数 1

文章标签：算法

本文链接：https://blog.csdn.net/bindloy/article/details/140432638

版权

198.打家劫舍

198. 打家劫舍 - 力扣（LeetCode）

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n + 1, 0);
        dp[0] = nums[0];
        if(n == 1){
            return dp[0];
        }
        dp[1] = nums[1];
        for(int i = 2; i < n; i++){
            if(i >= 3){
                dp[i] = max(dp[i - 2], dp[i - 3]) + nums[i];
            }else{
                dp[i] = dp[i - 2] + nums[i];
            }
            
        }
        return max(dp[n - 2], dp[n - 1]);
    }
};

213.打家劫舍II

213. 打家劫舍 II - 力扣（LeetCode）

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n == 1){
            return nums[0];
        }
        int res1 = rob(nums, 0, n - 2);
        int res2 = rob(nums, 1, n - 1);
        return max(res1, res2);
    }
private:
    int rob(vector<int>& nums, int start, int end){
        if(start == end){
            return nums[end];
        }
        int n = nums.size();
        vector<int> dp(n);
        dp[start] = nums[start];
        dp[start + 1] = max(nums[start], nums[start + 1]);
        for(int i = start + 2; i <= end; i++){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[end];
    }
};

337.打家劫舍III

337. 打家劫舍 III - 力扣（LeetCode）

/**
 * 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:
    int rob(TreeNode* root) {
        vector<int> dp = rob1(root);   // {不选，选}
        return max(dp[0], dp[1]);
    }
    vector<int> rob1(TreeNode* root){
        if(root == nullptr){
            return vector<int>({0, 0});
        }
        vector<int> left = rob1(root->left);
        vector<int> right = rob1(root->right);
        int val1 = root->val + left[0] + right[0];  // 选
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);  // 不选
        return vector<int>({val2, val1});
    }
};