leetcode337. 打家劫舍 III

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
// 动态规划
// 4 个孙子偷的钱 + 爷爷的钱 VS 两个儿子偷的钱 哪个组合钱多，
// 就当做当前节点能偷的最大钱数。这就是动态规划里面的最优子结构

// 暴力法
class Solution {
    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));
    }
}

// 优化
// 使用哈希表来存储结果，TreeNode 当做 key，能偷的钱当做 value
class Solution {
    public int rob(TreeNode root) {
        HashMap<TreeNode, Integer> memo = new HashMap<>();
        return helper(root, memo);
    }

    private int helper(TreeNode root, HashMap<TreeNode, Integer> memo) {
        if (root == null) return 0;
        // 如果哈希表有当前key，则直接返回
        if (memo.containsKey(root)) return memo.get(root);
        int money = root.val;

        if (root.left != null) {
            money += helper(root.left.left, memo) + helper(root.left.right, memo);
        }
        if (root.right != null) {
            money += helper(root.right.left, memo) + helper(root.right.right, memo);
        }

        int result = Math.max(money, helper(root.left, memo) + helper(root.right, memo));
        memo.put(root, result);
        return result;
    }
}

/**
 * 我们换一种办法来定义此问题
 * 每个节点可选择偷或者不偷两种状态，根据题目意思，相连节点不能一起偷
 * 当前节点选择偷时，那么两个孩子节点就不能选择偷了
 * 当前节点选择不偷时，两个孩子节点只需要拿最多的钱出来就行(两个孩子节点偷不偷没关系)
 * 我们使用一个大小为 2 的数组来表示 int[] res = new int[2] 0 代表不偷，1 代表偷
 * 任何一个节点能偷到的最大钱的状态可以定义为
 * 1.当前节点选择不偷：当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱
 * 2.当前节点选择偷：当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数
 * 表示为公式如下
 * root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) + Math.max(rob(root.right)[0], rob(root.right)[1])
 * root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;
 */
class Solution {
    public int rob(TreeNode root) {
        int[] result = helper(root);
        return Math.max(result[0], result[1]);
    }

    private int[] helper(TreeNode root) {
        int[] result = new int[2];
        if (root == null) return result;

        int[] left = helper(root.left);
        int[] right = helper(root.right);

        result[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        result[1] = left[0] + right[0] + root.val;

        return result;
    }
}