目录
198.打家劫舍
一维dp
滚动数组优化一维dp空间
进一步优化滚动数组
213.打家劫舍II
337.打家劫舍III（树形dp）
打家劫舍是dp解决的经典问题
注意树形dp337
198.打家劫舍
当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。
所以这里就更感觉到，当前状态和前面状态会有一种依赖关系，那么这种依赖关系都是动规的递推公式。
当然以上是大概思路，打家劫舍是dp解决的经典问题，接下来我们来动规五部曲分析如下：
- 确定dp数组以及下标的含义
dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
- 确定递推公式
决定dp[i]的因素就是第i房间偷还是不偷。
- 偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。
- 不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）
然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
- dp数组如何初始化
从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0] 和 dp[1]
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1]);
- 确定遍历顺序
dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！
一维dp
class Solution {public int rob(int[] nums) {if (nums.length == 1) return nums[0];int[] dp = new int[nums.length];dp[0] = nums[0];dp[1] = Math.max(nums[0], nums[1]);for (int i = 2; i < nums.length; i++) {dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);}return dp[nums.length - 1];}}- 时间复杂度: O(n)
- 空间复杂度: O(n)
滚动数组优化一维dp空间
int[] result = new int[3];
class Solution {public int rob(int[] nums) {// 使用滚动数组思想，优化空间// 分析本题可以发现，所求结果仅依赖于前两种状态，此时可以使用滚动数组思想将空间复杂度降低为3个空间int len = nums.length;if (len == 1) return nums[0];else if (len == 2) return Math.max(nums[0], nums[1]);int[] result = new int[3];result[0] = nums[0];result[1] = Math.max(nums[0], nums[1]);for (int i = 2; i < len; i++) {result[2] = Math.max(result[0] + nums[i], result[1]);result[0] = result[1];result[1] = result[2];}return result[2];}}进一步优化滚动数组
dp数组只存与计算相关的两次数据
class Solution {public int rob(int[] nums) {// 进一步优化滚动数组if (nums.length == 1) return nums[0];// 初始化dp数组// 优化空间 dp数组只用2格空间 只记录与当前计算相关的前两个结果int[] dp = new int[2];dp[0] = nums[0];dp[1] = Math.max(nums[0], nums[1]);int res = 0;for (int i = 2; i < nums.length; i++) {res = Math.max(dp[1], dp[0] + nums[i]);dp[0] = dp[1];dp[1] = res;}return dp[1];}}注意：最后是return dp[1]而不是return res。因为还有一个nums.length == 2的情况，除非单独做了处理，否则此时的res是为0没有进循环赋值的。
213.打家劫舍II
这道题目和198是差不多的，唯一区别就是成环了。
对于一个数组，成环的话主要有如下三种情况：
- 情况一：考虑不包含首尾元素
- 情况二：考虑包含首元素，不包含尾元素
- 情况三：考虑包含尾元素，不包含首元素
情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。
情况一二三是“考虑”的范围，而具体房间偷与不偷交给递推公式去抉择。
class Solution {public int rob(int[] nums) {if (nums.length == 1) return nums[0];else if (nums.length == 2) return Math.max(nums[0], nums[1]);return Math.max(robAction(nums, 0, nums.length - 1), robAction(nums, 1, nums.length));}//普通版的打家劫舍，参考198public int robAction(int[] nums, int start, int end) {int x = 0, y = 0, z = 0;// x 代表的是前一个房子的最大值（相当于 "i-2"）// y 代表的是当前房子的最大值（相当于 "i-1"）// z 是当前房子（nums[i]）是否偷的最大值，即 Math.max(y, x + nums[i])，选择偷或者不偷当前房子。for (int i = start; i < end; i++) {z = Math.max(y, x + nums[i]);x = y;y = z;}return z;}}- 时间复杂度: O(n)
- 空间复杂度: O(n)
337.打家劫舍III（树形dp）
（所谓树形DP就是在树上进行递归公式的推导）
这道题目和198，213也是如出一辙，只不过这个换成了树。
对于树的话，首先就要想到遍历方式，前中后序（深度优先搜索）还是层序遍历（广度优先搜索）。
本题一定是要后序遍历，因为通过递归函数的返回值来做下一步计算。
与198.打家劫舍，213.打家劫舍II一样，关键是要讨论当前节点抢还是不抢。
如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子（注意这里说的是“考虑”）
动态规划其实就是使用状态转移容器来记录状态的变化，这里可以使用一个长度为2的数组，记录当前节点偷与不偷所得到的的最大金钱。
这道题目算是树形dp的入门题目，因为是在树上进行状态转移，我们在讲解二叉树的时候说过递归三部曲，那么下面我以递归三部曲为框架，其中融合动规五部曲的内容来进行讲解。
- 确定递归函数的参数和返回值
这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。
dp数组以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
所以本题dp数组就是一个长度为2的数组！
那么有同学可能疑惑，长度为2的数组怎么标记树中每个节点的状态呢？
别忘了在递归的过程中，系统栈会保存每一层递归的参数。
如果还不理解的话，就接着往下看，看到代码就理解了哈。
- 确定终止条件
在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回
if (cur == NULL) return vector<int>{0, 0};这也相当于dp数组的初始化
- 确定遍历顺序
首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。
通过递归左节点，得到左节点偷与不偷的金钱。
通过递归右节点，得到右节点偷与不偷的金钱。
代码如下：
// 下标0：不偷，下标1：偷
vector<int> left = robTree(cur->left); // 左
vector<int> right = robTree(cur->right); // 右
// 中
- 确定单层递归的逻辑
如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0];
如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}
代码如下：
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};- 举例推导
最后头结点就是 取下标0 和 下标1的最大值就是偷得的最大金钱。
建议直接看代码3，树形dp。
方法1为暴力递归法，超时；方法2为方法1的优化递归版本，用map记录已经计算过的结果，避免重复计算。
class Solution {public int rob(TreeNode root) {
// // 1.递归去偷，超时(暴力递归法)
// if (root == null) return 0;
// int money = root.val;
// if (root.left != null)
// money += rob(root.left.left) + rob(root.left.right); // 跳过 root.left
// if (root.right != null)
// money += rob(root.right.left) + rob(root.right.right); // 跳过 root.right
// return Math.max(money, rob(root.left) + rob(root.right)); // money是偷当前root节点，后者是不偷当前节点// // 2.递归去偷，记录状态（记忆化递推）
// // 使用一个map把计算过的结果保存一下，这样如果计算过孙子了，那么计算孩子的时候可以复用孙子节点的结果。
// Map<TreeNode, Integer> memo = new HashMap<>();
// return robAction(root, memo);// 3.树形dp入门// res[0] 不偷 res[1] 偷// 不偷：Max(左孩子不偷，左孩子偷) + Max(右孩子不偷，右孩子偷)// root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +// Math.max(rob(root.right)[0], rob(root.right)[1])// 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷// root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;int[] res = robDP(root);return Math.max(res[0], res[1]);}// 3.树形dp入门public int[] robDP(TreeNode root) {int res[] = new int[2];if (root == null) return res;int[] left = robDP(root.left);int[] right = robDP(root.right);res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);res[1] = root.val + left[0] + right[0];return res;}// 2.递归去偷，记录状态（记忆化递推）
// public int robAction(TreeNode root, Map<TreeNode, Integer> memo) {
// if (root == null) return 0;
// if (memo.containsKey(root))
// return memo.get(root);
// int money = root.val;
// if (root.left != null)
// money += robAction(root.left.left, memo) + robAction(root.left.right, memo);
// if (root.right != null)
// money += robAction(root.right.left, memo) + robAction(root.right.right, memo);
// int res = Math.max(money, robAction(root.left, memo) + robAction(root.right, memo));
// memo.put(root, res);
// return res;
// }}第三十九天的总算是结束了，直冲Day41！（因为40休息嘿嘿）