给定两个单词 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 只包含小写英文字母

思路：

用递归的思路从右往左想，

如果两个 char 相同，那么不用删除，直接处理左侧剩余字符即可，

如果两个 char 不同，那么我们肯定至少要删除一个字符（删除次数 + 1），具体删哪一个都有可能，所以两种可能都尝试一次。

当一个字符串全部处理完毕之后，另一个字符串剩下的部分需要全部被删除，假设这个字符串当前下标是1，就代表还有（1 + 1）个字符没有被删除，对应递归结束的处理。

时间复杂度：O（MN）

空间复杂度：O（MN）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        @cache
        def dfs(i, j):
            if i < 0 or j < 0: # if one word is empty, we need to delete all left chars in the other word
                return max(i, j) + 1
            if word1[i] == word2[j]: # deletion is unnecessary
                return dfs(i - 1, j - 1)
            else: # try delete each one
                return 1 + min(dfs(i, j - 1) , dfs(i - 1, j))
        return dfs(m - 1, n - 1)

第二种思路：

将 Dfs + memo 的代码翻译成 DP。

时间复杂度：O（MN）

空间复杂度：O（MN）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        # @cache
        # def dfs(i, j):
        #     if i < 0 or j < 0: # if one word is empty, we need to delete all left chars in the other word
        #         return max(i, j) + 1
        #     if word1[i] == word2[j]: # deletion is unnecessary
        #         return dfs(i - 1, j - 1)
        #     else: # try delete each one
        #         return 1 + min(dfs(i, j - 1) , dfs(i - 1, j))
        # return dfs(m - 1, n - 1)
        # dfs + memo to DP
        dp = [[inf] * (n + 1) for _ in range(m + 1)]
        for i in range(n + 1): # initialize the first row
            dp[0][i] = i
        for j in range(m + 1): # initialize the first col
            dp[j][0] = j
        for i, x in enumerate(word1):
            for j, y in enumerate(word2):
                if x == y:
                    dp[i + 1][j + 1] = dp[i][j]
                else:
                    dp[i + 1][j + 1] = min(dp[i][j + 1], dp[i + 1][j]) + 1
        # print(dp)
        return dp[m][n]