字符串匹配（算法导论）

0.KMP

本节图文参考：http://blog.csdn.net/v_july_v/article/details/7041827

失配后，j = next[ j ]

寻找模式串中，各个子串的 { 所有前缀 } & { 所有后缀 } 的最大公共元素长度



最大长度值，整体右移一位就成了next数组

next[ j ]=k 的意思是除当前字符 p[ j ]以外的最长前缀后缀

#include<iostream>
#include<string>
#include<vector>
using namespace std;

void getNext(string &sstr,vector<int> &next)
{
next[0]=-1;//赋值-1，而不是0时，next[0]可以作为哨兵
int sl=sstr.size()-1;
int j=0;
int k=-1;
while(j<sl)
{
if(k==-1||sstr[j]==sstr[k])//sstr[j]是前缀，sstr[k]是后缀
{
++j;
++k;
next[j]=k;
}
else
{
k=next[k];//寻找更小的最长前缀后缀
}
}
}

bool KMP(string &mstr,string &sstr,vector<int> &next)
{
int ml=mstr.size();
int sl=sstr.size();
int i=0;
int j=0;
while(i<ml&&j<sl)
{
if(j==-1||mstr[i]==sstr[j])
{
i++;
j++;
}
else
{
j=next[j];
}
}
if(j==sl)
{
return true;
}
else
{
return false;
}
}

int main()
{
string mstr="BBCABCDABABCDABCDABDE";
string sstr="ABCDABD";
vector<int> next;
for(int i=0;i<sstr.size();i++)
{
next.push_back(-2);
}
getNext(sstr,next);
if(KMP(mstr,sstr,next))
cout<<"YES!"<<endl;
else
cout<<"NO!"<<endl;
}

关于KMP：http://blog.csdn.net/v_july_v/article/details/7041827真的写得很好

KMP中next数组优化
主要思想是：当sstr[ j ] ! = mstr[ i ]时，如果下个比较值sstr[ next [ j ] ]等于sstr[ j ]的话就不用再和s[ i ]比较了，必然会失配

两张图说明一切

#include<iostream>
#include<string>
#include<vector>
using namespace std;

void getNextval(string &sstr,vector<int> &next)
{
next[0]=-1;//赋值-1，而不是0时，next[0]可以作为哨兵
int sl=sstr.size()-1;
int j=0;
int k=-1;
while(j<sl)
{
if(k==-1||sstr[j]==sstr[k])
{
++j;
++k;
if(sstr[j]!=sstr[k])//如果下述先成立，这句的意思就是sstr[j]!=sstr[next[j]]
{
next[j]=k;
}
else
{
next[j]=next[k];
}
}
else
{
k=next[k];//寻找更小的最长前缀后缀
}
}
}

bool KMP(string &mstr,string &sstr,vector<int> &next)
{
int ml=mstr.size();
int sl=sstr.size();
int i=0;
int j=0;
while(i<ml&&j<sl)
{
if(j==-1||mstr[i]==sstr[j])
{
i++;
j++;
}
else
{
j=next[j];
}
}
if(j==sl)
{
return true;
}
else
{
return false;
}
}

int main()
{
string mstr="BBCABCDABABCDABCDABDE";
string sstr="ABCDABD";
vector<int> next;
for(int i=0;i<sstr.size();i++)
{
next.push_back(-2);
}
getNextval(sstr,next);
if(KMP(mstr,sstr,next))
cout<<"YES!"<<endl;
else
cout<<"NO!"<<endl;
}

1.RabinKarp

主要思想是把大的字符串或者字母字符串等映射成小的、数字字符串，（模式串的话，直接映射成一个数字，这样比对的时候就可以x=y一次比对了，而不用像暴力法一样模式串一位一位的比对）这样就可以相较于暴力法快了。

如果模式串转换后的数字太大，可以先mod一个较大的质数。mod所带来的问题是，有些是伪正确（7%10=7,17%10=7），面对这个问题，只要将正确和伪正确（待选目标）用暴力法验证一下就行了（这时候的暴力法是有目标的，而不是盲目的，所以开销不会像纯粹暴力法那样夸张）。

#include<iostream>
#include<string>
#include<vector>
#include<cmath>
using namespace std;
//为方便理解其核心思想，这里假设文本串T和模式串P都是由0~9的数构成。
//而且保证P转成数字之后，不会超出INT_MAX的范围，故也不再取模运算了
bool RabinKarp(string &T,string &P,const int &d)
{
int n=T.size();
int m=P.size();

int h=pow(d+0.0,m-1);//d^(m-1)，类似于存储过程中2^0，2^1，2^2，2^3，2^4一样
int p=0;//转后不变的模式串
int t=0;//转后会变的m长度大小的文本串子串

for(int i=0;i<m;i++)
{
p=d*p+(P[i]-'0');//求模式串的映射值
t=d*t+(T[i]-'0');//求初始时文本串m大小的子串（从0~m-1）的映射值
}
for(int s=0;s<n-m;s++)
{
if(p==t)
{
return true;
}
t=(t-(t/h)*h)*d+(T[m+s]-'0');//向右移一位，更新子串映射值
}
return false;
}
int main()
{
string T="258569236589780";
string P="2365";
if(RabinKarp(T,P,10))
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}