动态规划——编辑距离系列问题

1 概述

编辑距离原题——72. 编辑距离，是LeetCode上的一道 hard 级别的题目，该题允许对两个字符串进行增删改（没有查）的操作，而一些类似的题目可能操作起来没有这道题这么复杂，但是也可利用同样的思路去做，因此我们把这些题型提取出来，当作一个知识点来做巩固。下面将按照由易到难的顺序来依次解决这些题目，当然有一些题目也可以用贪心等思想去做，但是由于本文着重讲解动态规划算法，所以涉及到其它的算法暂不作讨论。

---

2 实战

2.1 判断子序列

LeetCode链接：392. 判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1：
输入：s = “abc”, t = “ahbgdc”
输出：true

示例 2：
输入：s = “axc”, t = “ahbgdc”
输出：false

提示：
0 <= s.length <= 100
0 <= t.length <= 10^4
两个字符串都只由小写字符组成。

• 思路：s 和 t 都从空串开始一点点扩，在这个过程中不断判断 s 的 子串是否为 t 子串的子序列，最终得到完整的 s 是否为完整的 t 的子序列。特别地，当 s 为 t 的子串的子序列时，s 一定也为 t 的子序列。

1. dp 数组和下标的定义

• 本题涉及到两个字符串，所以我们下意识定义一个二维 dp 数组，一维代表 s 字符串，另一维代表 t 字符串。dp[i][j] 表示以第 i - 1 位结束的 s 串是否为以 j - 1 位结束的 t 串的子序列。至于为啥定义为 i - 1 和 j - 1，纯粹是为了编码（初始化）方便，如果不是很明白，可以自行定义为以第 i 位和第 j 位结尾。

// dp[i][j] 以i-1结尾的s是否是以j-1结尾的t的子序列
boolean[][] dp = new boolean[lens + 1][lent + 1];

2. 递推公式

• 涉及到两个字符串（数组）的问题，大方向是分为两种情况来讨论 —— 当前位置的值相等、当前位置的值不相等：

• if (s[i - 1] == t[j - 1])：
  

当前位置的值相等时，我们可以同时去掉两字符串中该相等字符，判断以第 i - 2 位结束的 s 串是否为以 j - 2 位结束的 t 串的子序列，即考虑 dp[i - 1][j -1] 的值。如果以第 i - 2 位结束的 s 串是以 j - 2 位结束的 t 串的子序列，那么两个字符串都加上相等的这一位，就能确定以第 i - 1 位结束的 s 串是否为以 j - 1 位结束的 t 串的子序列；

除此之外，我们也可以仅去掉 t 串中的相同位，判断以第 i - 1 位结束的 s 串是否为以 j - 2 位结束的 t 串的子序列，即考虑 dp[i][j - 1]。如果以第 i - 1 位结束的 s 串为以 j - 2 位结束的 t 串的子序列，那么当 t 串加上去掉的那一位，该结论依旧成立。

所以当 s[i - 1] == t[j - 1] 时，dp[i][j] = dp[i - 1][j -1] || dp[i][j - 1]。

• if (s[i - 1] != t[j - 1])：
  

当 s 串的第 i-1 位不等于 t 串的第 j - 1 位时，我们将t 串的第 j - 1 位“删除”，判断以第 i - 1 位结束的 s 串是否为以 j - 2 位结束的 t 串的子序列，即 dp[i][j] = dp[i][j - 1]

• 综上所述：
  

3. 初始化

