代码-动态规划系列（更新中）

“抱佛脚”系列（代码部分）； 所有代码均基于 Python3；
记号 LC{xx} 表示 Leetcode 第 xx 题，例如 LC20 表示 Leetcode 第 20题。

动态规划之套路

动态规划本质是“遍历”，通过“记忆”中间结果减少重复计算。

两个关键步骤：

1. 定义状态
2. 定义状态转移方程

思考过程：

• 可以先用思考递归解决方案，然后再把递归转换成递推
• 还可以脑补一个 1/2/3/…维的表格，通过一步一步的递推将表格填满

高频题目

LC509 - 斐波那契数

https://leetcode-cn.com/problems/fibonacci-number/

F(0) = 0, F(1) = 1, F(n) = F(n-1) + F(n-2), 计算 F(n).

⚠️要点：

• 可以用递归，程序简单，但是指数计算复杂度
• 循环（动态规划）：只记录最近的两个数，利用递推公式计算，O(N)
• 最快的求解方式是使用矩阵连乘➕分治幂次计算，O(logN)，但是python写出来测试反而更慢 (T.T)

延伸：

• 有解析的通项公式
  • 相邻两项的线性组合是等比数列
  • 累加递推法可求出最后的通项公式是两个等比数列的差
• 相邻两项的比值趋近于黄金分割比(1+sqrt(5))/2～1.618
  • 证明1: 直接根据通项公式，求出比值极限（因为有一项趋于0）。
  • 先证明比值的极限存在（相邻两项之差的绝对值趋于0），再解方程的到极限值。

代码很简单，但是得注意边界啊啊啊！！！

class Solution:
    def fib(self, n: int) -> int:
        if n in {0, 1}:
            return n
        f0, f1 = 0, 1
        for i in range(n - 1):
            f0, f1 = f1, f0 + f1
        return f1

LC70 - 爬楼梯

https://leetcode-cn.com/problems/climbing-stairs/

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

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

1. 1 阶 + 1 阶
2. 2 阶

示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

⚠️要点

• 该题的本质是在计算斐波那契数列

class Solution:
    def climbStairs(self, n: int) -> int:
        n_2, n_1 = 0, 1
        for i in range(n):
            n_2, n_1 = n_1, n_2 + n_1
        return n_1

LC72 - 编辑距离

https://leetcode-cn.com/problems/edit-distance/

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：
插入一个字符
删除一个字符
替换一个字符

示例 1：
输入：word1 = “horse”, word2 = “ros”
输出：3
解释：
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

⚠️要点

• 遍历二维状态表 (n1 + 1) x (n2 + 1) --> 空间复杂度较高 O(n^2)
• 进阶：优化空间复杂度，每次只要记住三个状态即可（下次再写）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        n1, n2 = len(word1), len(word2)
        
        dp = [[0] * (n1 + 1) for i in range(n2 + 1)]
        for i1 in range(n1 + 1):
            dp[0][i1] = i1
        for i2 in range(n2 + 1):
            dp[i2][0] = i2

        for i1 in range(1, n1 + 1):
            for i2 in range(1, n2 + 1):

                dp[i2][i1] = min([
                    dp[i2 - 1][i1] + 1,
                    dp[i2][i1 - 1] + 1,
                    dp[i2 - 1][i1 - 1] + (0 if word1[i1 - 1] == word2[i2 - 1] else 1)
                ]) 

        return dp[n2][n1]

LC 53 最大子序和

链接：https://leetcode-cn.com/problems/maximum-subarray
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：
输入：nums = [1]
输出：1
示例 3：
输入：nums = [0]
输出：0

示例 5：
输入：nums = [-100000]
输出：-100000

⚠️要点

简单动态规划：

如果是最大子序和，且长度大于2，那么从开头到之后任何一点的子序列之和都应该大于0，否则去掉该子序列会得到一个sum更大的序列。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return nums[0]
        maxsum = nums[0]
        tmp = 0
        for x in nums:
            tmp += x
            maxsum = max(maxsum, tmp)
            tmp = max(tmp, 0)
        return maxsum

LC322 - 零钱兑换 （TODO）

链接：https://leetcode-cn.com/problems/coin-change
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
你可以认为每种硬币的数量是无限的。

示例 1：
输入：coins = [1, 2, 5], amount = 11
输出：3
解释：11 = 5 + 5 + 1
示例 2：
输入：coins = [2], amount = 3
输出：-1
示例 3：
输入：coins = [1], amount = 0
输出：0
示例 4：
输入：coins = [1], amount = 1
输出：1
示例 5：
输入：coins = [1], amount = 2
输出：2