337 House Robber III

这道题把题目理解错了，只是根据它举的两个例子去理解了，所以没有真正的把握题意

题意的本质是找到所有不相连的node的sum的最大和，那么首先就要找到不相连的node所能组成的集合，根据例子最直接的理解就是隔层的node都符合不相邻的条件，所有分成 奇数层 和 偶数层就可以了。。。于是按标准的层序遍历就可以搞定了，通过queue不断加入node，再pop node就okay了

结果发现，只能通过60/180的例子，没有通过的是一个中间隔了两层的node结果的sigma更大，瞬间才意识到 理解 有遗漏。。。

错误的层序遍历的代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int rob(TreeNode root) {
        if(root==null) return 0;
        int sum1=0;
        int sum2=0;
        Queue<TreeNode> queue= new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            Queue<TreeNode> next= new LinkedList<TreeNode>();
            while(!queue.isEmpty()){
                TreeNode curr=queue.poll();
                sum1+=curr.val;
                if(curr.left!=null) next.add(curr.left);
                if(curr.right!=null) next.add(curr.right);                
            }
            if(next.isEmpty()) return sum1>sum2?sum1:sum2;
            
            Queue<TreeNode> nextNext= new LinkedList<TreeNode>();
            while(!next.isEmpty()){
                TreeNode present=next.poll();
                sum2+=present.val;
                if(present.left!=null) nextNext.add(present.left);
                if(present.right!=null) nextNext.add(present.right);
            }
            if(nextNext.isEmpty()) return sum1>sum2?sum1:sum2;
            queue=nextNext;
        }
        
        return sum1>sum2?sum1:sum2;
    }
}

// 看懂题目这个问题就不难了，就是每层间隔加和所有node的val，最后看是奇数层还是偶数层加和更大

然后就没想法了，参考了别人的solution，用递归的方法来实现，代码如下，自己实现了一遍：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int rob(TreeNode root) {
        int[] nums = dfs(root);
        return Math.max(nums[0], nums[1]);
    }
    
    private int[] dfs(TreeNode node){
        int[] result= new int[2];
        if(node==null) return result;
        
        int[] left=dfs(node.left);
        int[] right=dfs(node.right);
        result[0]= node.val+ left[1] + right[1]; // 关键的理解在这里的两句，当前如果选择了node，那么它的左右子节点都不能选，所以是[1]
        result[1]= Math.max(left[0],left[1])+Math.max(right[0],right[1]); // 同理，如果当前的node么有去选择，那么子节点可以选，也可以不选，选不一点大，不选不一定小，因为有不能相邻的这样一个制约，就是通过这句code表示出来的。。
        return result;
    }
}