动态规划：不同的子序列

前言

        在计算机科学中，子序列问题是一个常见且重要的问题，特别是在字符串处理和生物信息学中。这个问题要求我们找出一个字符串（t）在另一个字符串（s）中作为子序列出现的次数，这是一个典型的计数问题，可以通过动态规划技术来解决。动态规划是解决这类问题的强有力工具，它通过避免重复计算和利用问题的结构特性，可以高效地找到解决方案。在实际应用中，这种方法不仅适用于字符串子序列问题，还可以推广到其他具有相似特性的问题。

        子序列定义：给定两个序列，如果第一个序列是第二个序列的重新排序（元素顺序可以改变），则第一个序列是第二个序列的子序列。例如，"abc" 是 "aabbc" 的子序列，但不是 "abdc" 的子序列。

        动态规划：动态规划是一种算法策略，用于解决具有重叠子问题和最优子结构特性的问题。它通过将问题分解为更小的子问题，并将子问题的解存储在一个表格中，从而避免了重复计算。

动态规划的适用性：在子序列问题中，动态规划的适用性主要体现在以下几个方面：

1. 最优子结构：子序列问题可以分解为更小的子问题，即在 s 的某个前缀中找到 t 的子序列。这个问题的最优解可以由其子问题的最优解推导出来。

2. 重叠子问题：在递归解决方案中，相同的子问题（例如，在 s 的某个子串中找到 t 的子序列）会被多次求解。动态规划通过存储这些子问题的解来避免重复计算。

思路

选择动态规划的原因是这个问题具有两个关键特性：

• 问题的最优解包含其子问题的最优解。即，s 的子序列中 t 出现的次数可以分解为更小子字符串的相同问题。
• 在递归过程中，相同的子问题被多次解决。动态规划通过存储这些子问题的解来避免重复计算。

解题过程

定义状态

        在动态规划中，状态的定义是核心。对于子序列问题，我们定义 dp[i][j] 表示在 s 的前 i 个字符中，t 的前 j 个字符作为子序列出现的次数。

初始化状态

        初始化状态是动态规划的第一步。对于子序列问题：

• dp[0][0] = 1：空字符串在任何字符串中都出现 1 次。
• dp[i][0] = 1：对于所有 i，空字符串 t 作为 s 的任何前缀的子序列出现 1 次。
• dp[m][j] = 0：对于所有 j < n，如果 s 结束了而 t 没有结束，则 t 不能作为 s 的子序列。

状态转移方程

        状态转移方程是动态规划中连接子问题和当前问题的关键。对于子序列问题：

• 如果 s[i-1] == t[j-1]，则 dp[i][j] 可以由两种情况得到：

  • s[i-1] 匹配 t[j-1]，并且 t 的剩余部分 t[j+1:] 作为 s[i+1:] 的子序列出现的次数，即 dp[i-1][j-1]。
  • s[i-1] 不匹配 t[j-1]，但 t[j:] 作为 s[i+1:] 的子序列出现的次数，即 dp[i-1][j]。

• 如果 s[i-1] != t[j-1]，则 dp[i][j] 仅由 dp[i-1][j] 决定，因为 s[i-1] 不贡献于构成 t[j-1] 的子序列。

迭代计算

        通过两层循环遍历 dp 数组，根据状态转移方程填充数组。外层循环遍历 s 的所有字符，内层循环遍历 t 的所有字符。

优化

        为了优化空间复杂度，可以使用滚动数组技术，只存储当前行和前一行的数据。由于 dp[i][j] 只依赖于 dp[i-1][j-1] 和 dp[i-1][j]，我们可以只使用两个数组来交替存储这些值。

取模操作

        由于题目要求结果需要对 10^9 + 7 进行取模，我们需要在每次更新 dp 数组时，对结果进行取模操作，以确保最终结果在要求的范围内。

复杂度

• 时间复杂度：O(m * n)，因为我们需要通过两个嵌套循环遍历整个 dp 数组。
• 空间复杂度：可以通过优化降低到 O(min(m, n))，使用滚动数组技术，只存储计算当前行所需的上一行数据。

code

class Solution(object):
    def numDistinct(self, s, t):
        len_s = len(s)
        len_t = len(t)
        dp = [[0] * (len_t + 1) for _ in range(len_s + 1)]

        # 初始化第一行和第一列
        for i in range(len_s + 1):
            dp[i][0] = 1

        # 填充dp数组
        for i in range(1, len_s + 1):
            for j in range(1, len_t + 1):
                if s[i - 1] == t[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
                else:
                    dp[i][j] = dp[i - 1][j]

        return dp[len_s][len_t] % (10**9 + 7)