字符串相似度之编辑距离算法

最新推荐文章于 2024-08-15 13:39:06 发布

IT少年

最新推荐文章于 2024-08-15 13:39:06 发布

阅读量1.2k

点赞数 1

分类专栏： C#知识文章标签：相似度编辑距离

C#知识专栏收录该内容

2 篇文章 0 订阅

订阅专栏

字符串编辑距离： 是一种字符串之间相似度计算的方法。给定两个字符串S、T，将S转换成T所需要的删除，插入，替换操作的数量就叫做S到T的编辑路径。而最短的编辑路径就叫做字符串S和T的编辑距离。

举个例子：S=“eeba” T="abac" 我们可以按照这样的步骤转变：(1) 将S中的第一个e变成a;(2) 删除S中的第二个e;(3)在S中最后添加一个c; 那么S到T的编辑路径就等于3。当然，这种变换并不是唯一的，但如果3是所有变换中最小值的话。那么我们就可以说S和T的编辑距离等于3了。

动态规划解决编辑距离

动态规划(dynamic programming)是一种解决复杂问题最优解的策略。它的基本思路就是：将一个复杂的最优解问题分解成一系列较为简单的最优解问题，再将较为简单的的最优解问题进一步分解，直到可以一眼看出最优解为止。

动态规划算法是解决复杂问题最优解的重要算法。其算法的难度并不在于算法本身的递归难以实现，而主要是编程者对问题本身的认识是否符合动态规划的思想。现在我们就来看看动态规划是如何解决编辑距离的。

还是这个例子：S=“eeba” T="abac" 。我们发现当S只有一个字符e、T只有一个字符a的时候，我们马上就能得到S和T的编辑距离edit(0,0)=1(将e替换成a)。那么如果S中有1个字符e、T中有两个字符ab的时候，我们是不是可以这样分解：edit(0,1)=edit(0,0)+1(将e替换成a后，在添加一个b)。如果S中有两个字符ee，T中有两个字符ab的时候，我们是不是可以分解成：edit(1,1)=min(edit(0,1)+1, edit(1,0)+1, edit(0,0)+f(1,1)). 这样我们可以得到这样一些动态规划公式：

如果i=0且j=0 edit(0, 0)=1

如果i=0且j>0 edit(0, j )=edit(0, j-1)+1

如果i>0且j=0 edit( i, 0 )=edit(i-1, 0)+1

如果i>0且j>0 edit(i, j)=min(edit(i-1, j)+1, edit(i,j-1)+1, edit(i-1,j-1)+f(i , j) )

小注：edit(i,j)表示S中[0.... i]的子串 si 到T中[0....j]的子串t1的编辑距离。f(i,j)表示S中第i个字符s(i)转换到T中第j个字符s(j)所需要的操作次数，如果s(i)==s(j)，则不需要任何操作f(i, j)=0；否则，需要替换操作，f(i, j)=1 。

这就是将长字符串间的编辑距离问题一步一步转换成短字符串间的编辑距离问题，直至只有1个字符的串间编辑距离为1。

///c#代码/

今天在群里聊天，提及了 "编辑距离" 算法。好久不用，重新练练手，免得日后用时乱找。 [sweat]

1. Levenshtein Distance

该算法又称之为 "编辑距离"，用于计算两个字符串的相似程度。原理很简单，就是返回将第一个字符串转换(删除、插入、替换)成第二个字符串的编辑次数。次数越少，意味着字符串相似度越高。

算法原理：Wikipedia - Levenshtein distance

Step1:

　　人民共和时代
　 0, 0, 0, 0, 0, 0, 0
中 1, 0, 0, 0, 0, 0, 0
华 2, 0, 0, 0, 0, 0, 0
人 3, 0, 0, 0, 0, 0, 0
民 4, 0, 0, 0, 0, 0, 0
共 5, 0, 0, 0, 0, 0, 0
和 6, 0, 0, 0, 0, 0, 0
国 7, 0, 0, 0, 0, 0, 0

Step2:

　　人民共和时代
　 0, 1, 2, 3, 4, 5, 6
中 1, 0, 0, 0, 0, 0, 0
华 2, 0, 0, 0, 0, 0, 0
人 3, 0, 0, 0, 0, 0, 0
民 4, 0, 0, 0, 0, 0, 0
共 5, 0, 0, 0, 0, 0, 0
和 6, 0, 0, 0, 0, 0, 0
国 7, 0, 0, 0, 0, 0, 0

