打家劫舍——动态规划——代码随想录

1、打家劫舍
（1）题目分析：
小偷沿街偷窃，影响偷窃的因素是相邻的房屋装有防盗系统，如果相邻房屋同一晚上被小偷闯入，系统会自动报警。
总的目标：
偷窃的金额最大
【动态规划五部曲】
a.确定dp数组以及下标的含义
考虑下标i以内，最多可以偷窃的金额dp[i]
b.确定递推公式
如果偷第i个房间dp[i] = dp[i-2] + nums[i];
如果不偷第i个房间dp[i] = dp[i-1];
取这两者的最大值
c.dp数组的初始化
由递推公式可知dp[0]和dp[1]
d.确定遍历顺序
dp[i]是根据dp[i-2]和dp[i-1]推导出来的，一定是从前往后遍历；
（2）代码实现

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

2.打家劫舍②
（1）题目分析
升级改进版是因为首尾元素相邻了，对题目进行分析，
情况一：考虑不包含首尾元素；
情况二：考虑包含首元素，不包含尾元素；
情况三：考虑包含尾元素，不包含首元素；
情况二和情况三都包含可情况一,
就相当于把这个拆分成两个打家劫舍最基础的题目
（2）代码实现

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0)return 0;
        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);
    }
    int robRange(vector<int>&nums,int start,int end){
        if(end == start) return nums[start];//如果只有一个元素的情况
        vector<int>dp(nums.size());//这里还是nums.size();用end-start下标会乱
        dp[start] = nums[start];//初始化头部元素
        dp[start+1] = max(nums[start],nums[start+1]);
        for(int i=start+2;i<=end;i++){//这里的起始位置i = start+2
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[end];
    }
};

注意，函数调用时的括号关系,不要把调用函数写到主函数内了；
调用函数中的参数之间要用“；”隔开，报错信息是，丢失了一个括号
3.打家劫舍③
（1）题目分析
每栋房子有且只有一个“父”房子与之相连，房屋的排列类似于二叉树；
考察的知识点是对树的遍历，对树遍历理解清楚了后，就能和以上已有进行遍历得出结果了。
递归三部曲+动规五部曲
a.确定递归函数的参数和返回值/动态规划中明确动态规划数组以及其返回值的含义
每一个节点都返回偷与不偷状态所得到的金钱，返回值就是一个长度为2的数组。
b.确定终止条件
在遍历的过程中，遇到空节点，很明显，无论偷还是不偷都是0，所以就返回。
c.确定遍历顺序
使用后序遍历，通过递归函数的返回值来做下一步计算；
递归左节点，得到左节点偷与不偷的金钱；
递归右节点，得到右节点偷与不偷的金钱。
d.确定单层递归逻辑
如果偷当前节点，左右孩子就不能偷；
不偷当前节点，左右孩子就能偷；
e.举例推导dp数组
（2）代码实现

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0],result[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};//递推表达式的推导，是否抢左右叶子节点
    }
};