leetcode 392. 判断子序列 C++ 2021-07-07

class Solution {
public:
    bool isSubsequence(string s, string t) 
    {
        int lens = s.size();
        int lent = t.size();
        int pos = 0;//定位在t中找到前一个和s一样的字符后的 比较起点

        if (lens > lent)
            return false;

        for (int i = 0; i < lens; ++i)
        {
            if (pos >= lent)
                return false;
                
            for (int j = pos; j < lent; ++j)
            {
                if (s[i] == t[j])
                {
                    pos = j + 1;
                    break;
                }
                if (j == lent - 1)
                    return false;
            }
        }
        return true;
    }
};

//双指针法，我觉得是上面的优雅写法
class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.length(), m = t.length();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] == t[j]) {
                i++;
            }
            j++;
        }
        return i == n;
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/is-subsequence/solution/pan-duan-zi-xu-lie-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

//DP解法很绕人 不想看了
t中从 位置i 开始往后  字符j  第一次出现的位置 f[i][j]
如果位置i 的字符是j 则f[i][j] = i
否则 f[i][j]=f[i+1][j]
因此我们要倒过来进行动态规划，从后往前枚举i。


//dp解法
    bool isSubsequence(string s, string t){
        int n = s.length(),m = t.length();
        //dp数组dp[i][j]表示字符串t以i位置开始第一次出现字符j的位置
        vector<vector<int>> dp(m + 1,vector<int> (26,0));

        //初始化边界条件，dp[i][j] = m表示t中不存在字符j
        for(int i=0;i<26;i++){
            dp[m][i] = m;
        }

        //从后往前递推初始化dp数组
        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++){
            //t中没有s[i] 返回false
            if(dp[add][s[i] - 'a'] == m){
                return false;
            }
            //否则直接跳到t中s[i]第一次出现的位置之后一位
            add = dp[add][s[i] - 'a'] + 1;
        }
        return true;
    }

class Solution {
public:
    bool isSubsequence(string s, string t) 
    {
   // dp[i][j]表示以下标i-1为结尾的字符串s【注意这是指循环过程中的整个s，而不是s子序列】 和 以下标j-1为结尾的字符串t 相同子序列的长度
        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] = dp[i][j - 1];
            }
        }
        if (dp[s.size()][t.size()] == s.size()) return true;
        return false;
    }
};

dp[i][j]表示以下标i-1为结尾的字符串s【注意这是指每次for循环过程中的整个s（例如第一次是a, 第二次就是ab)，而不是s子序列】 和 以下标j-1为结尾的字符串t 相同子序列的长度

另一种dp好懂一点