代码随想录算法训练营第五十一天_第九章_动态规划 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III-CSDN博客

本文链接：https://blog.csdn.net/Jane_10358/article/details/128764653

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

视频讲解

https://www.bilibili.com/video/BV1Te411N7SX 文章讲解

https://programmercarl.com/0198.%E6%89%93%E5%AE%B6%E5%8A%AB%E8%88%8D.html

思路：当前房屋偷与不偷取决于前一个房屋和前两个房屋是否被偷了
- dp[i]：下标 [0, i] 的房屋，最多可以偷窃的金额为dp[i]。
- 递推公式：dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
  - 如果偷房间 i：那么房间 i - 1 一定不能偷，只能在 [0, i - 2] 中偷
  - 如果不偷房间 i：可以在 [0, i - 1] 中偷
- 初始化：递推公式的基础是 dp[0] 和 dp[1]
  - dp[0]：偷房间0，即 dp[0] = nums[0]
  - dp[1]：在房间0和1中选一个偷，即 dp[1] = max(nums[0], nums[1])
- 遍历顺序：从前往后
代码：

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

LeetCdoe 213.打家劫舍II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

视频讲解

https://www.bilibili.com/video/BV1oM411B7xq 文章讲解

https://programmercarl.com/0213.%E6%89%93%E5%AE%B6%E5%8A%AB%E8%88%8DII.html

思路：首尾相接👉房间0 和房间num.size() - 1 最多偷一个
- 考虑在房间[0, num.size() - 2]中进行偷窃
- 考虑在房间[1, num.size() - 1]中进行偷窃
每种情况相当于在 一排房屋 中进行偷窃，两种情况结果取大，即为本题所求的最高金额。
代码：

// 代码随想录：解耦，思路上更清晰
class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        // 确保传入robRange的参数满足：start <= end
        int result1 = robRange(nums, 0, nums.size() - 2); // 考虑在房间[0, num.size() - 2]中进行偷窃
        int result2 = robRange(nums, 1, nums.size() - 1); // 考虑在房间[1, num.size() - 1]中进行偷窃
        return max(result1, result2);
    }
    // 198.打家劫舍的逻辑，考虑在房间[start, end]中进行偷窃
    int robRange(vector<int>& nums, int start, int end) {
        if (start == end) 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];
    }
};

// 自己：维护了一个二维dp数组
class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        if (nums.size() == 2) return max(nums[0], nums[1]);
        // dp[0][i]:在房间[0, i]偷窃到的最高金额
        // dp[1][i]:在房间[1, i]偷窃到的最高金额
        vector<vector<int>> dp(2, vector<int>(nums.size(), 0));
        dp[0][0] = nums[0];
        dp[0][1] = max(nums[0], nums[1]);
        dp[1][1] = nums[1];
        int i;
        // 至少三间
        for (i = 2; i < nums.size() - 1; ++i) {
            dp[0][i] = max(dp[0][i - 2] + nums[i], dp[0][i - 1]);
            dp[1][i] = max(dp[1][i - 2] + nums[i], dp[1][i - 1]);
        }
        // 最后一间
        dp[0][i] = max(dp[1][i - 2] + nums[i], dp[0][i - 1]);
        return dp[0][i];
    }
};

LeetCdoe 337.打家劫舍III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

视频讲解

https://www.bilibili.com/video/BV1H24y1Q7sY 文章讲解

https://programmercarl.com/0337.%E6%89%93%E5%AE%B6%E5%8A%AB%E8%88%8DIII.html

⭐树形dp：记录以每个节点为根节点的子树，在不偷 / 偷根节点两种情况下，偷该子树所能达到的最高金额👉后序遍历二叉树（需要通过左右子树的结果计算当前子树）

思路：

确定递归函数的参数和返回值：
```
vector<int> robTree(TreeNode* cur)
```
dp数组及其下标的含义：下标为0记录不偷该节点所得到的最高金额，下标为1记录偷该节点所得到的最高金额。
确定终止条件：
```
if (cur == NULL) return {0, 0};
```
（相当于dp数组的初始化）

确定单层递归的逻辑：

vector<int> left = robTree(cur->left); // 左
vector<int> right = robTree(cur->right); // 右

// 不偷cur
int val1 = max(left[0], left[1]) + max(right[0], right[1]);
// 偷cur
int val2 = cur->val + left[0] + right[0];

return {val1, val2};

不偷cur，那么偷不偷 cur 的子节点就没有限制了，分别取大相加即可。

代码：

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 {0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        // 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
        int val1 = max(left[0], left[1]) + max(right[0], right[1]);
        // 偷cur，那么就不能偷左右节点。
        int val2 = cur->val + left[0] + right[0];
        return {val1, val2};
    }
};
// 时间复杂度：O(n)，每个节点只遍历了一次
// 空间复杂度：O(log n)，算上递推系统栈的空间