Day55｜动态规划part16：583. 两个字符串的删除操作、72. 编辑距离、编辑距离总结篇-CSDN博客

本文链接：https://blog.csdn.net/weixin_43303286/article/details/132695955

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

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = "sea", word2 = "eat"
输出: 2
解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"
示例 2:

输入：word1 = "leetcode", word2 = "etco"
输出：4

这题其实和求最长子序列的题目是一样的，

题目让我们计算将两个字符串变得相同的最少删除次数，可以思考一下，最后这两个字符串会被删成什么样子？

删除的结果不就是它俩的最长公共子序列嘛！

因此把最后return的结果改一下就可以过：

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

编辑距离

leetcode链接：力扣题目链接

视频链接：动态规划终极绝杀！ LeetCode：72.编辑距离

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符
示例 1：

输入：word1 = "horse", word2 = "ros"
输出：3
解释：
horse -> rorse (将 'h' 替换为 'r')
rorse -> rose (删除 'r')
rose -> ros (删除 'e')
示例 2：

输入：word1 = "intention", word2 = "execution"
输出：5
解释：
intention -> inention (删除 't')
inention -> enention (将 'i' 替换为 'e')
enention -> exention (将 'n' 替换为 'x')
exention -> exection (将 'n' 替换为 'c')
exection -> execution (插入 'u')

这题之前学IR的时候也讲过，但是其实乍一看用算法实现是很复杂的，但有了之前的打基础，尝试用动态规划实现。

编辑距离算法在实际生活中其实很实用：

“为什么说它实用呢，因为前几天我就在日常生活中用到了这个算法。之前有一篇公众号文章由于疏忽，写错位了一段内容，我决定修改这部分内容让逻辑通顺。但是公众号文章最多只能修改 20 个字，且只支持增、删、替换操作（跟编辑距离问题一模一样），于是我就用算法求出了一个最优方案，只用了 16 步就完成了修改。”

首先我们看下如何模拟对字符串的编辑距离操作：

确定dp数组下标及其含义

dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。

确定递推公式，这里看s1[i - 1]与s1[j - 1]是否相等：

相等：指针同时向前移动，dp[i][j] = dp[i - 1][j - 1]

不相等：有三种操作最终求最小值

插入：word1插入一个元素，相当于word2删除一个元素，dp[i][j] = dp[i][j - 1] + 1；
替换：i, j都要移动，dp[i][j] = dp[i - 1] [j - 1] + 1
删除：word1删除一个元素，也就是移动i，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离再加上一个操作。dp[i][j] = dp[i- 1][j] + 1，

dp数组的初始化

那么dp[i][0] 和 dp[0][j] 表示什么呢？

dp[i][0] ：以下标i-1为结尾的字符串word1，和空字符串word2，最近编辑距离为dp[i][0]。

那么dp[i][0]就应该是i，对word1里的元素全部做删除操作，即：dp[i][0] = i;

同理dp[0][j] = j;

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循环，从前到后

循环打印dp数组

最终代码：

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

编辑距离总结

动态规划：392.判断子序列 (opens new window)给定字符串 s 和 t ，判断 s 是否为 t 的子序列。相当于编辑距离只计算删除的情况；
动态规划：115.不同的子序列 (opens new window)给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成：
- 一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。
- 一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。
动态规划：583.两个字符串的删除操作 (opens new window)给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。其实就是392的变体，当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：
- 情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1
- 情况二：删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1
- 情况三：同时删word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2

那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});