码迷,mamicode.com
首页 > 其他好文 > 详细

动态规划(四)——如何实现搜索引擎中的拼写纠错功能?

时间:2020-08-18 13:57:08      阅读:65      评论:0      收藏:0      [点我收藏+]

标签:turn   索引   规划   回溯法   string   效果   解答   递归   最长公共子串   

??如何量化两个字符串之间的相似程度呢?有一个非常著名的量化方法,那就是编辑距离(Edit Distance)。

??编辑距离指的就是,将一个字符串转化成另一个字符串,需要的最少编辑操作次数(比如增加一个字符、删除一个字符、替换一个字符)。编辑距离越大,说明两个字符串的相似程度越小;相反,编辑距离就越小,说明两个字符串的相似程度越大。对于两个完全相同的字符串来说,编辑距离就是 0。

??编辑距离有多种不同的计算方式,比较著名的有莱文斯坦距离(Levenshtein distance)和最长公共子串长度(Longest common substring length)。其中,莱文斯坦距离允许增加、删除、替换字符这三个编辑操作,最长公共子串长度只允许增加、删除字符这两个编辑操作。

??莱文斯坦距离和最长公共子串长度,从两个截然相反的角度,分析字符串的相似程度:

  • 莱文斯坦距离的大小,表示两个字符串差异的大小

  • 最长公共子串的大小,表示两个字符串相似程度的大小

??根据回溯算法的代码实现,我们可以画出递归树,看是否存在重复子问题。如果存在重复子问题,那我们就可以考虑能否用动态规划来解决;如果不存在重复子问题,那回溯就是最好的解决方法。

C++版代码如下

#include <iostream>
#include <math.h>
#include <string.h>
using namespace std;

#define MAXNUM 100010
#define DRIFT 1001

int minWeight = 9999;
int minDist = 0xFFFFFF;

// 回溯法求最短路径
void reCall(int cost[][4], int rows, int cols, int row, int col, int curS){
    if((row == (rows - 1)) && (col == (cols - 1))){
        //cout<<curS<<endl;
        if(curS < minWeight)
            minWeight = curS;
        return ;
    }
    // 向右走
    if(col < cols - 1)
        reCall(cost, rows, cols, row, col + 1,curS + cost[row][col + 1]);
    // 向下走
    if(row < rows - 1)
        reCall(cost, rows, cols, row + 1, col, curS + cost[row + 1][col]);
}

// 动态规划版
int dpRoad(int cost[][4], int n, int row, int col){
    int dp[n][n];
    memset(dp, -1, sizeof(dp));
    // 初始化第一行、第一列
    dp[0][0] = cost[0][0];
    for(int i = 1; i < n; i++){
        dp[0][i] = dp[0][i - 1] + cost[0][i];
        dp[i][0] = dp[i - 1][0] + cost[i][0];
    }

    for(int i = 1; i < n; i++){
        for(int j = 1; j < n; j++){
            dp[i][j] = cost[i][j] + min(dp[i - 1][j], dp[i][j - 1]);
        }
    }
    return dp[row - 1][col - 1];
}

// 回溯法求莱文斯坦编辑距离
void lwstBT(char str_1[], int n, char str_2[], int m, int i, int j, int edist){

    if(i == n || j == m){
        if(i < n)
            edist += (n - i);
        if(j < m)
            edist += (m - j);
        if(edist < minDist)
            minDist = edist;
        return ;
    }
    // 1、两字符相匹配
    if(str_1[i] == str_2[j])
        lwstBT(str_1, n, str_2, m, i + 1, j + 1, edist);
    else{
        // 2、删除a[i]或者b[j]前添加一个字符
        lwstBT(str_1, n, str_2, m, i + 1, j, edist + 1);
        // 3、删除b[j]或者a[i]前添加一个字符
        lwstBT(str_1, n, str_2, m, i, j + 1, edist + 1);
        // 4、替换
        lwstBT(str_1, n, str_2, m, i + 1, j + 1, edist + 1);
    }
}

int myMin(int x, int y, int z) {
    int minv = 0x7FFFFFFF;
    if (x < minv)
        minv = x;
    if (y < minv)
        minv = y;
    if (z < minv)
        minv = z;
    return minv;
}

int myMax(int x, int y, int z) {
    int maxv = -1;
    if (x > maxv) maxv = x;
    if (y > maxv) maxv = y;
    if (z > maxv) maxv = z;
    return maxv;
}

// 动态规划法求莱文斯坦编辑距离
int lwstDP(char a[], int n, char b[], int m) {
    int minDist[n][m];
    memset(minDist, -1, sizeof(minDist));
    for (int j = 0; j < m; ++j) { // 初始化第0行:a[0..0]与b[0..j]的编辑距离
        if (a[0] == b[j])
            minDist[0][j] = j;
        else if (j != 0)
            minDist[0][j] = minDist[0][j-1]+1;
        else
            minDist[0][j] = 1;
    }
    for (int i = 0; i < n; ++i) { // 初始化第0列:a[0..i]与b[0..0]的编辑距离
        if (a[i] == b[0])
            minDist[i][0] = i;
        else if (i != 0)
            minDist[i][0] = minDist[i-1][0]+1;
        else
            minDist[i][0] = 1;
    }
    for (int i = 1; i < n; ++i) { // 按行填表
        for (int j = 1; j < m; ++j) {
            if (a[i] == b[j])
                minDist[i][j] = myMin(minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]);
            else
                minDist[i][j] = myMin(minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]+1);
        }
    }

    return minDist[n-1][m-1];
}


