第50天-DP-第九章 ● 392.判断子序列 ● 115.不同的子序列

1. 判断子序列

• 为什么s[j]!= s[j]的时候 删除的是t的元素， dp[i][j] = dp[i][j-1]
  

class Solution {
public:

    // 1.普通方法
    bool isSubsequence1(string s, string t) {
        int i = 0;
    
        for(int j=0; j<t.size(); j++){
            if(i < s.size() && s[i] == t[j]){
                i++;
            }
        }

        if(i == s.size()){
            return true;
        }
        return false;
    }

    // 2.dp方法
    bool isSubsequence(string s, string t) {
        int l1 = s.size(), l2 = t.size();
        vector<vector<int>> dp(l1+1, vector<int>(l2 + 1, 0));

        for(int i=1; i<=l1; i++){
            for(int j=1; j<=l2; 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[l1][l2] == s.size()){
            return true;
        }
        
        return false;
    }
};

2. 不同的子序列 （没看懂, 先把答案写上）

class Solution {
public:
    int numDistinct(string s, string t) {
        /* 
        1.dp数组含义 dp[i][j]: 以i-1为结尾的s的子序列中 以j-1为结尾的t的个数为dp[i][j]
        2.确定递推公式
            2.1 s[i-1] t[j-1]相等
                分为两个部分: 第一部分用s[i-1]来匹配, 个数为dp[i-1][j-1], 不需要考虑s子串和t子串的最后一个字母
                             第二部分不用s[i-1]匹配, 个数为dp[i-1][j]
            2.2 s[i-1] t[j-1]不相等
                dp[i][j]= dp[i-1][j]
        */

        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
        for (int i = 0; i < s.size(); i++) dp[i][0] = 1;
        for (int j = 1; j < t.size(); j++) dp[0][j] = 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] + dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};