LeetCode-Edit Distance

算法分析与设计，第13周博客

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

给定两个字符串，s和t，要让s转变成t，对于每个字符，都有三种操作，插入、删除和替换，要求从s转换到t的最小的步骤。

用动态规划来求解的话，这道题并不难，关键还是如何表示和递推方程的构造。

不妨用dp(i, j)来表示从s[0:i]转换到t[0:j]所需的最小步骤，也就是一个缩小版的原问题。那么，现在的问题就在如何构造递推方程上了。

对于一个动态规划问题，和当前问题有关联的便是与之相邻的问题。然后，还需知道这个问题的开始点在那个地方，也就是，在什么情况下可以直接得出结论而不需要进一步的递归，开始点一般是最特殊或者最简单的情况。

那么，对于这一题，我们最后需要返回的是dp(n,m)，再根据dp的定义，那么这个问题一定是从dp(0,0)开始的，也就是说，需要从小到大填写这个动态表，那么每一个元素都会与它左上边的元素有关，这将最多涉及到三个元素，而其中一共有四种情况：

1. dp(0, 0)。这一个单独的元素，在它的左上边没有元素，所以需要单独讨论。在这种情况下，就只有两个字符之间的比较。dp(0,0) = s[0] == t[0] ? 0 : 1；这个是很明显的，如果两个相同，就不需要操作，否则需要替换操作。
2. dp(i, 0)，i > 0。这是第一列的情况。这里的每个元素的左上边都只有一个元素与之相邻，那便是dp(i-1, 0)。所以这两者必有关系。dp(i, 0) 比dp(i-1, 0)多了s[i]这个字符。那么可以把这个字符去掉，也就是dp(i, 0) = dp(i-1, 0)+1。也或者需要比较s[i]与t[0]的关系，这时dp(i, 0) = i+(s[i] == t[0] ? 0 : 1)。而只需要取两者之间的较小的那一个就可以确定dp(i, 0)的值了。两个操作的意思分别是：采用s[0:i-1]到t[0]的映射方式并且把s[i]直接删除；把s[0：i-1]全部删去，并比较s[i] 与t[0]的关系以决定两者的转变是否需要额外的操作。
3. dp(0, j), j > 0。这是第一列的情况。和第一行的情况是比较相似的。同样的道理：dp(0, j) = min{ dp(0, j-1)+1, j+(s[0] == t[j] ? 0 :1);
4. dp(i, j), i > 0 && j > 0。也就是除了上述三种情况的其他情况。这时，有三个元素与之相连，分别是dp(i-1, j-1) 、dp(i, j) 和dp(i, j-1)。而dp(i, j) = min{ dp(i-1, j-1)+(s[i] == t[j] ? 0 :1), dp(i-1,j )+1, dp(i, j-1)+1}。对应的情况分别是：采用s[0:i-1]到t[0:j-1]的转变，并根据s[i]和t[j]的关系进行修正；采用s[0:i-1]到t[0:j]的转变，并将s[i]删除；采用s[0:i]到t[0:j-1]的转变，并将t[j]插入。

这样，所有的情况都已经讨论完毕了，所实现的代码如下：

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

最后来看下这个算法的时间复杂度，有一个n*m的表格需要填写，所以时间复杂度和空间复杂度都是O(n*m)。