int lcsDP(char a[], int n, char b[], int m) {
    int maxlcs[n][m];
    for (int j = 0; j < m; ++j) {//初始化第0行:a[0..0]与b[0..j]的maxlcs
        if (a[0] == b[j])
            maxlcs[0][j] = 1;
        else if (j != 0)
            maxlcs[0][j] = maxlcs[0][j-1];
        else
            maxlcs[0][j] = 0;
    }

    for (int i = 0; i < n; ++i) {//初始化第0列:a[0..i]与b[0..0]的maxlcs
        if (a[i] == b[0])
            maxlcs[i][0] = 1;
        else if (i != 0)
            maxlcs[i][0] = maxlcs[i-1][0];
        else
            maxlcs[i][0] = 0;
    }
    for (int i = 1; i < n; ++i) { // 填表
        for (int j = 1; j < m; ++j) {
            if (a[i] == b[j])
                maxlcs[i][j] = myMax(maxlcs[i-1][j], maxlcs[i][j-1], maxlcs[i-1][j-1]+1);
            else
                maxlcs[i][j] = myMax(maxlcs[i-1][j], maxlcs[i][j-1], maxlcs[i-1][j-1]);
        }
    }

    return maxlcs[n-1][m-1];
}

int main()
{

    int cost[4][4]={{1, 3, 5, 9},{2, 1, 3, 4},{5, 2, 6, 7},{6, 8, 4, 3}};

    // 从(0, 0)开始走到(n-1, n-1),初始值路径值为1
    reCall(cost, 4, 4, 0, 0, 1);
    cout<<minWeight<<endl;
    cout<<dpRoad(cost, 4, 4, 4)<<endl;

    // 最长公共子串(从前到后)"mtcu"4个
    char str_1[7] = "mitcmu";
    char str_2[7] = "mtacnu";
    lwstBT(str_1, 6, str_2, 6, 0, 0, 0);
    cout<<minDist<<endl;
    cout<<lwstDP(str_1, 6, str_2, 6)<<endl;
    cout<<lcsDP(str_1, 6, str_2, 6);
    return 0;
}

解答开篇

??当用户在搜索框内,输入一个拼写错误的单词时,我们就拿这个单词跟词库中的单词一一进行比较,计算编辑距离,将编辑距离最小的单词,作为纠正之后的单词,提示给用户。

??这就是拼写纠错最基本的原理。不过,真正用于商用的搜索引擎,拼写纠错功能显然不会就这么简单。一方面,单纯利用编辑距离来纠错,效果并不一定好;另一方面,词库中的数据量可能很大,搜索引擎每天要支持海量的搜索,所以对纠错的性能要求很高。

??针对纠错效果不好的问题,我们有很多种优化思路:

  • 我们并不仅仅取出编辑距离最小的那个单词,而是取出编辑距离最小的 TOP 10,然后根据其他参数,决策选择哪个单词作为拼写纠错单词。比如使用搜索热门程度来决定哪个单词作为拼写纠错单词。

  • 我们还可以用多种编辑距离计算方法,比如今天讲到的两种,然后分别编辑距离最小的 TOP 10,然后求交集,用交集的结果,再继续优化处理。

  • 我们还可以通过统计用户的搜索日志,得到最常被拼错的单词列表,以及对应的拼写正确的单词。搜索引擎在拼写纠错的时候,首先在这个最常被拼错单词列表中查找。如果一旦找到,直接返回对应的正确的单词。这样纠错的效果非常好。

  • 我们还有更加高级一点的做法,引入个性化因素。针对每个用户,维护这个用户特有的搜索喜好,也就是常用的搜索关键词。当用户输入错误的单词的时候,我们首先在这个用户常用的搜索关键词中,计算编辑距离,查找编辑距离最小的单词。

??针对纠错性能方面,我们也有相应的优化方式。我讲两种分治的优化思路。

  • 如果纠错功能的 TPS 不高,我们可以部署多台机器,每台机器运行一个独立的纠错功能。当有一个纠错请求的时候,我们通过负载均衡,分配到其中一台机器,来计算编辑距离,得到纠错单词。

  • 如果纠错系统的响应时间太长,也就是,每个纠错请求处理时间过长,我们可以将纠错的词库,分割到很多台机器。当有一个纠错请求的时候,我们就将这个拼写错误的单词,同时发送到这多台机器,让多台机器并行处理,分别得到编辑距离最小的单词,然后再比对合并,最终决定出一个最优的纠错单词。

??真正的搜索引擎的拼写纠错优化,肯定不止这么简单,但是万变不离其宗。掌握了核心原理,就是掌握了解决问题的方法。

动态规划(四)——如何实现搜索引擎中的拼写纠错功能?

标签:turn   索引   规划   回溯法   string   效果   解答   递归   最长公共子串   

原文地址:https://www.cnblogs.com/flyingrun/p/13511965.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!