标签：
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:
3 / 2 3 \ \ 3 1Maximum amount of money the thief can rob = 3 + 3 + 1 = 7.
Example 2:
3
/ 4 5
/ \ \
1 3 1
Maximum amount of money the thief can rob = 4 + 5 = 9.
Credits:
Special thanks to @dietpepsi for adding this problem and creating all test cases.
Subscribe to see which companies asked this question
思路：
原问题分为：1）偷当前结点；2）不偷当前结点；两个问题
1）时的amount 为4个“孙子”结点的值的和；
2）时的amount为2个“孩子”结点的值的和。
java code:
/**
* 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 valOfNoRoot = 0; // 不偷当前结点
int valOfRoot = 0; // 偷当前结点
valOfNoRoot = rob(root.left) + rob(root.right);
if(root.left != null)
valOfRoot += rob(root.left.left) + rob(root.left.right);
if(root.right != null)
valOfRoot += rob(root.right.left) + rob(root.right.right);
return Math.max(valOfRoot + root.val, valOfNoRoot);
}
}这段代码花了：1133 ms
java代码勉强可以通过，但是c++过不了（c++的时间要求就短一些）。
这是由于递归过程中有大量的重复计算，因此可以将计算过的值保存起来，减少计算次数。
使用HashMap来保存已计算值的java code:
/**
* 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) {
HashMap<TreeNode, Integer> map = new HashMap<TreeNode, Integer>();
return rob(root, map);
}
private int rob(TreeNode root, HashMap<TreeNode, Integer> map) {
if(root == null) return 0;
if(map.containsKey(root)) return map.get(root);
int valOfNoRoot = 0; // 不偷当前结点
int valOfRoot = 0; // 偷当前结点
valOfNoRoot = rob(root.left, map) + rob(root.right, map);
if(root.left != null)
valOfRoot += rob(root.left.left, map) + rob(root.left.right, map);
if(root.right != null)
valOfRoot += rob(root.right.left, map) + rob(root.right.right, map);
int val = Math.max(valOfRoot + root.val, valOfNoRoot);
map.put(root, val);
return val;
}
}
c++ code:
/**
* 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> ret = robSub(root);
return max(ret[0], ret[1]);
}
vector<int> robSub(TreeNode* root) {
if(!root) return vector<int>(2);
vector<int> left= robSub(root->left);
vector<int> right= robSub(root->right);
vector<int> ret(2);
ret[0] = max(left[0], left[1]) + max(right[0], right[1]); // 不偷当前结点
ret[1] = root->val + left[0] + right[0]; // 偷当前结点
return ret;
}
};标签：
原文地址：http://blog.csdn.net/itismelzp/article/details/51627065
