打家劫舍系列（dp）

引言

打家劫舍类的题目是动态规划里的经典题目，有很多种变换形式，下面就介绍一下力扣里面的所有打家劫舍的题目；

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。

示例 1：输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 400

我们来分析一下这道题：
1，dp[i]代表 i 以内的房屋偷盗的最大金额；
2，如果在第 i 间房屋偷钱了，那么dp[i] = dp[i - 2] + nums[i]；
如果没有在第 i 间房屋偷钱，那么dp[i] = dp[i - 1]；
因为求最大值，所以dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])；
3，dp数组初始化无非就两种情况
dp[0] = nums[0]；
dp[1] = max(nums[0], nums[1]);
4，因为dp[i]是由dp[i - 1]和dp[i - 2]求得的，所以可以看出来遍历顺序就是从前到后遍历的；

代码如下：

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

这是打家劫舍1.0基础版，比较容易求出来，接下来我们来个升级版的；

打家劫舍II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：
输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：
输入：nums = [0]
输出：0

提示：
1 <= nums.length <= 100
0 <= nums[i] <= 1000

这道题里的房屋都围成了一个圈，这样和第一题不同的就是需要多考虑一下，
情况1：如果偷了第一个房屋，最后一个就不能偷；
情况2：如果没有偷第一个房屋（那就是从第二个房屋开始偷的），就可以偷最后一个；
可以发现单看哪种情况都是和打家劫舍1.0版本一样的；
所以我们需要单独求出两种情况的最大金额，然后取最大值即可；
为了方便求两种情况最大金额，再额外写个函数更好；

代码如下：

class Solution {public:int rob(vector<int>& nums) {int n =nums.size();if (n == 1) return nums[0];if (n == 2) return max(nums[1], nums[0]);//情况2和情况1return max(robRank(nums, 1, n - 1), robRank(nums, 0, n - 2));}int robRank(vector<int>& nums, int begin, int end) {vector<int> dp(nums.size());dp[begin] = nums[begin];dp[begin + 1] = max(nums[begin], nums[begin + 1]);for (int i = begin + 2; i <= end; ++i) {dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);}return dp[end];}
};

这道题就需要多考虑一下了，但是核心还是一样的；接下来来个不一样的

打家劫舍III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例1

示例2

这是一道树形dp的入门题，相似的题目，需要我们熟悉二叉树的遍历，而这道题需要用到的是后续遍历；
我们假设 1 为偷， 0 为不偷，那么我们需要一个递归函数，返回偷和不偷的金额即可，最后区它俩的最大值就是本题答案；
所以我们可以先确定返回值为一个vector数组，大小为2

vector<int> robTree(TreeNode* root)

那么这个递归函数的终止条件又是什么？
当传入节点 root 为空时，我们就返回{0, 0}就可以了；

if (!root) return vector<int>{0, 0};

接下来我们定义两个vector变量存放递归左子树和右子树的结果

vector<int> l = robTree(root -> left);
vector<int> r = robTree(root -> right);

最后我们就该确定递归逻辑了，这里分为两种情况
1，如果偷root，则左右孩子就不能偷

int ans1 = root -> val + l[0] + r[0];

2，如果不偷root，那么左右孩子都可以偷，但是偷或者不偷需要在这里选择一个最大值；

int ans2 = max(l[1], l[0]) + max(r[1], r[0]);

最后返回ans2和ans1就可以了，一定要注意返回时的顺序，不偷的在前，偷的在后

代码如下：

/*** 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:int rob(TreeNode* root) {vector<int> ans = robTree(root);return max(ans[0], ans[1]);}// 长度为2的数组,0不偷,1偷vector<int> robTree(TreeNode* root) {if (!root) return vector<int>{0, 0};vector<int> l = robTree(root -> left);vector<int> r = robTree(root -> right);int ans1 = root -> val + l[0] + r[0];          //偷rootint ans2 = max(l[1], l[0]) + max(r[1], r[0]);  //不偷rootreturn {ans2, ans1};}
};

总结

打家劫舍系列就结束了，这里三道题都是力扣原题，最后一道题用到了树形dp，所以需要多了解一下，前两道题目都很相似，都可以练练手，有什么问题也欢迎交流；