代码随想录第55天 | 392.判断子序列 、 115.不同的子序列

一、前言：

参考文献：代码随想录

今天的主题是对子序列和不同子序列进行统计；

二、判断子序列

1、思路：

本题延续了上一次的最长子序列的一题，就是判断t是否为s的子序列（可以不连续，但是不可以顺序调换）；

我们来用动态规划五部曲分析：

（1）dp数组的定义 + 初始化：

在i - 1与j - 1的边界下，有多少个元素相同；

vector<vector<int>> dp(s.size() + 1, vector<int> (t.size() + 1, 0));

为什么长度要多一个呢？因为这样的话dp[0][0]是没有意义的，这样就可以简化初始化的过程；

（2）递推公式：

这里的递推公式与上次一模一样，如果t[i] == t[j - 1]那么就可以直接让dp[i][j]继承dp[i - 1][j - 1] 并且加一；

（3）遍历顺序：

从(1,1)开始遍历；

2、整体代码如下：

class Solution {
public:
// 与最长重复子串相同
    bool isSubsequence(string s, string t) {
        // dp数组 + 初始化
        vector<vector<int>> dp(s.size() + 1, vector<int> (t.size() + 1, 0));

        // 遍历顺序
        for (int i = 1; i <= s.size(); i++)
        {
            for (int j = 1; j <= t.size(); j++)
            {
                // 递推公式
                if (s[i - 1] == t[j - 1])
                {
                    dp[i][j] = dp[i - 1][j - 1] +1;
                }
                else
                {
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        // 判断是否成立
        return s.size() == dp[s.size()][t.size()];

    }
};

 三、不同子序列

1、思路：

我们需要理清我们的需求：需要知道有几种匹配出相同字串的方法，需要返回的是几种方法；

本题利用的是dp数组来删除s和t来进行匹配，如果匹配成功就加上上一个状态的个数和没匹配成功的状态，换句话说就是上一个状态和删除s中一个字符的状态。

（1）定义dp数组：

vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t> (t.size() + 1, 0));

没有什么区别，只是换成了long long；

（2）初始化：

这里的初始化就有讲究了，必须要清楚这个dp数组的含义，在s[i - 1]之前以及t[j - 1]之前的（包含当前）匹配成功了不同种类的个数；所以当dp[i][0]表示的是t数组为空字符串时，有几种匹配匹配方式？肯定是一种嘛！接着就是dp[0][j]有几种匹配方式？s都为空了，是一种。dp[0][0]是一个重叠状态，但是他们刚好能匹配，所以为1；

（3）遍历顺序：

还是从(1,1)开始推到，开始遍历；

（4）递推公式：

也分为相等或者不相等两种情况，相等就继承i-1andj-1这个dp的状态再加上删除掉s当前元素的状态；

不相等就只要继承删掉当前s的状态即可；

2、整体代码如下：

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t> (t.size() + 1, 0));

        // 初始化
        for (int i = 0; i < s.size() + 1; i++)
        {
            // t的所有元素都删除了，所以空字符串，匹配模式只有一种
            dp[i][0] = 1;
        }
        for (int i = 1; i <= s.size(); i++)
        {
            for (int j = 1; j <= t.size(); j++)
            {
                // 递推公式
                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[s.size()][t.size()];
    }
};

The leaning time is: 1h

Leave Message:

 It is only with the heart that one can see rightly; what is essential is invisible to the sys.

只有用心才能看清；本质是肉眼看不见的。