leetcode337. 打家劫舍 III

传送门

题目: 在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
输入: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \ 
     3   1

输出: 7 解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7

方法1-暴力递归-最优子结构

我们使用爷爷-两个孩子-4个孙子来说明问题
首先来定义这个问题的状态：爷爷节点获取到最大的偷取的钱数？

1. 首先要明确相邻的节点不能偷，也就是爷爷选择偷，儿子就不能偷了，但是孙子可以偷
2. 二叉树只有左右两个孩子，一个爷爷最多2个儿子,4个孙子

根据以上条件，我们可以得出单个节点的钱该怎么算：

4个孙子偷的钱 + 爷爷的钱 VS 两个儿子偷的钱

哪个组合钱多，就当做当前节点能偷的最大钱数。这就是动态规划里面的最优子结构

4个孙子偷的钱加上爷爷的钱如下：

int rootMoney = root.val  +
   rob(root.left.left) +
   rob(root.left.right) +
   rob(root.right.left) + 
   rob(root.right.right)

两个儿子偷的钱如下：

int childMoney = rob(root.left) + rob(root.right);

挑选一个钱数多的方案则:int result = Math.max(rootMoney, childMoney);

int rob(TreeNode* root) {
	if (root == NULL) return 0;

    int rootMoney = root->val; // 爷爷+4个孙子的和
    if (root->left != NULL)
        rootMoney += rob(root->left->left) + 
        rob(root->left->right);
    if (root->right != NULL)
        rootMoney += rob(root->right->left) + 
        rob(root->right->right);

    int childMoney = rob(root->left) + 
    	rob(root->right); // 两个儿子的和
    
    return max(rootMoney, childMoney);   
}

方法2-记忆化-解决重复子问题

针对方法1速度太慢的问题，经过分析其实现，我们发现爷爷在计算自己能偷多少钱的时候，同时计算了4个孙子能偷多少钱，也计算了2个儿子能偷多少钱，这样没错，但是在儿子当爷爷时，它的儿子是上一轮的孙子，已经计算过了，所以就会产生重复计算一遍。

于是乎我们发现了一个动态规划的关键优化点：重复子问题

我们这一步针对重复子问题进行优化，优化方案可以是记忆化,但是之前的问题都是使用数组解决的，把每次计算的结果都存起来，下次如果再来计算，就从缓存中取，不再计算了，这样就保证每个数字只计算一次。

由于二叉树不适合拿数组当缓存，我们这次使用哈希表来存储结果

TreeNode当做key，能偷的钱当做value

方法1加上记忆化优化后代码如下

 int rob(TreeNode* root) {
    if (root == NULL) return 0;
    unordered_map<TreeNode*, int> hashMap;
    return robCore(root, hashMap);
 }

int robCore(TreeNode* root, unordered_map<TreeNode*, int> &hashMap) {
    if (root == NULL) return 0;
	if (hashMap.count(root) != 0) return hashMap[root];

	int rootMoney = root->val;

    if (root->left != NULL)
      rootMoney += robCore(root->left->left, hashMap) + 
      robCore(root->left->right, hashMap);

   if (root->right != NULL)
      rootMoney += robCore(root->right->left, hashMap) +
      robCore(root->right->right, hashMap);

   int childMoney = robCore(root->left, hashMap) + 
       robCore(root->right, hashMap);
       
   hashMap[root] = max(rootMoney, childMoney);
   return hashMap[root];   
 }

方法3. 树形动态规划

上面两种解法用到了孙子节点，计算爷爷节点能偷的钱还要同时去计算孙子节点投的钱，虽然有了记忆化，但是还是有性能损耗。

我们换一种办法来定义此问题
每个节点可选择偷或者不偷两种状态，根据题目意思，相连节点不能一起偷

1. 当前节点选择偷时，那么两个孩子节点就不能选择偷了
2. 当前节点选择不偷时，两个孩子节点只需要拿最多的钱出来就行(两个孩子偷不偷没关系)

我们使用一个大小为2的数组来表示 int[] dp = new int[2]; 0代表不偷，1代表偷

任何一个节点能偷到的最大钱的状态可以定义为:

1. 当前节点选择不偷:
   当前节点能偷到的最大钱数 = 左孩子能偷到的钱 + 右孩子能偷到的钱

2. 当前节点选择偷: 当前节点能偷到的最大钱数 =
   左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数

	public int rob(TreeNode root) {
        int[] dp = robCore(root);
        return Math.max(dp[0], dp[1]);
    }
    
    //每个节点只当作一次根节点 就不会重复递归多次计算了
    int[] robCore(TreeNode root) {
        if (root == null) return new int[]{0, 0};
    
        int[] dpLeft = robCore(root.left);
        int[] dpRight = robCore(root.right);

        int[] dpRoot = new int[2];

        // 当前节点不偷 = 
        // 左/右孩子能偷到的最大钱(左/右孩子偷和不偷 取max) 的和  
        dpRoot[0] = Math.max(dpLeft[0], dpLeft[1]) +
                    Math.max(dpRight[0], dpRight[1]);
        // 当前节点 偷 
        dpRoot[1] = root.val + dpLeft[0] + dpRight[0]; 

        return dpRoot;
    }