【刷题day48】动态规划 | 198.打家劫舍、213.打家劫舍II 、 337.打家劫舍III

198.打家劫舍

题目讲解

思路：
决定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]);

// 动态规划
class Solution {
	public int rob(int[] nums) {
		if (nums == null || nums.length == 0) return 0;
		if (nums.length == 1) return nums[0];

		int[] dp = new int[nums.length];
		dp[0] = nums[0];
		dp[1] = Math.max(dp[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];
	}
}

213.打家劫舍II

思路： 环形问题考虑将其展开为线性问题

由于首元素和尾元素不能同时选，所以可以将遍历范围划分为三种线性结构：

• 不考虑首尾元素
• 不考虑首元素
• 不考虑尾元素

又由于后两种情况均包含了第一种情况，所以只需考虑后两种情况的遍历范围，采用上一题的思路，最终二者求最大值即可 。

题目讲解

class Solution {
    public int rob(int[] nums) {
        if (nums.length < 2) return nums[0];
        int res1 = robRange(nums, 0, nums.length - 2);
        int res2 = robRange(nums, 1, nums.length - 1);
        return Math.max(res1, res2);
    }

    public int robRange(int[] nums, int start, int end) {
        if (start == end) 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

题目讲解

思路： 对于树的话，首先就要想到遍历方式，前中后序（深度优先搜索）还是层序遍历（广度优先搜索）。
本题一定是要后序遍历，因为通过递归函数的返回值来做下一步计算。
与198.打家劫舍，213.打家劫舍II一样，关键是要讨论当前节点抢还是不抢。
如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子

dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。所以本题dp数组就是一个长度为2的数组。因为树形结构不像线性结构那样有下标，可以标记dp数组所计算的范围，树形结构需要在递归的基础上利用动态规划思想，其实每个范围的dp在每一层的递归栈中就保存了，所以只需关注当前层即当前节点的dp数组值就好。

dp数组表示偷或不偷本结点的各自最大价值，长度为2
下标0不偷，下标1偷

class Solution {
    public int rob(TreeNode root) {
        int[] dp = robDP(root);
        // dp数组表示偷或不偷本结点的各自最大价值，长度为2
        // 下标0不偷，下标1偷
        return Math.max(dp[0], dp[1]);
    }

    public int[] robDP(TreeNode root) {
        int[] dp = new int[2];
        if (root == null) return dp;
        
        int[] dpL = robDP(root.left);
        int[] dpR = robDP(root.right);

    	// 不偷：Max(左孩子不偷，左孩子偷) + Max(又孩子不偷，右孩子偷)
    	// 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
        // 不偷root，dp[0]
        int val1 = Math.max(dpL[0], dpL[1]) + Math.max(dpR[0], dpR[1]);
        // 偷root，dp[1]
        int val2 = root.val + dpL[0] + dpR[0];
        dp[0] = val1;
        dp[1] = val2;
        return dp;
    }
}

class Solution {
    // 1.递归去偷，超时
    public int rob(TreeNode root) {
        if (root == null)
            return 0;
        int money = root.val;
        if (root.left != null) {
            money += rob(root.left.left) + rob(root.left.right);
        }
        if (root.right != null) {
            money += rob(root.right.left) + rob(root.right.right);
        }
        return Math.max(money, rob(root.left) + rob(root.right));
    }

    // 2.递归去偷，记录状态
    // 执行用时：3 ms , 在所有 Java 提交中击败了 56.24% 的用户
    public int rob1(TreeNode root) {
        Map<TreeNode, Integer> memo = new HashMap<>();
        return robAction(root, memo);
    }

    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;
    }
}