灵神题单_动态规划_入门DP_1.爬楼梯系列

• LeetCode 70.爬楼梯

DP三部曲	解释
设计状态	$f(i)$ 表示从 $0$ 到 $i$ 的方案数
递推公式	$f(i)=f(i-1)+f(i-2)$
边界条件	当 $i=0$ 或 $i=1$时 $f(i)$ = 1
最终答案	$f(n)$

方法1：DFS
时间复杂度：$O(2^n)$
空间复杂度：$O(n)$

class Solution:
    def climbStairs(self, n: int) -> int:
        def dfs(i):
            if i == 0 or i == 1:
                return 1
            return dfs(i - 1) + dfs( i - 2)
        return dfs(n)

方法2：记忆化DFS
时间复杂度：$O(n)$
空间复杂度：$O(n)$

class Solution:
    def climbStairs(self, n: int) -> int:
        @cache
        def dfs(i):
            if i == 0 or i == 1:
                return 1
            return dfs(i - 1) + dfs( i - 2)
        return dfs(n)

方法3：递推
时间复杂度：$O(n)$
空间复杂度：$O(n)$

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0] * (n + 1)
        dp[0] = dp[1] = 1
        for i in range(2, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

方法4：空间优化递推
时间复杂度：$O(n)$
空间复杂度：$O(1)$

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

• LeetCode 746.使用最小花费爬楼梯

DP三部曲	解释
设计状态	$f(i)$ 表示从 $0$ 到 $i$ 的最小花费
递推公式	$f(i)=min(f(i-1),f(i-2))+cost[i]$
边界条件	$f(0)=cost[0]$ 和 $f(1)=cost[1]$
最终答案	$min(f(n-2),f(n-1))$ 其中 $n$ 表示数组长度

方法1：记忆化DFS（递推公式与设计不一样）
时间复杂度：$O(n)$
空间复杂度：$O(n)$

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        @cache
        def dfs(i):
            if i == 0 or i == 1:
                return 0
            return min(dfs(i - 1) + cost[i - 1], dfs(i - 2) + cost[i - 2])
        return dfs(len(cost))

方法2：空间优化递推
时间复杂度：$O(n)$
空间复杂度：$O(1)$

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

• LeetCode 377.组合总和 Ⅳ

DP三部曲	解释
设计状态	$f(i)$ 表示和为 $i$ 的方案数
递推公式	$f(i)={\sum }_{j=0}^{n-1}f(i-nums[j])$ 其中 $n$ 表示数组长度
边界条件	$f(0)=1$ 和 $f(负数)=0$
最终答案	$f(target)$

方法1：自顶向下记忆化DFS
时间复杂度：$O(n\times target)$
空间复杂度：$O(target)$

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        @cache
        def dfs(i):
            if i == 0:
                return 1
            if i < 0:
                return 0
            ans = 0
            for x in nums:
                ans += dfs(i - x)
            return ans
        return dfs(target)

方法2：自底向上记忆化DFS
时间复杂度：$O(n\times target)$
空间复杂度：$O(target)$

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        @cache
        def dfs(val):            
            if val > target:
                return 0            
            if val == target:
                return 1
            ans = 0
            for x in nums:
                ans += dfs(val + x)
            return ans
        return dfs(0)

方法3：递推
时间复杂度：$O(n\times target)$
空间复杂度：$O(target)$

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

• LeetCode 2466.统计构造好字符串的方案数

DP三部曲	解释
设计状态	$f(i)$ 表示长度为 $i$ 的方案数
递推公式	$f(i)=f(i-zero)+f(i-one)$
边界条件	$f(0)=1$ 和 $f(负数)=0$
最终答案	${\sum }_{i=low}^{high}f(i)$

方法1：递推
时间复杂度：$O(high)$
空间复杂度：$O(high)$

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

• LeetCode 2266.统计打字方案数
  方法1：分组 + 递推(和LeetCode 377.组合总和 Ⅳ类似) + 乘法原理
  时间复杂度：$O(N)$
  空间复杂度：$O(N)$

N = 10 ** 5; MOD = 10 ** 9 + 7
f = [1, 1, 2] + [0] * N
for i in range(3, N + 1):
    f[i] = (f[i - 1] + f[i - 2] + f[i - 3]) % MOD

g = [1, 1, 2, 4] + [0] * N
for i in range(4, N + 1):
    g[i] = (g[i - 1] + g[i - 2] + g[i - 3] + g[i - 4]) % MOD
    
class Solution:
    def countTexts(self, pressedKeys: str) -> int:
        pressedKeys += '#'
        ch = pressedKeys[0]; cnt = 0; ans = 1
        for s in pressedKeys:
            if s == ch:
                cnt += 1
            else:
                if ch == '7' or ch == '9':
                    ans *= g[cnt]
                else:
                    ans *= f[cnt]
                ans %= MOD
                ch = s; cnt = 1
        return ans % MOD

方法2：分组(使用groupby函数) + 递推(和LeetCode 377.组合总和 Ⅳ类似) + 乘法原理
时间复杂度：$O(N)$
空间复杂度：$O(N)$

N = 10 ** 5; MOD = 10 ** 9 + 7
f = [1, 1, 2] + [0] * N
for i in range(3, N + 1):
    f[i] = (f[i - 1] + f[i - 2] + f[i - 3]) % MOD

g = [1, 1, 2, 4] + [0] * N
for i in range(4, N + 1):
    g[i] = (g[i - 1] + g[i - 2] + g[i - 3] + g[i - 4]) % MOD
    
class Solution:
    def countTexts(self, pressedKeys: str) -> int:
        from itertools import groupby
        ans = 1
        for ch, idxs in groupby(pressedKeys):
            L = len(list(idxs))
            if ch == '7' or ch == '9':
                ans *= g[L]
            else:
                ans *= f[L]
            ans %= MOD
        return ans