判断子序列 && 不同的子序列

1. 双指针

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int i = 0, j = 0;
        int res = 0;

        while(i < s.size() && j < t.size()){
            if(s[i] == t[j]){
                i++;
                res++;
            }

            j++;
        }

        return res == s.size();
    }
};

2. 动态规划
   这题和最长公共子序列很像，只是这题时一个序列是否为另外一个序列的子序列。

是编辑距离的入门题目，只需要计算删除的情况，不用考虑增加和替换的情况。

1. dp[i][j]是表示以下标i-1结尾的s与以下标j-1结尾的t的公共子序列的长度。
2. 当s[i-1] == t[j-1]时，dp[i][j] = dp[i-1][j-1] + 1;
   若不相等，则不考虑t[i-1]，则是s[i-1]与t[j-2]的dp[i][j-1]，故 dp[i][j] = dp[i][j-1] ;
3. dp数组初始化
   由递推公式可以看出，dp[i][j]依赖于dp[i-1][j-1] 和dp[i][j-1]，故dp[0][0]和dp[i][0]是需要初始化的。
4. 遍历顺序：从上到下，从左到右

class Solution {
public:
    //用最长公共子序列去求解
    bool isSubsequence(string s, string t) {
        vector<vector<int> > dp(s.size()+1, 
        vector<int>(t.size()+1, 0));

        int maxLen = INT_MIN;

        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];

                
            }
        }

        
        
        return dp[s.size()][t.size()] == s.size();
         
    }
};

判定子序列t在s中出现的次数。如果是要求连续序列，则可以考虑使用KMP。

1. dp[i][j]：以i-1结尾的t在以j-1结尾的s中出现的次数。
2. 确定递推公式：
3. 当s[j - 1] == t[i - 1]时，dp[i][j] = dp[i-1][j-1] + dp[i][j-1]，前一块表示用s[i-1]来匹配，后是不用s[i-1]来匹配。
   当s[j - 1] ！= t[i - 1]时，dp[i][j] = dp[i][j-1]，即不用s[i-1]来匹配。
4. dp数组初始化
   由递推公式可以看出，dp[i][0]和dp[0][j]是需要初始化的
   dp[0][j]是指以j-1结尾的s数组里包括空字符串的个数。则s删除所有元素，出现空字符串的个数就是1.故dp[0][j] = 1;
   而dp[i][0]一定为0，以i-1结尾的t在以j-1结尾的空中出现的次数，故初始化为0。

class Solution {
public:
    int numDistinct(string s, string t) {
        //rabbbit.    rabbit

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

        for(int i = 0; i < s.size(); i++)
            dp[0][i] = 1;

       // int res = 0;

        for(int i = 1; i <= t.size(); i++){
            for(int j = 1; j <= s.size(); j++){
                if(t[i-1] == s[j-1]){
                    dp[i][j] = dp[i-1][j-1] + dp[i][j-1];
                }
                else dp[i][j] = dp[i][j-1];

                
            }
        }

        return dp[t.size()][s.size()];
    }
};

和不同的子序列相比，这里就是两个字符串都可以进行删除操作。
dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。
递推公式：

1. 当word1[j-1] == word2[i-1]时，dp[i][j] = dp[i-1][j-1]
2. 当word1[j-1] != word2[i-1]时
   删除word1[j-1], dp[i][j] = dp[i][j-1] + 1; (+1代表删除操作)
   删除word2[i-1]，dp[i][j] = dp[i-1][j] + 1; (+1代表删除操作)
   同时删word1[i - 1]和word2[j - 1]，则dp[i][j] = dp[i - 1][j - 1] + 2; （+2代表两次删除操作）
   最后dp[i][j]取这三者的最小值

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int> > dp(word2.size() + 1, vector<int>(word1.size() + 1, 0));

        for(int i = 1; i <= word1.size(); i++)
            dp[0][i] = i;
        for(int i = 1; i <= word2.size(); i++)
            dp[i][0] = i;


        for(int i = 1; i <= word2.size(); i++){
            for(int j = 1; j <= word1.size(); j++){
                if(word2[i-1] == word1[j-1]){
                    dp[i][j] = dp[i-1][j-1];
                }
                else dp[i][j] = min(dp[i-1][j-1] 
                + 2, min(dp[i-1][j], 
                dp[i][j-1]) + 1);
            }
        }

        return dp[word2.size()][word1.size()];
    }
};