【动态规划】LeetCode 583. 两个字符串的删除操作 Java

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

我的代码，错误代码，只考虑到了字母出现的次数，没有考虑到两个字符串中字母出现的顺序

class Solution {
    public int minDistance(String word1, String word2) {
        int[] arr1 = new int[26];
        int[] arr2 = new int[26];
        for (char word : word1.toCharArray()) {
            arr1[word - 'a']++;
        }
        for (char word : word2.toCharArray()) {
            arr2[word - 'a']++;
        }
        int cnt = 0;
        for (int i = 0; i < 26; i++) {
            cnt += Math.abs(arr1[i] - arr2[i]);
        }
        return cnt;
    }
}

方法一，计算最长公共子序列

给定两个字符串word1和word2，分别删除若干字符之后使得两个字符串相同，则剩下的字符为两个字符串的公共子序列。为了使删除操作的次数少，剩下的字符应尽可能多。当剩下的字符为两个字符串的最长公共子序列时，删除的操作的次数最少。因此，可以计算两个字符串的最长公共子序列的长度，然后分别计算两个字符串的长度和最长公共子序列的长度之差，即为两个字符串分别需要删除的字符数，两个字符串各自需要删除的字符数之和即为最少的删除操作的总次数。

由这一题，引出LeetCode 1143 最长公共子序列

先看1143最长公共子序列的题解，然后再来看这题，代码几乎完全都不用变。

class Solution {
    public int minDistance(String word1, String word2) {
        return word1.length() + word2.length() - 2 * longestCommonSubsequence(word1, word2);
    }

    public int longestCommonSubsequence(String text1, String text2) {
        int n = text1.length();
        int m = text2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[n][m];
    }
}

复杂度分析：

• 时间复杂度：O(mn)，其中m和n分别是字符串word1和字符串word2的长度。二维数组dp有m+1行和n+1列，需要对dp中的每个元素进行计算
• 空间复杂度：O(mn)，其中m和n分别是字符串word1和word2的长度。创建了m+1行和n+1列的二维数组dp。

方法二，动态规划

直接使用动态规划计算最少删除操作次数，不需要计算最长公共子序列的长度。

假设字符串text1和text2的长度分别为m和n，创建m+1行和n+1列的二维数组dp，其中dp[i][j]表示使text1[0:i]和text2[0:j]相同的最少删除操作次数。

上述表示中，text1[0:i]表示text1的长度为i的前缀，text2[0:j]表示text2的长度为j的前缀。

考虑动态规划的边界情况：

• 当i=0时，text1[0:i]为空，空字符串和任何字符串要变成相同，只有将另一个字符串的字符全部删除，因此，对任意0<=j<=n，dp[0][j]=j
• 当j=0时，text2[0:j]为空，同理可得，对任意0<=i<=m，有dp[i][0]=i

当i>0 且 j>0时，考虑dp[i][j]的计算：

• 当text1[i-1]=text2[j-1]时，将这两个相同的字符称为公共字符，考虑使text1[0:i-1]和text2[0:j-1]相同的最少删除操作次数，再增加一个公共字符之后，最少删除操作次数不变，因此，dp[i][j]=dp[i-1][j-1]。
• 当text1[i-1]!=text2[j-1]时，考虑以下两项：
  • 使text1[0:i-1]和text2[0:j]相同的最少删除操作次数，加上删除word[i-1]的1次操作
  • 使text1[0:i]和text2[0:j-1]相同的最少删除操作次数，加上删除word[j-1]的1次操作

要得到使得text1[0:i]和text2[0:j]相同的最少删除操作次数，应取两项中较小的一项，因此，dp[i][j] = min(dp[i-1][j]，dp[i][j-1])+1

由此可以得到如下状态转移方程

class Solution {
    public int minDistance(String word1, String word2) {
        int n = word1.length();
        int m = word2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 0; i <= n; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= m; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1;
                }
            }
        }
        return dp[n][m];
    }

}

复杂度分析：

• 时间复杂度：O(mn)，其中m和n分别是字符串word1和word2的长度。二维数组dp有m+1行和n+1列，需要对dp中的每个元素进行计算
• 空间复杂度：O(mn)，其中m和n分别是字符串word1和word2的长度。创建了m+1行和n+1列的二维数组dp
  

1143. 最长公共子序列

最长公共子序列问题是典型的二维动态规划问题。

假设字符串text1和text2的长度分别为m和n，创建m+1行和n+1列的二维数组dp，其中dp[i][j]表示text1[0:i]和text2[0:j]的最长公共子序列的长度。

上述表示中，text1[0:i]表示text1的长度为i的前缀，text2[0:j]表示text2的长度为j的前缀。

考虑动态规划的边界情况：

• 当i=0时，text1[0:i]为空，空字符串和任何字符串的最长公共子序列的长度都是0，因此，对任意0<=j<=n，dp[0][j]=0
• 当j=0时，text2[0:j]为空，同理可得，对任意0<=i<=m，有dp[i][0]=0

因此，动态规划的边界情况是：当i=0或j=0时，dp[i][j] = 0

当i>0 且 j>0时，考虑dp[i][j]的计算：

• 当text1[i-1]=text2[j-1]时，将这两个相同的字符称为公共字符，考虑text1[0:i-1]和text2[0:j-1]的最长公共子序列，再增加一个字符（即公共字符）即可得到text1[0:i]和text2[0:j]的最长公共子序列，因此，dp[i][j]=dp[i-1][j-1]+1。
• 当text1[i-1]!=text2[j-1]时，考虑以下两项：
  • text1[0:i-1]和text2[0:j]的最长公共子序列
  • text1[0:i]和text2[0:j-1]的最长公共子序列

要得到text1[0:i]和text2[0:j]的最长公共子序列，应取两项中长度较大的一项，因此，dp[i][j] = max(dp[i-1][j]，dp[i][j-1])

由此可以得到如下状态转移方程

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {
        int n = text1.length();
        int m = text2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        return dp[n][m];
    }
}