Levenshtein Distance + LCS 算法計算兩個字符串的相似度

 【園里很多前輩寫過關於Levenshtein Distance算法的文章，對算法原理有很深入的剖析講解。我這里班門弄斧，盡我所能，將這個算法以更加通俗易懂的語言來闡述，有何紕漏，請指出和見諒】

Levenshtein Distance，編輯距離算法，是指從字符串A變成字符串B，所需的最少編輯（增，刪，插入）次數。應用也相當廣泛，這里我們用來求解兩個字符串的相似度。

算法原理我就不再說明（注，對於算法原理，請參照 http://en.wikipedia.org/wiki/Levenshtein_distance ），這里只圖解實現的過程。

【例子】假設現在有源串“jary”與目標串“jerry”，求源串到目標串的編輯距離。

圖解過程如下：

step 1：初始化如下矩陣

 

step 2：從源串的第一個字符（“j”）開始，從上至下與目標串進行對比

如果兩個字符相等，則在從此位置的左，上，左上三個位置中取出最小的值, 如果最小值在 左，上 這兩個位置上,則加1,如果在左上上,則加0；若不等，則在從此位置的左，上，左上三個位置中取出最小的值再加上1；

第一次，源串第一個字符“j” 與目標串的“j”對比,左，上，左上三個位置中取出最小的值0，因為兩字符相等，所以加上0；接着，依次對比“j”→“e”，“j”→“r”，“j”→“r”，，“j”→“y” 到掃描完目標串。

 

step 3：遍歷整個源串與目標串對比：

 

 

step 4：掃描完最后一列，則最后一個為最短編輯距離：

求出編輯距離，那么兩個字符串的相似度 Similarity = (Max(x,y) - Levenshtein)/Max(x,y)，其中 x,y 為源串和目標串的長度。（計算公式修改）

LCS算法:用於求解兩個字符串之間最長的公共子序列;

【例子】假如有“張則智”和“張則知”兩個字符串，求解步驟如下：

step 1：初始化如下矩陣，然后，“張則智”三個字分別跟“張”字對比，相同的為1+上一步的結果（左對角），不同位0；

 

step 2：依次使用源串與目標串對比，這里第二步是，“張則智”跟“則”對比，相同為1+上一步的結果（左對角），不同為0

step 3：對比完整個矩陣，掃描矩陣中最大的數為最長公共子序列；

 

計算出編輯距離，最長公共子序列，然后用 萬倉一黍 前輩提供的公式來計算：S(A,B)=LCS(A,B)/(LD(A,B)+LCS(A,B))

【注，在實際應用中，此公式會出現不足，感謝 萬倉一黍 前輩指出，實際應用中，應該配合使用 LCS 算法；可參考 http://www.cnblogs.com/grenet/archive/2010/06/04/1751147.html 】

代碼實現（使用C#來實現）

1. 計算編輯距離：

public static int LevenshteinDistance(string source, string target) 
{
    int cell = source.Length;
    int row = target.Length;
    if (cell == 0) 
    {
        return row;
    }
    if (row == 0) 
    {
        return cell;
    }
    int[, ] matrix = new int[row + 1, cell + 1];
    for (var i = 0; i <= cell; i++) 
    {
        matrix[0, i] = i;
    }
    for (var j = 1; j <= row; j++) 
    {
        matrix[j, 0] = j;
    }
    var tmp = 0;
    for (var k = 0; k < row; k++) 
    {
        for (var l = 0; l < cell; l++) 
        {
            if (source[l].Equals(target[k])) 
                tmp = 0;
            else 
                tmp = 1;
            matrix[k + 1, l + 1] = Math.Min(Math.Min(matrix[k, l] + tmp, matrix[k + 1, l] + 1), matrix[k, l + 1] + 1);
        }
    }
    return matrix[row, cell];
}

2. LCS算法代碼：

public static int LongestCommonSubsequence(string source, string target) 
{
    if (source.Length == 0 || target.Length == 0) 
        return 0;
    int len = Math.Max(target.Length, source.Length);
    int[, ] subsequence = new int[len + 1, len + 1];
    for (int i = 0; i < source.Length; i++) 
    {
        for (int j = 0; j < target.Length; j++) 
        {
            if (source[i].Equals(target[j])) 
                subsequence[i + 1, j + 1] = subsequence[i, j] + 1;
            else 
                subsequence[i + 1, j + 1] = 0;
        }
    }
    int maxSubquenceLenght = (from sq in subsequence.Cast < int > () select sq).Max < int > ();
    return maxSubquenceLenght;
}

2. 計算兩個字符串間的相識度：

public static float StringSimilarity(string source, string target) 2 { 3     var ld = LevenshteinDistance(source, target); 4     var maxLength = Math.Max(source.Length, target.Length); 5     return (float)(maxLength - ld) / maxLength; 6 }

 3. 計算兩個字符串的相似度：

public static float StringSimilarity(string source, string target) 
{
    var ld = LevenshteinDistance(source, target);
    var lcs = LongestCommonSubsequence(source, target);
    return ((float)lcs)/(ld+lcs);;
}

【2013.06.07 修改】在寫LD算法的時候，精簡了一部分代碼，引發一些計算錯誤，使結果不正確，已改正；感謝 混沌世界 指出；