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

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

力扣题目链接(opens new window)

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

示例：

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

---

动态规划求解 LCS

1. 状态定义：创建一个二维数组 dp，其中 dp[i][j] 表示 word1 的前 i 个字符和 word2 的前 j 个字符的最长公共子序列的长度。
2. 状态初始化：初始化 dp 数组的第一行和第一列为0，因为空字符串与任何字符串的最长公共子序列长度为0。
3. 状态转移：
   • 如果 word1[i - 1] == word2[j - 1]，则 dp[i][j] = dp[i - 1][j - 1] + 1。
   • 如果不相等，则 dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])。
4. 计算删除步骤：len(word1) + len(word2) - 2 * dp[len(word1)][len(word2)]。这是因为 dp[len(word1)][len(word2)] 是两个字符串的最长公共子序列长度，从每个字符串长度中减去这个值，然后相加，就是总共需要删除的字符数。

def minDistance(word1: str, word2: str) -> int:
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            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 m + n - 2 * dp[m][n]
 
# 测试代码
word1 = "sea"
word2 = "eat"
print(minDistance(word1, word2))  # 应该输出 2

72. 编辑距离

力扣题目链接(opens new window)

给你两个单词 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')
  解释： 意图 -> 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[i][j] 表示将 word1 的前 i 个字符转换成 word2 的前 j 个字符所需的最少操作数。
2. 状态初始化：
   • dp[0][j] 表示将空字符串转换为 word2 的前 j 个字符，需要 j 次插入操作。
   • dp[i][0] 表示将 word1 的前 i 个字符转换为空字符串，需要 i 次删除操作。
3. 状态转移：
   • 如果 word1[i - 1] == word2[j - 1]，则 dp[i][j] = dp[i - 1][j - 1]，无需额外操作。
   • 如果不相等，考虑以下三种操作：
     • 插入：dp[i][j - 1] + 1。
     • 删除：dp[i - 1][j] + 1。
     • 替换：dp[i - 1][j - 1] + 1。
   • 选择上述操作中的最小值作为 dp[i][j] 的值。
4. 最终结果：dp[len(word1)][len(word2)]。

def minDistance(word1: str, word2: str) -> int:
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
 
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            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[m][n]
 
# 测试代码
word1 = "horse"
word2 = "ros"
print(minDistance(word1, word2))  # 应该输出 3

 

#