_48LeetCode代码随想录算法训练营第四十八天-动态规划 | 583.两个字符串的删除操作、72.编辑距离、编辑距离总结篇

已于 2023-02-03 22:02:43 修改
阅读量168 收藏 1
点赞数 1
分类专栏： Algorithms 文章标签： 算法 动态规划 leetcode c++
于 2023-02-03 22:02:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44410704/article/details/128876735
版权

_48LeetCode代码随想录算法训练营第四十八天-动态规划 | 583.两个字符串的删除操作、72.编辑距离、编辑距离总结篇

题目列表

  • 583.两个字符串的删除操作
  • 72.编辑距离
  • 编辑距离总结篇

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

代码随想录地址：https://programmercarl.com/0583.%E4%B8%A4%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C.html

题目

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

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

示例 1：

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

示例 2:

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

提示：

  • 1 <= word1.length, word2.length <= 500
  • word1 和 word2 只包含小写英文字母

思路

  1. 确定dp数组（dp table）以及下标的含义

dp[i] [j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。

这里dp数组的定义有点点绕，大家要撸清思路。

  1. 确定递推公式
  • 当word1[i - 1] 与 word2[j - 1]相同的时候
  • 当word1[i - 1] 与 word2[j - 1]不相同的时候

当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});

因为 dp[i] [j - 1] + 1 = dp[i - 1] [j - 1] + 2，所以递推公式可简化为：dp[i] [j] = min(dp[i - 1] [j] + 1, dp[i] [j - 1] + 1);

  1. dp数组如何初始化

从递推公式中，可以看出来，dp[i] [0] 和 dp[0] [j]是一定要初始化的。

dp[i] [0]：word2为空字符串，以i-1为结尾的字符串word1要删除多少个元素，才能和word2相同呢，很明显dp[i] [0] = i。

dp[0] [j]的话同理

  1. 确定遍历顺序

所以遍历的时候一定是从上到下，从左到右。

  1. 动态推导dp数组

草稿纸。

代码

  • 时间复杂度：O(m * n) ，m表示word1的元素个数， n表示word2的元素个数。
  • 空间复杂度：O(m * n)
/*
 * @lc app=leetcode.cn id=583 lang=cpp
 *
 * [583] 两个字符串的删除操作
 */

// @lc code=start
class Solution {
public:
    int minDistance(string word1, string word2) {
        //定义及初始化dp数组
        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] + 1, dp[i][j - 1] + 1);
            }
        return dp[word1.size()][word2.size()];
    }
};
// @lc code=end
  • 时间复杂度：O(m * n) ，m表示word1的元素个数， n表示word2的元素个数。
  • 空间复杂度：O(n)
/*
 * @lc app=leetcode.cn id=583 lang=cpp
 *
 * [583] 两个字符串的删除操作
 */

// @lc code=start
class Solution {
public:
    int minDistance(string word1, string word2) {
        //定义及初始化dp数组
        vector<vector<int>> dp(2, vector<int>(word2.size() + 1, 0));
        for(int j = 0; j <= word2.size(); j++)
            dp[0][j] = j;
        //遍历
        for(int i = 1; i <= word1.size(); i++)
        {
            dp[i % 2][0] = i;//每次都要重新初始化dp[i % 2][0],因为后面的递推公式会用到，相当于dp数组列的初始化
            for(int j = 1; j <= word2.size(); j++)
            {
                
                if(word1[i - 1] == word2[j - 1])
                    dp[i % 2][j] = dp[(i - 1) % 2][j - 1];
                else
                    dp[i % 2][j] = min(dp[(i - 1) % 2][j] + 1, dp[i % 2][j - 1] + 1);
            }
        }            
        return dp[word1.size() % 2][word2.size()];
    }
};
// @lc code=end

72.编辑距离

代码随想录地址：https://programmercarl.com/0072.%E7%BC%96%E8%BE%91%E8%B7%9D%E7%A6%BB.html

题目

给你两个单词 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')

