Leetcode 72 Edit Distance （踩得坑及优化）

最新推荐文章于 2020-07-23 16:25:43 发布

ccutyear

最新推荐文章于 2020-07-23 16:25:43 发布

阅读量196

点赞数 1

分类专栏： LeetCode 文章标签：算法 leetcode 动态规划

本文链接：https://blog.csdn.net/ccutyear/article/details/84350959

版权

LeetCode 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

72. Edit Distance

Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2.You have the following 3 operations permitted on a word:

Insert a character
Delete a character
Replace a character

Example 1:

Input: word1 = "horse", word2 = "ros"
Output: 3
Explanation: 
horse -> rorse (replace 'h' with 'r')
rorse -> rose (remove 'r')
rose -> ros (remove 'e')

Example 2:

Input: word1 = "intention", word2 = "execution"
Output: 5
Explanation: 
intention -> inention (remove 't')
inention -> enention (replace 'i' with 'e')
enention -> exention (replace 'n' with 'x')
exention -> exection (replace 'n' with 'c')
exection -> execution (insert 'u')

题目大意：将word1变成word2需要几步，变化规则如下：

1. 在任意位置插入一个任意字符。

2. 删除任意位置的字符。

3.交换任意两个位置上的字符

解题思路：我记得这个动态规划题在某本书上碰到过，说是当年非常经典的一道笔试题。没想到会在这里碰到。

在两个单词中，若 word1 的第 i 个字符与 word2 的第j个字符相同，则将 word1 的前 i 个字符组成的子串变成 word2 的前 j 个字符组成的子串的结果与 word1 的前 i - 1 个字符组成的子串变成 word2 的前 j - 1 个字符组成的子串的结果相同。所以，我们便可以得到第一个动态转移方程式 : $dp\left [ i \right ]\left [ j \right ] = dp\left [ i - 1 \right ]\left [ j - 1 \right ]$ ，那么如果 word1 第 i 个字符与 word2 的第 j 个字符不同呢？我们将会进行三种操作：1. 将前 i 个字符组成的子串中删除一个字符。因为通过前 i - 1 个字符组成的子串便可变化为前 j 个字符组成的子串。动态转移方程式： $dp\left [ i \right ]\left [ j \right ] = dp\left [ i - 1\right ]\left [ j \right ] + 1$ 。2. 将前 i 个字符组成的子串中添加一个字符。因为通过前 i 个字符组成的子串可以变化为前 j - 1 个字符组成的子串。动态转移方程式： $dp\left [ i \right ]\left [ j \right ] = dp\left [ i \right ]\left [ j - 1 \right ] + 1$ 。3. 将前 i 个字符组成的子串中变化一个字符。因为通过前 i - 1个字符组成的子串可以变化为前 j - 1 个字符组成的子串。动态转移方程式： $dp\left [ i \right ]\left [ j \right ] = dp\left [ i - 1\right ]\left [ j - 1 \right ] + 1$ 。

综上所述：动态规划转移方程式：

$dp\left [ i \right ]\left [ j \right ] = \left\{\begin{matrix} dp\left [ i - 1 \right ]\left [ j - 1 \right ] \left ( word1\left [ i \right ]\left = word2 [ j \right ] \right )\\ min\left(dp\left [ i - 1 \right ]\left [ j - 1 \right ] ,dp\left [ i \right ]\left [ j - 1 \right ] , dp\left [ i - 1 \right ]\left [ j \right ] \right) \left ( word1\left [ i \right ]\left \neq word2 [ j \right ] \right ) \end{matrix}\right.$

基于这个思路我的代码（8ms）：

class Solution {
public:
    
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp;
        int len1 = word1.length();
        int len2 = word2.length();
        dp.push_back(vector<int>(len2 + 1,0));
        for(int i = 0; i <= len2; i++){
            dp[0][i] = i;
        }
        for(int i = 0; i <= len1; i++){
            dp.push_back(vector<int>(len2 + 1,0));
            dp[i][0] = i;
        }
        for(int i = 0; i < len1; i++){  //通过动态转移方程式进行计算
            for(int j = 0; j < len2; j++){
                if(word1[i] == word2[j]){
                    dp[i + 1][j + 1] = dp[i][j]; 
                }else{
                    dp[i + 1][j + 1] = min(dp[i + 1][j],min(dp[i][j + 1],dp[i][j])) + 1;
                }
            }
        }
        return dp[len1][len2];
    }
};

在进行push_back时必须多push_back一个不然的话会发生越界。返回错误是free(): invalid next size (fast): 0x00000000029e7e70 ***

参考了别人的代码后发现在通过动态转移方程式进行计算时永远都只对两行进行操作。所以，还可以进行优化。

优化后代码（4ms）:

class Solution {
public:
    int minDistance(string word1, string word2) {
        
        int len1 = word1.length();
        int len2 = word2.length();
        vector<vector<int>> dp(2,vector<int>(len2 + 1,0));
        for(int i = 0; i <= len2; i++){
            dp[1][i] = i;
        }
        for(int i = 0; i < len1; i++){
            dp[0].swap(dp[1]);
            dp[1][0] = i + 1;
            for(int j = 0; j < len2; j++){
                if(word1[i] == word2[j]){
                    dp[1][j + 1] = dp[0][j]; 
                }else{
                    dp[1][j + 1] = min(dp[1][j],min(dp[0][j + 1],dp[0][j])) + 1;
                }
            }
        }
        return dp[1][len2];
    }
};