代码随想录算法训练营第三十四天| 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

写代码的第三十四天
开始打家劫舍啦啦啦啦啦
为什么没有那么多错误版本？因为自己做不出来都是听卡哥思路做的。。。

198.打家劫舍

思路

这个题的动态规划就是当前这个屋子i究竟要不要抢劫，如果抢是一种情况，如果不抢是一种情况，一共两种。
解决问题1：dp[i]是什么意思？考虑当前屋子i抢劫的最大金额。（没说必须要抢劫这个，只是说考虑 要抢劫这个屋子）
解决问题2：递推公式是什么？如果当前屋子i要考虑抢劫的话，那么他前面的屋子一定是考虑不抢的，因为题意表明如果连续两个屋子抢劫是一定会被抓的，所以前面那间屋子是不能考虑抢的，所以抢钱的金额是dp[i-2]+nums[i]。如果当前屋子i不考虑抢劫的话，那么他前面的屋子是一定考虑抢劫的，所以抢钱的金额是dp[i-1]，我们那要的是最大金额，所以递推公式是dp[i]=max(dp[i-1],dp[i-2]+nums[i]).
解决问题3：dp数组初始化怎么设置？依据递推公式可以看出i只与i-1和i-2有关，所以初始化dp[0]和dp[1]，dp[0]=打劫第0家的最大金额nums[0]，dp[1]代表打劫第0，1家的最大金额max(dp[0],dp[1])。
解决问题4：遍历顺序是多少？从头开始遍历就可以。
解决问题5：输出dp数组。
错误第一版：没考虑nums数组为空或者为1的情况。

class Solution:
    def rob(self, nums: List[int]) -> int:
        dp = [0] * (len(nums) + 1)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
        return dp[len(nums)]

错误第二版：问题在于列表 dp 的长度被初始化为 len(nums) + 1，但在循环中只填充到 len(nums)-1 的位置。这会导致在 return dp[len(nums)] 这一行尝试访问列表 dp 中不存在的索引。（我不是很理解这个错误。。。。）

class Solution:
    def rob(self, nums: List[int]) -> int:
    	if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]
        dp = [0] * (len(nums) + 1)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
        return dp[len(nums)]

正确代码：

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums) == 1:
            return nums[0]
        dp = [0] * len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
        return dp[-1]

213.打家劫舍II

思路

本题和上一题的区别在于本题是成环的数组，所以本题可以分成三种情况，第一种不包含首位，第二种包含首不包含尾，第三种包含尾不包含首。这三种方法只是每次的数组范围不同，函数和其他的内容和上一个题一样一样的。
正确代码：下面的robrange函数逻辑还是上一道题的逻辑，start和end代表的都是下标。

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]
        nums1 = nums[:-1]
        nums2 = nums[1:-1]
        nums3 = nums[1:]
        result1 = self.robrange(nums1, 0, len(nums1) - 1)
        result2 = self.robrange(nums2, 0, len(nums2) - 1)
        result3 = self.robrange(nums3, 0, len(nums3) - 1)
        return max(result1, result2, result3)

    def robrange(self, nums, start, end):
        if start == end:
            return nums[start]
        dp = [0] * len(nums)
        dp[start] = nums[start]
        dp[start + 1] = max(nums[start], nums[start + 1])
        for i in range(start + 2, len(nums)):
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
        return dp[len(nums) - 1]

337.打家劫舍III

思路

这个题又变成树了
其实还是本结点要不要偷，如果考虑偷了那么孩子结点就不能偷了，如果不考虑偷本结点那么孩子结点就考虑偷。
dp数组代表的是当前结点究竟要不要偷，所以dp数组的长度是2，dp[0]代表不偷dp[1]代表偷，本题要采用后序遍历，最后到跟结点的时候就是我们要的最后的值。所以是根据叶子结点从下向上去找到跟结点，根据下面孩子结点的情况去考虑跟结点。最后得出跟结点的结果。
不偷val_0 = max(left[0]+left[1]) + max(right[0],right[1])
偷val_1 = node.val + left[0] + right[0]
正确代码：

class Solution:
    def rob(self, root: Optional[TreeNode]) -> int:
        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)