題目：

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;
    }
};

總結： 分類的時候一定要考慮完全。