leetcode - 刷题记录-探索初级算法-动态规划

1. 爬楼梯

   1. 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

      每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

      注意：给定 n 是一个正整数。

   2. class Solution:
          def climbStairs(self, n: int) -> int:
              if n == 1:
                  return 1
              elif n == 2:
                  return 2
              else:
                  # solution1
                  res = [1,2]
                  for i in range(2,n):
                      res.append(res[i-1]+res[i-2])
                  return res[-1]
                  # solution2
                  res_dic = {1:1,2:2}
                  for i in range(3,n+1):
                      res_dic[i] = res_dic[i-1]+res_dic[i-2]
                  return res_dic[n]
                  # solution3
                  tmp1 = 1
                  tmp2 = 2
                  for i in range(3,n+1):
                      res = tmp1 + tmp2
                      tmp1 = tmp2
                      tmp2 = res
                  return res

      通过

2. 买卖股票的最佳时机

   1. 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

      如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

      注意：你不能在买入股票前卖出股票。

   2. class Solution:
          def maxProfit(self, prices: List[int]) -> int:
              if len(prices) <= 1:
                  return 0
              buy = prices[0]
              sell = 0
              for i in range(1,len(prices)):
                  buy = min(buy,prices[i])
                  sell = max(sell,prices[i]-buy)
              return sell
             

      通过

   3. 动态规划，一开始理解，还是比较困难。buy是逐步找到整个序列中的最小值，sold则是buy之后的最大值。

3. 最大子序和

   1. 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

   2. class Solution:
          def maxSubArray(self, nums: List[int]) -> int:
              tmp = nums[0]
              res = tmp
              nums = nums[1:]
              for i in nums:
                  if tmp<0:
                      tmp = i
                  else:
                      tmp = tmp+i
                  res = max(res,tmp)
              return res

      通过，动态规划太难了。。。。。

4. 打家劫舍

   1. 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

      给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

   2. class Solution:
          def rob(self, nums: List[int]) -> int:
              if nums == []:
                  return 0
              if len(nums) <= 2:
                  return max(nums)
              res = [nums[0],max(nums[:2])]
              nums = nums[2:]
              for i in nums: 
                  tmp = max(res[-1],res[-2]+i)
                  res[0] = res[1]
                  res[1] = tmp
              return res[-1]

      通过