动态规划 70. 爬楼梯 198. 打家劫舍 120. 三角形最小路径和 62. 不同路径

70. 爬楼梯

• 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
  每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
  注意：给定 n 是一个正整数。

示例：

示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
4.  1 阶 + 1 阶 + 1 阶
5.  1 阶 + 2 阶
6.  2 阶 + 1 阶

思路：动态规划

第n阶楼梯的爬法，是n-1阶与n-2阶的和
$dp[i]=dp[i-1]+dp[i-2]$

代码实现：

class Solution:
    def climbStairs(self, n: int) -> int:
        if n < 2:
            return n
        dp = [0] * n

        dp[0] = 1
        dp[1] = 2

        for i in range(2, n):
            dp[i] = dp[i-1] + dp[i-2]

        return dp[-1]

198. 打家劫舍

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

示例：

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

思路：动态规划

代码实现：

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

120. 三角形最小路径和

• 给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

示例：

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

思路1（空间复杂度$O(n^2)$）：从第二层向下走

从第二层开始，遍历每层的每一个元素，取其与上一层左右元素的最小值，放入新的列表中。如第三层5的位置，上一层左为3，右为4，而3，4与上一层发生关系后已变成3+2=5和4+2=6，所以第三层5的位置最小值为5+5=10.

代码实现1：

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int: 
        ret = [[0 for j in range(i + 1)] for i in range(len(triangle))]
        ret[0][0] = triangle[0][0]

        for i in range(1, len(triangle)):
            for j in range(i + 1):
                left = ret[i - 1][j - 1] if j - 1 >= 0 else ret[i - 1][j]
                right = ret[i - 1][j] if j < i else ret[i - 1][j - 1]
                ret[i][j] = triangle[i][j] + min(left, right)
                
        return min(ret[-1])

思路2（空间复杂度$o(n)$）：倒着从底层向上走

第一层表示三角形的底层。

第一层（初始状态）4，1，8，3.

第一层到第二层
6: 4, 1 , 选择1 -> 7
5: 1, 8 , 选择1 -> 6
7: 8, 3 , 选择3 -> 10
状态更新为, 7, 6, 10

从第二层到第三层
3: 7, 6 , 选择6 -> 9
4: 6, 10 , 选择6 -> 10
状态更新为 9,10

第三层到第四层
2: 9,10 , 选择9 -> 11
因此最终是11.

代码实现2：

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        res = triangle[-1]  # 底层
        for i in range(len(triangle)-2, -1, -1):  # i从倒数第二层开始
            for j in range(len(triangle[i])):  # 每层第j和j+i最小的那个与上一层的j相加
                res[j] = min(res[j], res[j+1]) + triangle[i][j]
        
        return res[0]

62. 不同路径

• 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
  机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
  问总共有多少条不同的路径？
  
  例如，上图是一个7 x 3 的网格。有多少可能的路径？

示例：

示例 1:
输入: m = 3, n = 2
输出: 3
解释:
从左上角开始，总共有 3 条路径可以到达右下角。
1. 向右 -> 向右 -> 向下
2. 向右 -> 向下 -> 向右
3. 向下 -> 向右 -> 向右

示例 2:
输入: m = 7, n = 3
输出: 28

思路：动态规划

考虑最终位置，其路径数为左边方格路径数+上边方格路径数，即
$dp[i][j]=dp[i-1][j]+dp[i][j-1]$

代码实现：

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[0 for _ in range(m)] for _ in range(n)]

        for i in range(0, n):
            for j in range(0, m):
            	# 边缘情况
                if i == 0 or j == 0:
                    dp[i][j] = 1
                # 非边缘情况
                else:
                    dp[i][j] = dp[i-1][j] + dp[i][j-1]
        
        return dp[-1][-1]