KMP算法

下面来总结一下用来匹配字符串的KMP算法，以及怎么求next数组。

当然我们可以用笨办法可以进行字符串匹配和求next数组，但是学习算法不就是追求极致的过程么？

通过参考https://blog.csdn.net/sun20209527/article/details/79933237,可以通透的理解KMP是个什么过程,但细节处理和他会有些出入。

举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？

　　

 

我们先说一下next数组代表的是什么？就是一个字符串的每一个子串的前缀后缀的共有元素长度。

以"ABCDABD"为例，

　　－　"A"的前缀和后缀都为空集，共有元素的长度为0；

　　－　"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

　　－　"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

　　－　"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

　　－　"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

　　－　"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

　　－　"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

所以next[0] = 0 ; next[1] = 1 ; next[2] = 0; next[3] = 0 ; next[4] = 1; next[5] = 2 ; next[6] = 0 ;

下面就是KMP的具体过程：

1.

     B与A不匹配，所以搜索词后移一位。

2.

　　因为B与A不匹配，搜索词再往后移。

3.

　　就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

4.

这里出现了空格和D不匹配的现象.

5.

注意：这个操作一次连续移动了4位，我们把已经匹配的ABCDAB字符串的前缀移动到后缀的位置上就可以了！

6.

　　因为空格与A不匹配，继续后移一位。

7.

一直匹配。。。。一直到发现C和D不匹配。

8.

已经匹配的字符串ABCDAB还是把最大的 前缀放到后缀的位置上。然后继续匹配ABCDAB后面的字符。

9.

　　"部分匹配"的实质是，有时候，字符串头部和尾部会有重复。比如，"ABCDAB"之中有两个"AB"，那么我们可以利用next数组记录的信息搜移动之后，就可以来到第二个"AB"的位置。

 

 

#include<iostream>
#include<cstring>
using namespace std;
void getnext(string s,int next[])
{
	int n = s.size();	
	memset(next,0,sizeof(next));
	int k = 0;                      //k代表 最大前后缀长度 
	for(int i = 1,k = 0; i<n; i++)
	{
		while(k>0 && s[k] != s[i])
		{
			k = next[k-1];	
		} 
		
		if(s[i] == s[k])
		{
			k++;
		}
		next[i] = k;
	}

	
}
 //a 是主字符串   b是小字符串 
int kmp(string a,string b,int next[])
{
	
	int n = a.size() , i = 0;           //主字符串的长度，主字符串的下标 
	int m = b.size() , j = 0;			//小字符串的长度，已经匹配的个数 
	
	while(i < n) 
	{
		
		if(j==0)                       //如果小字符串中的第一个元素没有找到与大字符串中有匹配的，那就寻找===  
		{
			if(a[i] == b[j])
			{
				j++;                                      //已经匹配的个数 
			}
			else
			{
				i++;									 //主字符串的 下标 
			}
		}else{                        //已经有匹配的了 
			if(a[i+1] != b[j])    //如果不下一个字符不相等，那就移动小字符串，这个过程操作起来就是更改小字符串的下标。 
			{
				j = next[j-1];
			}	
		
			if(a[i+1] == b[j])  //如果相等那就比较下一个字符 
			{
				i++;
				j++;
				
			 }
	}
		
	    if(j == m)                    //如果小字符串全比较完了，那就是全匹配了，完成！ 否则大字符串中不存在 小字符串！ 
			return i;                //这里返回小字符串在大字符串中最后匹配成功的字符的下标 
	}
	return 0;	
}

int main()
{
	int next[1000];
	string a = "BBC ABCDAB ABCDABCDABDE";

	string b = "ABCDABD";
	
	getNext(next,b);
	

	cout<<"kmp:"<<kmp(a,b,next)<<endl;	
}

这里的求next数组我们可以用笨办法枚举的方法如下：

void getNext(int next[],string s)
{
	memset(next,0,sizeof(next));
	for(int i=0; i<s.size(); i++)
	{
		int ans = 0;
		
		string str = s.substr(0,i+1);
		for(int j=0; j<str.size()-1; j++)
		{
			string str1 = str.substr(0,j+1);			
			string str2 = str.substr(str.size()-j-1,str.size());
			if(str1==str2)
			{
				ans = j+1;
			}
		
		}
		
		next[i] = ans;
	}
} 

 

这样很容易懂，和容易写出来，但是效率很慢！所以在网上找到了一个特别精简的方法！

void getnext(string s,int next[])
{
	int n = s.size();
	memset(next,0,sizeof(next));
	int k = 0;                                  //k代表 最大前后缀长度 
	for(int i = 1,k = 0; i<n; i++)
	{
		while(k>0 && s[k] != s[i])             //精髓！！！！
		{
			k = next[k-1];	
		} 
		
		if(s[i] == s[k])
		{
			k++;
		}
		next[i] = k;
	}

	
}

 

k代表的是前一个字符串最长的前后缀长度 ； a[i]是新加上的字符

这里分几种情况：

1、如果s[0]......s[k-1]和s[i-k].......s[i-1]匹配，并且s[i] == s[k] ，那么next[i] = next[i-1]+1就可以了（简单的情况）

2、但是如果s[i] != s[k]呢？就是上面的标记精简的那段代码！

我们应该利用已经得到的next[0]···next[k-1]来求s[0]···s[k-1]这个子串中最大相同前后缀。因为！！在于s[k]已经和s[i]失配了，而且s[i-k] ··· s[i-1]又与s[0] ···s[k-1]相同，看来s[0]···s[k-1]这么长的子串是用不了了，那么我要找个同样也是s[0]打头、s[k-1]结尾的子串即s[0]···s[j-1](j==next[k-1])，看看它的下一项s[j]是否能和s[i]匹配。

用我们一个例子把：

ABADABA[B]

我们已经知道了 ABADABA的 next[6] = 3，也就是k=3，但是s[3]=D不等于s[7]=B，k= next[k-1] = next[2] =  1,再来比较s[1]和s[i],结果相等，那么next[7]=next[1]+1 = 2;