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

题解分析

解法一：动态规划

1. 本题属于【打家劫舍】系列的题目，前两道题目也是关于动态规划求解的类型：
   打家劫舍
   打家劫舍-2
2. 本题的解法与之前这两道题目的解法有一些不同，因为这是在树上做状态转移。仔细来看本题的题意：对于一个节点来说，小偷只能有两种操作，一种是偷，另一种是放弃偷本节点。进一步地，如果小偷选择偷当前节点，那么这就会影响子节点都不能被偷；而如果小偷选择不偷当前节点，那么子节点的状态将不受任何影响，因为子节点可以偷也可以不被偷，这不会违背题目的要求。
3. 通过以上的考虑，我们发现其实每个节点有两种状态，所以可以设置两种状态方程来实现状态的转移。f(i)表示当前节点被偷，而g(i)则表示当前节点不被偷。
4. 状态转移方程的定义如下：
   • \(f(i) = i.val + g(i.left) + g(i.right)\)；
   • \(g(i) = Math.max(f(i.left), g(i.left)) + Math.max(f(i.right), g(i.right))\);
5. 需要注意的是，本题在遍历二叉树的时候需要选择后序遍历的方式，因为根节点依赖于子节点的状态。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // f(i) = g(left) + g(right) + val; // 选当前节点的话，最大收益为不选左节点和不选右节点的和
    // g(i) = max(f(left), g(left)) + max(f(right), g(right)); // 不选当前节点的话，左右子节点均可选或者不选
    HashMap<TreeNode, Integer> fmap = new HashMap<>();
    HashMap<TreeNode, Integer> gmap = new HashMap<>();
    public int rob(TreeNode root) {
        dfs(root);
        return Math.max(fmap.getOrDefault(root, 0), gmap.getOrDefault(root, 0));

    }
    void dfs(TreeNode node){
        if(node == null)
            return;
        dfs(node.left);
        dfs(node.right);
        fmap.put(node, gmap.getOrDefault(node.left, 0) + gmap.getOrDefault(node.right, 0) + node.val);
        gmap.put(node, Math.max(fmap.getOrDefault(node.left, 0), gmap.getOrDefault(node.left, 0)) + 
                        Math.max(fmap.getOrDefault(node.right, 0), gmap.getOrDefault(node.right, 0)));
    }
}

解法二：动态规划压缩数组

1. 还是之前的总结，只要出现了动态规划，我们就应该想一想能否使用压缩数组来进行空间的压缩。
2. 考虑到本题的当前状态也只依赖于左右子节点的状态，所以可以使用两个变量来保存子节点的两个状态（即偷的最大收益和不偷的最大收益）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // f(i) = g(left) + g(right) + val; // 选当前节点的话，最大收益为不选左节点和不选右节点的和
    // g(i) = max(f(left), g(left)) + max(f(right), g(right)); // 不选当前节点的话，左右子节点均可选或者不选
    HashMap<TreeNode, Integer> fmap = new HashMap<>();
    HashMap<TreeNode, Integer> gmap = new HashMap<>();
    public int rob(TreeNode root) {
        int[] res = dfs(root);
        return Math.max(res[0], res[1]);

    }
    int[] dfs(TreeNode node){
        if(node == null)
            return new int[]{0, 0};
        int[] left = dfs(node.left);
        int[] right = dfs(node.right);
        int f = left[1] + right[1] + node.val;
        int g = Math.max(left[0], left[1]) +  Math.max(right[0], right[1]);
        
        return new int[]{f, g};// f表示选择当前节点的最大权值，g表示不选择当前节点的最大权值
    }
}