【动态规划】打家劫舍系列

题型列表

198. 打家劫舍
213. 打家劫舍 II
337. 打家劫舍 III

198. 打家劫舍

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额
= 1 + 3 = 4 。 示例 2：

输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5
号房屋 (金额 = 1)。 偷窃到的最高金额 = 2 + 9 + 1 = 12 。

解法步骤

1. List item

1.确定dp数组（dp table）以及下标的含义

dp[i]代表的是从第1号偷到当前第i号房间时，可以偷到的最大金额

2.确定递推公式

偷到当前dp[i]也就是第i号房间时，有两种选择(状态)偷或者不偷 选择这两种获利最大的就是结果
偷:上家就不能偷，需要把偷到前面上上家dp[i-2]的金额和当前第i号房间算上，就是偷窃当前的总金额即dp[i] =dp[i-2]+nums[i]
不偷: 偷到上家时最大金额也是偷到当前家的最大金额 即dp[i] = dp[i-1]
当前房间最大获利dp[i] = 最大值(偷，不偷) = max(dp[i-2]+nums[i], dp[i-1])

3.dp数组如何初始化

dp[0]只能选择偷是最大的获利
dp[1] 选择偷或者不偷
偷： dp[1] = nums[1] 前面dp[0]就不能算入了
不偷:dp[1] = nums[0] 选取最大获利即是dp[1] max(nums[0], nums[1])

4.确定遍历顺序

因为dp[0]、dp[1]即为第1、第2号房间初始化过了，那么循环从索引2开始即可

5.举例推导dp数组

正常情况
特例, 如长度分别为0 1 2时验证结果

代码如下

func rob(nums []int) int {
    //特判
    if len(nums) == 0  {
        return 0
    }
    if len(nums) == 1 {
        return nums[0]
    }
    if len(nums) == 2 {
        return max(nums[0], nums[1])
    }


    //初始化dp数组
    dp := map[int]int{}
    dp[0], dp[1] = nums[0], max(nums[0], nums[1])
    for i:=2; i<len(nums); i++ {
        dp[i] = max(dp[i-2]+nums[i], dp[i-1])
    }

    return dp[len(nums)-1]
}

func max(p1, p2 int) int {
    if p1 > p2 {
        return p1
    }
    return p2
}

213. 打家劫舍 II

题目描述

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例 1：
输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）,因为他们是相邻的。
示例 2：

输入：nums = [1,2,3,1] 输出：4 解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。 偷窃到的最高金额 = 1 + 3 = 4 。
示例 3：
输入：nums = [1,2,3] 输出：3
提示：
1 <= nums.length <= 100 0 <= nums[i] <= 1000

解法步骤

核心解法和198. 打家劫舍是一致的,不清楚的可以看上面第一题的解法, 不同点在于第一号房间和最后一号房间不能都偷(两者选其一)

这里我们可以考虑下， 这不就是选择偷不偷当前第i号房间产生最大获利是一样的嘛

1. 偷第一家，那么最后一家不能偷
2. 不偷第一家，那么偷最后一家

至于选第一种还是第二种，由哪个获利最大选哪个决定, 我们求解两次第一题解法逻辑，最后得个两者最大值完事

代码如下

func rob(nums []int) int {
    //特判
    if len(nums) == 0 {
        return 0
    }
    if len(nums) == 1 {
        return nums[0]
    }
    if len(nums) == 2 {
        return max(nums[0], nums[1])
    }

    //获取[0,n-1]的最大获利
    rangeA := robRange(nums, 0, len(nums)-1)
    //获取[1, n]的最大获利
    rangeB := robRange(nums, 1, len(nums)-1)
    //获取[0,n]整体最大获利
    return max(rangeA, rangeB)
}

func robRange(nums []int, start, length int) int {
    dp := map[int]int{}
    dp[0] = nums[start]
    dp[1] = max(nums[start],nums[start+1])
    for i:=2; i<length;  i++ {
        dp[i] = max(nums[start+i] + dp[i-2], dp[i-1])
    }
    return dp[length-1]
}


func max(p1 int, p2 int) int {
    if p1 > p2 {
        return p1
    }
    return p2
}

337. 打家劫舍 III

题目描述

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。
如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。
给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
示例 1:
desc 输入: root = [3,2,3,null,3,null,1] 输出: 7 解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7
示例 2:
Description 输入: root = [3,4,5,1,3,null,1] 输出: 9 解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9
提示：
树的节点数在 [1, 104] 范围内 0 <= Node.val <= 104

解法步骤

观点还是不变，每次遍历到当前结点时，两种选择，偷还是不偷，哪种选择获利最大， 而影响这个选择的因素有了变化， 由之前的数组换为了二叉树， 对于遍历二叉树有前、中、后序， 结合这道题的结果，入口(根节点)即为统算下面偷窃结果的最后一个节点，前中后序中，后序遍历符合该条件， 确定后序遍历

1.确定dp数组（dp table）以及下标的含义

这里不能用数组来表示含义了，递归遍历后序，将状态和获利情况更新到最后的根节点， 那么每次递归返回值为：当前节点偷/不偷的获利情况,上层节点根据下面子节点的获利情况再更新它的偷/不偷的获利情况

2.确定递推公式

先有下层左右子节点返回的情况
偷： 当前值cur.Val + 下层子节点不能偷时的获利情况(left.不偷 + right.不偷)
不偷:下层子节点偷时的最大获利情况(可以选择偷，也可以选择不偷，哪个获利最大选哪个)即max(left.偷, left.不偷) +max(right.偷, right.不偷)

3.dp数组如何初始化

到末尾节点时，下层节点返回[0, 0]即可

4.确定遍历顺序

后序遍历

5.举例推导dp数组

正常情况下结果
空节点
单个节点

代码如下

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func rob(root *TreeNode) int {
    res := robTree(root)

    return max(res[0], res[1])
}
//后序遍历
func robTree(curNode *TreeNode) []int {
    if curNode == nil { //终止条件
        return []int{0,0}
    }
    //当前节点的左节点的获利情况
    left := robTree(curNode.Left)
    //当前节点的右节点的获利情况
    right := robTree(curNode.Right)

    //当前节点进行偷窃的获利情况
    curRob := curNode.Val + left[0] + right[0]
    //当前节点不进行偷窃的获利情况
    curNotRob := max(left[0], left[1]) + max(right[0], right[1])

    //返回当前节点的获利情况
    return []int{curNotRob, curRob}
}

func max(p1, p2 int) int {
    if p1 > p2 {
        return p1
    }

    return p2
}