数据结构与算法笔记：基础篇 - 动态规划实战：如何实现搜索引擎中的拼写纠错功能？

概述

在 Trie 树章节我们讲过，利用 Trie 树，可以实现搜索引擎的关键词提示功能，这样可以节省用户输入搜索关键词的时间。实际上，搜索引擎在用户体验方面的优化还有很多，比如你可能经常会用的拼写纠错功能。

当你在搜索框中，一不小心输错时，搜索引擎会非常智能地检测出你的拼写错误，并且用对应地正确的单词来进行搜索。作为一名软件工程师，你是否想过，这个功能是怎么实现的？

---

如何量化两个字符串的相似度？

计算机只认识数字，所以要解答开篇的问题，我们就要先来看，如何量化两个字符串之间的相似程度呢？有一个非常著名的量化方法，那就是编辑距离（Edit Distance）。

顾名思义，编辑距离指的就是，讲一个字符串转化成另一个字符串，需要的最少编辑操作次数（比如增加一个字符、删除一个字符、替换一个字符）。编辑距离越大，说明两个字符串的相似程度越小；相反，编辑距离越小，说明两个字符串的相似程度就越大。对于两个完全相同的字符串来说，编辑距离就是 0。

根据所包含的编辑操作的种类的不同，编辑距离有多种不同的计算方式，比较著名的有莱文斯坦距离（Levenshtein Distance）和最长公共子串长度（Longest common substring length）。其中，莱文斯坦距离允许增加、删除、替换字符这三个编辑操作，最长公共子串长度只允许增加、删除字符这两个编辑操作。

而且，莱文斯坦距离和最长公共子串长度，从两个截然相反的角度，分析字符串的相似程度。莱文斯坦距离的大小，表示两个字符串差异的大小；而最长公共子串的大小，表示两个字符串相似程度的大小。

关于这两个计算方法，我举个例子说明下。这里面，两个字符串 mitcmu 和 mtacnu 的莱文斯坦距离是 3，最长公共子串长度是 4。

了解了编辑距离的概念之后，我们来看下，如何快速计算两个字符串之间的编辑距离。

如何编程计算莱文斯坦距离？

思考过程比结论更重要，所以，现在就给你展示下，解决这个问题，我的完成的思考过程。

这个问题是求把一个字符串变成另一个字符串，需要的最少编辑次数。整个求解过程，设计过个决策阶段，我们需要依次考察一个字符串中的每个字符，跟另一个字符串中的字符是否匹配，匹配的话如何处理，不匹配的话如何处理。所以，这个问题符合多阶段决策最优解模型。

前面讲了，贪心、回溯、动态规划可以解决的问题，都可以抽象成一个模型。要解决这个问题，可以先看下，用最简单的回溯法，该如何解决。

回溯是一个递归处理的过程。如果 a[i] 与 b[j] 匹配，我们递归考察 a[i+1] 和 b[j+1] 。如果 a[i] 与 b[j] 不匹配，那我们有多种处理方式可选：

• 可以删除 a[i]，然后递归考察 a[i+1] 和 b[j]。
• 可以删除 b[j]，然后递归考察 a[i] 和 b[j+1]。
• 可以在 a[i] 前面添加一个跟 b[j] 相同的字符，然后递归考察 a[i] 和 b[j+1]。
• 可以在 b[j] 前面添加一个跟 a[i] 相同的字符，然后递归考察 a[i+1] 和 b[j]。
• 可以将 a[i] 替换成 b[j]，或者将 b[j] 替换成 a[i]，然后递归考察 a[i+1] 和 b[j+1]。

我们将上面的回溯算法的处理思路，翻译成代码，就是下面的样子：

    private char[] a = "mitcmu".toCharArray();
    private char[] b = "mtacnu".toCharArray();
    private int n = 6;
    private int m = 6;
    private int minDist = Integer.MAX_VALUE; // 存储结果
    // 调用方式 lwsBT(0,0,0)
    public void lwsBT(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;
        }
        if (a[i] == b[i]) { // 字符匹配
            lwsBT(i+1, j+1, eDist);
        } else { // 字符不匹配
            lwsBT(i+1, j, eDist + 1); // 删除a[i],或者在b[j]前面添加一个跟a[i]相同的字符
            lwsBT(i, j+1, eDist + 1); // 删除b[j],或者在a[i]前面添加一个跟b[j]相同的字符
            lwsBT(i+1, j+1, eDist + 1); // 将a[i]替换成b[j]，或者将b[j]替换成a[i]
        }
    }

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

在递归树中，每个节点代表一个状态，状态包含三个变量 (i,j,eDist)，其中 eDist 表示处理到 a[i] 和 b[j] 时，已经执行的编辑操作的次数。

