198_打家劫舍

198.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。

动态规划主要分析步骤：有三步的，有五步的
三步：
1、找出子问题
2、分析状态问题
3、确定DP方程
五步：
1、确定dp数组以及下标的含义
2、确定递推公式
决定dp[i] 的因素就是第i房间偷还是不偷，如果偷，那么dp[i] = dp[i-2] + nums[i]
如果不偷则dp[i] = max(dp[i-2] + nums[i] , dp[i-1])
3、dp数组的初始化
从递推公式可以看出，递推的基础是从dp[0], dp[1]开始的
从dp[i]的定义上来讲，dp[0]一定是nums[0],dp[1] = max(nums[0],nums[1])
4、确定遍历顺序
5、举例推导dp数组

解法一（二维dp）：
动态规划的基本解法

class Solution:
    def rob(self, nums: List[int]) -> int:

        if nums == None or len(nums) == 0:   # 判空
            return 0
        
        if len(nums) == 1:    # 长度为1的情况
            return nums[0]
            
        a = [[0,0] for _ in range(len(nums))]    # 初始一个二维数组
        a[0][0] = 0      # 设定两个状态值0和1,0代表不偷，1代表偷
        a[0][1] = nums[0]

        for i in range(len(nums)):    # 遍历
            a[i][0] = max(a[i-1][0], a[i-1][1])   # 当前房子不偷的dp方程
            a[i][1] = a[i-1][0] + nums[i]        # 当前房子偷的dp方程

        return max(a[-1][0],a[-1][1])        # 返回最大值

解法二（一维dp）：

class Solution:
    def rob(self, nums: List[int]) -> int:

        if nums == None or len(nums) == 0:
            return 0
        
        if len(nums) == 1:
            return nums[0]

        a = [0] * len(nums)    # 初始化一个一维数组

        a[0] = nums[0]
        a[1] = max(nums[0],nums[1])

        for i in range(2,len(nums)):
            a[i] = max(a[i-1],a[i-2] + nums[i])

        return a[-1]

解法三（高端dp）：
国际站大佬的解法，我功力不够，先放这里，以示尊敬

class Solution:
    def rob(self, nums: List[int]) -> int:
      	a , b = 0, 0
        for num in nums:
            a, b = b, max(a + num, b)

        return b