力扣刷题||打家劫舍系列问题

说实话，遇到这题目的要求多少有点觉得有被冒犯的，开局就被当做小偷。

再次回顾动态规划

1、明确dp数组的含义，已经下标代表什么

2、确定递推公式

3、dp数组初始化

4、确定遍历顺序

5、打印dp数组，进行一个验证。

198. 打家劫舍 - 力扣（LeetCode）

思路：

当一个小偷进入房间，要么就是偷，要么就是不偷，所以，在这定义dp数组为，小偷进入该房间我选择偷还是不偷能得到的最大钱数。

因为相邻房间不能够偷窃，所以要么当前房间不能偷窃，要么就能够偷窃。所以有

dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

初始化，这里得从dp[2]开始，因为前面两个完全可以直接得出

dp[0] = nums[0];
//疑惑的点，就是当前房间偷还是不偷的问题
dp[1] = max(nums[1], nums[0]);

可能会有一个疑惑，为什么这样就能保证，相邻房间不被偷呢？在递推公式这，因为一开始，我就保证了，我要么偷当前房间，要么不偷，后面也是，也就是对前面的数值进行一个规划，就是一开始我就按照这个逻辑来的，并且取值也是按照正常逻辑走的。

class Solution {
public:
    int rob(vector<int>& nums) 
    {
        if (nums.size() == 0)return 0;
        if (nums.size() == 1)return nums[0];//从这里就已经说明了，要如何去除掉相关东西
        //定义dp数组，表示到第几个房间，所能够得到最大的钱
        vector<int>dp(nums.size());//其中包含了，nums.size个元素，并且每个位置都为0
        dp[0] = nums[0];
        //疑惑的点，就是当前房间偷还是不偷的问题
        dp[1] = max(nums[1], nums[0]);
        for (int i = 2; i < nums.size(); i++)
        {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);//这里是说明，我能偷还是不能偷，如果取哪个最大值，说明我当前这个能偷
            //因为在一开始都保证了一开始的正确，所以后面是不会出错的
        }
    }
};

213. 打家劫舍 II - 力扣（LeetCode）

思路：因为这里存在环的问题，根据题目，可以知道要么不取首元素，要么不取尾元素，这样才能够避免环尾和环头进行相邻。

也就是将此题分为两种情况，去除首元素，去除尾元素。

class Solution {
public:
    int  robmoney(vector<int>& result, int startIndex, int endIndex, vector<int>& nums)
    {
        if (startIndex == endIndex) return nums[startIndex];
        result[startIndex] = nums[startIndex];
        result[startIndex + 1] = max(nums[startIndex], nums[startIndex + 1]);
        for (int i = startIndex + 2; i <= endIndex; i++)
        {
            result[i] = max(result[i - 1], result[i - 2] + nums[i]);
        }
        return result[endIndex];
    }
    int rob(vector<int>& nums)
    {
        if (nums.size() == 0)return 0;
        if (nums.size() == 1)return nums[0];
        vector<int>dp1(nums.size());
        vector<int>dp2(nums.size());
        //dp数组初始化
        int i = robmoney(dp1, 0, nums.size() - 2, nums);
        int j = robmoney(dp2, 1, nums.size() - 1, nums);
        return max(i, j);
    }
};

在这里一定要记住，要判断传入的startIndex是否等于endIndex，若等于，则直接返回即可，因为在后面start+1这里会产生越界。对于第一个数组来说，不会，但是对于去除首元素会出现，我就是在这判断越界这一块存在一些问题。

337. 打家劫舍 III - 力扣（LeetCode）

本题相对而言，还是有难度的，对后序遍历，一刷过程，先这样，等待二刷。

class Solution {
public:
    vector<int> traval(TreeNode* root)
    {
        if (root == NULL)return vector<int>{0,0};
        vector<int> left = traval(root->left);
        vector<int> right = traval(root->right);
        int val1 = root->val + left[0] + right[0];
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return { val2,val1 };
    }
    int rob(TreeNode* root) 
    {
        vector<int>dp = traval(root);
        return max(dp[0], dp[1]);
    }
};