Step3:

　　人民共和时代
　 0, 1, 2, 3, 4, 5, 6
中 1, 1, 2, 3, 4, 5, 6
华 2, 2, 2, 3, 4, 5, 6
人 3, 2, 3, 3, 4, 5, 6
民 4, 3, 2, 3, 4, 5, 6
共 5, 4, 3, 2, 3, 4, 5
和 6, 5, 4, 3, 2, 3, 4
国 7, 6, 5, 4, 3, 3, 4

算法实现Code：

public static int LevenshteinDistance(string s1, string s2)
{
    if (s1 == s2)
        return 0;
    else if (String.IsNullOrEmpty(s1))
        return s2.Length;
    else if (String.IsNullOrEmpty(s2))
        return s1.Length;

    var m = s1.Length + 1;
    var n = s2.Length + 1;
    var d = new int[m, n];

    // Step1
    for (var i = 0; i < m; i++) d[i, 0] = i;

    // Step2
    for (var j = 0; j < n; j++) d[0, j] = j;

    // Step3
    for (var i = 1; i < m; i++)
    {
        for (var j = 1; j < n; j++)
        {
            var cost = s1[i - 1] == s2[j - 1] ? 0 : 1;

            var deletion = d[i - 1, j] + 1;
            var insertion = d[i, j - 1] + 1;
            var substitution = d[i - 1, j - 1] + cost;

            d[i, j] = Math.Min(Math.Min(deletion, insertion), substitution);
        }
    }

    return d[m - 1, n - 1];
}

2. LCS

LCS (Longest Common Subsequence) 算法用于找出两个字符串最长公共子串。

算法原理：

(1) 将两个字符串分别以行和列组成矩阵。
(2) 计算每个节点行列字符是否相同，如相同则为 1。
(3) 通过找出值为 1 的最长对角线即可得到最长公共子串。

　人民共和时代
中 0, 0, 0, 0, 0, 0
华 0, 0, 0, 0, 0, 0
人 1, 0, 0, 0, 0, 0
民 0, 1, 0, 0, 0, 0
共 0, 0, 1, 0, 0, 0
和 0, 0, 0, 1, 0, 0
国 0, 0, 0, 0, 0, 0

为进一步提升该算法，我们可以将字符相同节点(1)的值加上左上角(d[i-1, j-1])的值，这样即可获得最大公用子串的长度。如此一来只需以行号和最大值为条件即可截取最大子串。

　人民共和时代
中 0, 0, 0, 0, 0, 0
华 0, 0, 0, 0, 0, 0
人 1, 0, 0, 0, 0, 0
民 0, 2, 0, 0, 0, 0
共 0, 0, 3, 0, 0, 0
和 0, 0, 0, 4, 0, 0
国 0, 0, 0, 0, 0, 0

算法实现Code：

public static string LCS(string s1, string s2)
{
    if (s1 == s2)
        return s1;
    else if (String.IsNullOrEmpty(s1) || String.IsNullOrEmpty(s2))
        return null;

    var d = new int[s1.Length, s2.Length];

    var index = 0;
    var length = 0;

    for (int i = 0; i < s1.Length; i++)
    {
        for (int j = 0; j < s2.Length; j++)
        {
            // 左上角值
            var n = i - 1 >= 0 && j - 1 >= 0 ? d[i - 1, j - 1] : 0;

            // 当前节点值 = "1 + 左上角值" : "0"
            d[i, j] = s1[i] == s2[j] ? 1 + n : 0;

            // 如果是最大值，则记录该值和行号
            if (d[i, j] > length)
            {
                length = d[i, j];
                index = i;
            }
        }
    }

    return s1.Substring(index - length + 1, length);
}

心得：

我所需要的是LCS（），可以通过修改方法适应需求，通过计算相同字符个数相比第一个字符的占比。即可计算出相似度*%

没有准确的答案，有的只是把别人的东西转化成你的东西。劝诫自己和学习的朋友

代码摘自:http://blog.csdn.net/liuweibirthday/article/details/5895476