LeetCode题练习与总结：不同的子序列--115

一、题目描述

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 10^9 + 7 取模。

示例 1：

输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbit
rabbbit
rabbbit

示例 2：

输入：s = "babgbag", t = "bag"
输出：5
解释：
如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbag
babgbag
babgbag
babgbag
babgbag

提示：

• 1 <= s.length, t.length <= 1000
• s 和 t 由英文字母组成

二、解题思路

这个问题可以通过动态规划来解决。我们可以创建一个二维数组 dp，其中 dp[i][j] 表示在 s 的前 i 个字符中，包含 t 的前 j 个字符的子序列的数量。我们需要填充这个数组来找到最终的答案。

对于动态规划数组 dp 的填充，我们有以下几种情况：

1. 如果 s 的第 i 个字符等于 t 的第 j 个字符，那么 dp[i][j] 可以由两部分组成：

• 不使用 s 的第 i 个字符，只考虑前 i-1 个字符和 t 的前 j 个字符的匹配情况，即 dp[i-1][j]。
• 使用 s 的第 i 个字符，考虑 s 的前 i-1 个字符和 t 的前 j-1 个字符的匹配情况，即 dp[i-1][j-1]。

2. 如果 s 的第 i 个字符不等于 t 的第 j 个字符，那么我们只能忽略 s 的第 i 个字符，dp[i][j] 应该等于 dp[i-1][j]。

初始化时，dp[0][0] 应该为 1，因为两个空字符串的匹配情况只有一种，即不使用任何字符。其他的 dp[i][0] 应该为 1，因为 t 为空字符串时，匹配情况只有一种，即忽略所有 s 的字符。

三、具体代码

class Solution {
    public int numDistinct(String s, String t) {
        int MOD = 1000000007;
        int m = s.length();
        int n = t.length();
        int[][] dp = new int[m + 1][n + 1];

        // 初始化
        for (int i = 0; i <= m; i++) {
            dp[i][0] = 1;
        }

        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        return dp[m][n];
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 我们定义了两个循环，一个遍历字符串 s 的每个字符，另一个遍历字符串 t 的每个字符。
• 外层循环遍历 s 的长度 m，内层循环遍历 t 的长度 n。
• 在循环的每一次迭代中，我们执行了常数时间的操作，包括字符比较和模运算。
• 因此，时间复杂度是 O(m * n)，其中 m 是字符串 s 的长度，n 是字符串 t 的长度。

2. 空间复杂度

• 我们定义了一个二维数组 dp，其大小为 (m + 1) x (n + 1)，其中 m 和 n 分别是字符串 s 和 t 的长度。
• 这个数组用于存储每个子问题的解，即 s 的前 i 个字符中包含 t 的前 j 个字符的子序列的数量。
• 因此，空间复杂度是 O(m * n)，这是因为我们需要存储所有子问题的解。

五、总结知识点

1. 动态规划：这是一种通过将问题分解为更小的子问题来解决复杂问题的方法，通常用于优化问题。在本题中，我们使用动态规划来计算字符串 s 中包含字符串 t 的子序列的数量。

2. 二维数组：代码中使用了一个二维数组 dp 来存储动态规划的状态。二维数组是一种常用的数据结构，用于存储具有两个维度的数据。

3. 字符串操作：代码中使用了 charAt 方法来获取字符串中特定位置的字符，这是字符串操作的基本技巧。

4. 模运算：由于结果需要对一个大数 10^9 + 7 取模，代码中使用了模运算来避免整数溢出，并保持结果在一个合理的范围内。

5. 边界条件处理：在动态规划的初始化阶段，我们将 dp[i][0] 设置为 1，这是因为一个空字符串总是另一个字符串的子序列，且只有一种方式可以实现。

6. 循环结构：代码中使用了两个嵌套的循环来遍历字符串 s 和 t 的所有字符，这是实现动态规划的典型结构。

7. 递推关系：代码中建立了动态规划的递推关系，即如果当前字符匹配，则新的状态值是上方和左上方的值之和；如果不匹配，则新的状态值等于上方的值。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。