2024/06/18--代码随想录算法7/17|198.打家劫舍、213.打家劫舍II、337.打家劫舍III

本文主要是介绍2024/06/18--代码随想录算法7/17|198.打家劫舍、213.打家劫舍II、337.打家劫舍III，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

198.打家劫舍

力扣链接
在这里插入图片描述

动态规划5步曲

确定dp数组（dp table）以及下标的含义：
dp[i]: 下标i内（包括i）的房屋，最多可以偷到的金额为dp[i]
确定递推公式
dp[i] = max(dp[i-1], dp[i-2]+nums[i]）
dp数组如何初始化 dp[0] = nums[0] dp[1]= max(nums[0], nums[1])
确定遍历顺序:dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，那么一定是从前到后遍历！

时间复杂度: O(n)空间复杂度: O(n)

一维DP
class Solution:def rob(self, nums: List[int]) -> int:if len(nums) == 0:  # 如果没有房屋，返回0return 0if len(nums) == 1:  # 如果只有一个房屋，返回其金额return nums[0]# 创建一个动态规划数组，用于存储最大金额dp = [0] * len(nums)dp[0] = nums[0]  # 将dp的第一个元素设置为第一个房屋的金额dp[1] = max(nums[0], nums[1])  # 将dp的第二个元素设置为第一二个房屋中的金额较大者# 遍历剩余的房屋for i in range(2, len(nums)):# 对于每个房屋，选择抢劫当前房屋和抢劫前一个房屋的最大金额dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])return dp[-1]  # 返回最后一个房屋中可抢劫的最大金额

二维DP
class Solution:def rob(self, nums: List[int]) -> int:if not nums:  # 如果没有房屋，返回0return 0n = len(nums)dp = [[0, 0] for _ in range(n)]  # 创建二维动态规划数组，dp[i][0]表示不抢劫第i个房屋的最大金额，dp[i][1]表示抢劫第i个房屋的最大金额dp[0][1] = nums[0]  # 抢劫第一个房屋的最大金额为第一个房屋的金额for i in range(1, n):dp[i][0] = max(dp[i-1][0], dp[i-1][1])  # 不抢劫第i个房屋，最大金额为前一个房屋抢劫和不抢劫的最大值dp[i][1] = dp[i-1][0] + nums[i]  # 抢劫第i个房屋，最大金额为前一个房屋不抢劫的最大金额加上当前房屋的金额return max(dp[n-1][0], dp[n-1][1])  # 返回最后一个房屋中可抢劫的最大金额

【优化版】
class Solution:def rob(self, nums: List[int]) -> int:if not nums:  # 如果没有房屋，返回0return 0prev_max = 0  # 上一个房屋的最大金额curr_max = 0  # 当前房屋的最大金额for num in nums:temp = curr_max  # 临时变量保存当前房屋的最大金额curr_max = max(prev_max + num, curr_max)  # 更新当前房屋的最大金额prev_max = temp  # 更新上一个房屋的最大金额return curr_max  # 返回最后一个房屋中可抢劫的最大金额

213.打家劫舍II

力扣链接
在这里插入图片描述
与第一题的区别在于：成环

对于一个数组，成环的话，主要有以下3种情况：

考虑不包含首尾元素

考虑包含首尾元素，不包含尾元素

考虑包含首尾元素，不包含首元素

例如情况三，考虑尾巴元素，但是不一定要选，所以他包含了情况1，讨论2和3就行
时间复杂度: O(n) 空间复杂度: O(n)

class Solution:def rob(self, nums: List[int]) -> int:if len(nums) == 0:return 0if len(nums) == 1:return nums[0]result1 = self.robRange(nums, 0, len(nums) - 2)  # 情况二result2 = self.robRange(nums, 1, len(nums) - 1)  # 情况三return max(result1, result2)# 198.打家劫舍的逻辑def robRange(self, nums: List[int], start: int, end: int) -> int:if end == start:return nums[start]prev_max = nums[start]curr_max = max(nums[start], nums[start + 1])for i in range(start + 2, end + 1):temp = curr_maxcurr_max = max(prev_max + nums[i], curr_max)prev_max = tempreturn curr_max

2维DP

class Solution:def rob(self, nums: List[int]) -> int:if len(nums) < 3:return max(nums)# 情况二：不抢劫第一个房屋result1 = self.robRange(nums[:-1])# 情况三：不抢劫最后一个房屋result2 = self.robRange(nums[1:])return max(result1, result2)def robRange(self, nums):dp = [[0, 0] for _ in range(len(nums))]dp[0][1] = nums[0]for i in range(1, len(nums)):dp[i][0] = max(dp[i - 1])dp[i][1] = dp[i - 1][0] + nums[i]return max(dp[-1])

337.打家劫舍III

力扣链接
在这里插入图片描述
本题一定是要后序遍历，因为通过递归函数的返回值来做下一步计算。
与198.打家劫舍，213.打家劫舍II一样，关键是要讨论当前节点抢还是不抢。

如果抢了当前节点，两个孩子就不能动，如果没抢当前节点，就可以考虑抢左右孩子（注意这里说的是“考虑”）

动态规划其实就是使用状态转移容器来记录状态的变化，这里可以使用一个长度为2的数组，记录当前节点偷与不偷所得到的的最大金钱。
树形DP

确定递归函数的参数和返回值dp数组就是一个长度为2的数组！
确定终止条件【在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回】
确定遍历顺序【后序遍历，要通过递归函数的返回值来做下一步计算。】
确定单层递归的逻辑

时间复杂度O(n)，每个节点只遍历了一次
空间复杂度：O(log n)，算上递推系统栈的空间

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:def rob(self, root: Optional[TreeNode]) -> int:# dp数组（dp table）以及下标的含义：# 1. 下标为 0 记录 **不偷该节点** 所得到的的最大金钱# 2. 下标为 1 记录 **偷该节点** 所得到的的最大金钱dp = self.traversal(root)return max(dp)# 要用后序遍历, 因为要通过递归函数的返回值来做下一步计算def traversal(self, node):# 递归终止条件，就是遇到了空节点，那肯定是不偷的if not node:return (0, 0)left = self.traversal(node.left)right = self.traversal(node.right)# 不偷当前节点, 偷子节点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)