day56 | 583. 两个字符串的删除操作、72. 编辑距离

最新推荐文章于 2024-10-16 10:13:45 发布

我想喝冰阔乐

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量164

点赞数

分类专栏： LeetCode 刷题 C++ 文章标签： leetcode 算法数据结构动态规划 c++

本文链接：https://blog.csdn.net/weixin_45048521/article/details/131783771

版权

C++ 同时被 2 个专栏收录

82 篇文章 0 订阅

订阅专栏

LeetCode 刷题

81 篇文章 0 订阅

订阅专栏

解题及思路学习

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

https://leetcode.cn/problems/delete-operation-for-two-strings/

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

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

示例 1：

输入: word1 = "sea", word2 = "eat"
输出: 2

动态规划五部曲分析：

1、含义

dp[i][j] : 使得word1中下标为i - 1 和word2中下标为j - 1 相同所需的最小步数。

2、递推公式：

（1）当i-1和j-1对应元素相等的时候，此时不需要额外删除元素。 dp[i][j] = dp[i - 1][j - 1].

（2）当i-1 和j-1对应元素不相等，有三种情况，word1和word2分别删一个，以及两个都删一个求删除的最小步数。 dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j -1] +2).

3、初始化

需要初始化dp[i][0] 和dp[0][j]的情况。此时要删除的就是其中包含的元素，直接等于i或者j就行。

4、遍历顺序

由于需要用到前面的状态，所以从左往右，从上往下。

5、举例

以word1:“sea”，word2:"eat"为例，推导dp数组状态图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b8z0Q9ya-1689651377419)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/6e3deb1a-60ef-464b-ad7b-a739852f5ec5/Untitled.png)]

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

时间复杂度: O(n * m)
空间复杂度: O(n * m)

另一种思路是：找到最长公共子序列，之后用两个字符串的总长度减去两个最长公共子序列的长度即可。

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

时间复杂度: O(n * m)
空间复杂度: O(n * m)

72. 编辑距离

https://leetcode.cn/problems/edit-distance/

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

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

插入一个字符
删除一个字符
替换一个字符

示例 1：

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

思考：

1、这道题似乎可以先求最长公共子序列。如果最长公共子序列长度等于其中一个单词，则最少操作数等于单词长度差值。求出最长公共子序列之后，后序的操作次数计算有点复杂。这种思路舍弃。

2、直接用dp[i][j] 来表示讲下标为i- 1 的word1 转换成下标为i-2 的word2所需要的操作数。

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++) dp[i][0] = i;
        for (int j = 1; 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()];
    }
};

时间复杂度: O(n * m)
空间复杂度: O(n * m)

动规五部曲:

1、含义

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

2、递推公式

if (word1[i - 1] == word2[j - 1])
    不操作
if (word1[i - 1] != word2[j - 1])
    增
    删
    换

if (word1[i - 1] == word2[j - 1]) 那么说明不用任何编辑，dp[i][j] 就应该是 dp[i - 1][j - 1]，即dp[i][j] = dp[i - 1][j - 1];

if (word1[i - 1] != word2[j - 1])，此时就需要编辑了，如何编辑呢？

操作一：word1删除一个元素，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离再加上一个操作。

即 dp[i][j] = dp[i - 1][j] + 1;

操作二：word2删除一个元素，那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离再加上一个操作。

即 dp[i][j] = dp[i][j - 1] + 1;

word2添加一个元素，相当于word1删除一个元素。所以直接考虑删除的情况就可以了。

操作三：替换元素，word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增删加元素。

可以回顾一下，if (word1[i - 1] == word2[j - 1])的时候我们的操作是 dp[i][j] = dp[i - 1][j - 1] 对吧。

那么只需要一次替换的操作，就可以让 word1[i - 1] 和 word2[j - 1] 相同。

所以 dp[i][j] = dp[i - 1][j - 1] + 1;

3、初始化

dp[i][0] = i; dp[0][j] = j;

4、遍历顺序

dp[i][j] 是依赖左方，上方和左上方元素的。所以从左往右，从上往下。

5、举例推导

输入：word1 = "horse", word2 = "ros"为例，dp矩阵状态图如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zZWyw9HB-1689651377422)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/e21d4b97-17a1-4f80-90f7-cee1cc7a7989/Untitled.png)]