一天一大 lee(打家劫舍 III)难度:中等-Day20200805

题目:

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例

示例 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)
}