【算法笔记】K.M.P.字符串匹配

合集 - OI算法笔记(13)

1.【算法笔记】K.M.P.字符串匹配2022-01-18

2.【算法笔记】Tarjan 算法 · 上2022-01-213.【算法笔记】Manacher 算法2022-01-314.【算法笔记】二维凸包2022-01-305.【算法笔记】扩展 Euclid 算法2022-01-276.【算法笔记】Tarjan 算法 · 下2022-01-247.【算法笔记】Lagrange 插值法2022-04-148.【算法笔记】中国剩余定理（CRT）与扩展中国剩余定理（exCRT）2022-04-129.【算法笔记】Baby Step Giant Step（BSGS）及其扩展2022-04-0910.【算法笔记】Gauss 消元 · 行列式2022-04-0311.【算法笔记】Euler-Fermat 定理2022-03-1912.【算法笔记】快速 Fourier 变换（FFT）2022-03-1313.【算法笔记】乘法逆元2022-02-01

收起

• 本文总计约 5600 字，阅读大约需要 20 分钟。

前言

笔者学习 KMP 字符串匹配的过程实在是一个漫长的过程。本来 KMP 算法就是一个非常玄学的算法，再加上笔者脑子不大好，所以学习这个算法的时候就很迷糊 QwQ。

笔者的作文也经常得低分 QwQ，所以写的不好敬请谅解，不过我还是尽力把这个算法讲清楚的 ~ 如果有什么地方出现了事实错误，也希望读者加以指正。

不过话说回来，KMP 确实是一种充满美感的算法。当笔者第一次了解到这个算法的时候，态度是不屑一顾的；初次学习这个算法时，也迷迷糊糊不知道它在说什么；但当我充分地了解它的时候，我就会对它的思路感到惊奇，特别是对失配子串的处理上十分地美妙；而它 $\Theta(m+n)$ 的优秀的时间复杂度，更是让我们能体会到前人智慧之所在。所以，我才会写这样一篇博客来记录它。

问题引入

在生物研究中会遇见这样的问题：给定一个 $\tt{DNA}$ 母链，上面有一串碱基序列。现在有一个特定的基因序列 $\tt{gene}$，我们应该如何确定 $\tt{gene}$ 这个序列在 $\tt{DNA}$ 中出现了多少次？

样例输入：$\tt{DNA}=\tt{ATGATGCATGCATGAT}$，$\tt{gene}=\tt{ATGAT}$。
样例输出：$2$。
解释：在 $\tt{DNA}$ 序列中出现了两次 $\tt{ATGAT}$ 序列，如下图：

形式化地讲述这个问题：给定字符串 $\tt{str}$（以下称为母串）和 $\tt{model}$（以下称为模式串），求模式串在母串中作为连续的子串出现了多少次？

暴力破解

暴力破解的思路

最好想的一种做法就是暴力枚举。

以母串中每一个字符作为起点，向后截取长度为 $m$ 的子串（$m$ 为模式串的长度），判断能否与模式串相互匹配。如果匹配，则计数器 $+1$。如下图：

这种算法的思路很简单，代码也很好写，如下：

#include <iostream>
#include <cstring>
using namespace std;
const int maxN = 100001;

int ans;
char str[maxN], model[maxN];

/*** 字符串暴力匹配 ***/ 
int ViolentMatch(char* str, char* model) {
    int cnt = 0, n = strlen(str), m = strlen(model);
    for(int i = 0; i + m - 1 < n; ++i) {
        bool failed = false;

        for(int j = 0; j < m; ++j) {
            if(str[i + j] != model[j]) {   //发现失配字符就停止匹配
                failed = true;
                break;
            }
        }

        if(!failed) {      //如果成功匹配则计数器+1
            ++cnt;
        }
    }

    return cnt;
}

int main(void) {
	cin >> str >> model;
	ans = ViolentMatch(str, model);
	cout << ans;
	return 0;
} 

暴力破解的缺陷

这种做法固然非常简单，但是它非常的低效。

考虑如下输入：$\tt{str}=\tt{AAAAAAAAAAAAAAAAAAAAAA}$，$\tt{model}={AAAAB}$。

计算机每次枚举的时候，会一直匹配到模式串的最后一个字符才会发现失配了。这并不是最糟糕的，糟糕的是失配之后它只会回到第二个字符重新匹配，这就造成了大量的重复搜索。如下：

假如母串的长度为 $n$，模式串的长度为 $m$，那么上面这种最坏的情况下，程序大概需要在 $n\times m$ 步后才能全部匹配完成，即时间复杂度为 $\mathcal{O}(mn)$。所以，当 $n$ 和 $m$ 达到 $10^5$ 甚至 $10^6$ 数量级时，计算机就不能快速地得出答案了。

既然这种算法低效的原因是在母串上进行了大量的重复搜索，那么我们有没有一种算法，让母串上的起点位置不回退，扫一遍字符串就能得出答案呢？

答案是肯定的，这就是我们接下来所要介绍的：KMP 字符串匹配。

KMP 字符串匹配

什么是 KMP

