串的模式匹配__BF KMP

串的模式匹配的概念

        子串的定位操作是找子串在主串中从第pos个字符后首次出现的位置，又被称为“串的模式匹配”或“串匹配”。

串的模式匹配算法

朴素的模式匹配算法：BF模式匹配算法（Brute_Force算法），又称蛮力匹配算法。

KMP模式匹配算法（Knuth_Morris_Pratt算法）：可以大大避免重复遍历的情况。

BF模式匹配算法

主串为S，模式串为T（⼦串：主串的⼀部分，⼀定存在；模式串——不⼀定能在主串中找到。）

思路：

对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。

从主串S的第pos个字符开始，和模式串T的第一个字符进行比较，若相等，则继续逐个比较后续字符；否则回溯到主串S的第pos+1个字符依次和主串S中的一个连续的字符序列全部相等，则称模式匹配成功，此时返回模式串T的第一个字符在主串S中的位置；否则主串中没有和模式串相等的字符序列，称模式匹配不成功。

//返回子串T在主串中第pos个字符之后的位置，若不存在，则函数返回值为0
//其中，T非空,1<=pos<=StrLength(S)
int Index(String S, String T, int pos)
{
	int i = pos; //用于主串S中当前位置下标值，从pos位置开始匹配
	int j = 1;   //j用于子串T中当前位置下标值
	while(i <= S.len && j <= T.len) //当i小于S的长度并且j小于T的长度时，循环继续
	{
		if (S[i] == T[i]) //两字母相等则继续
		{
			++ i;
			++ j;
		}
		else //指针后退重新匹配
		{
			i = i - j + 2; //i退回到上次匹配首位的下一位
			j = 1;     //j退回子串T的首位
		}
	}
	if (j > T.len)
		return i-T[0];
	else
		return 0;
}

 时间复杂度分析：

1).匹配成功的情况：

a.最好情况即一开始就匹配成功，那么时间复杂度为O(m);

 b.稍微差一些的情况，每次都是首字母不匹配，那么对T串的循环就不必进行了，那么时间复杂度为O(n+m)。时间复杂度为O(n+m)，其中主串长度为n，模式串长度为m。根据等概率原则，平均是(n+m)/2次查找，时间复杂度为O(n+m);

 c.最坏的情况是，每次不成功的匹配都发生在串T的最后一个字符，最坏时间复杂度为O((n-m+1)*m)。

2).匹配失败的情况：

a.最好时间复杂度: O(n-m+1) = O(n-m)=O(n)；
b.最坏时间复杂度：O(n*m)。

KMP模式匹配算法

KMP算法是由D.E.Knuth,J.H.Morris和V.R.Pratt发表的一个模式匹配算法，可以大大避免重复遍历的情况。

思路：

我们在朴素的模式匹配算法中，主串的i值是不断回溯来完成的，但是这种回溯是可以省略的，KMP模式匹配算法就是让这没必要的回溯不再发生。而i值不回溯，也就是i值不可以变小，所以我们就只考虑j值。并且j值的变化与主串没有关系，关键取决于T串的结构中是否有重复的问题。即j值的大小取决于当前字符之前的串的前后缀相似度。因此在查找字符串前，先对要查找的字符串做一个分析，这样可以大大提高查找的速度。

next数组：

把T串各个位置j值的变化定义为一个next数组，next的长度是T串的长度

 

 如果前后缀n个字符相等k值就是n+1。

 求next数组的代码：

//通过计算返回子串T的next数组
void get_next(String T, int *next)
{
	int i,k;
	i = 1;
	k = 0;
	next[1] = 0;
	while (i < T.len)
	{
		if (k == 0 || T[i] == T[k])
		{
			++ i;
			++ k;
			next[i] = k;
		}
		else k = next[k];
	}
}

 KMP代码实现：

//返回子串T在主串S中第pos个字符之后的位置。若不存在，则返回0 
int Index_KMP(String S, String T, int pos)
{
	int i = pos;
	int j = 1; 
	int next[255];
	get_next(T, next);
	while (i <= S.len && j <= T.len) // 当i小于S的长度并且j小于T的长度时，循环继续 
	{
		if (j == 0 || S[i] == T[j])
		{
			++ i;
			++ j;
		}
		else j = next[j];			//j退回合适的位置，i值不变 
	}
	if (j > T.len)
		return i - T.len;
	else
		return 0;
}

时间复杂度分析：

KMP算法关键就是去掉了i值回溯的部分。对于get_next函数来说，若T的长度为m，因只涉及简单的单循环，其时间复杂度为O(m)，而i值的不回溯，使得while循环的时间复杂度为O(n)。所以整个算法的时间复杂度为O(n+m)。值得注意的是，KMP算法仅当模式串与主串之间存在许多“部分匹配”的情况下才体现它的优势，否则两者差异并不明显。

831. KMP字符串

给定一个字符串 S，以及一个模式串 P，所有字符串中只包含大小写英文字母以及阿拉伯数字。

模式串 P 在字符串 S 中多次作为子串出现。

求出模式串 P 在字符串 S 中所有出现的位置的起始下标。

输入格式

第一行输入整数 N，表示字符串 P 的长度。

第二行输入字符串 P。

第三行输入整数 M，表示字符串 S 的长度。

第四行输入字符串 S。

输出格式

共一行，输出所有出现位置的起始下标（下标从 0 开始计数），整数之间用空格隔开。

数据范围

1≤N≤10^5
1≤M≤10^6

输入样例：

3
aba
5
ababa

输出样例：

0 2

#include <bits/stdc++.h>

using namespace std;

const int N = 100010, M = 1000010;

int n, m;
int ne[N];  //next数组
char p[N], s[M];

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;
    
    //求next数组
    for (int i = 2, j = 0; i <= n; i ++)
    {
        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 ++)
    {
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j ++;
        if (j == n)
        {
            printf("%d ", i - n);
            j = ne[j];
        }
    }
    
    return 0;
}

KMP模式匹配算法的改进

总结改进过的KMP算法，它是在计算出next值的同时，如果a位字符与它next值指向的位字符相等，则该a位的nextval就指向b位的nextval值， 如果不等，则该a位的nextval值就是它自己a位的的值。

nextval的求法如下：

void get_nextval(char* t, int* next) 
{
 	int i = 0;
 	int j = -1;
	next[0] = -1;
 	int le = strlen(t);
 	while (i < le-1) {
  		if (j == -1 || t[i] == t[j]) //t[i]表示后缀的单个字符，t[k]表示前缀的单个字符 
		{
   			i ++;
   			j ++;
   			if (t[i] != t[j]) //若当前字符与前缀字符不同，则当前的k为nextval在i位置的值 
    			next[i] = j;
   			else next[i] = next[j];//如果与前缀字符相同，则将前缀字符的nextval值赋值给nextval在i位置的值 
  		}
  		else j = next[j];//若字符不相等，则k回溯 
 	}
}