编程问题:
在上次打劫完一条街道之后和一圈房屋后,小偷又发现了一个新的可行窃的地区。这个地区只有一个入口,我们称之为“根”。 除了“根”之外,每栋房子有且只有一个“父“房子与之相连。一番侦察之后,聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫,房屋将自动报警。计算在不触动警报的情况下,小偷一晚能够盗取的最高金额。
问题描述:
-
输入: [3,2,3,null,3,null,1]
输出: 7 -
输入: [3,4,5,1,3,null,1]
输出: 9
解法:
1.递归
打不打劫根节点,会影响打劫一棵树的收益:打劫根节点,则不能打劫左右子节点,但是能打劫左右子节点的四个子树(如果有)。不打劫根节点,则能打劫左子节点和右子节点,收益是打劫左右子树的收益之和。
时间复杂度O(6^N)
空间复杂度O(N)
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int rob(TreeNode* root) {
if (!root)
return 0;
int money = root->val;
if (root->left)
money += rob(root->left->left) + rob(root->left->right);
if (root->right)
money += rob(root->right->left) + rob(root->right->right);
return max(money, rob(root->left) + rob(root->right));
}
};
2.记忆化递归
由于在计算根节点时,计算了两个儿子以及四个孙子,当轮到儿子结点时,孙子结点已经被根节点计算过了,因此可以通过哈希表存储,减少重复计算。
时间复杂度O(4^N)
空间复杂度O(N)
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
unordered_map<TreeNode*, int> tmp;
int rob(TreeNode* root) {
if (!root)
return 0;
if (tmp.count(root))
return tmp[root];
int money = root->val;
if (root->left)
money += rob(root->left->left) + rob(root->left->right);
if (root->right)
money += rob(root->right->left) + rob(root->right->right);
tmp[root] = max(money, rob(root->left) + rob(root->right));
return tmp[root];
}
};
3.动态规划
可以用select[root]表示选择 root 节点的情况下,root 节点的子树上被选择的节点的最大权值和;unselect[root]表示不选择 root节点的情况下,root 节点的子树上被选择的节点的最大权值和;l 和 r 代表 root 的左右孩子。
当 root 被选中时,root 的左右孩子都不能被选中,故 root 被选中情况下子树上被选中点的最大权值和为 l 和 r 不被选中的最大权值和相加,即 select[root] = unselect[l] + unselect[r]。
当 root 不被选中时,root 的左右孩子可以被选中,也可以不被选中。对于root 的某个具体的孩子 x,它对 root 的贡献是 x 被选中和不被选中情况下权值和的较大值。
时间复杂度O(N)
空间复杂度O(N)
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
void dfs(TreeNode* root)
{
if (!root)
return;
rob(root->left);
rob(root->right);
select[root] = root->val + unselect[root->left] + unselect[root->right];
unselect[root] = max(select[root->left], unselect[root->left]) + max(select[root->right], unselect[root->right]);
}
public:
unordered_map<TreeNode*, int> select, unselect;
int rob(TreeNode* root) {
dfs(root);
return max(select[root], unselect[root]);
}
};