198. 打家劫舍
题目链接：198. 打家劫舍
思路：当前房屋偷与不偷取决于前一个房屋和前两个房屋是否被偷了。这里就更感觉到，当前状态和前面状态会有一种依赖关系，那么这种依赖关系都是动规的递推公式。动态规划五步曲：
-
dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
-
递推公式：dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i])
如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是容易混淆的点）
如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出下标为i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i - 2] 加上第i房间偷到的钱。
然后dp[i]取最大值
-
初始化：从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值，即：dp[1] = max(nums[0], nums[1])
-
遍历顺序：dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前向后遍历！
-
举例推导dp数组
以输入[2,7,9,3,1]为例。
红框dp[nums.length - 1]为结果。
class Solution {
public int rob(int[] nums) {
// dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]
int[] dp = new int[nums.length];
// 递推公式：dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
if (nums.length == 1) return nums[0];
// 初始化
dp[0] = nums[0];
dp[1] = nums[1] > nums[0] ? nums[1] : nums[0];
// 遍历顺序
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];
}
}
213. 打家劫舍 II
题目链接：213. 打家劫舍 II
思路：只需要考虑两种情况，包含第一家但是不包含最后一家，或者包含最后一家但是不包含第一家，其他思路与上一题相同。
class Solution {
public int rob(int[] nums) {
// 考虑两种情况，包含第一家不包含最后一家，包含最后一家不包含第一家
if (nums.length == 1) return nums[0];
int result1 = robRange(nums, 0, nums.length - 2);
int result2 = robRange(nums, 1, nums.length - 1);
return Math.max(result1, result2);
}
// 198.打家劫舍的逻辑
int robRange(int[] nums, int start, int end) {
if (end == start) return nums[start];
int[] dp = new int[nums.length];
dp[start] = nums[start];
dp[start + 1] = Math.max(nums[start], nums[start + 1]);
for (int i = start + 2; i <= end; i++) {
dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[end];
}
}
337. 打家劫舍 III
题目链接：337. 打家劫舍 III
思路：本题一定是要后序遍历，因为需要根据递归的返回值来做下一步计算。本题是一道树形dp的题目，因为需要在树的结构上进行状态转移。以递归三部曲为主，融合动态规划五步曲进行分析。
-
确定递归函数的参数和返回值
要求一个节点偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。
返回数组就是dp数组。**dp数组（dp table）以及下标的含义：**下标为0记录不偷该节点所得到的最大金钱，下标为1记录偷该节点所得到的最大金钱。
-
确定终止条件
在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回，这也相当于dp数组的初始化。
-
确定遍历顺序
首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。
通过递归左节点，得到左节点偷与不偷的金钱。
通过递归右节点，得到右节点偷与不偷的金钱。
-
确定单层递归的逻辑
如果不偷当前节点，那么就可以偷左右孩子，但是还要选出最大的，res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1])
如果偷了当前节点，那么，左右孩子就都不能偷，res[1] = node.val + left[0] + right[0]
-
举例推导dp数组
以示例1为例，dp数组状态如下：（注意用后序遍历的方式推导）
最后头结点就是取 下标0 和 下标1 的最大值就是偷得的最大金钱。
class Solution {
public int rob(TreeNode root) { // 树形dp，后序递归
// 一个二维的dp数组，代表偷当前节点和不偷当前节点所盗取的最高金额
int[] res = robAction(root);
return Math.max(res[0], res[1]);
}
int[] robAction(TreeNode node) {
int[] res = new int[2];
if (node == null) return res;
int[] left = robAction(node.left);
int[] right = robAction(node.right);
res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
res[1] = node.val + left[0] + right[0];
return res;
}
}
