牛客题解 | 计算字符串的编辑距离_1

题目

题目链接

解题思路

1. 编辑距离是指将一个字符串转换成另一个字符串所需的最少操作次数，允许的操作包括：

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

2. 使用动态规划求解：

   • 定义 $dp[i][j]$ 表示字符串1的前 $i$ 个字符转换到字符串2的前 $j$ 个字符所需的最小操作次数
   • 当字符相同时，$dp[i][j]=dp[i-1][j-1]$
   • 当字符不同时，$dp[i][j]=\min (dp[i-1][j],dp[i][j-1],dp[i-1][j-1])+1$
     • $dp[i-1][j]+1$ 表示删除操作
     • $dp[i][j-1]+1$ 表示插入操作
     • $dp[i-1][j-1]+1$ 表示替换操作

---

代码

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int minDistance(string word1, string word2) {
    int m = word1.length();
    int n = word2.length();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
    
    // 初始化边界
    for (int i = 0; i <= m; i++) {
        dp[i][0] = i;
    }
    for (int j = 0; j <= n; j++) {
        dp[0][j] = j;
    }
    
    // 动态规划
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; 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-1], min(dp[i-1][j], dp[i][j-1])) + 1;
            }
        }
    }
    
    return dp[m][n];
}

int main() {
    string str1, str2;
    while (cin >> str1 >> str2) {
        cout << minDistance(str1, str2) << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    public static int minDistance(String word1, String word2) {
        int m = word1.length();
        int n = word2.length();
        int[][] dp = new int[m + 1][n + 1];
        
        // 初始化边界
        for (int i = 0; i <= m; i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = j;
        }
        
        // 动态规划
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (word1.charAt(i-1) == word2.charAt(j-1)) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    dp[i][j] = Math.min(dp[i-1][j-1], 
                                Math.min(dp[i-1][j], dp[i][j-1])) + 1;
                }
            }
        }
        
        return dp[m][n];
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String str1 = sc.next();
            String str2 = sc.next();
            System.out.println(minDistance(str1, str2));
        }
    }
}

def min_distance(word1: str, word2: str) -> int:
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    # 初始化边界
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
    
    # 动态规划
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1
    
    return dp[m][n]

# 处理多组输入
while True:
    try:
        str1 = input()
        str2 = input()
        print(min_distance(str1, str2))
    except EOFError:
        break

---

算法及复杂度

• 算法：动态规划
• 时间复杂度：$\mathcal{O}(mn)$ - 其中 $m$ 和 $n$ 分别是两个字符串的长度
• 空间复杂度：$\mathcal{O}(mn)$ - 需要一个二维 $dp$ 数组