道长的算法笔记：KMP算法及其各种变体

(一)如何优化暴力算法

Waiting...

(二)KMP模板

　KMP 算法的精髓在于 $next$ 数组， $next[i]=j$ 代表 $p[1,j]=p[i-j+1,i]$ ， $next[i]$ 数值意义代表 $p[1,i]$ 所有前缀与后缀的最长公共部分，我们约定本文提到的前缀与后缀均为不包含原字符串 $p$ 本身。

　这个过程动手计算并不困难，但想理解代码为何如此实现倒并不简单。个人建议，自行动手画图计算 $next$ 数组，以此体会这个过程，否则永远不可能理解哪怕一行代码。由于 $next$ 可能会有命名与内置命名冲突的风险，因而我们的代码实现中写为 $nxt$ 而非 $next$ ，下文我们都将使用 $nxt$ ，同时为使代码实现起来更加简洁，我们所有字符串的索引均从 $1$ 开始计算。

　说完约定之后，接着来看模式串 $p$ 的最长前缀与后缀公共长度的计算过程，前缀字符最大可取到的范围是在 $s[1,n-2]$ ，后缀最大可取到的范围是在 $s[2,n-1]$ ，例如 $abcd$ 前缀包括 $\{a、ab、abc\}$ ，后缀包括了 $\{d、cd、bcd\}$ ，值得注意，后缀的字符出场顺序与原字符串 $p$ 是一样的，都是从左往右。回忆一下 $nxt[i] = j$ ，其含义是指 $p[1,j]=p[i-j+1,i]$ ，注意，此处使用方括号与逗号分隔的表示法是指左闭右闭区间，使用方括号与冒号分隔的切片表示法才是左闭右开区间。我们计算 $nxt$ 数组的过程其实就是字符串 $p$ 对其自身的匹配过程，我们错开一位再进行比较即可比对所有前缀与所有后缀之间，最大公共长度部分了。

　再看上图的匹配过程，如果失配，指向模式串的指针 $p$ 往左退，除非已经到达了退无可退的状态，方才跳出。在完成了向左移动退步的操作之后，再对当前文本串 $t[i]$ 位置与模式串进行对比，指针 $i$ 从始至终都只向右移动。下列模板来自 ACwing831 ，若条件允许，强烈建议购买 ACwing 算法课程，其它模板题亦有 LeetCode28、洛谷3375等等。

#include<bits/stdc++.h>
using namespace std;

#define MAXN 1000010

char txt[MAXN], pat[MAXN];

int nxt[MAXN];
int  main(){
    int n, m;
    scanf("%d %s", &n, pat + 1);
    scanf("%d %s", &m, txt + 1);
    // 显然i = 1不符合条件，此时即既没有非平凡前缀又没有非平凡后缀
    for(int i = 2, j = 0; i <= n; i++){
        while(j && pat[i] != pat[j + 1]) 
            j = nxt[j];
        if(pat[i] == pat[j + 1]) j++;
        nxt[i] = j;
    }
    for(int i = 1, j = 0; i <= m; i++){
        while(j && txt[i] != pat[j + 1])
            j = nxt[j];
        if(txt[i] == pat[j + 1]) j++;
        if(j == n){
            printf("%d ", i - n);
            j = nxt[j];
        }
    }
    printf("\n");
    return 0;
}

　KMP 算法的本质是利用字符串本身蕴含的冗余信息，通俗来说就是利用自身的相同部分来减少比对的次数，很直观的，当出现失配的时候，对于已经比过的、相同的部分，我们显然不需要重新再比对一次。

　当一个字符串是由某个循环节，循环若干次构成的时候，此时字符串蕴含的冗余信息几乎是最理想的状态，KMP 认为所有的字符串均是通过某个循环节，进行若干次循环之后，再截取子串获得的，例如字符串 $cabcabca$ 其实就是通过 $abc$ 循环四次之后所得的文本串 $txt$ 截取 $txt[3,10]$ 部分得到的。下文“KMP理解加深”章节中，我们会继续讨论这一点。

(三)KMP理解加深

(3.1)重复的子字符串问题

　给定一个非空的字符串 $s$ ，检查 $s$ 是否可以通过由其一个子串重复多次构成，假如 $s$ 包含若干子串 $x$ ，不妨记 $s=kx$ ，其中 $k>=2$ ，那么 $s+s=2kx$ ，掐头去尾丢弃两个字符，也就是相当于破坏了头尾部分两个 $x$ 子串，此番操作之后，剩余 $2(k-1)x$ ，由于 $k>=2$ ，代入可知 $s$ 至少会在 $2(k-1)x$ 出现一次，因而只要对于切片 $2s[1:-1]$ 检查是否包含 $s$ 即可知道 $s$ 是否可以通过由其一个子串重复多次构成。

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string cp = "#" + s;
        string txt = "#" + s.substr(1) + s; txt.pop_back();
        vector<int> nxt(cp.size() + 1, 0);
        for(int i = 2, j = 0; i < cp.size(); i++){
            while(j && cp[i] != cp[j + 1])
                j = nxt[j];
            if(cp[i] == cp[j + 1]) j++;
            nxt[i] = j;
        }
        for(int i = 1, j = 0; i < txt.size(); i++){
            while(j && txt[i] != cp[j + 1])
                j = nxt[j];
            if(txt[i] == cp[j + 1]) j++;
            if(j == cp.size() - 1){
                return true;
            }
        }
        return false;
    }
};

