7.KMP字符串

 

s是长串，p是子串

在数据范围较小时的暴力做法，两层循环

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n, m;
    char s[100], p[100];
    cin >> m >> p + 1; //输入短串
    cin >> n >> s + 1; //输入长串
    for (int i = 1; i <= n; i++) {
        bool flag = true;
        for (int j = 1; j <= m; j++) {
            if (s[i + j - 1] != p[j]) {
                flag = false;
                break;
            }
        }
        if (flag) {
            cout << i << " ";
        }
    }    
    return 0;
}

 KMP习惯下标从1开始

 

 KMP的核心就是在匹配失败时，p串往后最少移动到哪里继续尝试匹配

然后要实现上述操作，KMP的关键点就是：

寻找当前位置的前缀和后缀相等的长度的最大值。

为什么是最大值呢。因为这相当于每次向后移动的距离是最小的。保证不会漏掉可能的匹配起始点

 也就是需要对p串的每一个点进行预处理

上面黑字这句话就是next[]数组的含义

next[i]表示以i为终点的后缀，和从1开始的前缀相等，而且这个后缀的长度最长

如果next[i] = j的话

绿颜色的长度是j

 next[i] = j也就是说对于p串

p[1 ~ j] = p[i - j + 1, i]

然后我们这个next数组在匹配的过程当中是如何运用的

 

 到i - 1，以及到j是匹配的

此时如果s[i] != s[j + 1]的话

然后就需要把红颜色的串，往后移动了

然后就看从前往后最少移动多少

这个最少移动多少就是直接调用next[j]

最少移动的距离就是最大的后缀

对于图中j这个点而言，也就是找到以j这个点为终点的后缀，和从1开始的前缀最长是多少

以j为终点的这一段

 

 和从1开始的这一段相等

对于j这个点，直接调用next[j]

那么p串移动完之后的下标是多少，就是上图p串的绿色小串长度

也就是next[j]

也就是说p串需要移动到next[j]处

 然后当我们把p串换成next[j]处之后

再看p串next[j]后的一个点是不是和s[i]匹配

如果匹配继续往后做，如果不匹配，继续调用next数组，然后再看后面一个点是否和s[i]匹配

举个样例来看p的next[]数组是啥

前缀和后缀的长度一定要小于自己的长度

ne[1] = 0 不能等于自己

ne[i]就是从1~i这一段内的，前缀和后缀相等的最大长度

 

 时间复杂度O(n)

#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 1000010;
char p[N], s[M]; //p是子串，s是原串 
int ne[N]; //next数组，针对子串 
int main() {
    int n, m;
    cin >> n >> p + 1 >> m >> s + 1; //让串的下标从1开始 
    //求next数组[]的过程
    //1失败了就从0开始
    for (int i = 2, j = 0; i <= n; i++) { //是对p串预处理next数组
        while (j && p[i] != p[j + 1]) {
            j = ne[j];
        }
        if (p[i] == p[j + 1]) {
            j++;
        }
        ne[i] = j;
    } 
    //kmp的过程 
    for (int i = 1, j = 0; i <= m; i++) { //i是枚举s[i]
    //注意当前试图和s[i]匹配的是p[j + 1]
        while (j && s[i] != p[j + 1]) {
            //只要j没有退回起点
            j = ne[j];
        }
        if (s[i] == p[j + 1]) {
            j++;
        }
        if (j == n) { //匹配成功
            cout << i - n << " "; //全部匹配完了，然后减去子串长度，就是起始位置
            j = ne[j];
        }
    }
    return 0;
}