在字串s1（長為n）中匹配字串s2（長為m）

在不瞭解KMP的時候通常採用暴力法求解，即從s1開始往後逐個比較字元，如果匹配失敗則s1的標記點加一，再從s2開始逐個比較
這樣的話時間複雜度就為O(m*n)。（我之前都是用這種方式，雖然時間長但是能求出來）。

瞭解KMP之前先了解一下 “最長公共前後綴” 比如說一個字串 s2=“abcdabc”則最長公共前後綴為 abc
例如 s1=“abcabcabcabcabcabb” s2=“abcabb” 匹配時

a b c a b cabcabcabcabb
a b c a b b

如上所示當第一次匹配失敗時，按照暴力思維就是將s1標籤後移一位即s1[1]與s2[0]進行比較，以此類推。
而當s1[5]與s2[5]不匹配時，在s1與s2已經匹配的公共字串（上面的 abcab ）裡面找最長公共前後綴即 ab
然後回溯s2到最長公共字首的後一個字元與s1當前字元比較如下

a b cabcabcabcabb
a b cabb

接著繼續進行比較

a b c a b cabcabcabb
a b c a b b

當比較到s2的最後一位時匹配失敗，再回溯s2
a b cabcabcabb
a b cabb

再接著繼續進行比較
a b c a b cabcabb
a b c a b b

失敗後再回溯
a b cabcabb
a b cabb

再往後比較
a b c a b cabb
a b c a b b

失敗再回溯
a b cabb
a b cabb

匹配成功
a b c a b b
a b c a b b

好了，上面就是KMP的思想了，接下來我們解決如何求回溯到哪的問題，回溯到哪就是檢查已經匹配的字元中的最大公共前後綴，然後回溯到字首的後一個字元。
為了方便我們先開一個next陣列用來存放s2的最大公共前後綴。

void funnext(string s,vector<int> & next)
{
	int j,k;
	j=0;k=-1;
	next.push_back(-1);
	while(j<s.length()-1)
	{
		if(k==-1||s[j]==s[k])
		next[++j]=++k;
		else
		k=next[k];
	}
}

接下來就是KMP了

int KMP(string s1,string s2,vector<int> next)
{
	int j,k;
	j=k=0;
	while(j!=s1.length()&&k!=s2.length())
	{
		if(k==-1 || s1[j]==s2[k])
		{
			j++;
			k++;
		}
		else{
			k=next[k];
		}
	}
	if(k==s2.length()){
	return j-k;}
	else
	return -1;
}
 

時間複雜度由 O(m*n) 降到了O(m+n),空間複雜度變成了O(m)
當然了，還可以繼續優化，這裡就不進一步介紹了。
主要難理解的還是k=next[k]吧，哈哈哈。想明白了就行了。