代码随想录训练营第五十二天打卡|198.打家劫舍 213.打家劫舍II 337.打家劫舍III

198.打家劫舍

1.dp经典入门题目，dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。dp[i]的值不一定是偷了下标为i的那一家，只是这一家能偷，如果不偷这一家能带来更高的收益，那就不偷。理解递推公式的时候应紧密联系定义，随想录中的考虑我觉得不够形象。事实上dp[0]和dp[1]不一定需要特判，可以通过在dp数组插入两个初始状态来使代码简洁，但我认为特判更好理解一点。（注：本题还可以通过两个变量来优化空间）

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1)
            return nums[0];
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        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.打家劫舍II

1.本题是打家劫舍的进阶版，题解基本上都是把环拆开两次打劫取较大值。但为什么这样收益最大其实并没有说的很明白，我个人反复思考之后想出了一种自己觉得相对容易理解的解释。本题房屋是首尾相连的，第一家和最后一家不能同时偷。那么我先选择最后一家不偷，钱再多我也不偷，那么问题就退化成最初的打家劫舍版本。偷完之后我有点后悔，心里好像有只蚂蚁在爬，会不会最后一家钱很多呢？如果上天给我一次重来的机会，我选择不偷第一家，这样我就可以偷最后一家了，虽然不一定偷最后一家。这时候问题依然退化成最初的打家劫舍，比较两次收益，选取那个较大的。为什么这两种情况就包含了所有情况呢？考虑以上两种方案代表的是可以偷第一家和不可以偷第一家，或者说是不可以偷最后一家和可以偷最后一家，因此可以包含所有情况。（可以偷第一家不能偷最后一家，除了最后一家随便偷虽然不一定偷。不可以偷第一家可以偷最后一家，除了第一家随便偷虽然不一定偷）

class Solution {
public:
    int robRange(vector<int>& nums, int start, int end) {
        if (start == end)
            return nums[start];
        vector<int> dp(nums.size(), 0);
        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];
    }
    int rob(vector<int>& nums) {
        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);
    }
};

337.打家劫舍III

1.记忆化递推，在递归的过程中我们会进行许多重复的计算导致超时，所以我们可以用map记录计算过的值，然后在出现重复计算时把之前的结果拿来用。（如果对重复计算不理解可参考这句话：我们计算了root的四个孙子（左右孩子的孩子）为头结点的子树的情况，又计算了root的左右孩子为头结点的子树的情况，计算左右孩子的时候其实又把孙子计算了一遍。）

/**
 * 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:
    unordered_map<TreeNode*, int> umap; // 记录计算过的结果
    int rob(TreeNode* root) {
        if (root == NULL)
            return 0;
        if (root->left == NULL && root->right == NULL)
            return root->val;
        if (umap[root])
            return umap[root]; // 如果umap里已经有记录则直接返回
        // 偷父节点
        int val1 = root->val;
        if (root->left)
            val1 += rob(root->left->left) +
                    rob(root->left->right); // 跳过root->left
        if (root->right)
            val1 += rob(root->right->left) +
                    rob(root->right->right); // 跳过root->right
        // 不偷父节点
        int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子
        umap[root] = max(val1, val2);                  // umap记录一下结果
        return max(val1, val2);
    }
};

2.树形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:
    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};
    }
};

今日总结：打家劫舍。