题目描述（困难难度）

72. Edit Distance - 图1

由一个字符串变为另一个字符串的最少操作次数，可以删除一个字符，替换一个字符，插入一个字符，也叫做最小编辑距离。

解法一 递归

我们可以发现删除一个字符和插入一个字符是等效的，对于变换次数并没有影响。例如 “a” 和 “ab” ，既可以 “a” 加上一个字符 “b” 变成 “ab”，也可以是 “ab” 去掉一个字符 “b” 变成 “a”。所以下边的算法可以只考虑删除和替换。

首先，以递归的思想去考虑问题，思考如何将大问题化解为小问题。例如 horse 变为 ros，其实我们有三种可选方案。

72. Edit Distance - 图2

第一种，先把 horse 变为 ro ，求出它的最短编辑距离，假如是 x，然后 hosre 变成 ros 的编辑距离就可以是 x + 1。因为 horse 已经变成了 ro，然后我们可以把 ros 的 s 去掉，两个字符串就一样了，也就是再进行一次删除操作，所以加 1。

第二种，先把 hors 变为 ros，求出它的最短编辑距离，假如是 y，然后 hosre 变成 ros 的编辑距离就可以是 y + 1。因为 hors 变成了 ros，然后我们可以把 horse 的 e 去掉，两个字符串就一样了，也就是再进行一次删除操作，所以加 1。

第三种，先把 hors 变为 ro，求出它的最短编辑距离，假如是 z，然后我们再把 e 换成 s，两个字符串就一样了，hosre 变成 ros 的编辑距离就可以是 z + 1。当然，如果是其它的例子，最后一个字符是一样的，比如是 hosrs 和 ros ，此时我们直接取 z 作为编辑距离就可以了。

最后，我们从上边所有可选的编辑距离中，选一个最小的就可以了。

上边的第一种情况，假设了 horse 变为 ro 的最短编辑距离是 x，但其实我们并不知道 x 是多少，这个怎么求呢？类似的思路，也分为三种情况，然后选最小的就可以了！当然，上边的第二种，第三种情况也是类似的。然后一直递归下去。

最后，字符串长度不断地减少，直到出现了空串，这也是我们的递归出口了，如果是一个空串，一个不是空串，假如它的长度是 l，那么这两个字符串的最小编辑距离就是 l。如果是两个空串，那么最小编辑距离当然就是 0 了。

上边的分析，很容易就写出递归的写法了。

  1. public int minDistance(String word1, String word2) {
  2.     if (word1.length() == 0 && word2.length() == 0) {
  3.         return 0;
  4.     }
  5.     if (word1.length() == 0) {
  6.         return word2.length();
  7.     }
  8.     if (word2.length() == 0) {
  9.         return word1.length();
  10.     }
  11.     int x = minDistance(word1, word2.substring(0, word2.length() - 1)) + 1;
  12.     int y = minDistance(word1.substring(0, word1.length() - 1), word2) + 1;
  13.     int z = minDistance(word1.substring(0, word1.length() - 1), word2.substring(0, word2.length() - 1));
  14.     if(word1.charAt(word1.length()-1)!=word2.charAt(word2.length()-1)){
  15.         z++;
  16.     }
  17.     return Math.min(Math.min(x, y), z);
  18. }

解法二 动态规划

上边的算法缺点很明显，先进行了压栈，浪费了很多时间，其次很多字符串的最小编辑距离都进行了重复计算。对于这种，很容易想到动态规划的思想去优化。

假设两个字符串是 word1 和 word2。

ans[i][j] 来表示字符串 word1[ 0, i ) （word1 的第 0 到 第 i - 1个字符）和 word2[ 0, j - 1) 的最小编辑距离。然后状态转移方程就出来了。

if ( word1[m] == word2[n] )