所谓 KMP 算法，并不是由一个人发明的，而是三位计算机科学家 $\mathcal{D.E.Knuth}$，$\mathcal{J.H.Morris}$ 和 $\mathcal{V.R.Pratt}$ 共同发现的，故以三人姓氏的首字母命名。它可以通过一个辅助数组— — next 数组，来实现 $\Theta(n+m)$ 的时间复杂度内的字符串匹配。

KMP 算法的内容

我们现在以 $\tt{str}=\tt{ABCACABCABCABD}$，$\tt{model}={ABCABD}$ 为例，进行字符串匹配。

我们第一步先以母串第一个字符为起点进行匹配，匹配到第五个字符时发现失配了，如下图：

但是在此时，我们会发现前面已经匹配上了 $\tt{ABCA}$ 四个字符，那么就没有必要再倒回第二个字符慢慢来了，而因为模式串中匹配上的部分中，$\tt{A}$ 是其最长的公共前后缀，所以我们直接将模式串的起始位置移到第四个位置向后匹配。

但我们发现这个时候遇见第二个字符时就失配了，我们就将模式串再向后移动一位，但移动之后我们便发现匹配到第一位就失配了，于是就再向后移动一位，如下图：

接下来在匹配的时候，一直匹配到第六个字符时，我们才发现失配了，但我们已经知道了匹配上了 $\tt{ABCAB}$ 五个字符，这个时候，我们就可以直接跳到使最长公共前后缀重新匹配上的部分，并向后继续匹配。如图：

这样，我们就终于找到了字符串中匹配上的部分。

从上面，我们可以看出 KMP 算法的核心，即通过计算字符串每个前缀的最常公共真前后缀长度（这句话有一点绕 QwQ，要好好理解），来实现模式串在母串上一直前移而不回退。

而每个前缀的最长公共真前后缀长度，我们称为部分匹配值，并使用一个 next 数组记录。

生成 next 数组

我们生成 next 数组的方式，可以看做是模式串对模式串本身进行的 KMP 匹配。

先贴代码 QwQ：

const int maxN = 100001;

char str[maxN], model[maxN];
int Next[maxN], ans;

/*** 计算部分匹配值 ***/
void GetNext(char* model) {
    int m = strlen(model), j = 0;             //变量 j 用于统计字符串中当前的部分匹配值

    for(int i = 1; i < m; ++i) {
        while(j && model[j] != model[i]) {    //如果发现失配了，就往回退，直到退至可以匹配的地方
            j = Next[j-1];
        }

        if(model[j] == model[i]) {            //如果匹配上了，就让计数器加一
            ++j;
        }

        Next[i] = j;
    }
}

接下来对这个部分进行解释：以 $\tt{model}=\tt{ABCABDABCABC}$ 为例。
前面的 $3$ 个字符组成的前缀，next 值均为 $0$，即 $\textit{next}[0]=\textit{next}[1]=\textit{next}[2]=0$。这个时候，统计 next 值的变量 $j$ 始终为 $0$。

接下来，在计算第四、第五个字符的时候，发现 $\tt{AB}$ 是前五个字符的最长公共前后缀，于是 $\textit{next}[3]=1$，$\textit{next}[4]=2$，$j$ 增加到 $2$。如下图：

以此类推，失配的时候就回到可以匹配的最长公共前后就可以了：

代码实现

接下来，KMP 字符串匹配的主体部分就没有什么难的了，照着刚才说的算法思路实现就可以了：

#include <iostream>
#include <cstring>
using namespace std;
const int maxN = 1000001;

char str[maxN], model[maxN];
int Next[maxN], ans;

void GetNext(char* model) {                   //计算部分匹配值
    int m = strlen(model), j = 0;             //变量 j 用于统计字符串中当前的部分匹配值

    for(int i = 1; i < m; ++i) {
        while(j && model[j] != model[i]) {    //如果发现失配了，就往回退到可以匹配的地方
            j = Next[j - 1];
        }

        if(model[j] == model[i]) {             //如果匹配上了，就让计数器加一
            ++j;
        }

        Next[i] = j;
    }
}

int KMPMatch(char* str) {                      //KMP 字符串匹配主体
    int n = strlen(str), m = strlen(model), 
        j = 0, cnt = 0;

    for(int i = 0; i < n; ++i) {
        while(j && str[i] != model[j]) {       //如果发现失配，就往回退
            j = Next[j - 1];
        }

        if(str[i] == model[j]) {               //匹配一位，就让指针后移一位
            ++j;
        }

        if(j == m) {                           //发现了完全匹配的模式串，计数器加一
            cout << i - j + 2 << endl;         //输出发现的位置
            ++cnt;
        }
    }
    return cnt;
}

int main(void) {
    cin >> str >> model;

    GetNext(model);
    KMPMatch(str);

    //输出 next 数组
    for(int i = 0; model[i]; ++i) {
        cout << Next[i] << " ";
    }

    return 0;
}

时间复杂度分析

因为每次母串指针后移一位时，模式串的指针至多增加一位，所以此算法的时间复杂度即为 $\Theta(n+m)$，比起暴力算法有了很大的优化。

事实上，这种利用前后缀特性，减少反复搜索，就是 KMP 的核心思想，这种思想在许多其它的字符串算法中都很有作用，也是我们应该学习的思想。

例题

本题目列表会持续更新。

• [P3375]【模板】KMP字符串匹配
• [POI2006]OKR-Periods of Words