【动态规划】 LeetCode #72 编辑距离

题目链接：

LeetCode #72 编辑距离

题目描述：

72. 编辑距离
    给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。

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

插入一个字符
删除一个字符
替换一个字符

示例 1：

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

输入：word1 = “intention”, word2 = “execution”
输出：5
解释：
intention -> inention (删除 ‘t’)
inention -> enention (将 ‘i’ 替换为 ‘e’)
enention -> exention (将 ‘n’ 替换为 ‘x’)
exention -> exection (将 ‘n’ 替换为 ‘c’)
exection -> execution (插入 ‘u’)

解决方案：

二维动态规划，这个题的状态设置和之前不大一样，不像机器人走路之类的直观，设 dp[i][j] 为把长度为 i 的 word1 转换成长度为 j 的 word2 所使用的的最少操作数，则计算dp[i][j]有以下几种情况：

如果字符相等，dp[i][j] = dp[i-1][j-1]

如果字符不相等，需要选择一种操作：（具体理解后面讲）
插入一个字符：dp[i][j] = dp[i][j-1] + 1
删除一个字符：dp[i][j] = dp[i-1][j] + 1
替换一个字符：dp[i][j] = dp[i-1][j-1] + 1
dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1

初始化：
第一行：word1为空，想要得到word2只能插入字符
第一列：word2为空，想要得到空串只能在word1上删除字符

代码及理解：

/*
*二维动态规划：设 dp[i][j] 为把长度为 i 的 word1 转换成长度为 j 的 word2 所使用的的最少操作数
*如果字符相等，dp[i][j] = dp[i-1][j-1]
*如果字符不相等，有三种操作：
*插入一个字符：dp[i][j] = dp[i][j-1] + 1
*删除一个字符：dp[i][j] = dp[i-1][j] + 1
*替换一个字符：dp[i][j] = dp[i-1][j-1] + 1
*第一行：word1为空，想要得到word2只能插入字符
*第一列：word2为空，想要得到空串只能在word1上删除字符
*/
class Solution {
    public int minDistance(String word1, String word2) {
        if(word1 == null || word2 == null){//如果有任意一个串为0，只能通过多次增加/删除操作得到结果
            return Math.max(word1.length(), word2.length());
        }
        char[] w1 = word1.toCharArray();
        char[] w2 = word2.toCharArray();
        int[][] dp = new int[w1.length + 1][w2.length + 1];
        //对第一行、第一列进行初始化
        dp[0][0] = 0;
        for(int j = 1; j <= w2.length; j++){
            dp[0][j] = j;
        }
        for(int i = 1; i <= w1.length; i++){
            dp[i][0] = i;
        }
        for(int i = 1; i <= w1.length; i++){
            for(int j = 1; j <= w2.length; j++){
                if(w1[i - 1] == w2[j - 1]){//如果 word1 第 i 个字符和 word2 第 j 个字符相等（注意下标减1）
                    dp[i][j] = dp[i - 1][j - 1];
                }else{//如果字符不等，需要选择一种操作
                    dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j] ))+ 1;//三个数的最小值要用两次 Math.min()
                }
            }
        }
        return dp[w1.length][w2.length];
    }
}                                                                             

对于字符串的问题，八成都能用动态规划解决，并且遇到动态规划的题目，最好的方式就是画图，我们以word1 = “intention”, word2 = "execution"为例来进一步理解一下，当字符不相等时，状态转移方程式为什么是：
dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1

我们先输出一下dp[][]:

我们以 dp[5][4] 为例进行分析:

dp[5][4]的含义是，从 inten -> exec 最少需要几步操作。首先，字符 ‘n’ 和 ‘c’ 是不相等的（注意这里比较的是字符，而非字符串），我们可以采取以下操作来转换成 exec ：

①替换。即 ‘inte’ -> ‘exe’ + 1，而 ‘inte’ -> ‘exe’ 的最少操作数就是 dp[4][3]（注意此时字符串已经转换成了 ‘exe’），故选择替换操作，最少操作数为 dp[i][j] = dp[i-1][j-1] + 1 = 3 + 1 = 4；

②增加。即 ‘inten’ -> ‘exe’ + 1，而 ‘inten’ -> ‘exe’ 的最少操作数就是 dp[5][3]，故选择替换操作，最少操作数为 dp[i][j] = dp[i][j-1] + 1 = 4 + 1 = 5；

③删除。即当前的 ‘inten’ 删除了一个 ‘n’，再转换成 ‘exec’， 操作数即 ‘inte’ -> ‘exec’ + 1，而 ‘inte’ -> ‘exec’ 的最少操作数就是 dp[4][4]，故选择替换操作，最少操作数为 dp[i][j] = dp[i-1][j] + 1 = 3 + 1 = 4。

最终取三者中最小的，dp[5][4] = 4。需要注意的是，代码中三个数中的最小值需要用两次 Math.min()，即dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i][j - 1], dp[i - 1][j] ))+ 1;。

这种方法的时间复杂度为O(m*n)，空间复杂度为O(m*n)。其实空间复杂度还可以压缩到O(n)，如果把较小的串作为列数，最低可以将空间复杂度降低为O(min(m, n))，因为我们只用到了上方、左方、左上方的数据，其中上方和左方的数据是很容易获取的，只创建一维数组 dp[]，在计算 dp[j] 时，dp[j-1]已经是更新后的数据，即左方的数据，而此时的 dp[j] 还没有更新，保留的是上方的数据， 所以这个优化方法的难点就在于如何保存左上方的数据，后面会专门写一篇文章讲。