​ ans[m][n] = Math.min ( ans[m][n-1] + 1, ans[m-1][n] + 1, ans[m-1][n-1]）

if ( word1[m] != word2[n] )

​ ans[m][n] = Math.min ( ans[m][n-1] + 1, ans[m-1][n] + 1, ans[m-1][n-1] + 1）

然后两层 for 循环，直接一层一层的更新数组就够了。

  1. public int minDistance(String word1, String word2) {
  2.     if (word1.length() == 0 && word2.length() == 0) {
  3.         return 0;
  4.     }
  5.     if (word1.length() == 0) {
  6.         return word2.length();
  7.     }
  8.     if (word2.length() == 0) {
  9.         return word1.length();
  10.     }
  11.     int[][] ans = new int[word1.length() + 1][word2.length() + 1];
  13.     //把有空串的情况更新了
  14.     for (int i = 0; i <= word1.length(); i++) {
  15.         ans[i][0] = i;
  16.     }
  17.     for (int i = 0; i <= word2.length(); i++) {
  18.         ans[0][i] = i;
  19.     }
  20.     int n1 = word1.length();
  21.     int n2 = word2.length();
  22.     //从 1 开始遍历，从 0 开始的话，按照下边的算法取了 i - 1 会越界
  23.     for (int i = 1; i <= n1; i++) {
  24.         for (int j = 1; j <= n2; j++) {
  25.             int min_delete = Math.min(ans[i - 1][j], ans[i][j - 1]) + 1;
  26.             int replace = ans[i - 1][j - 1];
  27.             if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
  28.                 replace++;
  29.             }
  30.             ans[i][j] = Math.min(min_delete, replace);
  31.         }
  32.     }
  33.     return ans[n1][n2];
  34. }

时间复杂度：O（mn）。

空间复杂度：O（mn）。

如果你是顺序刷题的话，做到这里，一定会想到空间复杂度的优化，例如5题，10题，53题等等。主要想法是，看上边的算法，我们再求 ans[i][*] 的时候，我们只用到 ans[i - 1][*] 的情况，所以我们完全只用两个数组就够了。

  1. public int minDistance(String word1, String word2) {
  2.     if (word1.length() == 0 && word2.length() == 0) {
  3.         return 0;
  4.     }
  5.     if (word1.length() == 0) {
  6.         return word2.length();
  7.     }
  8.     if (word2.length() == 0) {
  9.         return word1.length();
  10.     }
  11.     int[][] ans = new int[2][word2.length() + 1];
  13.     for (int i = 0; i <= word2.length(); i++) {
  14.         ans[0][i] = i;
  15.     }
  16.     int n1 = word1.length();
  17.     int n2 = word2.length();
  18.     for (int i = 1; i <= n1; i++) {
  19.         //由于只用了两个数组，所以不能向以前一样一次性初始化空串，在这里提前更新 j = 0 的情况
  20.         ans[i % 2][0] = ans[(i - 1) % 2][0] + 1;
  21.         for (int j = 1; j <= n2; j++) {
  22.             int min_delete = Math.min(ans[(i - 1) % 2][j], ans[i % 2][j - 1]) + 1;
  23.             int replace = ans[(i - 1) % 2][j - 1];
  24.             if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
  25.                 replace++;
  26.             }
  27.             ans[i % 2][j] = Math.min(min_delete, replace);
  28.         }
  29.     }
  30.     return ans[n1 % 2][n2];
  31. }

时间复杂度：O（mn）。

空间复杂度：O（n）。

再直接点，其实连两个数组我们都不需要，只需要一个数组。改写这个可能有些不好理解，可以结合一下图示。

72. Edit Distance - 图3

在更新二维数组的时候，我们都是一列一列的更新。在更新 ? 位置的时候，我们需要橙色位置的信息，也就是当前列的上一个位置，和上一列的当前位置，和上一列的上一个位置。如果我们用一个数组，当前列的上一个位置已经把上一列的上一个位置的数据覆盖掉了，所以我们要用一个变量提前保存上一列的上一个位置以便使用。

  1. public int minDistance(String word1, String word2) {
  2.     if (word1.length() == 0 && word2.length() == 0) {
  3.         return 0;
  4.     }
  5.     if (word1.length() == 0) {
  6.         return word2.length();
  7.     }
  8.     if (word2.length() == 0) {
  9.         return word1.length();
  10.     }
  11.     int[] ans = new int[word2.length() + 1];
  13.     for (int i = 0; i <= word2.length(); i++) {
  14.         ans[i] = i;
  15.     }
  16.     int n1 = word1.length();
  17.     int n2 = word2.length();
  18.     for (int i = 1; i <= n1; i++) {
  19.         int temp = ans[0];
  20.         ans[0] = ans[0] + 1;
  21.         for (int j = 1; j <= n2; j++) {
  22.             int min_delete = Math.min(ans[j], ans[j - 1]) + 1;
  23.             //上一列的上一个位置，直接用 temp
  24.             int replace = temp;
  25.             if (word1.charAt(i - 1) != word2.charAt(j - 1)) {
  26.                 replace++;
  27.             }
  28.             //保存当前列的信息
  29.             temp = ans[j];
  30.             //再进行更新
  31.             ans[j] = Math.min(min_delete, replace);
  32.         }
  33.     }
  34.     return ans[n2];
  35. }

时间复杂度：O（mn）。

空间复杂度：O（n）。

总

动态规划的一系列操作，先递归，利用动态规划省略压栈的过程，然后空间复杂度的优化，很经典了。此外，对于动态规划数组的含义的定义也是很重要，开始的时候自己将 ans[i][j] 表示为 字符串 word1[ 0, i ]（word1 的第 0 到 第 i 个字符）和 word2[ 0, j - 1] 的最小编辑距离。和上边解法的区别只是包含了末尾的字符。这造成了初始化 ans[0][*] 和 ans[*][0] 的时候，会比较复杂，看到了这里-space-DP>)的解法，才有一种柳暗花明的感觉，思路是一样的，但更新ans[0][*] 和 ans[*][0] 却简单了很多。

windliang wechat

添加好友一起进步~

如果觉得有帮助的话，可以点击 这里 给一个 star 哦 ^^

如果想系统的学习数据结构和算法，强烈推荐一个我之前学过的课程，可以点击 这里 查看详情