Day41：198.打家劫舍、213.打家劫舍II、337.打家劫舍 III

---

198.打家劫舍

题目链接

思路

1. 确定dp数组（dp table）以及下标的含义
   dp[i]：考虑下标i以内的房屋，最多可以偷窃的金额为dp[i]。
   注意：dp[i]不是一定要偷第i个房间，它代表的是从0-i的范围房间内能偷的最大值。
2. 确定递推公式
   决定dp[i]的条件有第i房间偷还是不偷。
   如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i]
   如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑 i-1房
   然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
3. dp数组如何初始化
   从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])可以看出，递推公式的基础就是dp[0] 和 dp[1]。从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);
   vector dp(nums.size());
   dp[0] = nums[0];
   dp[1] = max(nums[0], nums[1]);
4. 确定遍历顺序
   dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历
5. 举例推导dp数组

代码实现

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()+1,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. 不考虑首尾
2. 考虑首不考虑尾
3. 不考虑首考虑尾

而第一种情况包含在2和3情况里，直接讨论2和3情况即可，这样一个环形数组又变成了线型数组，和打家劫舍一模一样。

代码实现

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

---

337.打家劫舍 III

题目链接

思路

这道题比上面那道题又加了一个档次，是二叉树和动态规划的结合运用，第一次见我也是一脸懵逼。这道题用递归结构分析：

1. 确定递归函数的参数和返回值
   这里我们要求一个节点偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。dp数组以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
2. 确定终止条件
   在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回{0,0}。这也相当于dp数组的初始化
3. 确定遍历顺序
   首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。
4. 确定单层递归的逻辑
   如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0];
   如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
   最后当前节点的状态就是{val2, val1}；

代码实现

class Solution {
public:
    vector<int> robTree(TreeNode* root){
        if(root==nullptr)return {0,0};
        //dp[0]为当前未偷，dp[1]为当前偷了
        vector<int> left=robTree(root->left);
        vector<int> right=robTree(root->right);
        int val1=max(left[1],left[0])+max(right[0],right[1]);
        int val2=root->val+left[0]+right[0];
        return {val1,val2};
    }
    int rob(TreeNode* root) {
        vector<int> result=robTree(root);
        return max(result[0],result[1]);
    }
};

记忆化递归法（其他解法）

可以使用一个map把计算过的结果保存一下，这样如果计算过孙子了，那么计算孩子的时候可以复用孙子节点的结果。
代码如下：

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

---