刷题第56天 | 583. 两个字符串的删除操作、72. 编辑距离

583. Delete Operation for Two Strings

题目链接：583. Delete Operation for Two Strings
思路链接：代码随想录动态规划-两个字符串的删除操作

思路

确定递推公式时，当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

那最后当然是取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});

Code

class Solution {
    public int minDistance(String word1, String word2) {
        // 1. 确定dp数组
        // 以i - 1为结尾的字符串word1,和以j - 1为结尾的字符串word2,想要达到相等，最少需要减去dp[i][j]的个数
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        // 2. 递推公式
            // 1. 当word1[i - 1]与word2[j - 1]不相同时
            // 1.1 删word1[i - 1]: dp[i - 1][j] + 1;
            // 1.2 删word2[j - 1]: dp[i][j - 1] + 1;
            // 1.3 删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));
            // 2. 当word1[i - 1]与word2[j - 1]相同时
            // dp[i][j] = dp[i - 1][j - 1] + 1;
        // 3. 数组初始化
        for (int i = 0; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= word2.length(); j++) {
            dp[0][j] = j;
        }
        // 4. 遍历顺序
        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)) {
                    dp[i][j] = Math.min(dp[i - 1][j - 1] + 2, Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                } else {
                    dp[i][j] = dp[i - 1][j - 1];
                }
            }
            // 5. 打印数组
            // for (int[] row : dp) {
            //     for (int item : row) {
            //         System.out.print(item + " ");
            //     }
            //     System.out.println();
            // }
            // System.out.println();
        }
        return dp[word1.length()][word2.length()];
    }
}

class Solution {
    public int minDistance(String word1, String word2) {
        // 动态规划方法2: 找出最大的重复序列长度
        // 1. 确定dp数组
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        // 2. 递推公式
        // if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
        //     dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
        // } else {
        //     dp[i][j] = dp[i - 1][j - 1] + 1;
        // }
        // 3. 初始化数组: 都是0
        // 4. 遍历顺序
        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)) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
            }
            // 5. 打印数组
            // for (int[] row : dp) {
            //     for (int item : row) {
            //         System.out.print(item + " ");
            //     }
            //     System.out.println();
            // }
            // System.out.println();
        }
        return word1.length() + word2.length() - 2 * dp[word1.length()][word2.length()];
    }
}

72. Edit Distance

题目链接：72. Edit Distance
思路链接：代码随想录动态规划-编辑距离

思路

学会删除操作，注意这里增加操作和删除操作是等价的，因此可以合并起来

Code

class Solution {
    public int minDistance(String word1, String word2) {
        // 1. 确定dp数组
        // 以word1[i - 1]为结尾的word1，和以word2[j - 1]为结尾的word2,变成相同最少需要进行的操作次数为dp[i][j]
        int[][] dp = new int[word1.length() + 1][word2.length() + 1];
        // 2. 递推公式
        // if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
            // 删和增是等价的，其中一个增相当于另外一个删
            // word1删除一个元素，那么就是以下标i - 2为结尾的word1 与 j-1为结尾的word2的最近编辑距离 再加上一个操作。
            // dp[i - 1][j] + 1
            // word2删除一个元素，那么就是以下标i - 1为结尾的word1 与 j-2为结尾的word2的最近编辑距离 再加上一个操作。
            // dp[i][j - 1] + 1
            // 替换
            // dp[i - 1][j - 1] + 1
            // -->> dp[i][j] = Math.min(dp[i - 1][j - 1] + 1, Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
        // } else {
            // 相等就不用操作
            // dp[i][j] = dp[i - 1][j - 1];
        // }
        // 3. 初始化数组
        for (int i = 0; i <= word1.length(); i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= word2.length(); j++) {
            dp[0][j] = j;
        }
        // 4. 遍历顺序
        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)) {
                    dp[i][j] = Math.min(dp[i - 1][j - 1] + 1, Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                } else {
                    dp[i][j] = dp[i - 1][j - 1];
                }
            }
            // 5. 打印数组
            // for (int[] row : dp) {
            //     for (int item : row) {
            //         System.out.print(item + " ");
            //     }
            //     System.out.println();
            // }
            // System.out.println();
        }
        return dp[word1.length()][word2.length()];
    }
}