KMP && Manacher && 扩展KMP整理

KMP算法：

kmp示例代码：

void cal_next(char *str, int *next, int len)
{
    next[0] = -1;//next[0]初始化为-1，-1表示不存在相同的最大前缀和最大后缀
    int k = -1;//k初始化为-1
    for (int q = 1; q <= len-1; q++)
    {
        while (k > -1 && str[k + 1] != str[q])//如果下一个不同，那么k就变成next[k]，注意next[k]是小于k的，无论k取任何值。
        {
            k = next[k];//往前回溯
        }
        if (str[k + 1] == str[q])//如果相同，k++
        {
            k = k + 1;
        }
        next[q] = k;//这个是把算的k的值（就是相同的最大前缀和最大后缀长）赋给next[q]
    }
}
int KMP(char *str, int slen, char *ptr, int plen)
{
    int *next = new int[plen];
    cal_next(ptr, next, plen);//计算next数组
    int k = -1;
    for (int i = 0; i < slen; i++)
    {
        while (k >-1&& ptr[k + 1] != str[i])//ptr和str不匹配，且k>-1（表示ptr和str有部分匹配）
            k = next[k];//往前回溯
        if (ptr[k + 1] == str[i])
            k = k + 1;
        if (k == plen-1)//说明k移动到ptr的最末端
        {
            //cout << "在位置" << i-plen+1<< endl;
            //k = -1;//重新初始化，寻找下一个
            //i = i - plen + 1;//i定位到该位置，外层for循环i++可以继续找下一个（这里默认存在两个匹配字符串可以部分重叠），感谢评论中同学指出错误。
            return i-plen+1;//返回相应的位置
        }
    }
    return -1;  
}
    char *str = "bacbababadababacambabacaddababacasdsd";
    char *ptr = "ababaca";
    int a = KMP(str, 36, ptr, 7);
    return 0;

kmp算法是用来找模式串是否在主串中出现，并返回第一次出现的位置。(模式串一般都比主串长度短，求的是模式串在主串中是否出现)

它有一个数组next[len]（len是ptr字符串的长度），next[i]这里面放的是模式串的前i个字符的最长公共前后缀。(前缀不包括第i个字符)

时间复杂度：O(n+m)

算法过程：

你求的是模式串在主串中出现的位置，next[i]数组是模式串前i个字符的最长公共前后缀。
S1=abadfgag 
S2=abac
next[0]=-1
next[1]=-1
next[2]=1
next[3]=-1
第一次匹配从S1第0位开始，得到S1[0,2]==S2[0,2]
那么下一次匹配还要从S1第1位开始吗？
不需要。kmp优化的就是这里，因为next[2]=1
那么就有S2[0]=S2[2],又因为S1[0,2]==S2[0,2]
所以S1[0]==S1[2],那么我们这次就可以直接从S1第3位开始匹配

具体过程点这里

例题：传送门

题意：

t组输入，给你一个模式串ptr，让你找出来它在str中出现的次数

题解：

