392. 判断子序列【动态规划】

✅做题思路or感想

法一：暴力

这道题一眼暴力，单指针遍历就可以解决，没什么好说的

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int index = 0;	//单指针指向s
        for (int i = 0; i < t.size(); ++i) {
            if (t[i] == s[index]) {	//如果匹配上了，则单指针指向s的下一位
                ++index;
            }
        }
        //如果单指针指向了s的最后一位，则说明s在t中完全匹配上了
        return index == s.size() ? true : false;
    }
};

法二：动态规划

题目是s是否为t的子序列，那么可以转换一下成求最大公共子序列的问题，如果最大公共子序列的长度等于s的长度，则说明s就是t的子序列

dp数组含义

子序列的题一般都这样子定义dp数组：dp[i][j]表示在s的[0, i - 1]和t的[0, j - 1]上最长的子序列长度（注意这里是范围里的最长子序列长度！）

为什么要这样子定义呢，因为这样子更方便针对空子数组做操作，比如dp[0][0]根据意义是nums1[-1]，nums2[-1]，而这本是无意义的，这里就把这个看作空的子数组

递推公式

判断单个字符是有两种可能

1. s[i - 1] == t[j - 1]

   • 因为检验的这两个元素相同，故可以拓展前一个的最大子序列的长度
   • 故有dp[i][j] = dp[i - 1][j - 1] + 1

2. s[i - 1] != t[j - 1]

   • 💡因为这两个元素不等，故无法拓展前一个的最大子序列长度，所以只能继承前一个最大子序列的长度了（想想dp数组含义，是在一个范围里面的最大子序列的长度，如[2, 3]的最大子序列长度为1，则包含它的[1, 5]的最大子序列长度至少也要是1（如果可以拓展的话，就+1
   • 而他继承的方向也有区别，可以继承dp[i - 1][j]，也可以继承dp[i][j - 1]，我们这里要选更大的，所以有dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
   • 💡为什么是这样子继承呢？
     • 在s[i - 1] != t[j - 1]的基础上，继承dp[i - 1][j]表示s[i - 1]肯定是用不了了，但是t[j - 1]可能还能用得上
     • 继承dp[i][j - 1]表示t[j - 1]肯定是用不了了，但是s[i - 1]可能还能用得上

初始化

没有什么特殊的声明，则都默认是没有公共子序列，即长度为0

遍历顺序

从小推大，故正序

class Solution {
public:
    bool isSubsequence(string s, string t) {
        vector<vector<int>>dp (s.size() + 1, vector<int>(t.size() + 1, 0));//这里默认初始化全部为0就好了
        for (int i = 1; i <= s.size(); ++i) {
            for (int j = 1; j <= t.size(); ++j) {
                if (s[i - 1] == t[j - 1]) {	//若能匹配的上，则能接着前面的长度 + 1
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {	//匹配不上，则继承
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        //如果最大子序列长度正好是s的长度，则说明s是t的子序列
        return dp[s.size()][t.size()] == s.size();
    }
};