算法基础——动态规划（1）（爬楼梯）

算法基础——动态规划（1）（爬楼梯）

• @cache：python中用hashmap记录入参和返回值的修饰器。为了练习思维，日常解题时尽量减少使用。
• 备忘录能降低时间复杂度，根据题目特点进行自底向上计算（又被人们称作递推：没有递只有归），再用滑动区间，从而降低空间复杂度（当然同时可能缺失靠前状态的信息，但不影响解决题目）

自顶向下变自底向上：递归边界变为数组初始值；dfs函数状态转移方程变为$f$数组状态计算方程；递归改为循环。

• 带备忘录的dp时间复杂度思考，递归调用树（状态空间树）中，若要产生递归调用，需要该节点未被计算出。故每个状态只会产生一个递归调用，所以状态个数乘以单个状态计算的时间复杂度，就是整体dp的时间复杂度。
• 自底向上不用滑动区间，记录的数组长度可以适当增加（增加虚拟状态），来避免计算越界。至于增加多少，增加的量应该赋予什么值，需要根据后面的实际状态决定。

1.1 爬楼梯

70 爬楼梯
本题增加了两个虚拟状态f0,f1=0,1是因为需要用到虚拟状态的状态是n=1与n=2，构造的虚拟状态值满足能正确计算出这两个状态就行，后面的状态不受虚拟状态影响了。

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

746 使用最小花费爬楼梯

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        f0,f1=0,0
        for i in range(len(cost)-1):
            f0,f1=f1,min(f0+cost[i],f1+cost[i+1])
        return f1

377 组合总和 Ⅳ

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        d=[-1]*(target+1)
        def dfs(n):# 数值为n的时候，可以产生的组合个数
            if n<0:
                return 0
            if n==0:
                return 1
            if d[n]!=-1:
                return d[n]
            lab=0
            for i in nums:
                lab+=dfs(n-i)
            d[n]=lab
            return lab
        return dfs(target)

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        f = [1] + [0] * target
        for i in range(1, target + 1):
            f[i] = sum(f[i - x] for x in nums if x <= i)
        return f[target]

2466 统计构造好字符串的方案数
本质就是爬楼梯题，模仿上面的代码可以写出如下：

class Solution:
    def countGoodStrings(self, low: int, high: int, zero: int, one: int) -> int:
        d=[1]+[0]*high
        for i in range(1,high+1):
            d[i]=sum(d[i-j] for j in [zero,one] if j<=i)
        return sum(d[low:])%(10**9+7)

但是运行后会发现时间复杂度与空间复杂度都很大，再看看其他解法，都是一样的。对比发现是取模的位置做了一些小操作。

class Solution:
    def countGoodStrings(self, low: int, high: int, zero: int, one: int) -> int:
        MOD = 1_000_000_007 #_仅仅起分隔作用
        f = [1] + [0] * high 
        for i in range(1, high + 1):
            if i >= one:  f[i] = (f[i] + f[i - one]) % MOD
            if i >= zero: f[i] = (f[i] + f[i - zero]) % MOD
        return sum(f[low:]) % MOD

2266 统计打字方案数
构建两种dp数组，对应对应字符不同数量的数字。再用乘法原则（数字之间不相互关联）。与上面的代码一样，处理mod都是过程中处理（对于求总和的乘或加运算，过程中先除不影响结果。

MOD = 10 ** 9 + 7
f = [1, 1, 2, 4]
g = [1, 1, 2, 4]
for _ in range(10 ** 5 - 3):  # 预处理所有长度的结果
    f.append((f[-1] + f[-2] + f[-3]) % MOD)
    g.append((g[-1] + g[-2] + g[-3] + g[-4]) % MOD)

class Solution:
    def countTexts(self, pressedKeys: str) -> int:
        ans = 1
        for ch, s in groupby(pressedKeys):# 分组函数，返回组内元素迭代对象s与标志值ch
            m = len(list(s))
            ans = ans * (g[m] if ch in "79" else f[m]) % MOD
        return ans

当然，采用对整个字符串dp的复杂的做法也能解决这一问题，但没有必要。