代码随想录算法训练营第48天 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

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

思路:

• 使用动态规划

• 1. 确定dp数组以及下标的含义

     • dp[j]的定义为：打劫1-j所房子最多能偷窃到的金额

  2. 确定递推公式

     // 状态转移方程
     dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1]);

  3. dp数组如何初始化

     vector<int> dp(nums.size() + 1, 0);
     dp[1] = nums[0];

  4. 确定遍历顺序

     for(int i = 2; i <= nums.size(); ++i) {
         dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1]);
     }

我的AC代码

// 时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
    int rob(vector<int>& nums) {
        vector<int> dp(nums.size() + 1, 0);
        dp[1] = nums[0];
        for(int i = 2; i <= nums.size(); ++i) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i - 1]);
        }
        return dp[nums.size()];
    }
};

标准答案

// 时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < nums.size(); i++) {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.size() - 1];
    }
};

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

思路:

• 这道题和198. 打家劫舍 - 力扣（Leetcode）的区别是所有房屋绕成了环装，即如果偷了第一个房子，就不能偷最后一个房子，反之亦然，那么我们考虑以下两种情况，一种是忽略第一个房子的时候剩下的房子最多能偷多少钱，第二种是忽略最后一个房子的时候剩下的房子最多能偷多少钱，计算能偷多少钱用198. 打家劫舍 - 力扣（Leetcode）的解题逻辑即可，这两种情况中的最大值就是答案

我的AC代码

// 时间复杂度O(n),空间复杂度O(n)
class Solution {
public:
    int robChoose(vector<int>& nums, int start, int length) {
        vector<int> dp(length + 1, 0);
        dp[1] = nums[start];
        for(int i = 2; i <= length; ++i) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i + start - 1]);
        }
        return dp[length];
    }
    int rob(vector<int>& nums) {
        if(nums.size() == 0) {
            return 0;
        }
        else if(nums.size() == 1) {
            return nums[0];
        }
        else if(nums.size() == 2) {
            return max(nums[0], nums[1]);
        }
        return max(robChoose(nums, 0, nums.size() - 1), robChoose(nums, 1, nums.size() - 1));
    }
};

标准答案

// 时间复杂度O(n),空间复杂度O(n)
// 注意注释中的情况二情况三，以及把198.打家劫舍的代码抽离出来了
class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        int result1 = robRange(nums, 0, nums.size() - 2); // 情况二
        int result2 = robRange(nums, 1, nums.size() - 1); // 情况三
        return max(result1, result2);
    }
    // 198.打家劫舍的逻辑
    int robRange(vector<int>& nums, int start, int end) {
        if (end == start) return nums[start];
        vector<int> dp(nums.size());
        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 - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
};

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

思路:

• 树形DP的入门题目，使用后序遍历，因为每个节点都有两个状态，偷或者不偷，所以递归的时候需要返回一个只有两个元素的vector<int>，用来记录偷和不偷时的最大价值，然后自底部向上，最终得到答案。需要注意的是，若选择偷该节点，那么其两个孩子不能偷，若选择不偷该节点，则可以考虑两个孩子

我的AC代码

// 时间复杂度O(n),空间复杂度O(logn)
class Solution {
public:
    int rob(TreeNode* root) {
        return max(ans(root)[0], ans(root)[1]);
    }
 
    vector<int> ans(TreeNode* root) {
        if(root == nullptr) {
            return vector<int>{0, 0};
        }
 
        vector<int> left = ans(root->left);
        vector<int> right = ans(root->right);
        // 不偷现在的节点 
        int val1 = max(left[0], left[1]) + max(right[0], right[1]);
        // 偷现在的节点
        int val2 = root->val + left[0] + right[0];
 
        return {val1, val2};
    }
};

标准答案

// 时间复杂度O(n),空间复杂度O(logn)
class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
    // 长度为2的数组，0：不偷，1：偷
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        // 偷cur，那么就不能偷左右节点。
        int val1 = cur->val + left[0] + right[0];
        // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
};