dp：打家劫舍123，环形数组，树形dp

打家劫舍

198.打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 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

思路

偷不同的房屋影响不同，可以找到一组连续的子问题，所以考虑使用dp
分五步走：

1. 确定dp数组及其下标含义：dp[i]表示偷完第i个房间的时候，最大的金额
2. 推导递推公式：
   对于每一个房间，可以由偷和不偷
   偷：dp[i] = dp[i-2] + nums[i]
   不偷： dp[i] = dp[i-1]
   我们要取最大值,所以递推公式为:dp[i] = max(dp[i-1],dp[i-2]+nums[i])
3. 初始化dp：下标为0时，只能偷nums[0],所以dp[0] = 0
   下标为1时，偷1和0中较大者：dp[1] = max(nums[0],nums[1])
4. 确定遍历顺序：j由j-2和j-1推导出，所以正序遍历
5. 举例推导dp数组

代码

public int rob(int[] nums) {
    if(nums.length == 0) return 0;
    if(nums.length == 1) return nums[0];
    int[] dp = new int[nums.length+1];
    dp[0] = nums[0];
    dp[1] = Math.max(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];
}

---

打家劫舍II

213. 打家劫舍 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

思路

此题所有房屋围成了一圈，所以选了第一个房子就不能选最后一个房子，选了最后一个房子就不能选第一个房子，所以此题应该分类讨论
即：不考虑第一个房子打家劫舍I 和 不考虑最后一个房子的打家劫舍I

代码

public int rob(int[] nums) {
	 if(nums.length == 0) return 0;
	    if(nums.length == 1) return nums[0];
	    int result1 = fun1(nums,0,nums.length-2);
	    int result2 = fun1(nums,1,nums.length-1);
	    return Math.max(result1,result2);
	}
	public int fun1(int[] nums, int begin, int end) {
	    if(begin == end) return nums[begin];
	    int[] dp = new int[nums.length + 1];
	    dp[begin] = nums[begin];
	    dp[begin + 1] = Math.max(nums[begin + 1],nums[begin]);
	    for(int i = begin + 2; i <= end; i++) {
	        dp[i] = Math.max(dp[i-1],dp[i-2] + nums[i]);
	    }
	    return dp[end];
	}

---

打家劫舍III

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

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

 3
/ \

2 3
\ \
3 1

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

 3
/ \

4 5
/ \ \
1 3 1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

思路

本题数包含二叉树的dp，也称树形dp，本题最要注意的点是，无后效性和后序遍历
后序遍历：因为本题的房间取与不取，取决于子节点的情况，所以应该是从后往前遍历，即二叉树的后序遍历
无后效性：当前结点 偷 与 不偷 决定了子节点的偷与不偷，所以将此关系确定成为一个状态存使用数组存储，从而取消除后效性

五步走：

1. 确定dp数组及其下标含义：由于引用树这一数据结构使用树的后序遍历，所以遍历过程都保存在了递归树中，所以只需要确定该结点偷与不偷，使用一个长度为2的一维数组dp[2]，dp[0] 表示不偷，dp[1] 表示偷，所以递归的返回值就是一个长度为2的数组，参数为当前结点
2. 推导dp方程：状态只有两种
   偷该结点，那么子节点不能偷：val1 = node.val + left[0] + right[0]
   不偷该结点，那么偷两个子节点的最大值：val2 = max(left[0],left[1]) + max(right[0],right[1])
   最后关系为：max(val1,val2)即，偷该结点的最大金额，不偷该结点的最大金额
3. 初始化：由于是后序遍历，所以空节点的金额一定是0，这也是递归的出口
4. 确定遍历方向：开头已经说明，该结点偷不偷取决于子节点偷不偷，所以遍历顺序是后序遍历
5. 举例推导dp数组

代码

public int rob(TreeNode root) {
     int[] result = robTree(root);
     return Math.max(result[0],result[1]);
 }
 public int[] robTree(TreeNode node) {
     if(node == null) return new int[]{0,0};

     int[] left = robTree(node.left);
     int[] right = robTree(node.right);

     int val1 = node.val + left[0] + right[0];
     int val2 = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
     return new int[]{val2,val1};
 }

总结

• 遇到环状dp思考分类讨论，将环断开分开讨论
• 遇到树形dp，思考遍历顺序（是否是后序遍历），判断该结点的值是依靠那些结点得来
  遍历二叉树，一般使用递归，要思考递归的返回值和参数，以及递归的结束条件
  消除后效性：使用数组存储当前结点状态（取或者不取），即在设计状态的时候，在后面加一维，消除后效性

参考

liweiwei：https://leetcode-cn.com/problems/house-robber-iii/solution/shu-xing-dp-ru-men-wen-ti-by-liweiwei1419/
Carl：https://mp.weixin.qq.com/s/BOJ1lHsxbQxUZffXlgglEQ