代码随想录算法训练营第五十五天 | LeetCode 583. 两个字符串的删除操作、72. 编辑距离、编辑距离总结

文章链接：两个字符串的删除操作、编辑距离、编辑距离总结
视频链接：两个字符串的删除操作、编辑距离

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

1.1 思路

1. 题目给我们两个字符串问两个字符串最少可以删除多少个元素使这两个字符串相同。本题相对于115. 不同的子序列难在于两个都可以删
2. dp 数组及其下标的含义：比较两个字符串里的每个元素是否相同的情况就定义二维数组，dp[i][j]：以 i-1 为结尾的 word1 和以 j-1 为结尾的 word2，为了让它们相同的最少操作次数为 dp[i][j]。定义 i-1 和 j-1 是为了方便初始化
3. 递推公式：if（word1[i-1]==word2[j-1]）dp[i][j]=dp[i-1][j-1] 因为这两个元素已经相同了，考虑与不考虑都是一样的，因此直接继承dp[i-1][j-1]，因为两个元素都相同了就可以不操作它们了。else 就是word1[i-1]!=word2[j-1] 的情况就需要删除元素了，如果删除word1[i-1]，dp[i][j]=dp[i-1][j]+1 这里就是模拟出了删除 word1[i-1]；如果删除word2[j-1]，dp[i][j]=dp[i][j-1]+1 这里就是模拟出了删除 word2[j-1]；如果都删了就是 dp[i][j]=dp[i-1][j-1]+2。因此如果两个元素不相同就是 dp[i][j]=Math.min（三个取最小值）
   
4. dp 数组的初始化：根据递推公式得到推导方向，因此第一行和列都需要初始化，dp[0][j] 表示以-1 为结尾即空字符串 word1，要想和 word2 相同的最小操作次数就应该是 j，因为 word2 就需要删掉 j 个元素；dp[i][0] 表示以-1 为结尾即空字符串 word2，要想和 word1 相同的最小操作次数就应该是 1，因为 word1 就需要删掉 i 个元素。其余下标因为会被覆盖，因此默认即可
5. 遍历顺序：从推导方向可以看出就是从左到右从上到下， for（int i=1；i<=word1.length()；i++）for（int j=1；word2<=t.length()；j++），为什么从 1 开始？为什么要等于号？以前解释过了。最终结果保存在 dp[word1.length()][word2.length()]
6. 打印 dp 数组：用于 debug
7. 其实本题也可以通过求1143. 最长公共子序列一样，求出最长公共子序列，然后两个原字符串总和相加减去 2 倍的最长公共子序列的长度就是要求的最小操作次数

1.2 代码

// dp数组中存储需要删除的字符个数
class Solution {
    public int minDistance(String word1, String word2) {
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        for (int i = 0; i < word1.length() + 1; i++) dp[i][0] = i;
        for (int j = 0; j < word2.length() + 1; j++) dp[0][j] = j;
        
        for (int i = 1; i < word1.length() + 1; i++) {
            for (int j = 1; j < word2.length() + 1; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
                    dp[i][j] = Math.min(dp[i - 1][j - 1] + 2,
                                        Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                }
            }
        }
        
        return dp[word1.length()][word2.length()];
    }
}
//DP - longest common subsequence (用最長公共子序列反推)
class Solution {
    public int minDistance(String word1, String word2) {
        char[] char1 = word1.toCharArray();
        char[] char2 = word2.toCharArray();

        int len1 = char1.length;
        int len2 = char2.length;

        int dp[][] = new int [len1 + 1][len2 + 1];

        for(int i = 1; i <= len1; i++){
            for(int j = 1; j <= len2; j++){
                if(char1[i - 1] == char2[j - 1])
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
            }
        }

        return len1 + len2 - (2 * dp[len1][len2]);//和leetcode 1143只差在這一行。
    }
}

2. LeetCode 72. 编辑距离

2.1 思路

