Day47 动态规划part09
198.打家劫舍
leetcode题目链接：. - 力扣（LeetCode）
题意：你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
- 示例 1：输入：[1,2,3,1]
- 输出：4，解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。
思路：当前状态和前面状态会有一种依赖关系，那么这种依赖关系都是动规的递推公式。
-
确定dp数组（dp table）以及下标的含义：dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
-
递推公式：决定dp[i]的因素就是第i房间偷还是不偷。
（1）如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。
（2）如果不偷第i房间，那么dp[i] = dp[i - 1]，即考 虑i-1房，（注意这里是考虑，并不是一定要偷i-1房，这是很多同学容易混淆的点）
然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
-
dp数组初始化：从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0] 和 dp[1]。所以dp[0] = nums[0], dp[1] = max(dp[0], nums[1]),注意这里的房间编号是从0开始计数的，所以最终返回dp[len(nums)-1]
-
遍历顺序：从小到大遍历，才能用到前面的状态，i=2开始
-
打印dp数组
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
dp = [0] *n
dp[0] = nums[0]
if n<=1:
return dp[n-1]
dp[1] = max(dp[0], nums[1])
for i in range(2, n):
dp[i] = max(dp[i-2]+nums[i], dp[i-1])
return dp[n-1]
213.打家劫舍II
leetcode题目链接：213. 打家劫舍 II - 力扣（LeetCode）
题意：你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着**第一个房屋和最后一个房屋是紧挨着的。**同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。
示例 1：
- 输入：nums = [2,3,2]
- 输出：3
- 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
思路：
对于一个数组，成环的话主要有如下三种情况：
- 情况一：考虑不包含首尾元素
- 情况二：考虑包含首元素，不包含尾元素（考虑但不代表一定选择）
- 情况三：考虑包含尾元素，不包含首元素
情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。分别按照上一题的思路求解，最终两者取一个最大值就可以了
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
if len(nums) == 0:
return 0
if len(nums) == 1:
return nums[0]
if len(nums) == 2:
return max(nums[0], nums[1])
# 考虑1-(n-1)
dp = [0] * (n-1)
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, n-1):
dp[i] = max(dp[i-1], dp[i-2]+nums[i])
# 考虑2-(n)
dp1 = [0] * (n-1)
dp1[0] = nums[1]
dp1[1] = max(nums[1],nums[2])
for i in range(2, n-1):
dp1[i] = max(dp1[i-1], dp1[i-2]+nums[i+1])
# print(dp, dp1)
return max(dp[-1], dp1[-1])
337.打家劫舍 III（二叉树和动态规划的结合）
leetcode题目链接：. - 力扣（LeetCode）
题意：在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
-
确定dp数组（dp table）以及下标的含义：每个节点只有两个状态，偷或者不偷 dp[0] 不偷获得的最大金钱，dp[1]偷当前节点获得的最大金钱（是节点的参数，表示节点状态），本题dp数组就是一个长度为2的数组。
-
确定二叉树的递归参数和返回值：传入当前节点(一开始传的是root)，返回的是这个节点偷和不偷两个状态得到的最大金钱，也就是dp数组
-
终止条件（返回值与初始化）：遇到空节点的话，很明显，无论偷还是不偷都是返回0
-
单层遍历逻辑（遍历顺序and递推公式）：后序遍历（左右中），最后在根节点偷和不偷的状态间取一个最大值。伪代码：
（1）如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0];
（2）如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
// 下标0：不偷，下标1：偷 vector<int> left = robTree(cur->left); // 左 vector<int> right = robTree(cur->right); // 右 // 偷cur int val1 = cur->val + left[0] + right[0]; // 不偷cur int val2 = max(left[0], left[1]) + max(right[0], right[1]); return {val2, val1}; -
打印dp数组
# 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):
dp = [0, 0]
# 递归终止条件，就是遇到了空节点，那肯定是不偷的
if not node:
return dp
dp_left = self.traversal(node.left)
dp_right = self.traversal(node.right)
# 不偷
dp[0] = node.val + dp_left[1] + dp_right[1]
# 偷
dp[1] = max(dp_left[0], dp_left[1]) + max(dp_right[0], dp_right[1])
return dp
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
