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')

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

二、解题思路

方法一、使用递归+map剪枝，设定通过修改字符串一去匹配字符串二，有四种情况

对于字符串1的位置i，字符串2的位置j。

1、i插入一个字符，和字符串2匹配，此时操作+1，递归获取字符串一i，字符串二j后面匹配需要编辑的最小距离。

2、修改i字符，和字符串2匹配，此时操作+1，递归获取字符串一i+1字符串二j+1后面匹配需要编辑的最小距离。

3、删除i字符，和字符串2匹配，此时操作+1，递归获取字符串一i+1，字符串二j后面匹配需要编辑的最小距离。

4、当word1[i] == word2[j]的时候，两个字母匹配，可以不操作，递归获取字符串一i+1，字符串二j+1后面匹配需要编辑的最小距离。

然后取前面四种情况的最小值。

方法二、动态规划。

1、dp[n][m] n<=word1.size(),m<=word2.size();数组大小为（n+1）*（m+1）。因为考虑到空字符串的情况。每个空串和另外一个字符串下标i的编辑距离为i（相当于需要删除或者添加i个字符）。

2、初始条件，dp[0][i] = i,d[i][0]=i;

3、动态方程，动态方程和递归条件一样，dp[i][j[ = min(dp[i-1][j] + 1,dp[i][j-1] + 1,dp[i-1][j-1]+1)，当word1[i-1] == word2[j-1]的时候dp[i][j[ = min(dp[i-1][j] + 1,dp[i][j-1] + 1,dp[i-1][j-1])。这里要注意的是dp[i][j]记录的是word1，word2，下标i-1，和j-1的字符串的最小编辑距离（因为考虑了空串）。

三、代码（动态规划以及递归都有）

class Solution {
public:
    int minDistance(string word1, string word2) {
        //map<string,int> save;
        if(word1.size() == 0)
            return word2.size();
        if(word2.size() == 0)
            return word1.size();
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1,0));
        for(int i = 0; i<= word1.size(); i++)
        {
            dp[i][0] = i;
        }
        for(int i = 0; i<= word2.size(); i++)
        {
            dp[0][i] = i;
        }
        for(int i = 1; i <= word1.size(); i++)
        {
            for(int j = 1; j <=word2.size(); j++)
            {
                int min_num = min(dp[i][j-1],dp[i-1][j]);
                min_num = min(dp[i-1][j-1],min_num);
                min_num += 1;
                if(word1[i-1] == word2[j-1])
                {
                    min_num = min(dp[i-1][j-1], min_num);
                }
                dp[i][j] = min_num;
            }
        }
        //int min_num = minDistance(word1,word2,0,0,save);
        return dp[word1.size()][word2.size()];
    }
    string genkey(int index1,int index2)
    {
        char s[100];
        sprintf(s,"%d,%d",index1,index2);
        return string(s);
    }
    int minDistance(string &word1, string& word2,int index1,int index2,map<string,int> &save) {
        if(index1 == word1.size())
            return word2.size()-index2;
        if(index2 == word2.size())
            return word1.size()-index1;
        string key = genkey(index1,index2);
        if(save.count(key) > 0)
            return save[key];
        int add_r = minDistance(word1,word2,index1,index2+1,save);
        int replace =  minDistance(word1,word2,index1+1,index2+1,save);
        int reduce = minDistance(word1,word2,index1+1,index2,save);
        int min_num = min(add_r,replace);
        min_num = min(min_num,reduce);
        min_num += 1;
        if(word1[index1] == word2[index2])
        {
            int same = minDistance(word1,word2,index1+1,index2+1,save);
            min_num = min(min_num,same);
        }
        save[key] = min_num;
        return min_num;
    }
};