编辑距离-leetcode-牛客

dp 20 计算字符串的编辑距离

题目描述

leetcode版本

给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

插入一个字符
删除一个字符
替换一个字符

牛客版本

Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家 Levenshtein 提出的，故又叫 Levenshtein Distance 。

例如：

字符串A: abcdefg

字符串B: abcdef

通过增加或是删掉字符 ”g” 的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。

要求：给定任意两个字符串，写出一个算法计算它们的编辑距离。

样例：
"eat"
"sea"
2
"algorithm"
"altruistic"
6
"horse"
"ros"
3
"intention"
"execution"
5

思路

首先是确定状态。确定什么样子的状态好呢？这种时候可以看看题目要的是什么？利用动态规划解题必然是需要得到的状态可以推导出结果。所以状态多跟要的相关。这题要的是两个字符串最短的编辑距离。那么我们就可以定义状态
$$dp(i,j):word1前i个元素转换得到word2前j个元素的编辑距离$$
在这里用前i个，而不是 到第i个只是为了编程方便。

那么接下来的状态转移方程呢？

考虑如下问题：

如果word1[0…i-1] 到 word2[0…j-1] 的变换需要 k 步，那么word1[0…i] 到 word[0…j]需要多少步？

答案是：

如果 word1[i] == word[j],

那么是k步。

为什么是k步？这种时候可以从 (i-1,j) 或者dp(i,j-1)的状态到达吗？

由于dp[i-1] [j-1] = k; 那么 对于dp(i-1,j) ，如果 i > j ,多补充了一个 元素 word2[j] ，可能刚好是word1中后面的元素，因此也就不再需要添加 一个元素 来让两个序列相等了。这样的话 dp(i-1,j) 的值就为k-1。如果新添加的这个元素 word2[j] 不是word1后续的元素，这样就需要 额外的删除和新增操作来让两个序列相等。这样dp(i-1,j) 的值就是k+1.

对于dp(i,j-1) 同理可得，dp(i,j-1) = k-1 或 k+1.

我们取最小值k-1做分析。

而从这两个状态到最后的dp(i,j)状态，又多了一个元素。而我们知道word[i] == word[j] ，如果我们前面用k-1步变了之前的序列，那么就需要拿出一步 添加或者删除 新增的那个元素，此时次数为k步。

如果之前都需要k+1步，那么从这两个状态到当前状态肯定不如从dp(i-1,j-1)更优。

因此，取三个状态 的最小值，为k步。

如果不相等，那么就需要把word[i] 变成 word[j], 那么就是k+1步；

如果word1[0…i] 到 word2[0…j-1] 的变换需要 k 步，那么word1[0…i] 到 word[0…j]需要多少步？

首先用k步，（这是最小的步数），把0到j-1变对，最后再用 删除 或者 添加 ，补全最后的 word1[i]。因此，需要k+1步。

如果word1[0…i-1] 到 word2[0…j] 的变换需要 k 步，那么word1[0…i] 到 word[0…j]需要多少步？

类似于上个问题，需要k+1步。

当前序列只可能从上述三个状态转移而来，我们只需要去看这三个状态哪个消耗最少，用它就行。

代码

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n = word1.size(), m = word2.size();
        vector<vector<int> > dp(n+1, vector<int>(m+1));
        for(int i = 0; i <= m; ++i) {//满足定义
            dp[0][i] = i;
        }
        for(int i = 0; i <= n; ++i) {
            dp[i][0] = i;
        }
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= m; ++j) {
                if(word1[i-1] == word2[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + 1;
                    dp[i][j] = min(dp[i][j], dp[i-1][j-1] + 1);
                }
            }
        }
        // for(int i = 0; i <= n; ++i) {
        //     for(int j = 0; j <= m; ++j) {
        //         cout << dp[i][j] << ' ';
        //     }
        //     cout << endl;
        // }
        return dp[n][m];
    }
};