leetcode337. 打家劫舍 III

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/house-robber-iii

题目描述

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
给定二叉树的 root 。返回在不触动警报的情况下，小偷能够盗取的最高金额

示例1：

输入: root = [3,2,3,null,3,null,1]
输出: 7
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

示例2：

输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9

提示：
树的节点数在 [1, 10000] 范围内
0 <= Node.val <= 10000

暴力递归

解题思路

二叉树是有两个分支，我们要分成两个方向讨论这个问题，
当前节点不选时，下面左节点和右节点都可选可不选。
如果当前节点选了，下面左节点和右节点都不能选了。
要去左节点的左右节点和右节点的左右节点去做选择，
好了知道这两种情况了，我们就可以正常写代码了。

代码演示

/**
* 主方法调用
*/
   public int rob(TreeNode root) {
        if(root == null){
            return 0;
        }
     
      return process(root);
    }
/**
* 递归 
*/
 public int process(TreeNode root){
 			//base case 
        if(root == null){
            return 0;
        }
        //当前节点不选的时候，我们去左右节点去做选择。
        int p1 = process(root.left);
        int p2 = process(root.right);
        //如果当前节点选择的话，剩下的就只能去当前节点的左节点下的左右节点做选择
        int p3 = 0;
        if(root.left != null){
            int n1 = process(root.left.left);
            int n2 = process(root.left.right);
            //左右两种情况是独立的，因此要加在一起
            p3 = n1 + n2;
        }
          //如果当前节点选择的话，剩下的就只能去当前节点的右节点下的左右节点做选择
        int p4 = 0;
        if(root.right != null){
            int n1 = process(root.right.left);
            int n2 = process(root.right.right);
             //左右两种情况是独立的，因此要加在一起
            p4 = n1 + n2;
        }
        //p3 和 p4 是选择当前节点下左右分支的情况，所以要加上当前节点的值。
        //和不选的情况做比较 选择最大值
        //p1 + p2 左右两种选择是不会互相影响的，因此要相加
        return Math.max((p1 + p2),(p3 + p4 + root.val));
    }

递归加缓存

暴力递归中有大量的重复计算，因此我们要把重复计算放到缓存里优化递归过程。
变量只有一个，递归时不断去选择不同节点，因此用HashMap 去记录就行了

代码演示

/**
 * 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 {
    public int rob(TreeNode root) {
        if(root == null){
            return 0;
        }
        HashMap<TreeNode,Integer> ans = new HashMap<>();
        return process(root,ans);
    }

     public int process(TreeNode root, HashMap<TreeNode,Integer> ans){
        if(root == null){
            return 0;
        }
        //缓存中如果有，直接在缓存中拿
        if(ans.containsKey(root)){
            return ans.get(root);
        }
        //不选当前节点时
        int p1 = process(root.left,ans);
        int p2 = process(root.right,ans);
        //选择当前节点时
        int p3 = 0;
   
        if(root.left != null){
            int n1 = process(root.left.left,ans);
            int n2 = process(root.left.right,ans);
            p3 = n1 + n2;
        }
        int p4 = 0;
        if(root.right != null){
            int n1 = process(root.right.left,ans);
            int n2 = process(root.right.right,ans);
            p4 = n1 + n2;
        }
        int p5 = Math.max((p1 + p2),(p3 + p4 + root.val));
        //结果放到缓存中
        ans.put(root,p5);
        return p5;
    }
   }