代码随想录-刷题第四十八天

198. 打家劫舍

题目链接：198. 打家劫舍

思路：当前房屋偷与不偷取决于前一个房屋和前两个房屋是否被偷了。这里就更感觉到，当前状态和前面状态会有一种依赖关系，那么这种依赖关系都是动规的递推公式。动态规划五步曲：

1. dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。

2. 递推公式：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]取最大值

3. 初始化：从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值，即：dp[1] = max(nums[0], nums[1])

4. 遍历顺序：dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前向后遍历！

5. 举例推导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的题目，因为需要在树的结构上进行状态转移。以递归三部曲为主，融合动态规划五步曲进行分析。

1. 确定递归函数的参数和返回值

   要求一个节点偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。

   返回数组就是dp数组。**dp数组（dp table）以及下标的含义：**下标为0记录不偷该节点所得到的最大金钱，下标为1记录偷该节点所得到的最大金钱。

2. 确定终止条件

   在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回，这也相当于dp数组的初始化。

3. 确定遍历顺序

   首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。

   通过递归左节点，得到左节点偷与不偷的金钱。

   通过递归右节点，得到右节点偷与不偷的金钱。

4. 确定单层递归的逻辑

   如果不偷当前节点，那么就可以偷左右孩子，但是还要选出最大的，res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1])

   如果偷了当前节点，那么，左右孩子就都不能偷，res[1] = node.val + left[0] + right[0]

5. 举例推导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;
    }
}

---