LeetCode115. 不同的子序列——字符串类动态规划

一、正向动态规划及其优化

class Solution {
public:
    int numDistinct(string s, string t) 
    {
        /*
        定义f(i,j)为s串的前i个字符的子序列中t的前j个字符出现的个数
        对新增进来的第i个字符，
        1.可以选择让他拼凑t的第j个字符(如果s[i - 1] == t[j - 1])
          这样就让s串的前i-1个字符只要拼凑t串的前j-1个字符就行 拼凑的方法数为f(i - 1,j - 1)
        2.也可以不让他拼凑t的第j个字符
          这样就让s串的前i-1个字符拼凑t串的前j个字符，拼凑的方法数为f(i - 1,j)
        所以状态转移方程为：
        if (s[i - 1] == t[j - 1]),f(i,j) = f(i - 1,j - 1) + f(i - 1, j)
        else f(i, j) = f(i - 1, j)
        考虑初始条件
        f(0,0) = 1 (空串凑空串 方法唯一) 
        f(i,0) = 1 (凑空串就只能拿空串凑 空串相当于空集，是唯一的)
        f(0,j) = 0 (空串什么也凑不出来)
        */
        int slen = s.size();
        int tlen = t.size();
        vector<vector<unsigned long long>> dp(slen + 1, vector<unsigned long long>(tlen + 1));
        for (auto& e : dp[0])
        {
            e = 0;
        }
        for (int i = 0; i <= slen; ++i)
        {
            dp[i][0] = 1;
        }
        for (int i = 1; i <= slen; ++i)
        {
            for (int j = 1; j <= tlen; ++j)
            {
                dp[i][j] = dp[i - 1][j];
                if (s[i - 1] == t[j - 1])
                {
                    dp[i][j] += dp[i - 1][j - 1];
                }
            }
        }
        return dp[slen][tlen];
    }
};

空间复杂度优化：

class Solution {
public:
    int numDistinct(string s, string t) 
    {
        /*
        定义f(i,j)为s串的前i个字符的子序列中t的前j个字符出现的个数
        对新增进来的第i个字符，
        1.可以选择让他拼凑t的第j个字符(如果s[i - 1] == t[j - 1])
          这样就让s串的前i-1个字符只要拼凑t串的前j-1个字符就行 拼凑的方法数为f(i - 1,j - 1)
        2.也可以不让他拼凑t的第j个字符
          这样就让s串的前i-1个字符拼凑t串的前j个字符，拼凑的方法数为f(i - 1,j)
        所以状态转移方程为：
        if (s[i - 1] == t[j - 1]),f(i,j) = f(i - 1,j - 1) + f(i - 1, j)
        else f(i, j) = f(i - 1, j)
        考虑初始条件
        f(0,0) = 1 (空串凑空串 方法唯一) 
        f(i,0) = 1 (凑空串就只能拿空串凑 空串相当于空集，是唯一的)
        f(0,j) = 0 (空串什么也凑不出来)
        */
        int slen = s.size();
        int tlen = t.size();
        vector<unsigned long long> dp(tlen + 1);
        dp[0] = 1;
        for (int i = 1; i <= slen; ++i)
        {
            for (int j = tlen; j >= 1; --j)
            {
                if (s[i - 1] == t[j - 1])
                {
                    dp[j] += dp[j - 1];
                }
            }
        }
        return dp[tlen];
    }
};

时间复杂度:$O(mn)$
空间复杂度:$O(n)$

二、反向动态规划

class Solution {
public:
    int numDistinct(string s, string t) 
    {
        /*
        定义f(i,j)为s串的部分串[i,末尾]中t串的部分串[j,末尾]出现的次数
        状态转移方程：
        if (s[i] == s[j]) 那么可以让[i + 1,末尾]直接组成[j,末尾]
        或者让[i + 1,末尾]组成[j + 1,末尾] 然后使用第i个字符补上
        f(i,j) = f(i + 1, j + 1) + f(i + 1, j)
        else f(i,j) = f(i + 1,j)
        边界条件 假设s串的长度是n t串的长度是m
        f(n,m) = 1 空串中只有空串
        f(n,j),n到末尾是空串,空串中不可能有除空串以外的串 f(n,j) = 0;
        f(i,m),m到末尾是也是空串，i中空串只出现了1次
        f(i,m) = 1
        求解的答案就是f(0,0)
        */
        int n = s.size();
        int m = t.size();
        vector<unsigned long long> dp(m + 1);
        dp[m] = 1;
        for (int i = n - 1; i >= 0; --i)
        {
            for (int j = 0; j < m; ++j)
            {
                if (s[i] == t[j])
                {
                    dp[j] += dp[j + 1];
                }
            }
        }
        return dp[0];
    }
};

时间复杂度:$O(mn)$
空间复杂度:$O(n)$