提示：

  • 0 <= word1.length, word2.length <= 500
  • word1 和 word2 由小写英文字母组成

思路

  1. 确定dp数组（dp table）以及下标的含义

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

  1. 确定递推公式

在确定递推公式的时候，首先要考虑清楚编辑的几种操作，整理如下：

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])，此时就需要编辑了，如何编辑呢？

  • 操作一 删：如果到dp[i - 1] [j]需要k步，那么到dp[i] [j] 需要多少步呢？ 此时就需要删除word1[i - 1]才可达到，于是dp[i][j] = dp[i - 1][j] + 1 = k + 1;

  • 操作二 增：如果到dp[i] [j - 1]需要k步，那么达到dp[i] [j]需要多少步呢？此时就需要删除word2[j - 1]才可达到(删除word2[j- 1]就相当于增word1[i - 1])；因此，dp[i][j] = dp[i][j - 1] + 1 = k + 1;

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

    其实就是dp[i - 1] [j - 1]加一步转化而来。

  1. dp数组如何初始化

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

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

同理dp[0] [j] = j;(此时就是填的操作了)

  1. 确定遍历顺序

从如下四个递推公式：

  • dp[i][j] = dp[i - 1][j - 1]
  • dp[i][j] = dp[i - 1][j - 1] + 1
  • dp[i][j] = dp[i][j - 1] + 1
  • dp[i][j] = dp[i - 1][j] + 1

可以看出dp[i][j]是依赖左方，上方和左上方元素的，如图：

72.编辑距离

所以在dp矩阵中一定是从左到右从上到下去遍历。

  1. 举例推导dp数组

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

72.编辑距离1

代码

  • 时间复杂度：O(m * n) ，m表示word1的元素个数， n表示word2的元素个数。
  • 空间复杂度：O(m * n)
/*
 * @lc app=leetcode.cn id=72 lang=cpp
 *
 * [72] 编辑距离
 */

// @lc code=start
class Solution {
public:
    int minDistance(string word1, string word2) {
        //定义dp数组
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));
        //初始化dp数组
        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, dp[i - 1][j - 1] + 1});
            }
        return dp[word1.size()][word2.size()];
    }
};
// @lc code=end

优化空间复杂度：

  • 时间复杂度：O(m * n) ，m表示word1的元素个数， n表示word2的元素个数。
  • 空间复杂度：O(n)
/*
 * @lc app=leetcode.cn id=72 lang=cpp
 *
 * [72] 编辑距离
 */

// @lc code=start
class Solution {
public:
    int minDistance(string word1, string word2) {
        //定义dp数组
        vector<vector<int>> dp(2, vector<int>(word2.size() + 1, 0));
        //初始化dp数组
        for(int j = 0; j <= word2.size(); j++)
            dp[0][j] = j;
        
        //遍历
        for(int i = 1; i <= word1.size(); i++)
        {
            dp[i % 2][0] = i;//每次都要重新初始化首列的元素，和初始化dp一个道理
            for(int j = 1; j <= word2.size(); j++)
            {
                
                if(word1[i - 1] == word2[j - 1])
                    dp[i % 2][j] = dp[(i - 1) % 2][j - 1];
                else
                    dp[i % 2][j] = min({dp[(i - 1) % 2][j] + 1, dp[i % 2][j - 1] + 1, dp[(i - 1) % 2][j - 1] + 1});
            }
        }            
        return dp[word1.size() % 2][word2.size()];
    }
};
// @lc code=end

编辑距离总结篇

代码随想录地址：https://programmercarl.com/%E4%B8%BA%E4%BA%86%E7%BB%9D%E6%9D%80%E7%BC%96%E8%BE%91%E8%B7%9D%E7%A6%BB%EF%BC%8C%E5%8D%A1%E5%B0%94%E5%81%9A%E4%BA%86%E4%B8%89%E6%AD%A5%E9%93%BA%E5%9E%AB.html

Jasmine-Lily
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jasmine-Lily

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值