Leetcode: House Robber III

The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the "root." Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that "all houses in this place forms a binary tree". It will automatically contact the police if two directly-linked houses were broken into on the same night.

Determine the maximum amount of money the thief can rob tonight without alerting the police.

Example 1:
     3
    / 
   2   3
        
     3   1
Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
Example 2:
     3
    / 
   4   5
  /     
 1   3   1
Maximum amount of money the thief can rob = 4 + 5 = 9.

https://discuss.leetcode.com/topic/39834/step-by-step-tackling-of-the-problem

rob(root) which will return the maximum amount of money that we can rob for the binary tree rooted at "root"

rob(root) = max(root.val+rob(gradchildren), rob(left)+rot(right)),

 think  about the possibilities of overlapping of the subproblems. For example, to obtain rob(root), we need rob(root.left), rob(root.right), rob(root.left.left), rob(root.left.right), rob(root.right.left), rob(root.right.right); but to get rob(root.left), we also needrob(root.left.left), rob(root.left.right), similarly for rob(root.right). The naive solution above computed these subproblems repeatedly, which resulted in bad time performance. Now if you recall the two conditions for dynamic programming: "optimal substructure" + "overlapping of subproblems", we actually have a DP problem. A naive way to implement DP here is to use a hash map to record the results for visited subtrees.

8ms DP solution:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    Map<TreeNode, Integer> map;
    public int rob(TreeNode root) {
        map = new HashMap<TreeNode, Integer>();
        return helper(root);
    }
    
    public int helper(TreeNode cur) {
        if (cur == null) return 0;
        if (map.containsKey(cur)) return map.get(cur);
        
        int val = 0; //initialize
        if (cur.left != null) {
            val += helper(cur.left.left) + helper(cur.left.right);
        }
        if (cur.right != null) {
            val += helper(cur.right.left) + helper(cur.right.right);
        }
        int curOpt = Math.max(val+cur.val, helper(cur.left)+helper(cur.right));
        map.put(cur, curOpt);
        return curOpt;
    }
}

 for each tree root, there are two scenarios: it is robbed or is not. rob(root) does not distinguish between these two cases, so "information is lost as the recursion goes deeper and deeper", which resulted in repeated subproblems.

Redefine rob(root)as a new function which will return an array of two elements, the first element of which denotes the maximum amount of money that can be robbed if "root" is not robbed, while the second element signifies the maximum amount of money robbed if root is robbed.

2ms DP solution:

public int rob(TreeNode root) {
    int[] res = robSub(root);
    return Math.max(res[0], res[1]);
}

private int[] robSub(TreeNode root) {
    if (root == null) {
        return new int[2];
    }
    
    int[] left = robSub(root.left);
    int[] right = robSub(root.right);
    
    int[] res = new int[2];
    res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
    res[1] = root.val + left[0] + right[0];
    
    return res;
}