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

发布于 17 天前  37 次阅读


AI 摘要

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