學習筆記——KMP算法

時間 2021-08-12

標籤 html ios git 算法數組函數 post 學習優化 spa 欄目 HTML 简体版

原文原文鏈接

如下均搬運自花姐姐的博客

閒話：$KMP$做爲一個經典的字符串算法，天然值得$OIer$學習，但每每因其實現難、不常考，致使$OIer$不想學~~（話說這不是人之常情嗎）~~，今天，讓咱們來解決這一毒瘤，改變咱們遇字符串就炸的現象吧！html

1、何謂模式串匹配

模式串匹配，就是給定一個須要處理的文本串（理論上應該很長）和一個須要在文本串中搜索的模式串（理論上長度應該遠小於文本串），查詢在該文本串中，給出的模式串的出現有無、次數、位置等。ios

這就至關於$OJ$上判斷程序對錯的過程，$OJ$經過匹配每個字符來判斷輸出結果的正誤，也算是一種模式串匹配。git

2、KMP算法的核心思想

首先，咱們來了解一下$KMP$算法的由來。度娘說算法

KMP算法是一種改進的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的。
所以人們稱它爲克努特—莫里斯—普拉特操做（簡稱KMP算法）。

~~然而，這些偉人我一個也不認識，但這並不妨礙它成爲一個偉大的算法。~~數組

首先，讓咱們來分析一下咱們樸素算法被$T$飛的緣由：咱們用低效的枚舉匹配文本串，致使在最壞狀況下該算法~~（好像也不能叫算法）~~退化成O（文本串長度*匹配串長度），其實也比較好卡，如如下數據函數

文本串：aaaaaaaaaaa......aaaaaaaaab (其中有1e6個a)
模式串：aaaaaaaaaaa......aaaaaaaaab (其中有5e5個a)

那麼，咱們要執行$2.5e6$次計算，會直接致使超時(TLE)post

既然如此，固然輪到咱們KMP算法閃亮登場了！學習

KMP 的精髓在於，對於每次失配以後，我都不會從頭從新開始枚舉，而是根據我已經得知的數據，從「某個特定的位置」開始匹配；而對於模式串的每一位，都有惟一的「特定變化位置」，這個在失配以後的特定變化位置能夠幫助咱們利用已有的數據不用從頭匹配，從而節約時間。優化

舉個栗子spa

文本串:abaabab
模式串:aba

正常的算法（暴力）會在第三個字符以後從新開始匹配，但讓咱們來看一看KMP算法的運行過程

文本串:abaabab
模式串:   	aba

因此，KMP在每次失配以後就能夠跳回以前的某一位，在從該位開始新的一輪匹配。

注意：
1.通常使用模式串來匹配失配數組。

2.匹配位置的肯定。

$str1$ 中，對於每一位 $str1(i) $,它的 $kmp$ 數組應當是記錄一個位置 $j, j≤i$而且知足 $str1(i)=str1(j) $而且在$j!=1 $時理應知足$str1(1)$至 $ str1(j−1) $ 分別與 $str1(i−j+1)~str1(i−1) $ 的每一位相等。

對於2,咱們能夠用前綴和後綴的思想來理解

模式串:abcdabc
前綴:a,ab,abc,abcd,abcda,abcdab,abcdabc
後綴:c,bc,abc,dabc,cdabc,bcdabc,abcdabc

用$kmp$數組記錄到它爲止的模式串前綴的真前綴和真後綴最大相同的位置（注意，這個地方沒有寫錯，是真的有嵌套qwq）。

如上面例子中，前綴和後綴的第三項相同，因此$kmp[7]=3$;

3、講了這麼多，直接上代碼吧

1.$string$類型的$KMP$

int nxt[MAXN];
void getnext(string t){
	int j=0,k=-1;
	nxt[0]=-1;
	while(j<t.size()){
		if(k==-1||t[j]==t[k]) nxt[++j]=++k;
        //1.當k=-1時，確定到頂了，不能再回溯，因此直接賦值
        //2.當t[j]==t[k]時，這個下標的nxt值就是上一個下標的值加1
		else k=nxt[k];//若是尚未找到，就返回上一個可回溯的下標再找
	}
}

