算法训练Day48 打家劫舍系列 | LeetCode198. 打家劫舍（普通直街道）；213. 打家劫舍II（环形房屋）；337. 打家劫舍III（树形房屋）
目录
LeetCode198. 打家劫舍
1. 思路
2. 代码实现
3. 复杂度分析
4. 思考与收获
LeetCode213. 打家劫舍II
1. 思路
2. 代码实现
3. 复杂度分析
4. 思考与收获
LeetCode337. 打家劫舍III
大致思路
方法一：暴力递归做法
1. 思路
2. 代码实现
3. 复杂度分析
4. 思考与收获
方法二：记忆化递归
1. 思路
2. 代码实现
3. 复杂度分析
4. 思考与收获
方法三：动态规划
1. 思路
2. 代码实现
3. 复杂度分析
4. 思考与收获
LeetCode198. 打家劫舍
链接：198. 打家劫舍 - 力扣（LeetCode）
1. 思路
打家劫舍是dp解决的经典问题，动规五部曲分析如下：
1.1 确定dp数组以及下标的含义
dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]；
1.2 确定递推公式
决定dp[i]的因素就是第i房间偷还是不偷。
- 如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。
- 如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）
然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
1.3 dp数组如何初始化
从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0] 和 dp[1]；
从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);
1.4 确定遍历顺序
dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！
1.5 举例推导dp数组
以示例二，输入[2,7,9,3,1]为例。红框dp[nums.size() - 1]为结果。
2. 代码实现
# time:O(N);space:O(N)
class Solution(object):
def rob(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
# dp[i] 定义是考虑下标i，包括i在内的房屋
# 最多可以偷窃的金额总和是dp[i]
# 边界情况
if len(nums) == 1: return nums[0]
# 初始化dp数组
dp = [0]*len(nums)
dp[0] = nums[0]
dp[1] = max(nums[0],nums[1])
# 遍历顺序：从左到右
for i in range(2,len(nums)):
# 递推公式（偷不偷i的）
dp[i] = max(dp[i-1],dp[i-2]+nums[i])
return dp[len(nums)-1]
3. 复杂度分析
-
时间复杂度：O(N)
N为nums数组的长度，for loop需要把dp数组的下标为2开始的每个数都遍历一遍，dp数组的长度和nums数组一样；
-
空间复杂度：O(N）
N为nums数组的长度，需要定义一个长度为N的dp数组；
4. 思考与收获
-
空间复杂度可以通过状态压缩继续优化；
# 状态压缩版本 # 不定义dp数组的版本，只用两个变量维护 # time:O(N);space:O(1) class Solution(object): def rob(self, nums): """ :type nums: List[int] :rtype: int """ if len(nums) == 1: return nums[0] if len(nums) == 2: return max(nums[0],nums[1]) first = nums[0] second = max(nums[0],nums[1]) for i in range (2,len(nums)): result = max(first+nums[i],second) first = second second = result return result -
打家劫舍是DP解决的经典题目，这道题也是打家劫舍入门级题目，后面我们还会变种方式来打劫的；
-
和01背包的题目对比，他只有物品价值和一定的限制条件（影响递推公式），没有背包容量的限制；
Reference：代码随想录 (programmercarl.com)
本题学习时间：40分钟。
LeetCode213. 打家劫舍II
链接：213. 打家劫舍 II - 力扣（LeetCode）
1. 思路
本题和 9.20 打家劫舍（LeetCode198）是差不多的，唯一区别就是成环了；
对于一个数组，成环的话主要有如下三种情况：
- 情况一：考虑不包含首尾元素
- 情况二：考虑包含首元素，不包含尾元素
- 情况三：考虑包含尾元素，不包含首元素
注意我这里用的是"考虑"，例如情况三，虽然是考虑包含尾元素，但不一定要选尾部元素！ 对于情况三，取nums[1] 和 nums[3]就是最大的。而情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以；
分析到这里，本题其实比较简单了，其余的逻辑和 9.20 打家劫舍（LeetCode198）是一样的了。
2. 代码实现
# 2022.11.07
# time:O(N);space:O(N)
class Solution(object):
def rob(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
# 题目中提示nums.length>=1,所以不需要考虑len(nums)==0的情况
if len(nums) == 1: return nums[0]
if len(nums) == 2: return max(nums[0],nums[1])
length = len(nums)
# 考虑偷首，但是不考虑偷尾
result1 = self.basicRob(nums[:-1])
# 考虑偷尾，但是不考虑偷首
result2 = self.basicRob(nums[1:])
return max(result1,result2)
def basicRob(self,newNums):
# 能执行的newNums的长度至少为2了
if len(newNums) == 2: return max(newNums[0],newNums[1])
dp = [0]*len(newNums)
dp[0] = newNums[0]
dp[1] = max(newNums[0],newNums[1])
for i in range(2,len(newNums)):
dp[i] = max(dp[i-1],dp[i-2]+newNums[i])
return dp[-1]
3. 复杂度分析
在9.20中分析过basicRob本身的时间复杂度为O(N)，空间复杂度为O(N)；
这里需要调用执行两次basicRob，然后取最大值，总体为2N的时空复杂度；
- 时间复杂度：O(N)
- 空间复杂度：O(N)
4. 思考与收获
- 仍然可以用状态压缩的方法优化空间复杂度到O(1）
- 成环之后还是难了一些的， 不少题解没有把“考虑房间”和“偷房间”说清楚；这就导致大家会有这样的困惑：情况三怎么就包含了情况一了呢？ 本文图中最后一间房不能偷啊，偷了一定不是最优结果。所以我在本文重点强调了情况一二三是“考虑”的范围，而具体房间偷与不偷交给递推公式去抉择。这样大家就不难理解情况二和情况三包含了情况一了。
Reference：代码随想录 (programmercarl.com)
本题学习时间：40分钟。
LeetCode337. 打家劫舍III
链接：337. 打家劫舍 III - 力扣（LeetCode）
大致思路
这道题目和 198.打家劫舍 213.打家劫舍II 也是如出一辙，只不过这个换成了树
如果对树的遍历不够熟悉的话，那本题就有难度了。对于树的话，首先就要想到遍历方式，前中后序（深度优先搜索）还是层序遍历（广度优先搜索）；本题一定是要后序遍历，因为通过递归函数的返回值来做下一步计算。
与198.打家劫舍，213.打家劫舍II一样，关键是要讨论当前节点抢还是不抢。如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子（注意这里说的是“考虑”）；
下面详细解析三种思路的做法。
- 暴力递归做法
- 记忆化递归做法
- 动态规划做法
方法一：暴力递归做法
1. 思路
递归三部曲：
- 确定函数的参数和返回值
参数就是二叉树的根节点，返回值是得到的一晚盗取的最大金额；
- 确定终止条件
如果当前节点为空，返回0，如果当前节点为叶子节点，返回节点的值；
- 单层递归逻辑
有两种情况，讨论当前遍历的节点抢还是不抢
-
如果抢当前遍历的节点 val1 += root.val
那它的两个左右孩子就不可以抢，只能考虑孙子们
- 看左孩子的左右孩子：
if root.left: val1 += self.rob(root.left.left) + self.rob(root.left.right)- 看右孩子的左右孩子
if root.right: val1 += self.rob(root.right.left) + self.rob(root.right.right) -
如果不抢当前遍历的节点 val2
那它的两个左右孩子可以考虑抢
val2 = self.rob(root.left) + self.rob(root.right)
return 这两种情况的最大值即可
2. 代码实现
# 方法一：暴力递归
# 单独测试可以AC，提交会超时
# time:O(2^N);space:O(logN)
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def rob(self, root):
"""
:type root: TreeNode
:rtype: int
"""
# 终止条件
if root == None: return 0
if root.left == None and root.right == None: return root.val
# 单层递归逻辑
# 情况一：偷当前的root
val1 = root.val
if root.left: val1 += self.rob(root.left.left) +self.rob(root.left.right)
if root.right: val1 += self.rob(root.right.left) + self.rob(root.right.right)
# 情况二：不偷当前的root
val2 = self.rob(root.left)+self.rob(root.right)
return max(val1,val2)
3. 复杂度分析
-
时间复杂度：O(2^N)
N为二叉树的节点个数，每个节点都有偷和不偷两个选择，这个时间复杂度不太标准，也不容易准确化，例如越往下的节点重复计算次数就越多；
-
空间复杂度：O(logN）
N为二叉树的节点个数，算上递推系统栈的空间；
4. 思考与收获
- 当然以上代码超时了，这个递归的过程中其实是有重复计算了。我们计算了root的四个孙子（左右孩子的孩子）为头结点的子树的情况，又计算了root的左右孩子为头结点的子树的情况，计算左右孩子的时候其实又把孙子计算了一遍，所以可以用记忆化递归的方式优化，引申出第二种做法；
方法二：记忆化递归
1. 思路
可以使用一个map把计算过的结果保存一下，这样如果计算过孙子了，那么计算孩子的时候可以复用孙子节点的结果；
2. 代码实现
# 方法二：记忆化递归
# time:O(N);space:O(N)
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def rob(self, root):
"""
:type root: TreeNode
:rtype: int
"""
# 终止条件
Map = {}
if root == None: return 0
if root.left == None and root.right == None: return root.val
if root in Map: return Map[root]
# 单层递归逻辑
# 情况一：偷当前的节点 val1
val1 = root.val
if root.left:
val1 += self.rob(root.left.left) + self.rob(root.left.right)
if root.right:
val1 += self.rob(root.right.left) + self.rob(root.right.right)
# 情况二：不偷当前节点 val2
val2 = self.rob(root.left) + self.rob(root.right)
# 把结果记录到Map里面去
Map[root] = max(val1,val2)
return max(val1,val2)
3. 复杂度分析
-
时间复杂度：O(N)
N为二叉树的节点个数；因为有了Map之后，每个节点只会递归的去计算一次，每次计算是常数级的加法，整体为O(N)；
-
空间复杂度：O(N)
N为二叉树的节点个数；递归栈空间为O(logN），Map需要把每个节点的值都储存一遍，所以为O(N)；
4. 思考与收获
- Map中的key是root，每个root是特别的，所以即使root.val是一样的也没关系；
- 在进入单层递归逻辑之前，需要检查一下root是否已经在Map里面（之前已经计算过了。
方法三：动态规划
1. 思路
在上面两种方法，其实对一个节点 偷与不偷得到的最大金钱都没有做记录，而是需要实时计算。
而动态规划其实就是使用状态转移容器来记录状态的变化，这里可以使用一个长度为2的数组，记录当前节点偷与不偷所得到的的最大金钱。
这道题目算是树形dp的入门题目，因为是在树上进行状态转移，我们在讲解二叉树的时候说过递归三部曲，那么下面以递归三部曲为框架，其中融合动规五部曲的内容来进行讲解。
1.1 确定递归函数的参数和返回值
这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组；
class Solution:
def rob(self, root: Optional[TreeNode]) -> int:
其实这里的返回数组就是dp数组。
1. 确定dp数组的定义
所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。所以本题dp数组就是一个长度为2的数组！
那么有同学可能疑惑，长度为2的数组怎么标记树中每个节点的状态呢？别忘了在递归的过程中，系统栈会保存每一层递归的参数。如果还不理解的话，就接着往下看，看到代码就理解了；
1.2 确定终止条件
在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回；
2. 相当于dp数组的初始化
# 递归终止条件，就是遇到了空节点，那肯定是不偷的
if not node: return (0, 0)
1.3 确定单层递归的逻辑
3. 确定遍历顺序
首先明确的是使用后序遍历。 因为通过递归函数的返回值来做下一步计算。
中间节点的dp数组，需要通过左节点和右节点的dp推导得到；
通过递归左节点，得到左节点偷与不偷的金钱。
通过递归右节点，得到右节点偷与不偷的金钱。
left = self.traversal(node.left)
right = self.traversal(node.right)
4. 确定dp[i]的递推公式
还是讨论偷不偷当前节点：
- 如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （如果对下标含义不理解就在回顾一下dp数组的含义）
- 如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
最后当前节点的状态就是{val2, val1};
即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}
最后头结点就是 取下标0 和 下标1的最大值就是偷得的最大金钱
# 不偷当前节点, 偷子节点
val_0 = max(left[0], left[1]) + max(right[0], right[1])
# 偷当前节点, 不偷子节点
val_1 = node.val + left[0] + right[0]
return (val_0, val_1)
5. 举例推导dp数组
以示例1为例，dp数组状态如下：（注意用后序遍历的方式推导）
最后头结点就是 取下标0 和 下标1的最大值就是偷得的最大金钱；
2. 代码实现
# 方法三：动态规划dp
# time:O(N);space:O(logN)
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution(object):
def rob(self, root):
"""
:type root: TreeNode
:rtype: int
"""
dp = self.traversal(root)
return max (dp)
def traversal(self,root):
# dp定义：二元组
# dp[0] 不偷当前节点得到的最大金钱
# dp[1] 偷当前节点得到的最大金钱
# base case
# 遇到空节点，偷不偷都是0
if root == None: return (0,0)
# 单层递归逻辑,后序遍历
# 左右
left = self.traversal(root.left)
right = self.traversal(root.right)
# 中
# 表示当前节点不偷，那么可以考虑偷孩子节点
# 取孩子节点二元组的最大值即可
val0 = max(left[0],left[1]) + max(right[0],right[1])
# 表示当前节点偷，那么只能不偷孩子节点
val1 = root.val + left[0] + right[0]
# 返回当前节点的二元组
return (val0,val1)
3. 复杂度分析
-
时间复杂度：O(N)
N为二叉树的节点个数；后序遍历，每个节点只遍历一次；
-
空间复杂度：O(logN)
N为二叉树的节点个数；算上递推系统栈的空间，每个节点的dp二元组就储存在每次递归的参数里；
4. 思考与收获
- 这道题是树形DP的入门题目，所谓树形DP就是在树上进行递归公式的推导。所以树形DP也没有那么神秘！只不过平时我们习惯了在一维数组或者二维数组上推导公式，一下子换成了树，就需要对树的遍历方式足够了解！
- 在讲解贪心专题的时候，也有类似在树上做贪心算法的题目：贪心算法：我要监控二叉树！ (opens new window)，也可以把这个算法起一个名字，叫做树形贪心，“树形贪心”词汇从此诞生，来自「代码随想录」；
Reference： 代码随想录 (programmercarl.com)
本题学习时间：100分钟。
本篇学习时间为3小时，总结字数近8000；主要解析了动态规划中打家劫舍这个系列的三个问题，从普通的直街道，到环形的街道，再到树形的街道，难度逐渐递增，解析非常透彻。（求推荐！）