代码随想录算法训练营第四十五天|不同的子序列、两个字符串的删除操作、编辑距离

不同的子序列 leetcode 115

不要求连续。

dp数组含义：以i为尾的s中有以j为尾的t的个数为dp[i][j]。

递推公式：如果s[i]==t[j]，就不需要考虑i和j这两个字母了，就等于以i-1为尾的s中有以j-1为尾的t的个数为dp[i-1][j-1]，这种情况是考虑使用i这种情况，还有不使用i的情况（例如：在bagg中找bag），此时不使用i就是以i-1为尾的s中有以j为尾的t的个数为dp[i-1][j]。

如果s[i]!=t[j]，则就是不使用i，和上面第二种情况相同，为dp[i-1][j]。因为是在s中找t所以不用模拟不使用j-1的情况，因为必须得用j-1。

初始化：由递推公式，第一行和第一列需要初始化，对于第一列，dp[i][0]，只要s[i]==t[0]就赋值加一并向后顺延。对于第一行dp[0][j]，第一个格子在对第一列赋值是已经初始化，其余格子初始化为0。

遍历顺序：从上到下，从左到右。

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size(),vector<uint64_t>(t.size(),0));
        int count=0;
        int num=0;
        for(int i=0;i<s.size();i++){
            if(s[i]==t[0]){
                count++;
                dp[i][0]=count;
            }else{
                dp[i][0]=count;
            }
        }
        for(int i=1;i<s.size();i++){
            for(int j=1;j<t.size();j++){
                if(s[i]==t[j]) dp[i][j]=dp[i-1][j-1]+dp[i-1][j];
                else dp[i][j]=dp[i-1][j];
            }
        }
        return dp[s.size()-1][t.size()-1];
    }
};

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

解法一：使用之前做过的最长公共子序列解决

找出两个字符串的最长公共子序列长度，然后两个字符串长度减去2倍的最长公共子序列长度就是需要的步数。

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

使用动态规划结果出现错误时，打印dp数组！可以解决很多问题！

解法二：代码随想录卡哥版本

dp数组含义：使以i-1为尾的word1和以j-1为尾的word2相同需要删除的步数为dp[i][j]。

递推公式：当word1[i]==word2[j]时，也就是说不用删，和上一步结果相同此时dp[i][j]=dp[i-1][j-1]。

如果word1[i]!=word2[j]，一共三种情况，删i-1就是dp[i-1][j]+1(其中dp[i-1][j]为使以i-2为尾的word1和以j-1为尾的word2相同需要删除的步数)，删j-1就是dp[i][j-1]+1，i-1和j-2都删就是删两步，为dp[i-1][j-1]+2，然后三种情况取最小值。

初始化：根据递推公式第一行和第一列需要初始化，对于第一行dp[0][j]，使以-1为尾（空字符串）的word1和以j-1为尾的word2相同需要删除的步数就是当前word2的长度j，所以dp[0][j]=j。对于第一列dp[i][0]，使以i-1为尾的word1和以-1为尾（空字符串）的word2相同需要删除的步数为i。其余格子初始化为0。

遍历顺序：从上到下，从左到右。

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(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+2);
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

编辑距离 leetcode 72

dp数组含义：使以i-1为尾的word1转化为以j-1为尾的word2的最少操作步数为dp[i][j]。

递推公式：如果word1[i]==word2[j]，则此时不需要任何操作，即dp[i][j]=dp[i-1][j-1];

对于最少操作次数，增加和删除是同理的，所以我们只需要考虑删除和替换即可，对于删除操作，当删除i-1时为dp[i-1][j]+1（使以i-2为尾的word1转化为以j-1为尾的word2的最少操作步数再加一步删除操作），同理删除j-1时为dp[i][j-1]+1。对于替换操作，就是使当前遍历的不同的字母相同，那么就是dp[i-1][j-1]+1（使以i-2为尾的word1转化为以j-2为尾的word2的最少操作步数加一步替换操作）。

初始化：根据递推公式，必须初始化第一行和第一列，对于第一行dp[0][j]（使以-1为尾的word1空字符串转化为以j-1为尾的word2的最少操作步数）应该增加j个字符所以dp[0][j]=j;同理dp[i][0]=i。

遍历顺序：从上到下，从左到右。

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(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+1);
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

出现的错误

if语句判断条件写成了：word1[i]==word2[j]。应该是if(word1[i-1]==word2[j-1])。

因为dp数组含义：使以i-1为尾的word1转化为以j-1为尾的word2的最少操作步数为dp[i][j]。