mirror of https://gitee.com/bigwinds/arangodb
99 lines
3.1 KiB
C++
99 lines
3.1 KiB
C++
#include "levenshtein.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief calculate the levenshtein distance of the two strings
|
|
///
|
|
/// This function implements the Damerau-Levenshtein algorithm to
|
|
/// calculate a distance between strings.
|
|
///
|
|
/// Basically, it says how many letters need to be swapped, substituted,
|
|
/// deleted from, or added to string1, at least, to get string2.
|
|
///
|
|
/// The idea is to build a distance matrix for the substrings of both
|
|
/// strings. To avoid a large space complexity, only the last three rows
|
|
/// are kept in memory (if swaps had the same or higher cost as one deletion
|
|
/// plus one insertion, only two rows would be needed).
|
|
///
|
|
/// At any stage, "i + 1" denotes the length of the current substring of
|
|
/// string1 that the distance is calculated for.
|
|
///
|
|
/// row2 holds the current row, row1 the previous row (i.e. for the substring
|
|
/// of string1 of length "i"), and row0 the row before that.
|
|
///
|
|
/// In other words, at the start of the big loop, row2[j + 1] contains the
|
|
/// Damerau-Levenshtein distance between the substring of string1 of length
|
|
/// "i" and the substring of string2 of length "j + 1".
|
|
///
|
|
/// All the big loop does is determine the partial minimum-cost paths.
|
|
///
|
|
/// It does so by calculating the costs of the path ending in characters
|
|
/// i (in string1) and j (in string2), respectively, given that the last
|
|
/// operation is a substitution, a swap, a deletion, or an insertion.
|
|
///
|
|
/// This implementation allows the costs to be weighted:
|
|
///
|
|
/// - w (as in "sWap")
|
|
/// - s (as in "Substitution")
|
|
/// - a (for insertion, AKA "Add")
|
|
/// - d (as in "Deletion")
|
|
///
|
|
/// Note that this algorithm calculates a distance _iff_ d == a.
|
|
///
|
|
/// @author https://github.com/git/git/blob/master/levenshtein.c
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int TRI_Levenshtein (char const* string1,
|
|
char const* string2,
|
|
int w,
|
|
int s,
|
|
int a,
|
|
int d) {
|
|
int len1 = static_cast<int>(strlen(string1));
|
|
int len2 = static_cast<int>(strlen(string2));
|
|
int* row0 = new int[len2 + 1];
|
|
int* row1 = new int[len2 + 1];
|
|
int* row2 = new int[len2 + 1];
|
|
|
|
for (int j = 0; j <= len2; j++) {
|
|
row1[j] = j * a;
|
|
}
|
|
|
|
int i;
|
|
for (i = 0; i < len1; i++) {
|
|
int *dummy;
|
|
|
|
row2[0] = (i + 1) * d;
|
|
for (int j = 0; j < len2; j++) {
|
|
/* substitution */
|
|
row2[j + 1] = row1[j] + s * (string1[i] != string2[j]);
|
|
/* swap */
|
|
if (i > 0 && j > 0 && string1[i - 1] == string2[j] &&
|
|
string1[i] == string2[j - 1] &&
|
|
row2[j + 1] > row0[j - 1] + w) {
|
|
row2[j + 1] = row0[j - 1] + w;
|
|
}
|
|
/* deletion */
|
|
if (row2[j + 1] > row1[j + 1] + d) {
|
|
row2[j + 1] = row1[j + 1] + d;
|
|
}
|
|
/* insertion */
|
|
if (row2[j + 1] > row2[j] + a) {
|
|
row2[j + 1] = row2[j] + a;
|
|
}
|
|
}
|
|
|
|
dummy = row0;
|
|
row0 = row1;
|
|
row1 = row2;
|
|
row2 = dummy;
|
|
}
|
|
|
|
i = row1[len2];
|
|
delete[] row0;
|
|
delete[] row1;
|
|
delete[] row2;
|
|
|
|
return i;
|
|
}
|
|
|