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

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

动态规划解法1:

• 与#115 不同的子序列相比，其实就是两个字符串都可以进行删除操作了，最终确定至少需要几步来使两个字符串相等。

五部曲：

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

2. 确定递推公式：

• 当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

        取最小值：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});

3. dp数组如何初始化：

• 从递推公式中，可以看出来，dp[i][0] 和 dp[0][j]是一定要初始化的。
• dp[i][0]：word2为空字符串，以i-1为结尾的字符串word1要删除多少个元素，才能和word2相同呢，要都删除才行，因此dp[i][0] = i。
• dp[0][j]同理，因此dp[0][j] = j

4. 确定遍历顺序: 

• 从递推公式 dp[i][j] = min(dp[i - 1][j - 1] + 2, min(dp[i - 1][j], dp[i][j - 1]) + 1); 和dp[i][j] = dp[i - 1][j - 1]可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。
• 所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

5. 打印检查

class Solution(object):
    def minDistance(self, word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        """
        dp = [[0]*(len(word2)+1) for _ in range(len(word1)+1)] #注意：下面两步初始化表明，i是行，j是列，那么这里就要清楚的知道要先len(word2)+1
        for i in range(len(word1)+1):
            dp[i][0] = i
        for j in range(len(word2)+1):
            dp[0][j] = j

        for i in range(1, len(word1)+1):
            for j in range(1, len(word2)+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-1]+2, dp[i-1][j]+1, dp[i][j-1]+1)
        
        return dp[len(word1)][len(word2)]

动态规划解法2:

• 与#1143 最长公共子序列基本相同，只要求出两个字符串的最长公共子序列长度即可，那么除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0]*(len(word2)+1) for _ in range(len(word1)+1)]

        for i in range(1, len(word1)+1):
            for j in range(1, len(word2)+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 len(word1) + len(word2) - dp[len(word1)][len(word2)]*2

72. 编辑距离

五部曲：

1. 确定dp数组以及下标的含义：dp[i][j] 表示以下标i-1为结尾的字符串word1，和以下标j-1为结尾的字符串word2，最近编辑距离为dp[i][j]。

2.  确定递推公式：重点是考虑清楚编辑的几种操作：

• if (word1[i - 1] == word2[j - 1])：不用任何编辑
  • 从dp[i][j]的定义，word1[i - 1] 与 word2[j - 1]相等了，那么就不用编辑了，以下标i-2为结尾的字符串word1和以下标j-2为结尾的字符串word2的最近编辑距离dp[i - 1][j - 1]就是 dp[i][j]了。
• 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;
    • Q：怎么都是删除操作，添加操作呢？
    • A：word2添加一个元素，相当于word1删除一个元素，例如 word1 = "ad" ，word2 = "a"，word1删除元素'd' 和 word2添加一个元素'd'，变成word1="a", word2="ad"， 最终的操作数是一样！
  • 操作三：替换元素，word1替换word1[i - 1]，使其与word2[j - 1]相同，此时不用增加元素，那么以下标i-2为结尾的word1 与 j-2为结尾的word2的最近编辑距离 加上一个替换元素的操作，dp[i][j] = dp[i - 1][j - 1] + 1;

           综上，当 if (word1[i - 1] != word2[j - 1]) 时取最小的，即：

dp[i][j] = min({dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]}) + 1;

3. dp数组如何初始化：

• 从递推公式中，可以看出来，dp[i][0] 和 dp[0][j]是一定要初始化的。
• dp[i][0] ：word2为空字符串，以i-1为结尾的字符串word1至少要编辑多少个元素，才能和word2相同呢，要都删除才行，因此dp[i][0] = i
• 同理dp[0][j] = j;

4. 确定遍历顺序：

• 从递推公式可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。
• 所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

5. 打印检查

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        dp = [[0]*(len(word2)+1) for _ in range((len(word1)+1))]

        for i in range(len(word1)+1):
            dp[i][0] = i
        for j in range(len(word2)+1):
            dp[0][j] = j

        for i in range(1, len(word1)+1):
            for j in range(1, len(word2)+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-1]+1, dp[i-1][j]+1, dp[i][j-1]+1)
        
        return dp[len(word1)][len(word2)]

总结：可以看出这道题与#583. 两个字符串的删除操作基本相同。难点在于递推公式，也就是几种情况的分析，并且时刻把握dp[i][j]的定义！