leetcode【每日一题】337. 打家劫舍 III Java

题干

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

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 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.

想法

明显动态规划
设f(root)表示取了root这个点的情况下的最大值
设g(root)表示不取root这个点的情况下它的子树最大值
可以确定的是如果取了这个root，那么root的两个子节点都不能取。
那么f（root）=root.val+g(root.left)+g(root.right)

如果现这个点不取，那么两个子树都是可以取可以不取，即：
g(root)=max(g(root.left),f(root.left))+max(g(root.right),f(root.right));

当然也有更快的方法，直接枚举对于每个树的情况，它取了，左子树右子树都不取，它不取，左子树取，不取，等等，不再赘述

Java代码

package daily;

import java.util.HashMap;
import java.util.Map;

public class NewRob {
    public  static  class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) {
            val = x;
        }
    }

    Map<TreeNode, Integer> f = new HashMap<>();
    Map<TreeNode, Integer> g = new HashMap<>();

    public int rob(TreeNode root) {
        dfs(root);
        return Math.max(f.getOrDefault(root, 0), g.getOrDefault(root, 0));
    }

    public void dfs(TreeNode root) {
        if (root == null) {
            return;
        }
        dfs(root.left);
        dfs(root.right);
        f.put(root, root.val + g.getOrDefault(root.left, 0) + g.getOrDefault(root.right, 0));
        g.put(root, Math.max(g.getOrDefault(root.left, 0), f.getOrDefault(root.left, 0)) + Math.max(g.getOrDefault(root.right, 0), f.getOrDefault(root.right, 0)));
    }


    public static  void main(String[] args){
        NewRob rob=new NewRob();
        TreeNode root=new TreeNode(3);
        root.left=new TreeNode(2);
        root.right=new TreeNode(3);
        root.right.left=null;
        root.right.right=new TreeNode(1);
        root.left.left=null;
        root.left.right=new TreeNode(3);


        System.out.println(rob.rob(root));
    }

}

更快的枚举法

class Solution {
    public int rob(TreeNode root) {
        if(root==null){
            return 0;
        }
        postorder(root);
        return root.val;
    }
    public void postorder(TreeNode root){
        if (root.left!=null){
            postorder(root.left);
        }
        if (root.right!=null){
            postorder(root.right);
        }
        int res1=0;
        int res2=root.val;
        if (root.left!=null){
            res1=res1+root.left.val;
            if (root.left.left!=null){
                res2=res2+root.left.left.val;
            }
            if (root.left.right!=null){
                res2=res2+root.left.right.val;
            }
        }
        if (root.right!=null){
            res1=res1+root.right.val;
            if (root.right.left!=null){
                res2=res2+root.right.left.val;
            }
            if (root.right.right!=null){
                res2=res2+root.right.right.val;
            }
        }
        root.val=Math.max(res1, res2);
    }
}

我的leetcode代码都已经上传到我的githttps://github.com/ragezor/leetcode