代码随想录算法训练营第四十八天|LeetCode198. 打家劫舍、LeetCode213. 打家劫舍 II、LeetCode337. 打家劫舍 III

一、LeetCode198. 打家劫舍

题目链接：198. 打家劫舍
背包问题求解。
1、确定dp[i]数组及其下标含义。dp[i] 表示到地i个房间所能偷到的最多金额。
2、递推公式：有两个方向推导而来。
（1）偷第i的房间：则dp[i] = dp[i - 2] + nums[i]。
（2）不偷第i个房间：则dp[i] = d[i - 1]。
所以dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])。
3、初始化：dp[0] = nums[0], dp[1] = max(nums[0], nums[1])
4、遍历顺序，从下标2开始，从小到达遍历。
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(), 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 - 2] + nums[i], dp[i - 1]);
        }

        return dp[nums.size() - 1];

    }
};

二、LeetCode213. 打家劫舍 II

题目链接：213. 打家劫舍 II
这道题跟上道题类似，只是需要考虑两种情况。1、考虑头不考虑尾，2、考虑尾不考虑头。
代码如下：

class Solution {
public:
    int trave(const 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];
    }
    int rob(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        if(nums.size() == 1) return nums[0];

        int result1 = trave(nums, 0, nums.size() - 2);//考虑头不考虑尾
        int result2 = trave(nums, 1, nums.size() - 1);//考虑尾不考虑头
        return max(result1, result2);
        

    }
};

三、LeetCode337. 打家劫舍 III

题目链接：337. 打家劫舍 III
用一个数组保存每个节点偷与不偷的最大值状态。
利用后序递归去遍历二叉树。

递归左右子节点得到左右子节点偷与不偷的最大值：

 vector<int>leftdp = robtree(root -> left);//向左递归，左子节点偷与不偷的最大值
 vector<int>rightdp = robtree(root -> right);//向右递归，右子节点偷与不偷的最大值

处理当前节点偷与不偷：
1、偷当前节点，则左右字节点都不能偷
2、不偷当前节点，则取左右子节点偷与不偷的最大值相加

int cur1 = root -> val + leftdp[0] + rightdp[0];//偷当前节点
int cur2 = max(leftdp[0], leftdp[1]) + max(rightdp[0], rightdp[1]);//不偷当前节点

代码如下：

class Solution {
public:
    vector<int> robtree(TreeNode* root) {
        if(root == NULL) return {0, 0};//如果当前节点为空，则偷与不偷都是0

        vector<int>leftdp = robtree(root -> left);//向左递归，左子节点偷与不偷的最大值
        vector<int>rightdp = robtree(root -> right);//向右递归，右子节点偷与不偷的最大值

        int cur1 = root -> val + leftdp[0] + rightdp[0];//偷当前节点
        int cur2 = max(leftdp[0], leftdp[1]) + max(rightdp[0], rightdp[1]);//不偷当前节点

        return {cur2, cur1};
    }
    int rob(TreeNode* root) {
        vector<int>result = robtree(root);

        return max(result[0], result[1]);//返回头节点偷与不偷的最大值

    }
};