在递归树中，(i,j) 两个变量的重复节点很多，比如 (3,2) 、(2,3)。对于 (i,j) 相同的节点，我们只需要保留 eDist 最小的，继续递归就可以了。所以，状态就从 (i,j,eDist) 变成了 (i,j,min_dist)，其中 min_dist 表示处理到 a[i] 和 b[j]，已经执行的最少编辑次数。

看到这里，你有没有觉得，这个问题跟上两章将的动态规划的例子非常相似？不过，这个问题的状态转移方式，要比之前讲到的例子要复杂的多。上篇文章讲的矩阵最短路径问题中，到达 (i,j) 只能通过 (i-1,j) 或 (i,j-1) 两个状态转移过来，而本章这个问题，状态 (i,j) 可能从 (i-1,j) 、(i,j-1)、(i-1,j-1) 三个状态中的任意一个转移过来。

基于刚刚的分析，我们可以尝试着吧状态转移的过程，用公式写出来。这就是前面讲到的状态转移方程。

如果：a[i]!=b[j]，那么 min_edist(i,j) 就等于：
min(min_edist(i-1,j)+1, min_edist(i,j-1)+1, min_edist(i-1,j-1)+1)

如果：a[i]=b[j]，那么 min_edist(i,j) 就等于：
min(min_edist(i-1,j)+1, min_edist(i,j-1)+1, min_edist(i-1,j-1))

其中，min表示求三个数中的最小值

了解了状态与状态之间的递推关系，我们画出一个二维的状态表，按照行依次来填充表中的每个值。

现在既有状态转移方便，又理清了完整的填表过程，代码实现就非常简单了。

    public int lwstDP(char[] a, int n, char[] b, int m) {
        int[][] minDist = new int[n][m];
        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 < m; 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][0] + 1;
            else minDist[i][0]=1;
        }
        for (int i = 1; i < n; i++) { // 按行填表
            for (int j = 1; j < m; j++) {
                if (a[i] == a[j]) minDist[i][j] = min(minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]);
                else minDist[i][j] = min(minDist[i-1][j]+1, minDist[i][j-1]+1, minDist[i-1][j-1]+1);
            }
        }
        return minDist[n-1][m-1];
    }

    private int min(int x, int y, int z) {
        int minV = Integer.MAX_VALUE;
        if (x < minV) minV = x;
        if (y < minV) minV = y;
        if (z < minV) minV = z;
        return minV;
    }

你可能会说，虽然能看懂你讲的思路，但遇到新的问题，我还是会感觉无从下手。这种感觉是非常正常的。关于复杂算法问题的解决思路，还有一些经验、技巧，可以分享给你

当我们拿到一个问题时，我们可以先不考虑，计算机如何实现这个问题，而是单穿考虑 “人脑” 会如何去解决这个问题。人脑比较倾向于思考具象化、摸的着看得见的东西，不适合思考过于抽象的问题。所以，我们需要把抽象问题具象化。那如何具象化呢？我们可以实例化几个测试数据，通过人脑去分析具体实例的解，然后总结规律，再尝试套用学过的算法，看看能够解决。

此外，还有一个非常有效、但也算不上技巧的东西，那就是多练。实际上，等你做多了题目之后，自然就会有感觉，看到问题，立马就能想到能否动用动态规划解决，然后直接就可以寻找最优子结构，写出动态规划方程，然后将状态转移翻译成代码。

如何编程计算最长公共子串长度？

前面我们讲到，最长公共子串作为编辑距离的一种，只允许增加、删除字符两种操作。从名字上，你可能觉得它看起来跟编辑距离没什么关系。实际上，从本质上说，它表征也是两个字符串之间的相似程度。

这个问题的解决思路，跟莱文斯坦距离的解决思路非常相似，也可以用动态规划来解决。刚刚已经详细讲解了莱文斯坦距离的动态规划，所以针对这个问题，我直接定义状态，然后写状态转移方程。

每个状态还是包括三个变量 (i,j,max_lcs)，max_lcs 表示 a[0…i] 和 b[0…j] 的最长公共子串长度。那 (i,j) 这个状态都是由哪些状态转移过来的呢？

我们先来看看回溯的处理思路。我们从 a[0] 和 b[0] 开始，依次考察各个字符串中的字符是否匹配。

• 如果 a[i] 与 b[j] 互相匹配，我们将最长公共子串长度加一，并且继续考察 a[i+1] 与 b[j+1]。
• 如果 a[i] 与 b[j] 不匹配，最长公共子串长度不变，这个时候，有两种不同的决策陆续：
  • 删除 a[i]，或者在 b[j] 前面加上一个字符，然后继续考察 a[i+1] 与 b[j]。
  • 删除 b[j]，或者在 a[i] 前面加上一个字符，然后继续考察 a[i] 与 b[j+1]。