利用KMP算法，只需要在kmp原来的基础上稍微改一下就可以用来求次数

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=1000005;
const int INF=0x3f3f3f3f;
char str[maxn],ptr[maxn];
int ans;
void get_next(int len,int *next)
{
    next[0]=-1;
    int k=-1;
    for(int i=1;i<=len-1;++i)
    {
        while(k>-1 && ptr[k+1]!=ptr[i])
            k=next[k];
        if(ptr[k+1]==ptr[i])
        {
            k+=1;
        }
        next[i]=k;
    }
}
void kmp(int slen,int plen)
{
    int next[plen]; //这个next数组长度只能定义plen个长度，大的话会出错 
    get_next(plen,next);
    int k=-1;
    for(int i=0;i<slen;++i)
    {
        while(k>-1 && ptr[k+1]!=str[i])
        {
            k=next[k];
        }
        if(ptr[k+1]==str[i])
        {
            k=k+1;
        }
        if(k==plen-1)
        {
            ans++;
            k=next[k];
            //i=i-plen+1+1;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        ans=0;
        scanf("%s%s",ptr,str);
        int slen=strlen(str);
        int plen=strlen(ptr);
        kmp(slen,plen);
        printf("%d
",ans);
    }
    return 0;
}

有些题目利用next数组的特性来做，比如G - Seek the Name, Seek the Fame

这道题目需要找出来模式串中前后缀的所有相同长度，而不只是求最长

比如“alala”,它的最长相同前后缀是“ala”，但是还有“a”。等到把所有前后缀相同长度输出之后，再输出一下模式串长度就可以了。

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=400005;
const int INF=0x3f3f3f3f;
char ptr[maxn];
int w[maxn];
void get_next(int len,int *next)
{
    next[0]=-1;
    int k=-1;
    for(int i=1;i<=len-1;++i)
    {
        while(k>-1 && ptr[k+1]!=ptr[i])
            k=next[k];
        if(ptr[k+1]==ptr[i])
        {
            k+=1;
        }
        next[i]=k;
    }
}
int main()
{
    int n;
    while(~scanf("%s",ptr))
    {
        int len=strlen(ptr);
        int next[len];
        get_next(len,next);
        int g=0,k=next[len-1];
        //w[g++]=next[len-1]+1;
        while(k>=0)
        {
            w[g++]=k+1;
            k=next[k];

        }
        sort(w,w+g);
        for(int i=0;i<g;++i)
            if(w[i]!=w[i-1] && i!=0)
            printf("%d ",w[i]);
            else if(i==0) printf("%d ",w[i]);
        printf("%d
",len);
    }
    return 0;
}

扩展kmp：

扩展KMP求的是对于原串S1的每一个后缀子串与模式串S2的最长公共前缀。它有一个next[]数组和一个extend[]数组。

next[i]表示为模式串S2中以i为起点的后缀字符串和模式串S2的最长公共前缀长度.

extend[i]表示为以字符串S1中以i为起点的后缀字符串和模式串S2的最长公共前缀长度.

复杂度：拓展kmp算法的总体复杂度为O(n+m)的。其中n为母串的长度，m为子串的长度。

算法过程：

S1=aaabaaaaaab
S2=aaaaab
第一步，我们先对原串S1和模式串S2进行逐一匹配，直到发生不配对的情况。我们可以看到，S1[0]=S2[0],S1[1]=S2[1],S1[2]=S2[2],S1[3] ≠S2[3],此时匹配失败，第一步结束，我们得到S1[0,2]=S2[0,2],即extend[0]=3;

Extend[0]的计算如第一步所示，那么extend[1]的计算是否也要从原串S1的1位置，模式串的0位置开始进行逐一匹配呢？扩展KMP优化的便是这个过程。从extend[0]=3的结果中，我们可以知道，S1[0,2]=S2[0,2],那么S1[1.2]=S2[1,2]。因为next[1]=4,所以S2[1,4]=S2[0,3],即S2[1,2]=S[0,1],可以得出S1[1,2]=S2[1,2]=S2[0,1],然后我们继续匹配，S1[3] ≠S2[3],匹配失败，extend[1]=2;

之后也这样

 

具体过程点这里

给出n组询问，每一组询问包含两个字符串t s，问s中是否包含t。（t中有’?’，’?’可以代替任何字符）。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<algorithm>
using namespace std;
int l1,l2,n;
char s[100009],t[100009];
int nxt[100009];
void next_make()
{
    int t1=0,t2=-1;
    nxt[0]=-1;
    while(t1<l1)
    {
        if(t2==-1||t[t1]==t[t2]||t[t2]=='?') nxt[++t1]=++t2;
        else t2=nxt[t2];
    }
}
void match(int t1,int t2)
{
    while(t1<l1&&t2<l2)
    {
        if(t1==-1||t[t1]==s[t2]||t[t1]=='?') t1++,t2++;
        else t1=nxt[t1];
    }
    if(t1==l1) printf("God bless You!
");
    else printf("Game Over!
");
    return; 
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        cin>>t;cin>>s;
        l1=strlen(t);
        l2=strlen(s);
        next_make();
        match(0,0);
    }
    return 0;
} 

Manacher算法：

当我们遇到字符串为“aaaaaaaaa”，之前的算法就会发生各个回文相互重叠的情况，会产生重复计算，然后就产生了一个问题，能否改进？答案是能，1975年，一个叫Manacher发明了Manacher Algorithm算法，俗称马拉车算法，其时间复杂为O(n)。

例题：

HDU - 3613

给你一个字符串（仅含字母），每个字母有一个价值，把字符串切断成两部分，若其中一部分为回文串，则其价值等于各字母价值和相加；否则为0。总价值为两部分价值相加，求最大价值。

题解：

先用manacher求出回文子串长度，再枚举切割点，若切后子串的中点是回文中心，且回文长度扩展到i点，则这个子串为回文，记录价值。最后输出最大价值。

代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=5e5+10;
char str[maxn*2],s[maxn];
int len,Len[maxn*2],val[maxn],v[30];
void init()
{
    memset(str,0,sizeof(str));
    int k=0;
    str[k++]='$';
    for(int i=1;i<=len;++i)
    {
        str[k++]='#';
        str[k++]=s[i];
    }
    str[k++]='#';
    len=k;
}
void manacher()
{
    Len[0]=0;
    int sum=0;
    int id,mx=0;
    for(int i=1;i<len;++i)
    {
        if(i<mx) Len[i]=min(mx-i,Len[2*id-i]);
        else Len[i]=1;
        while(str[i-Len[i]]==str[i+Len[i]]) Len[i]++;
        if(Len[i]+i>mx)
        {
            mx=Len[i]+i;
            id=i;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        for(int i=0;i<26;++i)
            scanf("%d",&v[i]);
        scanf("%s",s+1);
        len=strlen(s+1);
        for(int i=1;i<=len;++i)
        {
            val[i]=val[i-1]+v[s[i]-'a'];
        }
        int n=len;
        init();
        manacher();
        int ans=0;
        for(int i = 1; i < n; i++){
            int tmp = 0;
            if(Len[i + 1] - 1 == i){
                if(i % 2){
                    tmp += val[i / 2] * 2 + v[s[(i + 1) / 2] - 'a'];
                }
                else{
                    tmp += val[i / 2] * 2;
                }
            }
            if(Len[i + n + 1] - 1 == n - i){
                if((n - i) % 2){
                    tmp += (val[i + (n - i) / 2] - val[i]) * 2 + v[s[i + (n + 1- i) / 2] - 'a'];
                }
                else{
                    tmp += (val[i + (n - i) / 2] - val[i]) * 2;
                }
            }
            ans = max(ans, tmp);
        }
        printf("%d
",ans);
    }
    return 0;
}

板子：

/*  这是一个板子 
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
//算法主体
int maxLcsplength(string str) {
    //空字符串直接返回0
    if (str.length() == 0) {
        return 0;
    }
    //记录下manacher字符串的长度，方便后面使用
    int len = (int)(str.length() * 2 + 1);
    //开辟动态数组chaArr记录manacher化的字符串
    //开辟动态数组pArr记录每个位置的回文半径
    char *chaArr = new char[len];
    int* pArr = new int[len];
    int index = 0;
    for (int i = 0; i < len;i++) {
        chaArr[i] = (i & 1) == 0 ? '#' : str[index++];
    }
    //到此完成对原字符串的manacher化
    //R是最右回文边界，C是R对应的最左回文中心，maxn是记录的最大回文半径
    int R = -1;
    int C = -1;
    int maxn = 0;
    //开始从左到右遍历
    for (int i = 0; i < len; i++) {
        //第一步直接取得可能的最短的回文半径，当i>R时，最短的回文半径是1，反之，最短的回文半径可能是i对应的i'的回文半径或者i到R的距离
        pArr[i] = R > i ? min(R - i, pArr[2 * C - i]) : 1;
        //取最小值后开始从边界暴力匹配，匹配失败就直接退出
        while (i + pArr[i]<len && i - pArr[i]>-1) {
            if (chaArr[i + pArr[i]] == chaArr[i - pArr[i]]) {
                pArr[i]++;
            }
            else {
                break;
            }
        }
        //观察此时R和C是否能够更新
        if (i + pArr[i] > R) {
            R = i + pArr[i];
            C = i;
        }
        //更新最大回文半径的值
        maxn = max(maxn, pArr[i]);
    }
    //记得清空动态数组哦
    delete[] chaArr;
    delete[] pArr;
    //这里解释一下为什么返回值是maxn-1，因为manacherstring的长度和原字符串不同，所以这里得到的最大回文半径其实是原字符串的最大回文子串长度加1，有兴趣的可以自己验证试试
    return maxn - 1;
}
int main()
{
    string s1 = "";
    cout << maxLcsplength(s1) << endl;
    string s2 = "abbbca";
    cout << maxLcsplength(s2) << endl;
    return 0;
}
*/


/* 
#include<stdio.h>
#include<string.h>
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=5e5+10;
char str[maxn*2],s[maxn];
int len,Len[maxn*2],val[maxn],v[30];
void init()
{
    memset(str,0,sizeof(str));
    int k=0;
    str[k++]='$';
    for(int i=1;i<=len;++i)
    {
        str[k++]='#';
        str[k++]=s[i];
    }
    str[k++]='#';
    len=k;
}
void manacher()
{
    Len[0]=0;
    int sum=0;
    int id,mx=0;
    for(int i=1;i<len;++i)
    {
        if(i<mx) Len[i]=min(mx-i,Len[2*id-i]);
        else Len[i]=1;
        while(str[i-Len[i]]==str[i+Len[i]]) Len[i]++;
        if(Len[i]+i>mx)
        {
            mx=Len[i]+i;
            id=i;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        for(int i=0;i<26;++i)
            scanf("%d",&v[i]);
        scanf("%s",s+1);
        len=strlen(s+1);  //3
        
        //printf("%d**
",len); //3
        //init();
        //manacher();
        //printf("%d**
",len);  //8,这个是字符串处理完之后的长度 
        //for(int i=0;i<=len;++i){
        //    printf("%d %d
",i,Len[i]);
        //} 
        
        
        for(int i=1;i<=len;++i)
        {
            val[i]=val[i-1]+v[s[i]-'a'];
        }
        int n=len;
        init();
        manacher();
        int ans=0;
        for(int i = 1; i < n; i++){
            int tmp = 0;
            if(Len[i + 1] - 1 == i){
                if(i % 2){
                    tmp += val[i / 2] * 2 + v[s[(i + 1) / 2] - 'a'];
                }
                else{
                    tmp += val[i / 2] * 2;
                }
            }
            if(Len[i + n + 1] - 1 == n - i){
                if((n - i) % 2){
                    tmp += (val[i + (n - i) / 2] - val[i]) * 2 + v[s[i + (n + 1- i) / 2] - 'a'];
                }
                else{
                    tmp += (val[i + (n - i) / 2] - val[i]) * 2;
                }
            }
            ans = max(ans, tmp);
        }
        printf("%d
",ans);
        
    }
    return 0;
} 
*/



/*

#include <cstdio>

#include <cmath>

#include <cstring>

#include <cstdlib>

#include <iostream>

#include <algorithm>

#include <queue>

#include <stack>

using namespace std;

char a[51000005];

char s[102000005];

int p[51000005];

int maxp,p0,l;

int ans=1;

void manacher()

{

    for(int i=1;i<l;i++)

    {

        if(i<maxp)

        {

            int j=(p0<<1)-i;

            p[i]=min(p[j],p[p0]+p0-i);

        }else

        {

            p[i]=1;

        }

        while(s[i-p[i]]==s[i+p[i]])

        {

            p[i]++;

        }

        if(i+p[i]>maxp)

        {

            p0=i;

            maxp=i+p[i];

        }

    }

}

int main()

{

    scanf("%s",a+1);

    l=strlen(a+1);

    p[1]=1;

    s[0]=s[1]='#';

    for(int i=1;i<=l;i++)

    {

        s[2*i]=a[i];

        s[2*i+1]='#';

    }

    l=(l<<1)+2;

    s[l]='0';

    manacher();

    for(int i=1;i<=l;i++)

    {

        ans=max(ans,p[i]-1);

    }

    printf("%d
",ans);

    return 0;

}

*/ 板子