代码随想录算法训练营day56| 583. 两个字符串的删除操作、72. 编辑距离

Lixygg

已于 2023-02-04 11:33:56 修改

阅读量162

点赞数

分类专栏：代码随想录算法训练营文章标签：算法 leetcode 动态规划数据结构 java

于 2023-02-03 08:52:27 首次发布

本文链接：https://blog.csdn.net/weixin_45368277/article/details/128860352

版权

代码随想录算法训练营专栏收录该内容

50 篇文章 14 订阅

订阅专栏

文章介绍了使用动态规划解决LeetCode上的两道问题——583.两个字符串的删除操作和72.编辑距离。核心思想是通过构建二维数组dp来存储子问题的解，比较字符是否相同，计算最少的删除、插入或替换操作次数。

摘要由CSDN通过智能技术生成

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

题目链接
思路：动态规划
代码：

class Solution {
    public int minDistance(String word1, String word2) {
        // dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串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(); i++) {
            for (int j = 1; j <= word2.length(); j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    // 当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
                    // 当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
                    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()];
    }
}

Leetcode 72. 编辑距离

题目链接
思路：

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

代码：

class Solution {
    public int minDistance(String word1, String word2) {
        // dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        // 初始化
        for (int i = 1; i <= word1.length(); i++) {
            dp[i][0] =  i;
        }
        for (int j = 1; j <= word2.length(); j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= word1.length(); i++) {
            for (int j = 1; j <= word2.length(); 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[word1.length()][word2.length()];
    }
}