两个单词之间的编辑距离

参考博客: https://github.com/youngwind/blog/issues/106

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符
示例 1:

输入: word1 = “horse”, word2 = “ros”
输出: 3
解释:
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/edit-distance
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

对于给定的两个单词，如何使得word1经过最少的步骤转换成为word2呢，自己学习了网上的一些解法，对于递归和动态规划，两种方法的实现方式不同，但是基本思想是相同的，基本思想如下：
对于两个单词，如果要将一个单词变换成为另一个单词，那么我们需要考虑对于单词的每一个字母，使其与另一个单词的每一个字母相同，即进行相应的编辑使得这两个字母相同，然后依次对需要编辑的其他字母进行编辑

• 以 d [ i ] [ j ] 表示 长度为 word1 中长度为i的子串到 word2 中长度为 j 的 子串需要的最小最小的编辑距离
• 当 i 和 j 分别等于对应字符串的长度时，即d[word1.lenggth()][word2.length()]即为我们所求
• 对于长度为 i 和长度为 j 的子串，如果两个子串的最后一个字符相等， 即 word1.charAt(i-1)==word2.charAt(j-1)
  那么两个子串的编辑距离 d [ i ][ j ]=d[ i-1 ][ j - 1 ]，即等于长度为i-1和长度为j-1的子串的编辑距离， 这个比较好理解,因为相同不用编辑了呀，
• 当两个子串的最后一个字符不相等的时候，即 word1.charAt(i-1) ！= word2.charAt(j-1)，这个时候我们就需要进行相应的编辑了，
• 编辑 方法一 ： d[ i ] [ j ] = d [ i ] [ j - 1] + 1
• ： 对于字符串abc 和 acd 两个字符串最后一个字符不相等，
• ：可以通过 添加字母的方式， 我们假设添加 d ，则 abc 变为abcd ，
• ： 从abcd 到 acd 的编剧距离即等于 abc 到 ac 的编辑距离，因为d相等，即 d[ i ] [ j ] = d [ i ] [ j - 1] + 1
• ： 其实在这里增加字符和删除 acd 中的 字符 d 的效果时相同的。
• 编辑 方法二：d [ i ] [ j ] = d [ i - 1] [ j ] + 1
• ： 通过添加字母 c 的方式，则 acd 变为 acdc
• ：从abc 到acd 的编辑距离变为 从 ab 到 acd 的编辑距离，因为c 相等，即 d [ i ] [ j ] = d [ i - 1] [ j ] + 1
• ： 在这里添加字母c 的方式和删除 abc 中字母 c 的效果相同
• 编辑 方法三 ：d[ i ] [ j ] =d[ i - 1] [ j - 1 ] + 1
• ： 通过替换字母的方式 我们可以将 abc 最后字母替换为d 即 abd 到 acd （也可以 abc 到 acc 替换为 c）
• ： 相应的编辑距离变为 d[ i ] [ j [] = d [ i -1 ] [ j - 1] +1
  对于上面的三种变换方式，我们取三个中的最小值取获得相应的最小的编辑距离

在编码求解的过程中

• 对于动态规划的方法我们需要给出相应的初始值，
• 对于递归的方法我们需要给出边界值

class 编辑距离 {

 //递归解法  
     public static int minDistanceWay1(String word1, String word2) {
     // 减少重复运算，不然会超时
        int[][] dis = new int[word1.length() + 1][word2.length() + 1];
        for (int i = 0; i <= word1.length(); i++) {
            Arrays.fill(dis[i], -1);
        }
        return recursion(word1, word2, word1.length(), word2.length(), dis);
    }

    private static int recursion(String word1, String word2, int length1, int length2, int[][] dis) {
        if (dis[length1][length2] > -1) {
            return dis[length1][length2];
        }
        if (length1 == 0) {
            return length2;
        } else if (length2 == 0) {
            return length1;
        } else if (word1.charAt(length1 - 1) == word2.charAt(length2 - 1)) {
            // 两个字符相等的话我们就直接比较前一个字符
            int distance = recursion(word1, word2, length1 - 1, length2 - 1, dis);
            dis[length1][length2] = distance;
            return distance;
        } else {
            // 删除字符和添加字符我们达到的效果是一样的
            // 当两个字符串不相等的时候我们就删除word1的最后一个字符，计算(m-1,n)这两个字符串之间的最短编辑距离
            int deleteWord1 = recursion(word1, word2, length1 - 1, length2, dis);
            // 删除word2的最后一个字符
            int deleteWord2 = recursion(word1, word2, length1, length2 - 1, dis) + 1;
            // 替换一个word1或者word2中的任意一个字符
            int replaceWord = recursion(word1, word2, length1 - 1, length2 - 1, dis);
            int distance = Math.min(Math.min(deleteWord1, deleteWord2), replaceWord) + 1;
            dis[length1][length2] = distance + 1;
            return distance;
        }
    }

//  动态规划解法
    public static int minDistanceWay2(String word1, String word2) {
        int lenWord1 = word1.length();
        int lenword2 = word2.length();
        // minDis[i][j]表示长度为i和长度为j的单词之间的最小编辑距离
        int[][] minDis = new int[lenWord1 + 1][lenword2 + 1];
        for (int i = 1; i <= lenWord1; i++) {
            minDis[i][0] = i;
        }

        for (int j = 1; j <= lenword2; j++) {
            minDis[0][j] = j;
        }

        for (int i = 1; i <= lenWord1; i++) {
            for (int j = 1; j <= lenword2; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    minDis[i][j] = minDis[i - 1][j - 1];
                } else {
                    int deleteWord1 = minDis[i - 1][j] + 1;
                    int deleteWord2 = minDis[i][j - 1] + 1;
                    int replaceWord = minDis[i - 1][j - 1] + 1;
                    minDis[i][j] = Math.min(Math.min(deleteWord1, deleteWord2), replaceWord);
                }
            }
        }
        return minDis[word1.length()][word2.length()];
    }

    public static void main(String[] args) {
        System.out.println(minDistanceWay2("b", ""));
        System.out.println(minDistanceWay2("dinitrophenylhydrazine", "benzalphenylhydrazone"));
    }
}```