Leetcode-编辑距离

原题链接：https://leetcode-cn.com/problems/edit-distance/description/

1、题目描述：

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：

1. 插入一个字符
2. 删除一个字符
3. 替换一个字符

示例 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’)

2、递归实现

理解编辑的含义：

• 如果word1[i] == word2[j]，那么比较word1[0…i-1]和word2[0…j-1]，即只需要看对应前面一个字符是否相同就可以了。
• 否则，有三个选项：
  1.插入操作：比较word1[0…i]和word[0…j-1]的结果
  2.删除操作：比较word[0…i-1]和word[0…j]的结果
  3.替换操作：比较word[0…i-1]和word[0…j-1]的结果
  至于选择哪一种，最简单的方法是全部试一遍，哪个操作最终得到的编辑距离小，就选谁。因此可以从上到下递归得到最终的最短距离，代码如下：

class Solution{
public:
	int minDist(string word1,string word2){
		int len1=word1.length();
		int len=word2.length();
		if(len1 == 0 || len2 == 0){
			return max(len1,len2)  //如果某一个字符串为空，另一个要执行len长度的删除操作
		}
		if(word1.back() == word2,back()){
			return minDist(word1.substr(0,len1-1-1),word2.substr(0,len2-1));
		}
		else{
			return 1+min(minDist(word1,word2.substr(0,len2-1),
						 minDist(word1.substr(0,len1-1),word2),
						 minDist(word1.substr(0,len1-1),word2.substr(0,len2-1)));
		}
	}
};

3、动态规划实现

使用递归求解会超时，是因为求解过程存在重叠子问题，
DP求解的一般步骤：

1. 确定原问题与子问题
2. 确定状态
3. 确定边界条件
4. 确定状态转移方程

对本题来说，原问题是求word1[0…i]到word2[0…j]的最小编辑距离，子问题是求word1[0…i-1]到word1[0…j]、word1[0…i]到word1[0…j-1]、word1[0…i-1]到word1[0…j-1]…等等的最先编辑距离。状态单一就是通过以上三种方式所走的最短步数。边界条件是当word1为空时，word2的前i个字符最短距离就是i本身，同理当word2为空时，word1的前i个字符最短距离就是i本身。所以本题是一个二维DP问题，状态转移方程
$$dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+1))$$
dp[i][j - 1] + 1表示插入操作，在word1[i]插入一个和word2[j]一样的字符，那么word2[j]就被匹配了，前移一位j-1继续和i对比，操作数+1；
dp[i-1][j]+1表示删除操作，直接把word1[i]这个字符删除，前移一位i-1继续和j比较，操作数+1；
dp[i-1][j-1]表示把word1[i]替换成word2[j]这样他两就匹配了，同时前移i,j一位继续对比，操作数+1。

代码如下：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1=word1.length();
        int len2=word2.length();

        vector<vector<int>> dp(len1+1,vector<int>(len2+1));  //创建二维dp数组
        //确定边界状态
        for(int i=0;i<len1+1;i++){  
            dp[i][0]=i;
        }
        for(int i=0;i<len2+1;i++){
            dp[0][i]=i;
        }
		//根据状态转移方程求解dp[len1][len2]
        for(int i=1;i<len1+1;i++){
            for(int j=1;j<len2+1;j++){
                if(word1[i-1] == word2[j-1]){
                    dp[i][j]=dp[i-1][j-1];
                }
                else{
                    dp[i][j]=min(min(dp[i-1][j]+1,dp[i][j-1]+1),dp[i-1][j-1]+1);
                }
            }
        }
        return dp[len1][len2];
    }

递归和DP求解的区别是：递归求解是自顶向下，有重叠求解；动态规划求解是自底向上，动态数组的建立避免了重复求解子问题。DP代码量一般不多，主要是思想和如何确定子问题和状态转移方程，如果之前没接触过二维dp，那么这个题做起来就无从下手，多联系！

4、参考Blog

详解编辑距离(Edit Distance)及其代码实现
LeetCode官方解题