相似度计算方法-编辑距离 (Edit Distance)

xy2006860

已于 2024-08-15 13:42:03 修改

阅读量1.1k

点赞数 29

文章标签：算法

于 2024-08-15 13:39:06 首次发布

本文链接：https://blog.csdn.net/xy2006860/article/details/141217016

版权

定义

编辑距离（Edit Distance），也称为Levenshtein距离，是一种衡量两个字符串相似度的方法。它定义为从一个字符串转换为另一个字符串所需的最少单字符编辑操作次数，这些操作包括插入、删除或替换一个字符。

计算方法

对于两个字符串 $S_1 = (s_{11}, s_{12}, \ldots, s_{1m})$ 和 $S_2 = (s_{21}, s_{22}, \ldots, s_{2n})$ ，编辑距离 $d_E(S_1, S_2)$ 可以通过动态规划的方式计算，其中 $m$ 和 $n$ 分别是 $S_1$ 和 $S_2$ 的长度。

定义一个 $(m+1) \times (n+1)$ 的矩阵 $D$ ，其中 $D[i][j]$ 表示 $S_1$ 的前 $i$ 个字符到 $S_2$ 的前 $j$ 个字符的编辑距离。

初始化矩阵的第一行和第一列为：

$D[i][0] = i \quad \text{for } 0 \leq i \leq m$
$D[0][j] = j \quad \text{for } 0 \leq j \leq n$

动态规划的状态转移方程为：

$D[i][j] = \min \left( \begin{array}{c} D[i-1][j] + 1 \\ D[i][j-1] + 1 \\ D[i-1][j-1] + 1_{s_{1i} \neq s_{2j}} \end{array} \right)$

其中 $1_{s_{1i} \neq s_{2j}}$ 是指示函数，当 $s_{1i} \neq s_{2j}$ 时返回 1，否则返回 0。

最终的编辑距离为：

$d_E(S_1, S_2) = D[m][n]$

逻辑解析

编辑距离可以通过动态规划方法来求解。动态规划的核心是构建一个二维表来存储中间结果，并使用这些中间结果来解决更大的子问题。在这个问题中，我们构建一个矩阵 dp，其中 dp[i][j] 表示字符串 $S_1$ 的前 i 个字符到字符串 $S_2$ 的前 j 个字符的编辑距离。

初始化

初始化矩阵的第一行和第一列，因为要从空字符串转换到任意长度的字符串，只需要相应的插入或删除操作次数。因此，dp[i][0] = i 和 dp[0][j] = j。

动态规划方程

对于每个 dp[i][j] 的值，我们可以考虑以下情况来决定其值：

如果 s1[i-1] == s2[j-1]，则不需要做任何操作，所以 dp[i][j] = dp[i-1][j-1]。
如果 s1[i-1] != s2[j-1]，则可以考虑以下三种操作：
- 替换：将 s1[i-1] 替换成 s2[j-1]，那么 dp[i][j] = dp[i-1][j-1] + 1。
- 删除：从 s1 中删除一个字符，那么 dp[i][j] = dp[i-1][j] + 1。
- 插入：在 s1 中插入一个字符，那么 dp[i][j] = dp[i][j-1] + 1。
如果进入到步骤2，我们肯定选择替换、删除、插入距离最小的一项，即对应上述计算方法中的状态转移方程。
等迭代计算完成后，最终的答案就是 dp[m][n]，其中 m 和 n 分别是字符串 $S_1$ 和 $S_2$ 的长度。

删除逻辑解析

对于替换操作来说，理解起来很简单， $S_1$ 的前 i-1个字符到的前j-1个字符的编辑距离是dp[i-1][j-1]，再加一次替换操作，即是最后的 dp[i][j] = dp[i-1][j-1] + 1。

当我们考虑从 $S_1$ 中删除一个字符时，我们实际上是在比较 $S_1$ 的前 i-1 个字符与 $S_2$ 的前 j 个字符的编辑距离。这意味着我们从 $S_1$ 中删除了第 i 个字符。

在动态规划表 dp 中，dp[i][j] 表示字符串 $S_1$ 的前 i 个字符到字符串 $S_2$ 的前 j 个字符的编辑距离。如果我们想从 $S_1$ 中删除一个字符，那么可以这样理解：

我们从 s1 的前 i-1 个字符到 s2 的前 j 个字符的编辑距离 dp[i-1][j] 开始。
然后加上一次删除操作的成本，即 + 1。

因此，动态规划方程中的删除操作可以表示为： $dp[i][j]=dp[i-1][j]+1$ 。

状态转移：
- dp[i-1][j] 表示从 $S_1$ 的前 i-1 个字符到 $S_2$ 的前 j 个字符的编辑距离。
- dp[i][j] 表示从 $S_1$ 的前 i 个字符到 $S_2$ 的前 j 个字符的编辑距离。
删除操作：
- 如果我们从 $S_1$ 中删除第 i 个字符，那么 $S_1$ 的前 i 个字符到 $S_2$ 的前 j 个字符的编辑距离就变成了 $S_1$ 的前 i-1 个字符到 $S_2$ 的前 j 个字符的编辑距离加上一次删除操作的成本。
- 因此，dp[i][j] = dp[i-1][j] + 1。

删除示例