　这道题是比较简单的面试题，检查字符串是否可由多个重复的子串构成，本题放在此处主要是为了下一题分析字符串子串循环节长度、循环次数做铺垫。

　为了便于形式化表达，我们不妨使用记号 $nxt^2[j]$ 代表 $nxt[nxt[j]]$ ，以此类推，我们可以写出 $nxt^k[j]$ , 其中 $k$ 是整数，且不大于 $n-1$ ，这种形式化的表达会在下文帮助我们理解 KMP 算法的本质。

(3.2)串周期

　给定一个字符串，其前缀是从第一个字符开始的连续若干个字符，在本例中，我们规定前缀包括字符串本身，例如 $abaab$ 共有前缀 $\{a，ab，aba，abaa，abaab\}$ ，我们希望对每个前缀 $s[1,i]，(i>1)$ 判断是否具有循环节，如果存在循环节，其长度是多少，循环次数是多少。

　对于某一个字符串 $s[1,i]$ ，在其众多的 $nxt[1...i]$ 候选项中，如果存在于一个 $nxt[x],x\in[1...i]$ 使得 $i\%i - nxt[x] = 0$ , 那么 $s[1,i-nxt[x]]$ , 也即第二行图例中的灰色部分，即为 $s[1,i]$ 循环元，其循环次数 $K=i/(i-nxt[x])$ 。

　其实，只要 $s[1,i]$ 是由若干循环节构成的，那么我们要找的 $nxt[x]$ 其实就是 $nxt[i]$ ，因为 $nxt[i]$ 代表着 “失配时指针向左移动最少的位置”，如果存在其它 $nxt[x]，x \neq i$ 同样满足 $i\%i - nxt[x] = 0$ ，则其需要移动的位置一定多于 $nxt[i]$ ，也就是说，此时的 $i-nxt[x]$ 并非最小单元长度。

　举个例子，比如字符串 $abababab$ ，最小的循环节应为 $ab$ ，长度 $2$ ，满足 $8\%2=0$ ，但是 $abab$ 长度 $4$ ，也能构成一个循环节，同样满足 $8\%4=0$ ，但它并非最小循环节。

#include <bits/stdc++.h>
#include <algorithm>
using namespace std;

char str[1000010];
int nxt[1000010];

int n;
int kase;
int main(){
    while(scanf("%d", &n) != EOF){
        if(n == 0) break;
        scanf("%s", str + 1);
        for(int i  = 2, j =0; i <= n; i++){
            while(j && str[i] != str[j + 1])
                j = nxt[j];
            if(str[i] == str[j + 1]){
                j++;
            }
            nxt[i] = j; 
        }
        printf("Test case #%d\n", ++kase);
        for(int i = 2; i <= n; i++){
            if(i % (i - nxt[i]) == 0 && nxt[i]){
                printf("%d %d\n", i, i/(i - nxt[i]));
            }
        }
        printf("\n");
    }
    return 0;
}

　本题能够延伸得到一些其它结论，详见下列条目，其中 $x$ 代表的含义与上文相同：

如果 $i-nxt[i]$ 能够整除 $i$ ，那么 $s[1,i]$ 具有最小循环节，长度 $i-nxt[i]$
如果 $i-nxt[x]$ ，( $x>0$ 且 $x \neq i)$ 能够整除 $i$ ，那么 $s[1,i]$ 具有循环元，长度 $i-nxt[x]$
其余候选项 $nxt[x]$ 均满足 $x > 0, x = nxt^k[i]$ ，其中 $k=1,2,3,4...n-1$
任意一个循环元的长度必然是最小循环元的整数倍
如果 $i-nxt[i]$ 无法整除 $i$ ，那么任意 $i-nxt[x]$ 均不可能作为 $s[1,i]$ 循环元
无论 $m=i-nxt[i]$ 可否整除 $i$ ， $i-nxt[x]$ 都等于若干倍 $m$ ，也即 $i-nxt[x]=bm$

　对于最后一条可能的会使得感到抽象，我们举个例子。使用的 $abc$ 作为循环节反复拼接四次构成新字符串 $abcabcabcabc$ ，然后截取其中一个片段 $cabcabca$ 作为我们接下来分析的文本串 $txt$ ，我们先算这个片段 $nxt$ 数组。

　显然文本串 $txt$ 没有循环节，但是 $8-nxt[8]=3$ ，所得的数值 $3$ 竟然就是我们最初用于构造的 $txt$ 循环节的长度， $8-nxt^2[8]=6$ ，所得数值恰好是循环节的两倍，符合我们上面所说的规律，这是巧合吗？我们接着往下迭代，由于 $nxt^3[8]=0$ 已经不在候选项中了，我们不再往下分析。其实，上述的过程其实并非巧合，相反其恰恰道出了 KMP 算法的本质，也即所有字符串均可通过循环节进行若干次循环之后截取子串得到。通常 $i-nxt[i]$ 即可推算得出用于构造 $s[1,i]$ 文本串的循环节长度。理解了这点，也就不难做出 AC4188连接字符串、UVA10298这几道题了。