337. House Robber III（python+cpp）

题目：

The thief has found himself a new place for his thievery again. There is only one entrance to this area, called the “root.” Besides the root, each house has one and only one parent house. After a tour, the smart thief realized that “all houses in this place forms a binary tree”. It will automatically contact the police if two directly-linked houses were broken into on the same night.
Determine the maximum amount of money the thief can rob tonight without alerting the police.
Example 1:

Input: [3,2,3,null,3,null,1]

     3
    / \    
   2   3
    \   \ 
     3   1
Output: 7  
Explanation: Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.

Example 2:

Input: [3,4,5,1,3,null,1]

     3
    / \    
    4   5  
   / \   \   
  1   3   1
Output: 9 
Explanation: Maximum amount of money the thief can rob = 4 + 5 = 9.

解释：
房间构成二叉树的街区，不能连续偷盗两个具有直接连接的房间。
这个问题还是要进行分类，将原始问题分解成两个子问题，对于一个根节点root，我们可以重新定义一个函数robSub()，这个函数返回两个元素，分别代表偷盗root所代表的房间和不偷盗root所代表的房间，取两个中最大的一个即可。
python代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def robSub(root):
            res=[0]*2
            left=[0]*2
            right=[0]*2
            if root.left:
                left=robSub(root.left)
            if root.right:
                right=robSub(root.right)
            #不偷盗root
            res[0]=max(left[0],left[1])+max(right[0],right[1])
            #偷盗root
            res[1]=root.val+left[0]+right[0]
            return res
        res=[0]*2
        if root:
            res=robSub(root)
        return max(res[0],res[1])

c++代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int rob(TreeNode* root) {
        vector<int>res(2,0);
        if(root)
            res=robSub(root);
        return max(res[0],res[1]);
    }
    vector<int> robSub(TreeNode *root)
    {
        vector<int>res(2,0);
        vector<int>left(2,0);
        vector<int>right(2,0);
        if (root->left)
            left=robSub(root->left);
        if(root->right)
            right=robSub(root->right);
        //不偷盗root
        res[0]=max(left[0],left[1])+max(right[0],right[1]);
        //偷盗root那么它的两个子节点必然是不能被偷盗的
        res[1]=root->val+left[0]+right[0];
        return res;
    }
};

总结：
分类的时候一定要考虑完全。