假设我们有两个字符串 s1 = "kitten" 和 s2 = "sitting"，我们来计算 dp[1][1] 的值，即从 s1 的前 1 个字符到 s2 的前 1 个字符的编辑距离。

初始化：
- s1 的前 1 个字符是 "k"。
- s2 的前 1 个字符是 "s"。
删除操作：
- 如果我们从 s1 中删除 "k"，那么 dp[1][1] 应该等于 dp[0][1] + 1。
- dp[0][1] 是从空字符串到 "s" 的编辑距离，即 1。
- 因此，dp[1][1] = 1 + 1 = 2。

插入逻辑解析

插入操作意味着在字符串中插入一个字符以使其更接近字符串 $S_2$ 。当我们考虑在中插入一个字符时，我们实际上是在比较的前 i 个字符与的前 j-1 个字符的编辑距离。这意味着我们在的末尾插入了的第 j 个字符。

在动态规划表 dp 中，dp[i][j] 表示字符串的前 i 个字符到字符串的前 j 个字符的编辑距离。如果我们想在中插入一个字符，那么可以这样理解：

我们从的前 i 个字符到的前 j-1 个字符的编辑距离 dp[i][j-1] 开始。
然后加上一次插入操作的成本，即 + 1。

因此，动态规划方程中的插入操作可以表示为： $dp[i][j]=dp[i][j-1]+1$ 。

状态转移：
- dp[i][j-1] 表示从 $S_1$ 的前 i 个字符到 $S_2$ 的前 j-1 个字符的编辑距离。
- dp[i][j] 表示从 $S_1$ 的前 i 个字符到 $S_2$ 的前 j 个字符的编辑距离。
插入操作：
- 如果我们在 $S_1$ 的末尾插入 $S_2$ 的第 j 个字符，那么 $S_1$ 的前 i 个字符到 $S_2$ 的前 j 个字符的编辑距离就变成了 $S_1$ 的前 i 个字符到 $S_2$ 的前 j-1 个字符的编辑距离加上一次插入操作的成本。
- 因此，dp[i][j] = dp[i][j-1] + 1。

插入示例

假设我们有两个字符串 s1 = "kitten" 和 s2 = "sitting"，我们来计算 dp[1][2] 的值，即从 s1 的前 1 个字符到 s2 的前 2 个字符的编辑距离。

初始化：
- s1 的前 1 个字符是 "k"。
- s2 的前 2 个字符是 "si"。
插入操作：
- 如果我们在 s1 的末尾插入 "s"，那么 dp[1][2] 应该等于 dp[1][1] + 1。
- dp[1][1] 是从 "k" 到 "s" 的编辑距离，假设已经计算过为 1。
- 因此，dp[1][2] = 1 + 1 = 2。

代码实现

public class EditDistance {

    public static void main(String[] args) {
        String str1 = "kitten";
        String str2 = "sitting";

        int distance = calculateEditDistance(str1, str2);
        System.out.printf("The edit distance between '%s' and '%s' is: %d\n", str1, str2, distance);
    }

    /**
     * 计算两个字符串之间的编辑距离。
     *
     * @param s1 第一个字符串
     * @param s2 第二个字符串
     * @return 两个字符串之间的编辑距离
     */
    public static int calculateEditDistance(String s1, String s2) {
        int[][] dp = new int[s1.length() + 1][s2.length() + 1];

        // 初始化第一行和第一列
        for (int i = 0; i <= s1.length(); i++) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= s2.length(); j++) {
            dp[0][j] = j;
        }

        // 动态规划填充dp数组
        for (int i = 1; i <= s1.length(); i++) {
            for (int j = 1; j <= s2.length(); j++) {
                int cost = (s1.charAt(i - 1) == s2.charAt(j - 1)) ? 0 : 1;
                dp[i][j] = Math.min(Math.min(dp[i - 1][j] + 1,      // 删除
                                             dp[i][j - 1] + 1),     // 插入
                                    dp[i - 1][j - 1] + cost);    // 替换
            }
        }

        return dp[s1.length()][s2.length()];
    }
}

注意，从代码中可以看出，编辑距离的时间复杂度和空间复杂度都是 $O(m \times n)$ 。

优劣势

优势

全面考虑编辑操作：
- 编辑距离考虑了三种基本的编辑操作：插入、删除和替换，能够全面地评估字符串之间的差异。
计算稳定性：
- 编辑距离的计算基于动态规划方法，保证了计算结果的一致性和准确性。

编辑距离的劣势

时间复杂度：
- 编辑距离的计算复杂度为 $O(m\times n)$ ，其中 $m$ 和 $n$ 分别是两个字符串的长度。
- 对于较长的字符串，计算时间可能会较长，编辑距离的计算可能会消耗大量的时间和计算资源。
不考虑编辑操作的成本：
- 编辑距离默认每种编辑操作的成本相同，但实际上不同类型的编辑操作可能有不同的成本。
- 例如，在某些应用场景中，替换操作可能比插入或删除操作成本更高。
不适用于非字符串数据：
- 编辑距离主要用于字符串数据，对于非字符串数据（如数值型数据或图像数据）可能不适用。
空间复杂度：
- 动态规划方法需要存储一个 $(m+1)\times (n+1)$ 的矩阵，这在处理长字符串时可能导致较高的空间复杂度。