题目:
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。 这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。 一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
示例
- 示例 1
输入: [3,2,3,null,3,null,1]
3
/ \
2 3
\ \
3 1
输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
- 示例 2
输入: [3,4,5,1,3,null,1]
3
/ \
4 5
/ \ \
1 3 1
输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.
抛砖引玉
思路
- 已知相连的节点不能累加，则任意选一个节点就能将树分成两组,包含这个节点的不包含这个节点
- 用 dpRoot 保存包含这个节点的结果
- dp 存贮不包含这个节点的结果
设节点 node：
- 包含 node,dpRoot[node]应该等于这个节点的值+相邻节点不被包含着的值 dpRoot[node] = node.val+dp[node.left]+dp[node.right]
- 不包含 node，则 node.left 与 node.right 不受限，可以任选包含或者不被包含，取可能的最大值：
- dpRootLeft[node.left]、dp[node.left]
- dpRootLeft[node.right]、dp[node.right]
特殊条件及递归终止条件
- root 伪 null 返回 0
- 递归至最后一层节点 null，终止递归
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
if (root === null) return 0
// 二叉树中节点值可能重复，则使用map记录节点位置
let dpRoot = new Map(), // 包含key对应的节点
dp = new Map() // 不包含key对应的节点
function dfs(node) {
// 递归终止
if (node === null) return 0
// 递归枚举包含node.left的情况
dfs(node.left)
// 递归枚举包含node.right的情况
dfs(node.right)
let dpRootLeft = dpRoot.get(node.left) || 0,
dpRootRight = dpRoot.get(node.right) || 0,
dpLeft = dp.get(node.left) || 0,
dpRight = dp.get(node.right) || 0
// 包含传入节点这
dpRoot.set(node, node.val + dpLeft + dpRight)
// 选不包含传入节点
dp.set(node, Math.max(dpRootLeft, dpLeft) + Math.max(dpRootRight, dpRight))
}
// 递归枚举包含根据点的情况
dfs(root)
return Math.max(dpRoot.get(root), dp.get(root))
}
- 因为 dpRoot 与 dp 计算时都值依赖那相邻节点的值
- 则可以再递归中返回需要相邻的包含、不包含的两种可能
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
let [dpRoot, dp] = dfs(root)
function dfs(root) {
if (root === null) return [0, 0]
// 枚举分别包含左右节点的情况
let [dpRootLeft, dpLeft] = dfs(root.left),
[dpRootRight, dpRight] = dfs(root.right)
let dpRoot = root.val + dpLeft + dpRight,
dp = Math.max(dpRootLeft, dpLeft) + Math.max(dpRootRight, dpRight)
return [dpRoot, dp]
}
return Math.max(dpRoot, dp)
}
- 不相邻节点累加，即node.val与node.left、node.right不同组
- 递归调用rob，返回包含输入节点、不包含输入点的和最大值
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
// 递归终止条件
if (root == null) return 0
let Root = 0,// 包含根节点
noRoot = 0 // 不包含根节点
// 累加存在的不相邻节点
let Root = root.val
if (root.left) {
Root += rob(root.left.left) + rob(root.left.right)
}
if (root.right) {
Root += rob(root.right.left) + rob(root.right.right)
}
// 不包含根节点节点累加
let noRoot = rob(root.left) + rob(root.right)
return Math.max(Root, noRoot)
}
博客: 小书童博客
每天的每日一题，写的题解会同步更新到公众号一天一大 lee 栏目 欢迎关注留言
公号: 坑人的小书童
