101 不同的子序列（Distinct Subsequences）

1 题目

题目：不同的子序列（Distinct Subsequences）
描述：计算出给定字符串 S 和 T, 字符串S中有多少个子序列字符串和字符串T相同。子序列字符串是原始字符串删除一些(或零个)字符之后得到的字符串, 并且不能改变剩下字符的相对位置。(比如 “ACE” 是 ABCDE 的一个子序列, 而 “AEC” 不是)，len(S)<=200，len(T)<=30。

lintcode题号——118，难度——medium

样例1：

输入：
S = "rabbbit"
T = "rabbit"
输出：3
解释：你可以删除 S 中的任意一个 'b', 所以一共有 3 种方式得到 T.

样例2：

输入：
S = "abcd"
T = ""
输出：1
解释：只有删除 S 中的所有字符这一种方式得到 T

2 解决方案

2.1 思路

  使用动态规划的方式解，将状态dp[i][j]定义为表示S的前i字符构成的子串其中与T相同的子序列数，则如果S的第i个字符与T的第j个字符相同，不取第i字符匹配得到结果数与dp[i - 1][j]的情况相同，取第i字符匹配得到结果数与dp[i - 1][j - 1]情况相同，相加即可；如果S的第i个字符与T的第j个字符不同，则不会取第i字符匹配，结果数与dp[i - 1][j]的情况相同，理清动态规划的四要素即可解出。

双序列型动态规划：由于将状态定义成前i个字符的状态，所以前0个对象的状态~前i个对象的状态，一共有i+1个状态，所以容器的长度需要增加一位，注意与坐标型动态规划区分。

2.3 时间复杂度

  算法会遍历二维数组，假设S字符串和T字符串的长度分别为m、n，则算法的时间复杂度为O(m*n)。

2.4 空间复杂度

  使用了二维数组数据结构，容量为m*n，空间复杂度为O(m*n)。

3 源码

细节：

1. 动态规划的四要素：状态、方程、初始化、答案。（四要素在之前的题目数字三角形¹中有详细介绍）
2. 状态：用dp[i][j]表示S的前i字符构成的子串其中与T相同的子序列数。
3. 方程：分两种情况，如果S的第i个字符与T的第j个字符相同，不取第i字符匹配得到结果数=dp[i - 1][j]，取第i字符匹配得到结果数=dp[i - 1][j - 1]，相加即可；如果S的第i个字符与T的第j个字符不同，则不会取第i字符匹配，结果数=dp[i - 1][j]。
4. 初始化：S的任意字符都能有一种方式构成T的前0字符子串，S前0字符无法构成与T相同的子序列。注意dp[0][0]是1，如果把j循环的初始化放后面会将dp[0][0]覆盖为1。
5. 答案：S中所有字符与T所有字符相同的子序列数目，即dp[maxI]dp[maxJ]。

C++版本：

/**
* @param S: A string
* @param T: A string
* @return: Count the number of distinct subsequences
*/
int numDistinct(string &S, string &T) {
    // write your code here
    if (T.empty())
    {
        return 1;
    }

    // 状态：dp[i][j]表示S的前i字符构成的子串其中与T相同的子序列数
    vector<vector<int>> dp(S.size() + 1, vector<int>(T.size() + 1));

    // 初始化：S的任意字符都能有一种方式构成T的前0字符子串，S前0字符无法构成与T相同的子序列
    for (int j = 0; j < dp.front().size(); j++)
    {
        dp[0][j] = 0;
    }
    for (int i = 0; i < dp.size(); i++) // 注意dp[0][0]是1，如果把j循环的初始化放后面会覆盖dp[0][0]为1
    {
        dp[i][0] = 1;
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 1; j < dp.front().size(); j++)
        {
            // 方程：如果S的第i个字符与T的第j个字符相同，不取第i字符匹配得到结果数=dp[i - 1][j]，取第i字符匹配得到结果数=dp[i - 1][j - 1]，相加即可
            if (S[i - 1] == T[j - 1])
            {
                dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
            }
            else // 方程：如果S的第i个字符与T的第j个字符不同，则不会取第i字符匹配，结果数=dp[i - 1][j]
            {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }

    return dp[dp.size() - 1][dp.front().size() - 1]; // 答案：S中所有字符与T所有字符相同的子序列数目
}

---

1. 数字三角形：https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