void KMP(string s,string t){
	int i=0,j=0;
	while(i<s.size()){
		if(j==-1||s[i]==t[j]){++i;++j;}
        //1.當j=-1時，說明到了邊界，把文本串的指針加1,再從新開始新一輪匹配
        //2.當s[i]==t[j]時，說明匹配到了，那就指針日後移，看下一位可否匹配
		else j=nxt[j];//若是沒有到邊界又沒有匹配到，就回溯看可否從新匹配
		if(j==t.size()){printf("%lld\n",i-t.size()+1);j=nxt[j];}
        //當j==t.size()時，說明已經徹底匹配了，輸出答案，並回溯匹配其餘位置上的合法答案
        //對輸出結果的解釋:i表示到下標爲i的位置時兩串徹底匹配，減去（t.size()-1）就是減去模式串的長度，結果就是匹配的起始位置
	}	
}

2.$char$數組類型的$KMP$

#include <iostream>
#include <cstdio>
#include <cctype>
#include <cstring>
#define il inline
#define ll long long
#define gc getchar
#define int long long
#define R register
using namespace std;
//---------------------初始函數-------------------------------
il int read(){
	R int x=0;R bool f=0;R char ch=gc();
	while(!isdigit(ch)) {f|=ch=='-';ch=gc();}
	while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=gc();}
	return f?-x:x;
}

il int max(int a,int b) {return a>b?a:b;}

il int min(int a,int b) {return a<b?a:b;}


//---------------------初始函數-------------------------------

const int MAXN=1e6+10;
char s1[MAXN],s2[MAXN];
int kmp[MAXN];

signed main(){
	scanf("%s%s",s1+1,s2+1);
    //細節：s1+1表示從下標爲一的位置開始讀入，方便以後的操做
	int lens1=strlen(s1+1),lens2=strlen(s2+1);
    //由於char不像string同樣有不少自帶函數，因此要用<cstring>庫中的函數求長度
	kmp[0]=kmp[1]=0;//初始化
	for(R int j=1,k=0;j<lens2;++j){
		while(k&&s2[j+1]!=s2[k+1]) k=kmp[k];
        //當k>0且s2[j+1]!=s2[k+1]時，說明既沒有到邊界又沒有匹配到，就回溯看可否從新匹配
		if(s2[j+1]==s2[k+1]) ++k;
        //由上面的while循環可知，如今的k必定是匹配的，因此咱們只須要判斷這一位可否比上一位多匹配一個字符
		kmp[j+1]=k;//賦值這一位最多能匹配的字符
	}
	for(R int j=0,k=0;j<lens1;++j){
		while(k&&s1[j+1]!=s2[k+1]) k=kmp[k];
        //當k>0且s2[j+1]!=s2[k+1]時，說明既沒有到邊界又沒有匹配到，就回溯看可否從新匹配
		if(s1[j+1]==s2[k+1]) ++k;
        //由上面的while循環可知，如今的k必定是匹配的，因此咱們只須要判斷這一位可否比上一位多匹配一個字符
		if(k==lens2){printf("%lld\n",j+1-lens2+1);k=kmp[k];}
        //當k==lens2時，說明已經徹底匹配了，輸出答案，並回溯匹配其餘位置上的合法答案
        //對輸出結果的解釋:j表示到下標爲j+1的位置時兩串徹底匹配，減去（lens2-1）就是減去模式串的長度，結果就是匹配的起始位置        
	}
	for(R int i=1;i<=lens2;++i) printf("%lld ",kmp[i]);
	return 0;
}

好了，$KMP$的基本內容到此結束，在加一個時間複雜度分析就完美了。如下引用$rqy$的話：

每次位置指針$i++$時，失配指針$j$至多增長一次，因此$j$至多增長$len$次，從而至多減小$len$次，因此就是$\Theta$（$len_N$+$len_M$)=$\Theta$(N+M)。

其實咱們也能夠發現，$ KMP $算法之因此快，不只僅因爲它的失配處理方案，更重要的是利用前綴後綴的特性，從不會反反覆覆地找，咱們能夠看到代碼裏對於匹配只有一重循環，也就是說 $KMP$ 算法具備一種「最優歷史處理」的性質，而這種性質也是基於$ KMP $的核心思想的。