1. 本题是给我们两个字符串，如何让 word1 和 word2 相等，可以通过添加、删除、替换元素，对 word1 和 word2 操作都可以，增加 word1 的元素也就是相当于删除 word2 的元素，因此操作方式很多样
2. dp 数组及其下标的含义：比较两个字符串的相同情况我们要定义一个二维数组，dp[i][j]：以 i-1 为结尾的 word1 和以 j-1 为结尾的 word2 最少操作次数为 dp[i][j] 能使两个字符串相等。为什么以 i-1 和 j-1 结尾是为了方便初始化
3. 递推公式：要求相同就要比较每个元素，讨论它们相同与不相同的情况 if（word1[i-1]==word2[j-1]）dp[i][j]=dp[i-1][j-1] 因为两个元素都相同了，就可以不改变操作次数，不需要任何操作。else 就是两个元素不相同，有增加、删除、替换等操作，如果删掉 word1 的第 i-1 个元素，那就是 dp[i][j]=dp[i-1][j]+1，也就是以 i-2 为结尾和以 j-1 为结尾的相同的最小操作数的基础上+1，如果删掉 word2 的第 j-1 个元素，dp[i][j]=dp[i][j-1]+1，如果两个元素不相同选择替换元素，无论是替换 word1 的还是 word2 的，把其中一个的替换成另一个的就可以了，因此是 dp[i][j]=dp[i-1][j-1]+1，这里含义是把 word1 的第 i-1 个元素换成了 word2 的第 j-1 个元素或者 word2 的第 j-1 个元素换成了 word1 的第 i-1 个元素。因此 dp[i][j]=Math.min（三者取最小值）。为什么这里没有添加元素的操作呢？因为对 word1 添加其实就相当于对 word2 删除，反之也是同理，因此我们用删除代替了添加，效果是一样的
   
4. dp 数组的初始化：根据递推公式得到推导方向，因此我们要初始化第一行和列都初始化了，dp[i][0]，也就是以 i-1 为结尾的字符串 word1 和以-1 为结尾的空字符串 word2，word1 要最少操作 i 次才能与 word2 相等，因此 for（int i=0；i<=word1.length()；i++）dp[i][0]=i；dp[0][j]，以-1 为结尾的空字符串 word1 和以 j-1 为结尾的字符串 word2，word2 最少操作 j 次才能与 word1 相等，因此 for（int j=0；j<=word2.length()；j++）dp[0][j]=j。为什么取等于号，因为 dp是以 i-1 为结尾和 j-1 为结尾的，一定要取等了，才能表示最后一个元素为结尾。其余下标无所谓，会被覆盖，默认为 0 即可。
5. 遍历顺序：根据递推公式和推导方向，就一定是从左到右和从上到下，for（int i=1；i<=word1.length()；i++）for（int j=1；word2<=t.length()；j++），为什么从 1 开始？为什么取等于号？上面解释过了。最终结果保存在 dp[word1.length()][word2.length()]
6. 打印 dp 数组：用于 debug

2.2 代码

public int minDistance(String word1, String word2) {
    int m = word1.length();
    int n = word2.length();
    int[][] dp = new int[m + 1][n + 1];
    // 初始化
    for (int i = 1; i <= m; i++) {
        dp[i][0] =  i;
    }
    for (int j = 1; j <= n; j++) {
        dp[0][j] = j;
    }
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            // 因为dp数组有效位从1开始
            // 所以当前遍历到的字符串的位置为i-1 | j-1
            if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i][j - 1]), dp[i - 1][j]) + 1;
            }
        }
    }
    return dp[m][n];
}

3. 编辑距离总结

本题是通过三道题铺垫而来的

3.1 392. 判断子序列

if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = dp[i][j - 1];

3.2 115. 不同的子序列

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

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

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] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});
}

3.4 72. 编辑距离

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 - 1][j], dp[i][j - 1]}) + 1;
}