打家劫舍1

def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 分为两个情况，偷还是不偷，
        # dp[i]为考虑到第i个房间时的最大值
        
        if len(nums) == 0:  # 如果没有房屋，返回0
            return 0
        if 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]  # 返回最后一个房屋中可抢劫的最大金额

打家劫舍2

成环的情况

def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums)<=3:
            return max(nums)

        # 有不考虑第一间房子和最后一间房子 这样的两种情况
        if len(nums)>3:
            dp=[0]*len(nums)
            dp2=[0]*len(nums)
            # 初始化
            # 考虑第一种情况
            dp[0]=nums[0]
            dp[1]=max(nums[1],nums[0])

            # 考虑第二种情况
            dp2[1]=nums[1]
            dp2[2]=max(nums[1],nums[2])
            
            for i in range(2,len(nums)-1):
                dp[i]=max(nums[i]+dp[i-2],dp[i-1])
                print(dp[i])

            for j in range(3,len(nums)):
                dp2[j]=max(nums[j]+dp2[j-2],dp2[j-1])
                print(dp2[j])

            return max(dp[-2],dp2[-1])

打家劫舍3

def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 树形dp，dp数组就是一个状态转移的列表
        # 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]