随想录训练营41/60 | LC 198.打家劫舍；LC 213.打家劫舍II ；LC 337.打家劫舍III

LC 198.打家劫舍

题目链接：LC 198.打家劫舍
思路：偷第i家，通过第i-1和第i-2家得到，哪个大选择哪个。对dp[0]和dp[1]进行初始化。
代码：

class Solution {
public:
    int rob(vector<int>& nums) {
        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<dp.size(); i++){
            dp[i] = max(dp[i-1], dp[i-2]+nums[i]);
        }
        return dp.back();
    }
};

LC 213.打家劫舍II

题目链接：LC 213.打家劫舍II
思路：若投了开始那家，就不能偷最后一家，若偷了最后一家，就不能偷开始那家。本来计划用flag来看开头或者最后是否被占用，但是在过程中有可能将开始的节点删除。
因此，将问题进行拆分，对0至n-1与1至n分别进行dp统计最大值，然后比较两者找到最大值。
代码：

class Solution {
public:
    int robRange(vector<int>& nums, int begin, int end){
        if(begin==end)return nums[begin];
        vector<int> dp(end-begin);
        dp[0] = nums[begin];
        dp[1] = max(nums[begin], nums[begin+1]);
        for(int i=2; i<dp.size(); i++){
            dp[i] = max(dp[i-2]+nums[begin+i], dp[i-1]);
        }
        return dp.back();
    }
    int rob(vector<int>& nums) {
        if(nums.size()==1)return nums[0];
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        if(nums.size()==2)return dp[1];
        int a = robRange(nums, 0, nums.size()-1);
        int b = robRange(nums, 1, nums.size());
        cout << a <<endl;
        cout << b << endl;
        int c = max(a, b);
        return c;
    }
};

LC 337.打家劫舍III

题目链接：LC 337.打家劫舍III
思路：自己的思路为层次遍历二叉树，将每层的金额之和保存，然后像上面问题一样去偷。
本题思路：**遍历二叉树，二叉树的节点有两个值，分别为使用该节点值时的最大值，不使用该节点时的最大值；为什么每个节点要用到两个值？**因为可以用一个值的，但是一个值要对节点的孩子和孙子分别进行判断；若每个节点中有两个值，那么就只需看该节点的孩子节点即可。
代码：

/**
 * 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:
    //二叉树遍历
    //返回值为二维数组，第一个值是若不偷当前节点最大为多少，第二值为偷当前节点最大值为多少
    vector<int> robTree(TreeNode* root){
        //终止条件
        if(root==nullptr)return vector<int>(2, 0);
        //递归规则
        vector<int> left = robTree(root->left);
        vector<int> right = robTree(root->right);
        //若不加该节点
        vector<int> result(2, 0);
        result[0] = max(left[1], left[0])+max(right[1], right[0]);
        //若加这个节点
        result[1] = root->val+left[0]+right[0];
        return result;
    }
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
};