Optimization 优化Levenshtein距离算法

我有一个存储过程，它使用Levenshtein距离来确定最接近用户键入内容的结果。唯一真正影响速度的是在选择距离最小的记录之前计算所有记录的Levenshtein距离的函数（我已经用0代替对Levenshtein函数的调用验证了这一点）。该表有150万条记录，因此即使是最轻微的调整也可能会缩短几秒钟。现在整个过程都要持续10分钟。以下是我使用的方法：

ALTER function dbo.Levenshtein
( 
    @Source nvarchar(200), 
    @Target nvarchar(200) 
) 
RETURNS int
AS
BEGIN
DECLARE @Source_len int, @Target_len int, @i int, @j int, @Source_char nchar, @Dist int, @Dist_temp int, @Distv0 varbinary(8000), @Distv1 varbinary(8000)

SELECT @Source_len = LEN(@Source), @Target_len = LEN(@Target), @Distv1 = 0x0000, @j = 1, @i = 1, @Dist = 0

WHILE @j <= @Target_len
BEGIN
    SELECT @Distv1 = @Distv1 + CAST(@j AS binary(2)), @j = @j + 1
END

WHILE @i <= @Source_len
BEGIN
    SELECT @Source_char = SUBSTRING(@Source, @i, 1), @Dist = @i, @Distv0 = CAST(@i AS binary(2)), @j = 1

WHILE @j <= @Target_len
BEGIN
    SET @Dist = @Dist + 1
    SET @Dist_temp = CAST(SUBSTRING(@Distv1, @j+@j-1, 2) AS int) +
                  CASE WHEN @Source_char = SUBSTRING(@Target, @j, 1) THEN 0 ELSE 1 END

    IF @Dist > @Dist_temp
    BEGIN
        SET @Dist = @Dist_temp
    END

    SET @Dist_temp = CAST(SUBSTRING(@Distv1, @j+@j+1, 2) AS int)+1

    IF @Dist > @Dist_temp SET @Dist = @Dist_temp
    BEGIN
        SELECT @Distv0 = @Distv0 + CAST(@Dist AS binary(2)), @j = @j + 1
    END
END

SELECT @Distv1 = @Distv0, @i = @i + 1
END

RETURN @Dist
END

ALTER函数dbo.Levenshtein
( 
@源nvarchar（200），
@目标nvarchar（200）
) 
返回整数
作为
开始
声明@Source\u len int、@Target\u len int、@i int、@j int、@Source\u char nchar、@Dist int、@Dist\u temp int、@Distv0 varbinary（8000）、@Distv1 varbinary（8000）
选择@Source\u len=len（@Source），@Target\u len=len（@Target），@Distv1=0x0000，@j=1，@i=1，@Dist=0
而@j我过去做这件事的方式是将“数据库”（实际上是用于拼写更正的单词词典）存储为trie

然后，我使用分支绑定例程查找最近的匹配条目。对于小距离，所需的时间是距离的指数。对于大距离，它在字典的大小上是线性的，正如您现在看到的

Branch and bound基本上是trie的深度优先树遍历，但有一个错误预算。在每个节点上，跟踪当前levenshtein距离，如果超过预算，则修剪树的该分支

首先，你在预算为零的情况下进行步行。那只能找到精确的匹配项。如果你找不到一个匹配的，那么你就用一个预算去做。将在距离1处查找匹配项。如果你找不到，那么你的预算是2，以此类推。这听起来效率很低，但由于每次步行都比前一次花费更多的时间，所以时间主要由你最后一次步行决定

新增：代码大纲（请原谅我的C）：

//trie节点的哑版本，按字母索引。你可以提高。
typedef结构tnodeTag{
tnodeTag*p[128]；
}tnode；
tnode*top；//的黎波里山顶
无效漫游（tnode*p、char*s、int-budget）{
int i；
如果（*s==0）{
if（p==NULL）{
//打印当前的trie路径
}
}
否则如果（预算>=0）{
//试着删除这封信
步行（p、s+1、预算-1）；
//尝试交换两个相邻的字母
如果（s[1]）{
掉期（s[0]，s[1]）；
步行（p、s、预算-1）；
掉期（s[0]，s[1]）；
}
如果（p）{
对于（i=0；i<128；i++）{
//尝试精确匹配
如果（i==*s）步行（p->p[i]，s+1，预算）；
//尝试替换此字符
如果（i！=*s）步行（p->p[i]，s+1，预算-1）；
//试着插入这封信
步行（p->p[i]，s，预算-1）；
}
}
}
}

基本上，您可以通过跳过字母并在同一节点上搜索来模拟删除字母。您可以通过降低trie而不推进s来模拟插入字母。您可以通过假装字母匹配（即使不匹配）来模拟替换字母。当你掌握了窍门后，你可以添加其他可能的不匹配，比如用O替换0，用L或I替换1——诸如此类愚蠢的东西

您可能想添加一个字符数组参数来表示您在trie中找到的当前单词。
您分析过这个词并查看过索引吗？将计算出的值存储在每行中，如果目标列出现变化，则进行更新……不，我没有分析它。。。我必须看看如何做到这一点，这是我第一次尝试优化存储过程之前。我无法存储计算值，这正用于搜索，搜索输入很少会重复。大纲将非常有用。我理解用错误预算行走，但我真的不知道如何做深度优先的树行走…@Matt：深度优先的树行走？您可以只使用递归dfs函数，也可以使用堆栈。查一查，太好了！我一直在研究代码，试图将其转换为SQL，到目前为止，它工作正常。我不太确定如何将整个表转换为Trie，以及如何遍历它。。。它不像C，我们有指针或其他东西。有人有什么想法吗？我可能会把这个问题作为另一个问题发布。再次感谢你的帮助@马特：我不认为你能在SQL中真正做到这一点。我认为您必须获取所有数据并用其他语言构建一个trie。请检查这个问题：有关如何在SQL中执行此操作的详细信息。
// dumb version of trie node, indexed by letter. You can improve.
typedef struct tnodeTag {
  tnodeTag* p[128];
} tnode;

tnode* top; // the top of the trie

void walk(tnode* p, char* s, int budget){
  int i;
  if (*s == 0){
    if (p == NULL){
      // print the current trie path
    }
  }
  else if (budget >= 0){
    // try deleting this letter
    walk(p, s+1, budget-1);
    // try swapping two adjacent letters
    if (s[1]){
      swap(s[0], s[1]);
      walk(p, s, budget-1);
      swap(s[0], s[1]);
    }
    if (p){
      for (i = 0; i < 128; i++){
        // try exact match
        if (i == *s) walk(p->p[i], s+1, budget);
        // try replacing this character
        if (i != *s) walk(p->p[i], s+1, budget-1);
        // try inserting this letter
        walk(p->p[i], s, budget-1);
      }
    }
  }
}