【动态规划】—— 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’)
解题思路
思路
1.分为两种情况，① 字符相同，② 字符不同
- 字符相同时，为了使编辑距离最小，不应该对它们有任何操作，直接往前移动i，j
- 字符不同，则对操作进行三选一：插入(insert)、删除(delete)、替换(replace)
- 还有两种base case ： ① 当j走完了s2 ，如果 i 没有走完s1，直接删除s1 中长的字符，缩短为s2 ；② i 走完了s1，j还没有走完s2 ，直接插入s2剩下的字符到s1即可
伪代码：
if s1[i] == s2[j]:
啥都不做
i，j同时向前移动
else：
三选一：
插入：insert
删除：delete
替换：replace
递归的伪代码
def minDistance(s1, s2) -> int:
def dp(i, j):
# base case
if i == -1: return j + 1
if j == -1: return i + 1
if s1[i] == s2[j]:
return dp(i - 1, j - 1) # 啥都不做
else:
return min(
dp(i, j - 1) + 1, # 插⼊
dp(i - 1, j) + 1, # 删除
dp(i - 1, j - 1) + 1 # 替换
)
# i， j 初始化指向最后⼀个索引
return dp(len(s1) - 1, len(s2) - 1)
方法
递归方法
递归方法，但是会产生很多重复子问题 —— 会超时
使用字符串子串进行操作，但是在java中如此做会占用大量的空间，因此我们使用将String转换为char[]的方法
public int minDistance_1(String word1, String word2) {
char[] w1 = word1.toCharArray();
char[] w2 = word2.toCharArray();
return recur(w1,word1.length() - 1,w2,word2.length() - 1);
}
private int recur(char[] w1, int x, char[] w2, int y) {
if (x == -1 || y == -1)
return Math.max(x,y) + 1;
if (w1[x] == w2[y])
return recur(w1, x-1, w2, y-1);
else return Math.min(Math.min(recur(w1, x - 1, w2, y - 1), //替换
recur(w1, x - 1, w2, y)), //删除
recur(w1, x, w2, y - 1)) + 1; //插入
}
由于递归方法产生的重复子问题太多，会导致超时，则有两个方法把重复的子问题记录下来，① 备忘录记录重复子问题，② DP table的方法记录重复子问题
自顶向下
/**
* 备忘录记录重复子问题 自顶向下
*/
int[][] mem;
public int minDistance_2(String word1, String word2) {
char[] w1 = word1.toCharArray(), w2 = word2.toCharArray();
mem = new int[w1.length][w2.length];
return recur_2(w1, word1.length() - 1, w2, word2.length() - 1);
}
private int recur_2(char[] w1, int x, char[] w2, int y) {
if (x == -1 || y == -1)
return Math.max(x,y) + 1;
if (w1[x] == w2[y])
return recur_2(w1,x - 1,w2,y - 1);
else {
if (mem[x][y] != 0)
return mem[x][y];
int res = Math.min(Math.min(recur(w1, x - 1, w2, y - 1), //替换
recur(w1, x - 1, w2, y)), //删除
recur(w1, x, w2, y - 1)) + 1; //插入
mem[x][y] = res;
return res;
}
}
DP table记录重复子问题 自底向上
public int minDistance(String word1, String word2) {
int n1 = word1.length();
int n2 = word2.length();
int[][] dp = new int[n1 + 1][n2 + 1];
//第一行
for (int i = 1; i <= n2; i++) {
dp[0][i] = dp[0][i - 1] + 1;
}
for (int i = 1; i <= n1; i++) {
dp[i][0] = dp[i - 1][0] + 1;
}
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= n2 ; j++) {
if (word1.charAt(i - 1) == word2.charAt( j - 1) )
dp[i][j] = dp[i - 1][j- 1];
else
//insert = dp[i][j - 1] 插入 replace = dp[i - 1][j - 1] 替换 delete = dp[i - 1][j] 删除
dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1],dp[i][j - 1]),dp[i - 1][j]) + 1;
}
}
return dp[n1][n2];
}
那么求出了最小的编辑距离，具体怎么操作呢？即路径怎么走？
我们应该给dp数组增加额外的信息：
Node[][] dp;
class Node {
int val;
int choice;
// 0 代表啥都不做
// 1 代表插入
// 2 代表删除
// 3 代表替换
}
class Node{
int val;
int choice;
Node(int val,int choice){
this.val = val;
this.choice = choice;
}
}
即，把前面的 int [][] dp 升级成 Node[][] dp
package leetcode;/**
* Copyright (C), 2019-2021
* author candy_chen
* date 2021/3/17 22:13
*
* @Classname leetcode_72
* Description: 测试
*/
/**
*
*/
public class leetcode_72 {
class Node{
int val;
int choice;
Node(int val,int choice){
this.val = val;
this.choice = choice;
}
int minDistance(String s1,String s2){
int m = s1.length();
int n = s2.length();
Node[][] dp = new Node[m + 1][n + 1];
//base case
for (int i = 0; i <= m; i++) {
//s1转换成s2只需要删除一个字符
dp[i][0] = new Node(i,2);
}
for (int j = 1; j <= n; j++) {
//s1转换成s2只需要插入一个字符
dp[0][j] = new Node(j,1);
}
//状态转移方程
// 0 代表啥都不做
// 1 代表插入
// 2 代表删除
// 3 代表替换
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if(s1.charAt(i - 1) == s2.charAt(j - 1)){
//如果两个字符相同，则什么都不需要做
Node node = dp[i - 1][j - 1];
dp[i][j] = new Node(node.val,0);
}else {
//否则，记录代价最小的操作
dp[i][j] = minNode(
dp[i - 1][j] ,
dp[i][j - 1] ,
dp[i-1][j-1]
);
}
//并且将编辑距离加1
dp[i][j].val++;
}
}
// 根据dp table 反推具体操作过程并打印
printResult(dp,s1,s2);
return dp[m][n].val;
}
//反推结果并打印具体的操作
private void printResult(Node[][] dp, String s1, String s2) {
int rows = dp.length;
int cols = dp[0].length;
int i = rows - 1,j = cols - 1;
System.out.println("Change s1 = " + s1 + " to s2= " + ":\n");
while (i != 0 && j != 0){
char c1 = s1.charAt(i - 1);
char c2 = s2.charAt(j - 1);
int choice = dp[i][j].choice;
System.out.println("s1[" + (i - 1) + "]:");
switch (choice){
case 0:
//跳过
System.out.println("skip '" + c1 + "'");
i--;j--;
break;
case 1:
//跳过
System.out.println("insert '" + c2 + "'");
j--;
break;
case 2:
//跳过
System.out.println("delete '" + c1 + "'");
i--;
break;
case 3:
//跳过
System.out.println("replace '" + c1 + "'" + "with '" + c2 + "'");
i--;j--;
break;
}
}
while (i > 0){
System.out.print("s1[" + (i - 1) + "]:");
System.out.println("delete '" + s1.charAt(i - 1) + "'");
i--;
}
//如果s2还没有走完，则剩下的都是需要插入s1的
while (j > 0){
System.out.print("s1[0]");
System.out.println("insert '" + s2.charAt(j - 1) + "'");
j--;
}
}
//计算delete、insert、replace中代价最小的操作
private Node minNode(Node a, Node b, Node c) {
Node res = new Node(a.val,2);
if (res.val > b.val){
res.val = b.val;
res.choice = 1;
}
if (res.val > c.val){
res.val = c.val;
res.choice = 3;
}
return res;
}
}
}
参考：labuladong