反过来也就是说，如果我们要计算 a[0…i] 和 b[0…j] 的最长公共子串长度 max_lcs(i,j)，我们只能通过下面三个状态转移过来：

• (i-1,j-1,max_lcs)，其中 max_lcs 是 a[0…i-1] 和 b[0…j-1] 的最长公共子串长度。
• (i-1,j,max_lcs)，其中 max_lcs 是 a[0…i-1] 和 b[0…j] 的最长公共子串长度。
• (i,j-1,max_lcs)，其中 max_lcs 是 a[0…i] 和 b[0…j-1] 的最长公共子串长度。

如果把这个转移过程，用状态转移方程写出来，就是下面这个样子：

如果：a[i]==b[j]，那么max_lcs就等于：
max((i-1,j-1,max_lcs)+1, (i-1,j,max_lcs), (i,j-1,max_lcs))

如果：a[i]!=b[j]，那么max_lcs就等于：
max((i-1,j-1,max_lcs), (i-1,j,max_lcs), (i,j-1,max_lcs))

其中max表示求三数中的最大值

有了状态转移方程，代码实现就简单多了。

    public int lcs(char[] a, int n, char[] b, int m) {
        int[][] maxlcs = new int[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 = 0; i < n; i++) { // 填状态表
            for (int j = 0; j < m; j++) {
                if (a[i] == b[j]) max(maxlcs[i-1][j-1]+1, maxlcs[i][j-1], maxlcs[i-1][j]);
                else max(maxlcs[i-1][j-1], maxlcs[i][j-1], maxlcs[i-1][j]);
            }
        }
    }

    private int max(int x, int y, int z) {
        int maxv = Integer.MIN_VALUE;
        if (x > maxv) maxv = x;
        if (y > maxv) maxv = z;
        if (z > maxv) maxv = z;
        return maxv;
    }

如何实现搜索引擎中的拼写纠错功能？

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

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

针对纠错效果不好的问题，我们有很多种优化的思路，这里我介绍几种。

• 我们并不仅仅取出编辑距离最小的那个单词，而是取出编辑距离最小的 TOP 10，然后根据其他参数，决策选择哪个单词作为拼写纠错单词。比如使用搜索热门程度来决定哪个单词作为拼写纠错单词。
• 我们还可以用多种编辑距离计算方法，比如本章讲到的两种，然后分别编辑距离最小的 TOP 10，然后求交集，用交集的结果，再继续优化处理。
• 我们还可以通过统计用户的搜索日志，得到最常被拼错的单词列表，以及对应的拼写正确的单词。搜索引擎在拼写纠错的时候，首先在这个最常被拼错单词列表中查找。如果一旦被找到，直接返回对应的正确的单词。这样纠错效果非常好。
• 还有更加高级一点的做法，引入个性化因素。针对每个用户，维护这个用户特有的搜索喜好，也就是常用的搜索关键词。当用户输入错误的单词时，我们首先在这个用户常用的搜索关键词中，计算编辑距离，查找编辑距离最小的单词。

针对纠错性能方面，我们也有相应的优化方式。这里讲两种分支的优化思路。

• 如果纠错功能的 TPS 不高，我们可以部署多台机器，每台机器运行一个独立的纠错功能。当有一个纠错请求的时候，我们通过负载均衡，分配到其中一台机器，来计算编辑距离，得到纠错单词。
• 如果纠错系统的响应时间太长，也就是每个纠错请求处理时间过长，我们可以将纠错的词库，分割到很多台机器。当有一个纠错请求的时候，我们就将这个拼写错误的单词，同时发送到这么多台机器，让多台机器，分别得到编辑距离最小的单词，然后再比对合并，最终决出一个最优的纠错单词。

真正的搜索引擎的拼写纠错优化，肯定不止我们讲的这么简单，但是万变不离其宗。掌握了核心原理，就是掌握了解决问题的方法，剩下就靠你自己的灵活运用和实战操练了。

小结

动态规划的内容到此就讲完了，不知道你掌握得如何呢？

动态规划的理论尽管不复杂，总结起来就是 “一个模型三个特征”。但是，要想灵活应用并不简单。要想真正理解、掌握动态规划，你只有多联系。

这三篇文章中讲到的几个动态规划问题都非常经典，是我精心筛选出来的。很多动态规划问题其实都可以抽象成这几个问题模型，所以，你一定要多看几遍，多思考一下，争取真正搞懂它们。

只要弄懂这几个问题，一般的动态规划问题，你应该都可以应付。对于动态规划这个知识点，你就算是入门了，再学习更加复杂的就会简单很多。