|
| 1 | +今天我们看一道 leetcode hard 难度题目：[编辑距离](https://leetcode.cn/problems/edit-distance/description/)。 |
| 2 | + |
| 3 | +## 题目 |
| 4 | + |
| 5 | +给你两个单词 `word1` 和 `word2`， 请返回将 `word1` 转换成 `word2` 所使用的最少操作数。 |
| 6 | + |
| 7 | +你可以对一个单词进行如下三种操作： |
| 8 | + |
| 9 | +- 插入一个字符 |
| 10 | +- 删除一个字符 |
| 11 | +- 替换一个字符 |
| 12 | + |
| 13 | +示例1： |
| 14 | + |
| 15 | +``` |
| 16 | +输入：word1 = "horse", word2 = "ros" |
| 17 | +输出：3 |
| 18 | +解释： |
| 19 | +horse -> rorse (将 'h' 替换为 'r') |
| 20 | +rorse -> rose (删除 'r') |
| 21 | +rose -> ros (删除 'e') |
| 22 | +``` |
| 23 | + |
| 24 | +## 思考 |
| 25 | + |
| 26 | +看到题目的第一感觉是按照人的直觉做题，比如示例中 `horse` 与 `ros` 其中都有 `os`，那么最短编辑距离肯定要维持 `os` 相对位置不变。但该方法可能更适合大模型用直觉做题，而不是和用代码编写，背后有太多无法固化的逻辑。 |
| 27 | + |
| 28 | +看来只能用动态规划暴力解决，但如何定义变量呢？ |
| 29 | + |
| 30 | +如果我们仅用一个变量，只有两种定义方法： |
| 31 | + |
| 32 | +- `dp(i)` 返回 `word1` 下标为 `i` 时最短编辑距离。 |
| 33 | +- `dp(i)` 返回 `word2` 下标为 `i` 时最短编辑距离。 |
| 34 | + |
| 35 | +对第一种定义，我们的目标是计算出 `dp(word1.length-1)`，其中 `dp(-1)` 即 `word1` 从空字符串转换为 `word2` 需要的编剧距离显然是 `word2.length`，即把 `word2` 依次添加到 `word1`。但严重的问题是 `dp(i)` 与 `dp(i-1)` 的关系没有意义，因为从 `dp(-1)` 开始，就已经全部完成了 `word1` 到 `word2` 的转换，如果要计算 `dp(0)`，就只能删除 `word1` 的第 `i` 项，依此类推，这样无法模拟各种可能的操作。对第二中定义也类似。 |
| 36 | + |
| 37 | +这种想法的根本问题是，将 `word1` 到 `word2` 转换时，要么一次从空字符串转换为完整的 `word2`，要么从完整的 `word1` 转换为空字符串，这背后无法体现一个一个字符的考虑，所以必须用两个变量，分别定义 `i`、`j` 下标才行。 |
| 38 | + |
| 39 | +## 动态规划 |
| 40 | + |
| 41 | +有了上面的思考，动态规划的定义就清楚了： |
| 42 | + |
| 43 | +定义 `i` 为 `word1` 下标，`j` 为 `word2` 下标，`dp(i,j)` 返回 `word1` 下标为 `i`，且 `word2` 下标为 `j` 时最短编辑距离。 |
| 44 | + |
| 45 | +让我们再审视一下 `dp(i,j)` 的含义：除了返回最短编辑距离外，正因为我们知道了最短编辑距离，所以无论操作步骤、过程如何，**都可以假设我们只要做了若干步操作，下标分别截止到 `i`、`j` 的 `word1`、`word2` 内容就完全相同了**！这真是太优美了，一下就把复杂的问题简单化了，我们只要考虑当前步骤，也要清晰的知道之前步骤的状态代表什么含义。 |
| 46 | + |
| 47 | +接下来考虑状态转移，由于没有任何操作限制，我们必须把所有可能的转移都考虑进去，包括： |
| 48 | + |
| 49 | +- `i-1,j` |
| 50 | +- `i,j-1` |
| 51 | +- `i-1,j-1` |
| 52 | + |
| 53 | +也许会有新手问，为什么没有考虑 `i-2,j`、`i-3,j-1` 等等情况？这是因为函数是递归调用的，`i-2,j` 等价于 `i-1,j` + `i-1,j`，为了简化代码复杂度，只考虑一层转换的心智负担最低，又能通过递归实现所有操作可能性。 |
| 54 | + |
| 55 | +此时老手可能会问，那 `i-1,j-1` 不就等价于 `i-1,j` + `i,j-1` 吗？这么列出来不是重复了吗？说的很对，我们要意识到这一点，但同时还要进一步意识到每一步操作都有成本，本题还支持替换字符串操作，该操作可以一步实现 `i-1,j` + `i,j-1` 两步行为，考虑它可以减少操作步骤，肯定会影响到最终答案。 |
| 56 | + |
| 57 | +接着我们要思考状态转移方程是什么，仔细阅读下面的思考过程： |
| 58 | + |
| 59 | +对于 `i-1,j`，因为 `i-1,j` 经过 `dp(i-1,j)` 次数的操作后，`word1[0,i-1]` 与 `word2[0,j]` 已经完全相同了，我们的目的就是让两边字符串相同，所以 `word1[i]` 这个多出来的字符串需要毫不留情的删除，删除需要一步，因此 `dp(i,j) = dp(i-1,j) + 1`，该步是删除。 |
| 60 | + |
| 61 | +对于 `i,j-1`，因为 `i,j-1` 经过 `dp(i,j-1)` 次数的操作后，`word1[0,i]` 与 `word2[0,j-1]` 已经完全相同了，我们的目的就是让两边字符串相同，所以 `word2[j]` 这个字符是截止到 `word1[0,i]` 需要新增上去的，因此 `dp(i,j) = dp(i,j-1) + 1`，该步是新增。 |
| 62 | + |
| 63 | +对于 `i-1,j-1`，因为 `i-1,j-1` 经过 `dp(i-1,j-1)` 次数的操作后，`word1[0,i-1]` 与 `word2[0,j-1]` 已经完全相同了，我们的目的就是让两边字符串相同，所以对于 `word1[i]` 到 `word2[j]` 来说，如果它俩字符相同，则不需要操作，如果不相同，执行一次替换操作即可，因此在 `word1[i]` 与 `word2[j]` 不同是，`dp(i,j) = dp(i,j-1) + 1`，该步是替换。 |
| 64 | + |
| 65 | +对 `i-1,j-1` 的思考让我们意识到需要优先考虑 `word1[i]` 与 `word2[j]` 相同的情况，这种情况只要看前一个字符的结果就行，不需要产生额外的操作，因此转移方程是：`dp(i,j) = dp(i-1,j-1)`。 |
| 66 | + |
| 67 | +最后再考虑一下边界情况，当 `word1` 与 `word2` 任意为空时，只要执行非空字符串长度次数的增或删就行了。 |
| 68 | + |
| 69 | +```ts |
| 70 | +function minDistance(word1: string, word2: string): number { |
| 71 | + // 任意一个字符串为空时，执行非空字符串长度次数的增或删 |
| 72 | + if(word1 === '' || word2 === '') { |
| 73 | + return word1.length + word2.length |
| 74 | + } |
| 75 | + |
| 76 | + const dp = new Map() |
| 77 | + |
| 78 | + function getDp(i: number, j: number) { |
| 79 | + return dp.get(`${i},${j}`) |
| 80 | + } |
| 81 | + |
| 82 | + function calcDp(i: number, j: number) { |
| 83 | + // 兼容下边界情况 |
| 84 | + if (i === 0 && j === 0) { |
| 85 | + return word1[0] === word2[0] ? 0 : 1 |
| 86 | + } |
| 87 | + |
| 88 | + if (word1[i] === word2[j]) { |
| 89 | + return getDp(i-1, j-1) |
| 90 | + } |
| 91 | + |
| 92 | + return Math.min( |
| 93 | + // i-1, j: 删除第 i 项 |
| 94 | + getDp(i-1, j) + 1, |
| 95 | + // i, j-1: 增加第 i 项 |
| 96 | + getDp(i, j-1) + 1, |
| 97 | + // i-1, j-1: 替换第 i 项 |
| 98 | + getDp(i-1, j-1) + 1 |
| 99 | + ) |
| 100 | + } |
| 101 | + |
| 102 | + for (let i = 0; i < word1.length; i++) { |
| 103 | + dp.set(`${i},-1`, i + 1) |
| 104 | + } |
| 105 | + |
| 106 | + for (let j = 0; j < word2.length; j++) { |
| 107 | + dp.set(`-1,${j}`, j + 1) |
| 108 | + } |
| 109 | + |
| 110 | + for (let i = 0; i < word1.length; i++) { |
| 111 | + for (let j = 0; j < word2.length; j++) { |
| 112 | + dp.set(`${i},${j}`, calcDp(i, j)) |
| 113 | + } |
| 114 | + } |
| 115 | + |
| 116 | + return getDp(word1.length-1, word2.length-1) |
| 117 | +}; |
| 118 | +``` |
| 119 | + |
| 120 | +其中花了我一些时间的地方在于边界情况处理，比如当 `i=0` 时，`dp(i-1,j)` 就出现了 `i=-1` 的情况，因此对于 `i`、`j` 都要提前计算一下为 `-1` 时的值，而当下标为 `-1` 时，等价于该字符串为空，那么空字符串如何转换为 `word2`，或 `word1` 如何转换为空字符串呢？只要执行对方下标 + 1 次的增或删就行了。 |
| 121 | + |
| 122 | +## 总结 |
| 123 | + |
| 124 | +当意识到该题没有捷径时，就要考虑动态规划方案了，而动态规划第一难点在于定义参数，第二难点在于写状态转移方程，而只要定义对了参数，状态转移方程也就呼之欲出了，因此最难的一步就是定义参数，对这道题参数定义还有疑问的小伙伴可以回到 思考 章节重新阅读一下。 |
| 125 | + |
| 126 | +> 讨论地址是：[精读《算法 - 编辑距离》· Issue #501 · dt-fe/weekly](https://github.com/dt-fe/weekly/issues/501) |
| 127 | +
|
| 128 | +**如果你想参与讨论，请 [点击这里](https://github.com/dt-fe/weekly)，每周都有新的主题，周末或周一发布。前端精读 - 帮你筛选靠谱的内容。** |
| 129 | + |
| 130 | +> 版权声明：自由转载-非商用-非衍生-保持署名（[创意共享 3.0 许可证](https://creativecommons.org/licenses/by-nc-nd/3.0/deed.zh)） |
0 commit comments