第四十五天 第九章 动态规划part12 115.不同的子序列 583. 两个字符串的删除操作 72. 编辑距离

 115.不同的子序列  

1.首先容器大小要设置为uint64_t,不然会越界，不能全部通过。

2.理解递推公式：

当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成。

一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。即不需要考虑当前s子串和t子串的最后一位字母，所以只需要 dp[i-1][j-1]。

一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。

例如： s：bagg 和 t：bag ，s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。当然也可以用s[3]来匹配，即：s[0]s[1]s[3]组成的bag。

所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]

所以递推公式为：dp[i][j] = dp[i - 1][j];

这里我将s,t遍历顺序改变了。

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(t.size() + 1, vector<uint64_t>(s.size() + 1, 0));
        // 初始化第一行，表示当 t 为空字符串时，s 的任意前缀子序列中包含 t 的情况为 1
        for (int j = 0; j <= s.size(); ++j) {
            dp[0][j] = 1;
        }
        // 填充 dp 矩阵
        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()];
    }
};

583. 两个字符串的删除操作  

主要是计算出两个字符串的最长公共子序列。前面题目做过。

class Solution {
public:
    int minDistance(string word1, string word2) {
         vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        for (int i = 1; i <= word1.size(); ++i) {
            for (int j = 1; j <= word2.size(); ++j) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }   
                else{
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        int total=dp[word1.size()][word2.size()];
        int res=word1.size()-total + word2.size()-total;
        return res;
    }
};

下面这种方法也行。

用删除的办法，这里的dp数组的则是表示删除的最小次数。

还要注意初始化，例如word1=空，word2=abbb， 如果想要将word2变为word1，我们最少需要word2大小的步数。

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
        for (int i = 0; i <= word1.size(); i++) dp[i][0] = i;
        for (int j = 0; j <= word2.size(); j++) dp[0][j] = j;
        for (int i = 1; i <= word1.size(); i++) {
            for (int j = 1; j <= word2.size(); j++) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

72. 编辑距离

这题和上面一题很类似，主要就是要将对word1的增加操作理解为对word2的删除操作。如果是替换，则表示前面的元素都相同了，我们不需要删除增加操作，所以我们要将前一次的最小编辑次数dp[i-1][j-1]加上一，代表替换操作。然后取最小值。

class Solution {
public:
    int minDistance(string word1, string word2) {
       vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
         for (int i = 0; i <= word1.size(); ++i) {
            dp[i][0] = i;
        }
         for (int j = 0; j <= word2.size(); ++j) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= word1.size(); ++i) {
            for (int j = 1; j <= word2.size(); ++j) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }   
                else{
                    dp[i][j] = min({dp[i - 1][j], dp[i][j - 1],dp[i-1][j-1]}) +1;
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};