原题:
https://leetcode-cn.com/problems/house-robber-iii/submissions/
在上次打劫完一条街道之后和一圈房屋后,小偷又发现了一个新的可行窃的地区。这个地区只有一个入口,我们称之为“根”。 除了“根”之外,每栋房子有且只有一个“父“房子与之相连。一番侦察之后,聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫,房屋将自动报警。
计算在不触动警报的情况下,小偷一晚能够盗取的最高金额。
方法一
在看完这道题目后,第一反应这是一个动态规划问题,我们定义process(TreeNode root)
返回以root
为根节点的子树的偷窃最高价值。
是否可以得到一个简单的递推关系process(root)=root.val+process(root.left)+process(root.right)
呢?根据题意,显然是不可以的,如果偷窃了root
,则不能偷窃root.left
和root.right
。这样,我们必须用一个变量来标识以root
为根节点的子树偷盗价值中是否包含root
的价值,这样我们的递归函数变成了process(TreeNode root,boolean can)
,其中变量can
表示了root
节点是否被偷窃。于是得到了以下代码
class Solution {
public int rob(TreeNode root) {
return process(root,true);
}
/*返回以root节点为根节点的子树的偷窃最大价值*/
public int process(TreeNode root,boolean can){
if(root==null)
return 0;
int result_1=0;
int result_2=0;
if(can==true){//偷窃该节点
result_1+=root.val;
result_1+=process(root.left,false);
result_1+=process(root.right,false);
}
//不偷窃该节点,偷窃左右节点
result_2+=process(root.left,true);
result_2+=process(root.right,true);
return Math.max(result_1,result_2);
}
}
每一步递归的含义是计算以root
为根节点的子树的偷窃最大价值。
对于递归的节点root
,如果可以在该节点偷盗,那么对于以该节点为根的子树的偷窃最大值就有两种情况组成,一种是偷窃root
节点,因此就不能偷窃左右子节点;另一种是不偷窃root
节点,偷窃其左右节点。比较这两种情况中偷窃数额最大的一种然后返回给上一层递归程序。如果 root
节点不能偷窃,那么就只有一种情况了。
虽然这么写最后通过了,但是耗时非常长
方法二
由于方法一耗时很长,我开始思考有没有可以进行优化的地方。
在处理以root
为根节点的子树的偷盗价值时,方法一遍历了两次,一次can
变量赋为false
,一次赋值为true
,其实这两种情况通过一个递归函数就能得到答案。
class Solution {
public int rob(TreeNode root) {
int[] res =core(root);
return Math.max(res[0],res[1]);
}
//res[0]为不包括根节点的最大值,res[1]为包括根节点的最大值
public int[] core(TreeNode root){
if(root==null)
return new int[]{0,0};
if(root.left==null&&root.right==null){
return new int[]{0,root.val};
}
int[] l=core(root.left);
int[] r=core(root.right);
int[] result=new int[2];
result[0]=Math.max(l[0],l[1])+Math.max(r[0],r[1]);
result[1]=root.val+l[0]+r[0];
return result;
}
}
通过返回一个数组int[ ]
,其中int[0]
表示不含root
价值且以root
为根节点的盗窃最大值,int[1]
表示含有root
价值且以root
为根节点的盗窃最大值,其思路与方法一其实是类似的,但是大大减少了递归的数量,提高了运算速度。