[leetcode] 72. Edit Distance

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character
b) Delete a character
c) Replace a character

今天的题目是计算字符串衍变所需要的最小步骤数，题目难度为Hard。

给定两个字符串wrod1和word2，假定长度分别为m和n，针对各自最后一个字符，有三种方式从word1衍变出word2：

• 先将word1[0~m-1]衍变为word2[0~n-2]，之后在word2后面插入word2[n-1]；
• 先将word1[0~m-2]衍变为word2[0~n-1]，之后在word1后面删除word1[m-1]；
• 先将word1[0~m-2]衍变为word2[0~n-2]，之后将word1[m-1]替换为word2[n-1]；

我们用ops[i][j]表示将word1[0~i-1]衍变为word2[0~j-1]所需的最小步骤数，则:

ops[i][j] = min(ops[i][j-1] + 1, ops[i-1][j] + 1, ops[i-1][j-1] + 1);

如果word1[i-1] == word2[j-1]，第三种情况替换的步骤可以省去，则

ops[i][j] = min(ops[i][j-1] + 1, ops[i-1][j] + 1, ops[i-1][j-1]);

同时有如下规律（稍后证明）：

ops[i-1][j-1] <= ops[i-1][j] + 1;

ops[i-1][j-1] <= ops[i][j-1] + 1;

即最后一个字符相同时，用word1[0~i-2]衍变为word2[0~j-2]，然后最后一个字符保持不变所需的步骤数最小，则

ops[i][j] = ops[i-1][j-1];

现在证明ops[i-1][j-1] <= ops[i-1][j] + 1，如果ops[i-1][j-1] > ops[i-1][j] + 1，可以先通过ops[i-1][j]步将word1[0~i-2]衍变为word2[0~j-1]，然后再删除word2[j-1]即可从word1[0~i-2]衍变为word2[0~j-2]，共用了ops[i-1][j]+1步，而ops[i-1][j-1]是从word1[0~i-2]衍变为word2[0~j-2]的最小步骤数，矛盾，证毕。另外一个的证明是类似的。

通过以上分析，即可得出如下推导规律：

word1[i-1] == word2[j-1]时：ops[i][j] = ops[i-1][j-1]；

word1[i-1] != word2[j-1]时：ops[i][j] = min(ops[i][j-1] + 1, ops[i-1][j] + 1, ops[i-1][j-1] + 1);

而从空字符串衍变为长度为k的字符串最小需要k步，从长度为k的字符串衍变为空字符串也最少需要k步，有了初始状态之后即可通过动态规划的方法求出最终结果，具体代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<vector<int>> ops(m+1, vector<int>(n+1, 0));
        
        for(int i=0; i<=m; ++i) ops[i][0] = i;
        for(int i=0; i<=n; ++i) ops[0][i] = i;
        for(int i=1; i<=m; ++i) {
            for(int j=1; j<=n; ++j) {
                if(word1[i-1] == word2[j-1])
                    ops[i][j] = ops[i-1][j-1];
                else
                    ops[i][j] = min(ops[i-1][j], min(ops[i][j-1], ops[i-1][j-1])) + 1;
            }
        }
        
        return ops[m][n];
    }
};

看了下别人的代码，还可以在空间上进行优化，上面代码的空间复杂度为O(mn)，在m*n的矩阵推导过程中，每个位置的数据只跟它左边、上面和左上位置的三个数据相关，所以可以缓存下左上位置的数据，然后每行就只需要一个数据来进行计算了，这样可以把空间复杂度降为O(m)。视m和n的大小关系，最终空间复杂度可以降为O(min(m,n))。具体代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<int> ops(m+1, 0);
        
        for(int i=1; i<=m; ++i) ops[i] = i;
        for(int j=1; j<=n; ++j) {
            int pre = ops[0];
            ops[0] = j;
            for(int i=1; i<=m; ++i) {
                int tmp = ops[i];
                if(word1[i-1] == word2[j-1]) 
                    ops[i] = pre;
                else
                    ops[i] = min(pre, min(ops[i], ops[i-1])) + 1;
                pre = tmp;
            }
        }
        
        return ops[m];
    }
};