LeetCode--392. 判断子序列(双指针，动态规划)

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true
示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false
 

提示：

0 <= s.length <= 100
0 <= t.length <= 10^4
两个字符串都只由小写字符组成。

 最直白的思路就是，一个一个的匹配。（双指针）

class Solution {
public:
    bool isSubsequence(string s, string t) {
      //  int l1=s.size();
      //  int l2=t.size();
      int l1=s.length();
      int l2=t.length();


      //  int i,j;
      int i=0,j=0;
        while(i!=l1,j!=l2)
        {
            if(s[i]==t[j])
            i++;

            j++;
        }
        return i==l1;
    }
};

动态规划来写：

dp[i][j] 表示字符串t 以i位置开始 第一次出现字符j 的位置

（为了之后的查询我们可以直接跳转来查找）

动归方程：逆着来动归，初始化末尾边界的

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n=s.size();
        int m=t.size();
        vector<vector<int>> dp(m+1,vector<int>(26,0));
        

        //初始化
        for(int j=0;j<26;j++)
        {
            dp[m][j]=m;
        }
        //动态规划
        for(int i=m-1;i>=0;i--)
        {
            for(int j=0;j<26;j++)
            {
                if(t[i]=='a'+j)
                {
                    dp[i][j]=i;
                }
                else
                {
                    dp[i][j]=dp[i+1][j];
                }
            }
        }
        //对于本次的输入和输出
        int add=0;
        for(int i=0;i<n;i++)
        {
            if(dp[add][s[i]-'a']==m)
            {
                return false;
            }
            add=dp[add][s[i]-'a']+1;
        }
        return true;
    }
};