[leetcode-337]House Robber III(java)

原题：House RobberIII

对于这种树形结构，应该很容易想到使用递归的方法，这里的难点在于递归的时候相邻点不能同时访问，因此我写成了第一种做法，也ac了，但是这样并不好，因为它对很多点都会重复遍历。

于是在网上看到了第二种写法，很优雅，它定义了一个数据结构，对于当前节点，如果不使用该节点会拿多少钱，如果使用该节点又会多少钱。
很显然，对于一个节点而言，比如root，
那么rootMoney.notUse = 左子节点的最大值+右子节点的最大值（无所谓左子节点和右子节点是否使用）
rootMoney.use = root.val + 左子节点的notUse + 右子节点的NotUse。
这种代码结构感觉会更清秀一些。

/**
 * 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 rootVal = root.val;
        int leftHand = 0,rightHand = 0;
        if(root.left != null){
            int l1 = rob(root.left.left);
            int l2 = rob(root.left.right);
            rootVal += l1+l2;
            leftHand = rob(root.left);
        }
        if(root.right != null){
            int r1 = rob(root.right.left);
            int r2 = rob(root.right.right);
            rootVal += r1+r2;
            rightHand = rob(root.right);
        }
        if(leftHand + rightHand > rootVal)
            return leftHand+ rightHand;
        return rootVal;
    }
}

代码2【elegant】

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    class Money{
        int notUse;//不使用该节点时的money
        int use;//使用该节点时的money

        Money(){
            notUse = 0;
            use = 0;
        }
    }
    public int rob(TreeNode root) {
        Money rootMoney = getMoney(root);
        return Math.max(rootMoney.notUse,rootMoney.use);
    }
    private Money getMoney(TreeNode root){
        if(root == null)
            return new Money();
        Money leftMoney = getMoney(root.left);
        Money rightMoney = getMoney(root.right);

        Money rootMoney = new Money();
        rootMoney.use = root.val + leftMoney.notUse + rightMoney.notUse;
        rootMoney.notUse = Math.max(leftMoney.notUse,leftMoney.use) + Math.max(rightMoney.notUse,rightMoney.use);

        return rootMoney;
    }
}