【笔试练习题】（动态规划）leetcode 115 Distinct Subsequences + 97. Interleaving String

115. Distinct Subsequences

题目描述：https://leetcode.com/problems/distinct-subsequences/

即判断一个字符串S可以匹配多少个子串T。

例子1：

Input: S = "rabbbit", T = "rabbit"
Output: 3
Explanation:

As shown below, there are 3 ways you can generate "rabbit" from S.
(The caret symbol ^ means the chosen letters)

rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^

例子2：

Input: S = "babgbag", T = "bag"
Output: 5
Explanation:

As shown below, there are 5 ways you can generate "bag" from S.
(The caret symbol ^ means the chosen letters)

babgbag
^^ ^
babgbag
^^    ^
babgbag
^    ^^
babgbag
  ^  ^^
babgbag
    ^^^

采用动态规划求解：

class Solution {
public:
    int numDistinct(string s, string t) {
        if(t.empty()){
            return 1;
        }
        if(s.empty()){
            return 0;
        }
        
        vector<vector<long long int>> dp(t.size(), vector(s.size(), (long long int)0));
        int tmp = 0;
        for(int i = 0; i < s.size(); ++i){
            if(s[i] == t[0]){
                ++tmp;
            }
            dp[0][i] = tmp;
        }
        
        for(int i = 1; i < t.size(); i++){
            for(int j = 1; j < s.size(); j++){
                if(t[i] == s[j]){
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1]; // 和前面的t[i]配过对的个数 + 可以和这个t[i][j]配对的个数
                }
                else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
       return dp[t.size() - 1][s.size() - 1];
    }
};

 

97. Interleaving String 

题目描述：https://leetcode.com/problems/interleaving-string/

即判断字符串s3是否由s1与s2构成。

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if(s1.size() + s2.size() != s3.size()){
            return false;
        }
        // dp记录了s1中的前i个字符和s2中的前j个字符，是否和s3中的前i+j个字符是匹配的
        vector<vector<int>> dp(s1.size() + 1, vector<int> (s2.size() + 1, -1));
        // 初始化
        dp[0][0] = 0;
        for(int i = 1; i <= s1.size(); ++i){
            if(dp[i - 1][0] != -1){
                if(s1[i - 1] == s3[dp[i - 1][0]]){
                    dp[i][0] = dp[i - 1][0] + 1;
                }
            }
        }
        for(int j = 1; j <= s2.size(); ++j){
            if(dp[0][j - 1] != -1){
                if(s2[j - 1] == s3[dp[0][j - 1]]){
                    dp[0][j] = dp[0][j - 1] + 1;
                }
            }
        }
        // 动态规划算法        
        for(int i = 1; i <= s1.size(); ++i)
        {
            for(int j = 1; j <= s2.size(); ++j){
                // 如果s1的前i-1个字符和s2中的前j个字符加起来和s3中的前i+j-1个字符匹配
                // 则比较s1的第i个字符和s3的第i+j个字符
                if(dp[i - 1][j] != -1){
                    if(s1[i - 1] == s3[dp[i - 1][j]]){
                        dp[i][j] = dp[i - 1][j] + 1;
                    }
                }
                // 如果s1的前i个字符和s2中的前j-1个字符加起来和s3中的前i+j-1个字符匹配
                // 则比较s2的第j个字符和s3的第i+j个字符
                if(dp[i][j - 1] != -1){
                    if(s2[j - 1] == s3[dp[i][j - 1]]){
                        dp[i][j] = dp[i][j - 1] + 1;
                    }
                }
            }
        }
        if(dp[s1.size()][s2.size()] != -1){
            return true;
        }
        else{
            return false;
        }
    }
};

写注释的时候，突然意识到可以不用int型变量构建dp表，用bool型逻辑更加通顺，于是修改为：

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        if(s1.size() + s2.size() != s3.size()){
            return false;
        }
        // dp记录了s1中的前i个字符和s2中的前j个字符，是否和s3中的前i+j个字符是匹配的
        vector<vector<bool>> dp(s1.size() + 1, vector<bool> (s2.size() + 1, false));
        // 初始化
        dp[0][0] = true;
        for(int i = 1; i <= s1.size(); ++i){
            if(dp[i - 1][0]){
                if(s1[i - 1] == s3[i - 1]){
                    dp[i][0] = true;
                }
            }
        }
        for(int j = 1; j <= s2.size(); ++j){
            if(dp[0][j - 1]){
                if(s2[j - 1] == s3[j - 1]){
                    dp[0][j] = true;
                }
            }
        }
        // 动态规划算法        
        for(int i = 1; i <= s1.size(); ++i)
        {
            for(int j = 1; j <= s2.size(); ++j){
                // 如果s1的前i-1个字符和s2中的前j个字符加起来和s3中的前i+j-1个字符匹配
                // 则比较s1的第i个字符和s3的第i+j个字符是否匹配
                if(dp[i - 1][j]){
                    if(s1[i - 1] == s3[i + j - 1]){
                        dp[i][j] = true;
                    }
                }
                // 如果s1的前i个字符和s2中的前j-1个字符加起来和s3中的前i+j-1个字符匹配
                // 则比较s2的第j个字符和s3的第i+j个字符是否匹配
                if(dp[i][j - 1]){
                    if(s2[j - 1] == s3[i + j - 1]){
                        dp[i][j] = true;
                    }
                }
            }
        }
        return dp[s1.size()][s2.size()];
    }
};