动态规划之爬楼梯模型

文章目录

• 爬楼梯模型
• • [LeetCode 746. 使用最小花费爬楼梯](#LeetCode 746. 使用最小花费爬楼梯)
  • • 思路
    • [Golang 代码](#Golang 代码)
  • [LeetCode 377. 组合总和 Ⅳ](#LeetCode 377. 组合总和 Ⅳ)
  • • 思路
    • [Golang 代码](#Golang 代码)
  • [LeetCode 2466. 统计构造好字符串的方案数](#LeetCode 2466. 统计构造好字符串的方案数)
  • • 思路
    • [Golang 代码](#Golang 代码)
  • [LeetCode 2266. 统计打字方案数](#LeetCode 2266. 统计打字方案数)
  • • 思路
    • [Golang 代码](#Golang 代码)

爬楼梯模型

爬楼梯模型是动态规划当中的一个经典模型，可以抽象为：在当前这一步，你有若干个可选的操作，比如前进一步或前进两步，试问最少需要多少步能够到达终点。一个可能的变形是每一步具有固定的代价，试问到达终点的最小代价是多少。

最经典的爬楼梯问题就是初始时你处于第一层（第零级台阶），每次可以爬一个台阶或两个台阶，请问到达第 n 级台阶最少需要多少步。

依据这个最基本的爬楼梯模型，派生出了许多变体，参考灵茶山艾府整理的文档：分享丨【算法题单】动态规划（入门/背包/划分/状态机/区间/状压/数位/树形/优化），将这些题目的思路在此进行收录。

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

思路

可以看作是爬楼梯问题最简单的变体，在爬楼梯的过程中为每一步引入了代价，试问爬到终点最小的代价是多少。

使用 dp 数组记录的状态就是爬到当前这一级台阶的最小代价，由此可以推出状态转移方程：dp[i] = min(dp[i - 1] + cost[i - 1] + dp[i - 2] + cost[i - 2])，根据状态转移方程直接写代码即可。

Golang 代码

func minCostClimbingStairs(cost []int) int {
    n := len(cost)
    if n < 3 {
        return min(cost[0], cost[1])
    }
    dp := make([]int, n + 1)
    for i := 2; i <= n; i ++ {
        dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
    }
    return dp[n]
}

LeetCode 377. 组合总和 Ⅳ

思路

可以将最终的 target 视为要攀爬的目标楼梯数，将 nums 数组当中的数字视为一次行动可以攀爬的楼梯数，这道题目可以抽象为一个爬楼梯问题。

具体来说，使用 dp 数组记录爬到某一层需要多少次行动，初始化 dp[0] = 1，作为动态规划的边界状态。状态转移方程可以写为： d p i = ∑ j = 0 n − 1 d p i − n u m s \[ j dpi = \sum^{n-1}_{j=0}dpi-nums\[j dpi=∑j=0n−1dpi−nums\[j，前提是 i ≥ n u m s j i\geq numsj i≥numsj。

Golang 代码

func combinationSum4(nums []int, target int) int {
    n := len(nums)
    dp := make([]int, target + 1)
    dp[0] = 1
    for i := 1; i <= target; i ++ {
        for j := 0; j < n; j ++ {
            if i >= nums[j] {
                dp[i] += dp[i - nums[j]]
            }
        }
    }
    return dp[target]
}

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

思路

从这一题开始，稍有难度。其实这道题本质上也是一个爬楼梯问题，zero 和 one 指的就是一次行动可以攀爬的楼梯数，只要爬上的台阶大于等于 low，就可以记录答案。

使用 dp 数组记录的是构造长度为 i 的字符串的方案数，只要 i 大于等于 low，那么dp[i]就是答案的一部分。

可以得到初步的状态转移方程：

dp[i]=dp[i-one]+dp[i-zero]

还需要考虑由于答案可能过大的取模情况，详见代码。

Golang 代码

func countGoodStrings(low int, high int, zero int, one int) int {
    dp := make([]int, high + 1)
    dp[0] = 1
    const MOD int = 1e9 + 7
    ans := 0
    for i := 1; i <= high; i ++ {
        if i >= zero {
            dp[i] = dp[i - zero] % MOD
        }
        if i >= one {
            dp[i] = (dp[i] + dp[i - one]) % MOD
        }
        if i >= low {
            ans = (ans + dp[i]) % MOD
        }
    }
    return ans
}

LeetCode 2266. 统计打字方案数

思路

这应该是灵神题单里最难的一道题，实际上也是一道爬楼梯问题。具体来说，根据不同数字的重复数，每一个号码能够构造出的字母方案可以被视为一个爬楼梯问题。比如对于数字 3，它对应的字符是"def"，如果按 1 次 3，那么只能构造出 d，如果按 2 次，可以构造出 dd 或 e，按 3 次，可以构造出 ddd/de/f/ed，使用 dp 来记录重复号码可能构造出的字符数，对于 7 和 9 之外的号码，状态转移方程是dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]，而对于 7 和 9 这两个有四个字符的号码，状态转移方程是dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3] + dp[i - 4]。预先将这两个 dp 数组处理出来即可。

每一次对一段重复的号码进行统计（最小的重复数是 1，也就是只按下一次这个按键），之后如果号码不再重复，就统计答案，这里要用到乘法原理，因为不同号码构造出的可能字符数的情况是互斥的。

Golang 代码

func countTexts(pressedKeys string) int {
    const MOD int = 1e9 + 7
    n := len(pressedKeys)
    dp3 := []int{1, 1, 2, 4}
    dp4 := []int{1, 1, 2, 4}
    for i := 4; i <= n; i ++ {
        dp3 = append(dp3, (dp3[i - 1] + dp3[i - 2] + dp3[i - 3]) % MOD)
        dp4 = append(dp4, (dp4[i - 1] + dp4[i - 2] + dp4[i - 3] + dp4[i - 4]) % MOD)
    }
    ans, cnt := 1, 1    // ans 记录最终的答案, cnt 记录当前字符的重复数
    for i := 1; i < n; i ++ {
        if pressedKeys[i] == pressedKeys[i - 1] {
            // 当前字符和前一个字符重复, cnt ++
            cnt ++
        } else {
            // 当前字符和前一个字符不重复, 此时要做的就是统计答案
            // 需要注意的是, 现在统计的是前一个字符的答案, 当前字符要在下一次 pressedKeys[i] != pressedKeys[i - 1] 的时候统计
            // 这就意味着 i == n - 1 的情况需要在这个 for loop 之后单独考虑
            if pressedKeys[i - 1] == '7' || pressedKeys[i - 1] == '9' {
                ans = ans * dp4[cnt] % MOD
            } else {
                ans = ans * dp3[cnt] % MOD
            }
            cnt = 1 // 重复的字符数重置为 1
        }
    }
    if pressedKeys[n - 1] == '7' || pressedKeys[n - 1] == '9' {
        ans = ans * dp4[cnt] % MOD
    } else {
        ans = ans * dp3[cnt] % MOD
    }
    return ans
}