• 从递推公式可以看出 dp[i][j] 都是依赖于 dp[i - 1][j - 1] 和 dp[i][j - 1]，所以需要对 dp[0][0] 、 dp[i][0] 和 dp[0][j]是一定要初始化的。而且我们初始化一定要严格按照 dp 数组的定义来：dp[i][j] 表示以第 i - 1 位结束的 s 串是否为以 j - 1 位结束的 t 串的子序列。
• 当 j 为 0 时，以 j - 1 位结束的 t 串为空串，而「任何以第 i - 1 位结束的非空 s 串」不可能是「以 j - 1 位结束的 t 串为空串」的子序列，即 dp[i][0] = false (i != 0)，而 dp[0][0] = true；
• 当 i 为 0 时，以 i - 1 位结束的 s 串为空串，该空串是「任何以第 j - 1 位结尾的 t 串」的子序列，即 `dp[0][j] = true。

// 初始化 dp[0][j] = true, dp[i][0] = false
// 由于boolean数组默认就是false，所以d[i][0]不用单独初始化
for (int j = 0; j <= lent; j++) {
    dp[0][j] = true;
}

4. 确认遍历顺序

• 从递推公式可以看出 dp[i][j] 都是依赖于 dp[i - 1][j - 1] 和 dp[i][j - 1]，那么遍历顺序也应该是从上到下，从左到右

5. 举例推导 dp 数组
   

• 完整代码如下：

public boolean isSubsequence(String s, String t) {
    // 特判
    if (s == null || s.length() == 0) return true;
    if (t == null || t.length() == 0) return false;
    
    int lens = s.length();
    int lent = t.length();
    char[] chars = s.toCharArray();
    char[] chart = t.toCharArray();
    // dp[i][j] 以i-1结尾的s是否是以j-1结尾的t的子序列
    boolean[][] dp = new boolean[lens + 1][lent + 1];
    
    
    // 初始化 dp[0][j] = true, dp[i][0] = false
    for (int j = 0; j <= lent; j++) {
        dp[0][j] = true;
    }
    
    for (int i = 1; i <= lens; i++) {
        for (int j = 1; j <= lent; j++) {
            // 递推公式两种情况都有 dp[i][j] = dp[i][j - 1]，将其提取出来
            dp[i][j] = dp[i][j - 1];
            if (chars[i - 1] == chart[j - 1]) {
                dp[i][j] |= dp[i - 1][j - 1];
            }
        }
    }
    
    return dp[lens][lent];
}

• 其它做法：
  1. 双指针
  2. 求 s 和 t 的最长公共子序列，最后判断该最长公共子序列的长度是否与 s 相等

---

2.2 不同的子序列

LeetCode链接：115. 不同的子序列

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的一个子序列，而 “AEC” 不是）

题目数据保证答案符合 32 位带符号整数范围。

示例 1：
输入：s = “rabbbit”, t = “rabbit”
输出：3
解释：
如下图所示, 有 3 种可以从 s 中得到 “rabbit” 的方案。

示例 2：
输入：s = “babgbag”, t = “bag”
输出：5
解释：
如下图所示, 有 5 种可以从 s 中得到 “bag” 的方案。

提示：
0 <= s.length, t.length <= 1000
s 和 t 由英文字母组成

• 思路：本题与392. 判断子序列 比较类似，只不过上一题求“是不是”，而本题求“有多少”。同样的思路，s 和 t 都从空开始，一点点扩展为完整的 s 和 t，在这个扩展的过程中，不断计算并记录“ s 的子序列中 t 出现的个数 ”，最终当 s 和 t 完整时的结果即为所求。按照动归五部曲如下：

1. dp 数组和下标的定义

• dp[i][j] 表示以 i - 1 位结尾的 s 的子序列中出现以 j - 1 位结尾的 t 的子串的次数

// dp[i][j] 以i - 1结尾的s串的子序列中与以j - 1结尾t串相等的个数
int[][] dp = new int[lens + 1][lent + 1];

2. 递推公式

• if (s[i - 1] == t[j - 1])：
  • 考虑 s 的 i - 1 位：dp[i][j] = dp[i - 1][j - 1]
  • 不考虑 s 的 i - 1 位：dp[i][j] = dp[i - 1][j]
• if (s[i - 1] != t[j - 1])：
  • 考虑 s 的 i - 1 位：dp[i][j] = 0
  • 不考虑 s 的 i - 1 位：dp[i][j] = dp[i - 1][j]
• 综上：
  

3. 初始化

• 从递推公式中可以看出需要初始化 dp[i][0]、dp[0][j] 和 dp[0][0]，并且我们在初始化的时候，一定要“死扣” dp 数组的定义，根据定义来进行初始化！dp[i][j] 表示 s[0: i -1] 的子序列中出现 t[0: j - 1] 的次数。
• 当 j 为0时，t[0: j - 1] 表示空，而 s 的任意子数组的子序列中必有一个空数组，所以 dp[i][0] = 1;
• 同理当i 为0时，s[0: i -1] 为空，空数组的子序列也位空，不可能包含 t 的子数组，所以 dp[0][j] = 0;
• 特殊地，dp[0][0] = 1

// 初始化 dp[i][0] = 1; dp[0][j] = 0
for (int i = 0; i <= lens; i++) {
    dp[i][0] = 1;
}

4. 确认遍历顺序

• 从递推公式 dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出 dp[i][j] 都是根据左上方和正上方推出来的。
• 所以遍历的时候一定是从上到下，从左到右，这样保证 dp[i][j] 可以根据之前计算出来的数值进行计算。

5. 举例推导 dp 数组
   

• 代码如下：

public int numDistinct(String s, String t) {
    if (s == null || s.length() == 0) return 0;
    if (t == null || t.length() == 0) return s.length();
    char[] chars = s.toCharArray();
    char[] chart = t.toCharArray();
    int lens = chars.length;
    int lent = chart.length;
    
    // dp[i][j] 以i - 1结尾的s串的子序列中与以j - 1结尾t串相等的个数
    // 递推公式：if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
    //          if (s[i - 1] != t[j - 1]) dp[i][j] = dp[i - 1][j]
    int[][] dp = new int[lens + 1][lent + 1];
    
    // 初始化 dp[i][0] = 1; dp[0][j] = 0
    for (int i = 0; i <= lens; i++) {
        dp[i][0] = 1;
    }
    
    for (int i = 1; i <= lens; i++) {
        for (int j = 1; j <= lent; j++) {
            if (chars[i - 1] == chart[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
            } else {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    
    return dp[lens][lent];
    
}

---

2.3 小结

392. 判断子序列 和 115. 不同的子序列 我们都可以按照上图的思路去做：

• 首先判断两个串中当前位置的元素是否相等，如果相等，再在求子序列的字符串中分为两种情况：考虑该位置的元素、不考虑该位置的元素；
• 如果当前位置不相等，一般在求子序列的字符串中就不考虑该位置的元素，因为即使考虑了，对结果也没有贡献。

---

2.4 两个字符串的删除操作

LeetCode链接：583. 两个字符串的删除操作

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

示例：
输入: “sea”, “eat”
输出: 2
解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"

提示：
给定单词的长度不超过500。
给定单词中的字符只含有小写字母。

• 思路：

1. dp 数组及下标定义

• dp[i][j] 表示以 i - 1 结尾的 word1 与以 j - 1 结尾的 word2 相等的最少删除次数

2. 递推公式

• word1[i - 1] == word2[j - 1]：dp[i][j] = dp[i - 1][j - 1]
• word1[i - 1] != word2[j - 1]：
  • 删 word1[i - 1]，最少操作次数为 dp[i - 1][j] + 1
  • 删 word2[j - 1]，最少操作次数为 dp[i][j - 1] + 1
  • 同时删 word1[i - 1] 和 word2[j - 1]，操作的最少次数为 dp[i - 1][j - 1] + 2
  • 取上述三种情况中的最小值，所以当 word1[i - 1] != word2[j - 1] 时，dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2)

3. 初始化

• 根据递推公式可知需要初始化 dp[i][0] 、dp[0][j] 和 dp[0][0]，而且我们初始化的时候一定要遵循 dp 数组的定义来：
• 当 i 为0时，word1[0 : i - 1] 表示空数组，如果想让 word2[0 : j - 1] 变成 word1[0 : i - 1] （空数组），则 word2[0 : j - 1] 应该删除 j 步，即 dp[0][j] = j；
• 同理，当 j 为0时，word2[0 : j - 1] 表示空数组，如果想让 word1[0 : i - 1] 变成word2[0 : j - 1]（空数组），则 word1[0 : i - 1] 应该删除 i 步，即 dp[i][0] = i；
• 特殊地，dp[0][0] = 0

4. 确定遍历顺序

• 从递推公式 dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 2) 和 dp[i][j] = dp[i - 1][j - 1] 可以看出 dp[i][j] 都是根据左上方、正上方、正左方推出来的。

• 所以遍历的时候一定是从上到下，从左到右，这样保证 dp[i][j] 可以根据之前计算出来的数值进行计算。

5. 举例推导 dp 数组

• 代码如下：

public int minDistance(String word1, String word2) {
    // 特判
    if (word1 == null || word1.length() == 0) return word2.length();
    if (word2 == null || word2.length() == 0) return word1.length();
    char[] char1 = word1.toCharArray();
    char[] char2 = word2.toCharArray();
    
    int len1 = char1.length;
    int len2 = char2.length;
    
    // dp[i][j] 使word1[0:i-1]与word2[0:j-1]相等的最少删除次数
    int[][] dp = new int[len1 + 1][len2 + 1];
    
    // 递推公式
    // if word1[i - 1] == word2[j - 1]: dp[i][j] = dp[i - 1][j - 1]
    // if word1[i - 1] != word2[j - 1]: dp[i][j] = min(dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1)
    
    // 初始化: dp[i][0] = i; dp[0][j] = j; dp[0][0] = 0
    for (int i = 0; i <= len1; i++) dp[i][0] = i;
    for (int j = 0; j <= len2; j++) dp[0][j] = j;
    
    for (int i = 1; i <= len1; i++) {
        for (int j = 1; j <= len2; j++) {
            if (char1[i - 1] == char2[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1];
            } else {
                dp[i][j] = Math.min(dp[i - 1][j - 1] + 2, Math.min(dp[i - 1][j], dp[i][j - 1]) + 1);
            }
        }
    }
    
    return dp[len1][len2];
}

---

2.5 编辑距离

LeetCode链接： 72. 编辑距离

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
你可以对一个单词进行如下三种操作：

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

示例 1：
输入：word1 = “horse”, word2 = “ros”
输出：3
解释：
horse -> rorse (将 ‘h’ 替换为 ‘r’)
rorse -> rose (删除 ‘r’)
rose -> ros (删除 ‘e’)

示例 2：
输入：word1 = “intention”, word2 = “execution”
输出：5
解释：
intention -> inention (删除 ‘t’)
inention -> enention (将 ‘i’ 替换为 ‘e’)
enention -> exention (将 ‘n’ 替换为 ‘x’)
exention -> exection (将 ‘n’ 替换为 ‘c’)
exection -> execution (插入 ‘u’)

提示：
0 <= word1.length, word2.length <= 500
word1 和 word2 由小写英文字母组成

• 思路

1. dp 数组及下标定义

• dp[i][j] 表示以 i - 1 位结尾的 word1 转换成以 j - 1 位结尾的 word2 所需要的最少操作步数

2. 递推公式

• word1[i - 1] == word2[j - 1]：dp[i][j] = dp[i - 1][j - 1]
• word1[i - 1] != word2[j - 1]：
  • 删除 word1 的第 i - 1 位：dp[i][j] = dp[i - 1][j] + 1，删除 word1 的第 i - 1 位之后我们需要比较的是以 i - 2 位结尾的 word1 与j - 1 位结尾的 word2 相等时所需要的最少操作步数（即 dp[i - 1][j]），最后再加上删除的一步的 1；
  • 替换 word1 的第 i - 1 位，dp[i][j] = dp[i - 1][j - 1] + 1，替换word1 的第 i - 1 位之后，word1 的第 i - 1 位与 word2 的第 j- 1 位就相等了，此时我们需要比较的是以 i - 2 位结尾的 word1 与j - 2 位结尾的 word2 相等时所需要的最少操作步数（即 dp[i - 1][j - 1]），最后再加上替换的这一步的 1；
  • word1 新增一位：dp[i][j] = dp[i][j - 1] + 1，word1添加一个元素，相当于word2删除一个元素
    
  • 删除 word2 的第 j - 1 位：dp[i][j] = dp[i][j - 1] + 1，删除 word2 的第 j - 1 位之后我们需要比较的是以 j - 2 位结尾的 word2 与i - 1 位结尾的 word1 相等时所需要的最少操作步数（即 dp[i][j - 1]），最后再加上删除的一步的 1；
  • 替换 word2 的第 j - 1 位，dp[i][j] = dp[i - 1][j - 1] + 1，替换word2 的第 j - 1 位之后，word1 的第 i - 1 位与 word2 的第 j- 1 位就相等了，此时我们需要比较的是以 i - 2 位结尾的 word1 与j - 2 位结尾的 word2 相等时所需要的最少操作步数（即 dp[i - 1][j - 1]），最后再加上替换的这一步的 1；
  • word2 新增一位：dp[i][j] = dp[i - 1][j] + 1，word2添加一个元素，相当于word1删除一个元素
    

3. 初始化
4. 确定遍历顺序
5. 举例推导 dp 数组

• 代码如下：

参考

• 代码随想录