392判断子序列

判断子序列

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

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。

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

示例 1:
s = "abc", t = "ahbgdc"

返回 true.

示例 2:
s = "axc", t = "ahbgdc"

返回 false.

后续挑战 :

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

思路：依次取s中元素在t中查找
字符串s是字符串t的子序列，那么字符串s中的所有字符都会按照顺序出现在字符串t中。
对子串进行遍历，同时也对母串进行遍历，一旦两个字符串匹配之后，就选择从母串匹配后的下一个位置继续下面的匹配，
而不在从头开始匹配。空串也是母串的子串。

解法1：
//40 ms    16.8 MB    
class Solution {
public:
    bool isSubsequence(string s, string t) {
        //暴力的解法
        //为空串时 也是子串
        int cnt=0;
        bool flag;
        for(int i=0;i<s.size();i++){
            flag=false;//标记不能找到
            for(int j=cnt;j<t.size();j++){
                if(s[i]==t[j]){
                    flag=true;//标记能找到
                    cnt=j+1;//从匹配的字符后面下一个开始 继续查找，当长度10亿时，超时
                    break;
                }
            }
            if(flag==false){//没有匹配的单词，可以返回false 了
                return false;
            }
        }
         return true;
    }
};

解法2：
//48ms 17 MB
class Solution {
public:
    bool isSubsequence(string s, string t) {
        //双指针解法：
        int i,j;
        for(i=0,j=0;i<s.size()&&j<t.size();j++){
            if(s[i]==t[j]){
                i++;
            }
        }
        return i==s.size();

    }

};

 1 思路：
 2 
 3 状态：dp[i][j]为s的从头开始到i的子字符串是否为t从头开始到j的子字符串的子序列
 4 
 5 状态转移公式：
 6 
 7 当char[i]==char[j]时，则字符i一定是j的子序列，如果0~i-1子字符串是0~j-1子字符串的子序列，则dp[i][j]=true，所以dp[i][j] = dp[i-1][j-1]；
 8 当char[i]!=char[j]时，即判断当前0~i子字符串是否是0~j-1的子字符串的子序列，即dp[i][j] = dp[i][j - 1]。如ab，eabc，虽然s的最后一个字符和t中最后一个字符不相等，但是因为ab是eab的子序列，所以ab也是eabc的子序列
 9 初始化：空字符串一定是t的子字符串的子序列，所以dp[0][j]=true;任意字符串非空 都不是 空字符的字符串 dp[i>0][0]=false;
10 
11 结果：返回dp[sLen][tLen]

解法3：1508 ms    78.3 MB

class Solution {
public:
    bool isSubsequence(string s, string t) {
        //使用动态规划做：虽然很慢，但是需要练习一下
        int lens=s.size(),lent=t.size();
        if(lens==0) return true;
        if(lens>lent) return false;
      //  bool dp[101][600010];//数组越界初始化500001,遇到551742长度
        bool dp[lens+1][lent+1];//可以使用 字符串长度进行初始化
        for(int i=1;i<=lens;i++) dp[i][0]=false;//任意字符串s都不是空串的字符串
        for(int j=0;j<=lent;j++) dp[0][j]=true;//任意空串 s  都是 字符串t的 子串
        for(int i=1;i<=lens;i++){
            for(int j=1;j<=lent;j++){
                if(s[i-1]==t[j-1]) dp[i][j]=dp[i-1][j-1];
                else dp[i][j]=dp[i][j-1];
            }
        }
        return dp[lens][lent];

    }
};

解法4：112 ms    34 MB
class Solution {
public:
    bool isSubsequence(string s, string t) {
        unordered_map<char,vector<int>> mp;
        int len,left,right;
        for(int i=0;i<t.size();i++){
            mp[t[i]].push_back(i);//对每个t中的字符 存储它所在的位置，由小到大
        }
        int curloc=0;//当前位置为0
        for(char ch:s){//对字符串s中的每个字符 进行遍历
            len=mp[ch].size();//取出t中相对应字母所在的 所有位置,进行查找
            if(len==0) return false;//为空,字符串t中没有出现相应的字母 
            if(curloc>mp[ch][len-1]) return false;//如果当前位置超过t中相对应字符的最后一个位置，无法匹配
            left=0,right=len-1;
            while(left<right){//执行完这个二分查找之后，left==right 
                int mid=(left+right)/2;
                if(mp[ch][mid]>curloc) right=mid;
                else left=mid+1;
            }
            curloc=mp[ch][left];
        }
        return true;
    }
};