动态规划 198. 打家劫舍

198. 打家劫舍

思路：动态规划

代码实现：

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相加
	        print(min(res[j], res[j+1]))
	        res[j] = min(res[j], res[j+1]) + triangle[i][j]