KMP--作用、模板、题单总结（包含题解）

最新推荐文章于 2022-07-09 11:24:23 发布
最新推荐文章于 2022-07-09 11:24:23 发布
阅读量231 收藏 1
点赞数 5
分类专栏： 笔记 文章标签： c语言 算法 acm竞赛 c++ 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48024524/article/details/120726153
版权

模板

#include <cstdio>
#include <cstring>
using namespace std;
int n;
char ts[100];
char ms[100];
int next[100];
int len;
 
void getNext()
{
    int i = 0, j = -1;
    next[0] = -1;
    while (i != len){
        if (j == -1 || ts[i] == ts[j]){
            next[++i] = ++j;
        }
        else
            j = next[j];
    }
}
int KmpMatch(char ms[], char ts[])
{
    int tlen = strlen(ts);
    for(int i = 0, j = 0; ms[i];)
    {
        if(j == -1 || ms[i] == ts[j])
        {
            if(j == tlen - 1)
                return i - tlen + 1;
            else 
                i++, j++;
        }
        else 
            j = next[j];
    }
    return -1;
}

Next数组的各种操作

  • 求最小循环节

看案例意会即可

if (len % (len - nxt[len]) == 0)
	printf("%d\n", len - nxt[len]);

2
abcabcabcabc
-1000123456789

  • next数组的规格

能求到next[n]这一位。

  • 在一个字母序列中，求有没有字母序列在前缀、后缀以及中间都出现。

既然要求三个相同的子串，而且有两个还必须在开头和结尾，那就求Next数组，Next数组存的是前后缀相同的长度，所以只需要找【2*i，L-Next[i]】之间相同的字串，即Next[j]==i;

  • 找循环串的每一个结束

    while(nex[len] != 0)
{
	q.push(nex[len]);
	len = nex[len];
}
while(!q.empty())
{
	printf("%d ",q.top());
	q.pop();
}

  • 补全循环串的最小个数

    (len -nex[len]) -len %(len-nex[len])

KmpMatch函数里的各种操作

  • 求有多少个可分开的子串

    int KmpMatch(char ms[],char ts[])
{
    BuildNext( ts);
    int tlen = strlen(ts);
    for(int i = 0,j = 0; ms[i]; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
        	//这一段是关键
            if(j == tlen-1 )
            {
               con++;
               j = 0;
               i++;
            }
            else
                i++,j++;
        }
        else
            j  = nex[j];
    }
    return -1;
}

  • 求有多少个可以重复的子串

    int KmpMatch(char ms[],char ts[])
{
    int cnt = 0;
    int tlen = strlen(ts);
    for(int i = 0,j = 0; ms[i]; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
            i++;
            j++;
            if(j == tlen)
            {
                //这里是关键
                j = nex[j];
                cnt ++;
            }
        }
        else j = nex[j];
    }
    return cnt;
}

例题

Uva 445 Periodic Strings

#include <cstdio>
#include<iostream>
#include <cstring>
using namespace std;
char str[100];
int nxt[100];
int len;
void getNext()
{
    int i = 0, j = -1;
    nxt[0] = -1;
    while (i != len){
        if (j == -1 || str[i] == str[j]){
            nxt[++i] = ++j;
        }
        else
            j = nxt[j];
    }
}
int main()
{
    scanf("%d", &n);
    while (n--){
        scanf("%s", str);
        len = strlen(str);
        getNext();
        if (len % (len - nxt[len]) == 0)
            printf("%d\n", len - nxt[len]);
        else
            printf("%d\n", len);
        if (n)
            printf("\n");
    }
    return 0;
}

hdu 剪花布条

#include<cstdio>
#include<cstring>
using namespace std;

int nex[100000];
int con;
void BuildNext(char ts[])
{
    nex[0] = -1;
    for(int i = 0, j = -1;ts[i]; )
    {
        if(j == -1 || ts[i] == ts[j])
            nex[++i] = ++j;

        else j = nex[j];
    }
}

int KmpMatch(char ms[],char ts[])
{
    BuildNext( ts);
    int tlen = strlen(ts);
    for(int i = 0,j = 0; ms[i]; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
            if(j == tlen-1 )
            {
               con++;
               j = 0;
               i++;
            }
            else
                i++,j++;
        }
        else
            j  = nex[j];
    }
    return -1;
}

int main()
{
   char ms[10000];
   char ts[10000];
   while(scanf("%s",&ms))
   {
       if(ms[0] =='#') return 0;
       scanf("%s",&ts);
        con = 0;
       KmpMatch(ms,ts);
       printf("%d\n",con);

   }
}

hdu 4847 Wow！Such Doge！

#include<iostream>
#include<cstdio>
#include<cstring>

int doge[10];
int dogE[10];
int doGe[10];
int doGE[10];
int dOge[10];
int dOgE[10];
int dOGe[10];
int dOGE[10];
int Doge[10];
int DogE[10];
int DoGe[10];
int DoGE[10];
int DOge[10];
int DOgE[10];
int DOGe[10];
int DOGE[10];
void Buildnext(int as[],const char ts[])
{
    as[0] = -1;
    for(int i = 0, j = -1; ts[i]; )
    {
        if(j == -1 || ts[i] == ts[j])
            as[++i] = ++j;
        else j = as[j];
    }
}

void init_next()
{
    Buildnext(doge,"doge");
    Buildnext(dogE,"dogE");
    Buildnext(doGe,"doGe");
    Buildnext(doGE,"doGE");
    Buildnext(dOge,"dOge");
    Buildnext(dOGe,"dOGe");
    Buildnext(dOGE,"dOGE");
    Buildnext(Doge,"Doge");
    Buildnext(DogE,"DogE");
    Buildnext(DoGe,"DoGe");
    Buildnext(DoGE,"DoGE");
    Buildnext(DOge,"DOge");
    Buildnext(DOgE,"DOgE");
    Buildnext(DOGe,"DOGe");
    Buildnext(DOGE,"DOGE");
    Buildnext(dOgE,"dOgE");
}

int KmpMatch(char ms[], int nex[], const char ts[])
{
    int cnt = 0;
    for(int i = 0,j = 0;ms[i]; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
            i++;
            j++;
        }
        else j = nex[j];
        if(j == strlen(ts))
        {
            cnt++;
            j = 0;
        }
    }
    return cnt;
}
int main()
{
    int cnt = 0;
    char s1[100000];
    init_next();
    while(scanf("%s",&s1)!= EOF)
    {
        cnt +=KmpMatch(s1,doge,"doge")+KmpMatch(s1,dogE,"dogE")+KmpMatch(s1,doGe,"doGe")+KmpMatch(s1,doGE,"doGE");
        cnt +=KmpMatch(s1,dOge,"dOge")+KmpMatch(s1,dOgE,"dOgE")+KmpMatch(s1,dOGe,"dOGe")+KmpMatch(s1,dOGE,"dOGE");
        cnt +=KmpMatch(s1,Doge,"Doge")+KmpMatch(s1,DogE,"DogE")+KmpMatch(s1,DoGe,"DoGe")+KmpMatch(s1,DoGE,"DoGE");
        cnt +=KmpMatch(s1,DOge,"DOge")+KmpMatch(s1,DOgE,"DOgE")+KmpMatch(s1,DOGe,"DOGe")+KmpMatch(s1,DOGE,"DOGE");
    }
    printf("%d\n",cnt);

}

hdu 1686、poj 3461 Oulipo

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int nex[1000000];

void Buildnext(char ts[])
{
    nex[0] = -1;
    for(int i = 0,j  = -1; ts[i]; )
    {
        if(j == -1 ||ts[i] == ts[j])
            nex[++i] = ++j;
        else j = nex[j];
    }
}

int KmpMatch(char ms[],char ts[])
{
    int cnt = 0;
    int tlen = strlen(ts);
    for(int i = 0,j = 0; ms[i]; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
            i++;
            j++;
            if(j == tlen)
            {
                j = nex[j];
                cnt ++;
            }
        }
        else j = nex[j];


    }
    return cnt;
}

int main()
{
    int t;
    cin>>t;

    while(t--)
    {
        char ts[10000000], ms[10000000];
        scanf("%s %s",&ts,&ms);
        Buildnext(ts);
        printf("%d\n", KmpMatch(ms,ts));

    }
}

hdu 1711 Number Sequence

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

int ts[1000000], ms[1000000];
int nex[1000000];
void Buildnext(int ts[],int len2)
{
    nex[0] = -1;
    for(int i = 0,j  = -1; i<=len2; )
    {
        if(j == -1 ||ts[i] == ts[j])
            nex[++i] = ++j;
        else j = nex[j];
    }
}

int KmpMatch(int ms[],int ts[],int tslen, int len)
{
    int cnt = 0;
    int tlen = tslen;
    for(int i = 0,j = 0; i<len; )
    {
        if(j == -1 || ms[i] == ts[j])
        {
             i++,j++;
        }
        else j = nex[j];
        if(j == tlen )
            {
                return i- tlen + 1;
            }
    }
    return -1;
}

int main()
{
    int t;
    scanf("%d",&t);

    while(t--)
    {

        int len,len2;
        scanf("%d%d",&len,&len2);
        for(int i = 0;i<len; i++) scanf("%d",&ms[i]);
        for(int i = 0;i<len2; i++) scanf("%d",&ts[i]);
        Buildnext(ts,len2);
        int ans =  KmpMatch(ms,ts,len2, len);
        printf("%d\n",ans);

    }
}

hdu 4763 Theme Section（参考）

思路：

既然要求三个相同的子串，而且有两个还必须在开头和结尾，那就求Next数组，Next数组存的是前后缀相同的长度，所以只需要找【2*i，L-Next[i]】之间相同的字串，即Next[j]==i;

#include<stdio.h>
#include<string.h>
#include<string>
#include<algorithm>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int N=1000005;
 
char s[N];
int Next[N],l;
 
void get_Next()
{
    int i=0,j=-1;
    Next[0]=-1;
    while(i<l)
    {
        if(j==-1||s[i]==s[j])
            Next[++i]=++j;
        else
            j=Next[j];
    }
}
 
int KMP()
{
    int i,j;
    for(i=Next[l]; i; i=Next[i])
        for(j=2*i; j<=l-i; j++)
            if(Next[j]==i)
                return i;
    return 0;
}
 
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",s);
        int ans=0,k,i,j;
        l=strlen(s);
        get_Next();
//        for(i=1; i<=l; i++)
//            printf("%d ",Next[i]);
//        printf("\n");
        printf("%d\n",KMP());
    }
    return 0;
}

参考：https://blog.csdn.net/qq_41984014/article/details/81626493?ops_request_misc=&request_id=&biz_id=102&utm_term=theme%20section&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-1-81626493.nonecase&spm=1018.2226.3001.4187

poj 2046 Power Strings

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int nex[1000005];
char ms[1000005];
int cnt;
void BuildNext()
{
    nex[0] = -1;
    for(int i =0,j = -1;ms[i]; )
    {
        if(j == -1 || ms[i] == ms[j])
            nex[++i] = ++j;

        else j = nex[j];
    }
}
int main()
{
    int cyc;
    while(scanf("%s",&ms)!= EOF && strcmp(ms,".") != 0 )
    {
            BuildNext();
            int len = strlen(ms);
           
            cyc = len - nex[len];

            if(len %cyc == 0)
                printf("%d\n", len /cyc);
            else
                printf("1\n");
    }
    return 0;
}

poj 2752 Seek the Name, Seek the Fame

#include<cstdio>
#include<iostream>
#include<cstring>
#include<stack>
using namespace std;
int nex[1000000];
char ms[1000000];
int cnt;
void BuildNext()
{
    nex[0] = -1;
    for(int i =0,j = -1;ms[i]; )
    {
        if(j == -1 || ms[i] == ms[j])
        nex[++i] = ++j;

        else j = nex[j];
    }
}

int main()
{
    while(scanf("%s",&ms) != EOF)
    {
        stack<int>q;
        int len  = strlen(ms);
        BuildNext();
        q.push(len);
        while(nex[len] != 0)
        {
            q.push(nex[len]);
            len = nex[len];
        }
        while(!q.empty())
        {
            printf("%d ",q.top());
            q.pop();
        }
        printf("\n");
    }
}

poj 2185 Milking Grid （难题）

#include<iostream>
#include<cstring>
#include<iostream>
using namespace std;
char cow[10010][80];
char rvercow[80][10010];

int nexrow[10010];
int nexcol[10010];

int row,col;

void getnexrow()
{
    int j = -1,k = 0;
    nexrow[0] = -1;
    while(k < row)
    {
        if(j == -1 || !strcmp(cow[k],cow[j]))
        {
            k++;
            j++;
            nexrow[k] = j;
        }
        else j = nexrow[j];
    }
}

void getnexcol()
{
    int j = -1,k = 0;
    nexcol[0] = -1;
    while(k < col)
    {
        if(j == -1 ||!strcmp(rvercow[k],rvercow[j]))
        {
            j++,k++;
            nexcol[k] = j;
        }
        else
            j = nexcol[j];
    }
}

int main()
{
    while(cin>>row>>col)
    {
        for(int i =0;i < row;i++)
            cin>>cow[i];
        getnexrow();

        for(int i =0; i<row; i++)
            for(int j = 0; j<col; j++)
                rvercow[j][i] = cow[i][j];
        getnexcol();

        int minn = (row - nexrow[row]) * (col - nexcol[col]);
        cout<<minn<<endl;

    }
    return 0;
}

poj 3080 Blue Jeans

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

int nex[1000000];
void BuildNex(string t)
{
    nex[0] = -1;
    int i = 0,j = -1;
    int len = t.length();
    while(i <len)
    {
        if(j == -1 || t[i] == t[j])
        {
            nex[++i] = ++j;
        }
        else j = nex[j];
    }
}
int kmp(string s,string t)
{
    int i = 0, j = 0;
    int lens = s.length(),lent = t.length();
    while(i < lens && j <lent)
    {
        if(j == -1 || s[i] == t[j])
            i++,j++;
        else j = nex[j];

        if(j == lent)
            return i-j+1;
    }
    return -1;
}
int main()
{
    int nn;
    scanf("%d",&nn);
    string s[15];
    while(nn--)
    {
        int n;
        cin>>n;
        for(int i = 0; i<n;i++) cin>>s[i];
        string t;
        string res;
        int ma = 0;
        for(int i = 0;i < 60;i++)
        {
            for(int j = i+1; j<= 60;j++)
            {
                t = string(s[0].begin()+i,s[0].begin()+j);
                BuildNex(t);
                int f = 0;
                for(int k = 1;k<n; k++)
                {
                    if(kmp(s[k],t) == -1)
                    {
                        f = 1;
                        break;
                    }
                }

                if(!f)
                {
                    if(ma<= j-i)
                    {
                        if(ma<j-i) res = t;
                        else res = min(res,t);
                        ma = j - i;
                    }
                }
            }
        }
        if(ma <3) printf("no significant commonalities\n");
        else
            cout<<res<<endl;
    }

}

hdu 1358 Period

#include<cstdio>
#include<iostream>
using namespace std;

int nex[1000005];
char ts[1000005];
void Buildnex(char ts[])
{
    nex[0] = -1;
    for(int i = 0, j = -1;ts[i]; )
    {
        if(j == -1 || ts[i] == ts[j])
            nex[++i] = ++j;
        else j = nex[j];
    }


}
int times;
int main()
{
    int t;
    times = 0;
    while(scanf("%d",&t)!=EOF)
    {
        if(t == 0)
            return 0;
        times++;

            scanf("%s",ts);

        Buildnex(ts);
        printf("Test case #%d\n",times);
        for(int i = 2;i<=t;i++)
        {
            if(i%(i-nex[i]) == 0 && i/(i-nex[i]) > 1)
            {
                cout<<i<<" "<<i/(i-nex[i])<<endl;
            }
        }
        cout<<endl;
    }

}

hdu 3746 Cyclic Nacklace

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int nex[1000005];
char ts[1000005];

void Buildnex(char ts[])
{
    nex[0] = -1;
    for(int i =0,j = -1;ts[i]; )
    {
        if(j == -1 || ts[i] == ts[j])
        {
            nex[++i] = ++j;
        }
        else j = nex[j];
    }
}

int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        scanf("%s",&ts);
        Buildnex(ts);
        int len = strlen(ts);
        if(len % (len -nex[len]) == 0 && len != (len -nex[len]))
            cout<<0<<endl;
        else
        cout<<(len -nex[len]) -len %(len-nex[len])<<endl;

    }
}
CSWish
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
kmp-学习理解记录
01-20
本片是在回忆kmp的时候写下的，最近老师再讲这个，又发现之前写的都忘的差不多了在这里从新写一下笔记，纯小白文字： 基础暴力： 再看kmp的时候我们先来讲讲常规的模式串的暴力匹配，对于常规的一个文本串S以及一个匹配的字串P，最简单的想法就是两个指针，从S和P的头开始匹配，两个指针i，j同时开始出发，然后当i和P的第一个字符匹配的时候然后i，j同时递增，当j走到P的最后，字符串的匹配就完成了，但是如果中间某一段不匹配了就需要回到第一个匹配到P的首字母的i的位置，光打字可能有点难以理解，所以还是拿图说话，这里假设S的字符串为easdkjfassdfwe，然后需要匹配的模式串P为ass。 ok，第一步
算法笔记(一）—— KMP算法练习题
m0_58367586的博客
02-24 1296
1.实现strStr 解法一:暴力匹配(BF)算法 int strStr(char * haystack, char * needle){ assert(haystack!=NULL&&needle!=NULL); int len1=strlen(haystack); int len2=strlen(needle); int i=0,j=0; if(len2==0) { return 0; } if..
KMP习题集
weixin_44412226的博客
05-01 387
模板题 剪花布条 AC代码 #include <bits/stdc++.h> using namespace std; void getNext(char p[],int Next[]){ Next[0]=-1; int i=0,j=-1; int n=strlen(p); while(i<n){ if(j==-1||p[i]==p...
KMP基础题目合集
m0_46260869的博客
07-27 764
kmp首先对字符串进行处理，找到相同前后缀，减少遍历次数，举几个例子 ·a a b a a b a a a -1 0 1 0 1 2 3 4 5 2 ·a b c d a b c a -1 0 0 0 0 1 2 3 1 i/(i-Next[i]) 当前串的长度/循环节的长度 =连续重复数据组数 -1是对Next [0] 数组的初始化，字串与父串分别一个指针，从0开始，如果no match，则子串返回Next值的位置，减少重复对比。 NUSOJ 2867 题意：有T组数据，每组数据有两个数组a，b，长度
java 中模式匹配算法-KMP算法实例详解
08-30
主要介绍了java 中模式匹配算法-KMP算法实例详解的相关资料,需要的朋友可以参考下
KMP算法例题
someng的博客
02-26 899
KMP算法 因为之前已写过KMP算法的总结，在这里就不介绍KMP算法了。借鉴的博客为KMP算法理解 例题一：Youhane Assembler 题目描述 详细描述见此链接 题目分析 本题大意是给出两个字符串s1,s2，要求求出最长公共s1的后缀和s2的前缀。本题主要是运用KMP的思想。将两个字符串链接起来，并且在他们中间加一个’#'作为分隔标志。这样只要求出Next数组，即可求出最长公共前后缀。...
kmp算法总结及题目
qq_40807366的博客
03-12 1486
KMP算法（看毛片算法）是一种改进的字符串匹配算法 KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n) kmp算法中最总要的是next数组，然后什么是next数组呢？ next数组就是优化“看毛片算法”的辅助数组，没有next数组kmp...
数据结构学习笔记——KMP算法中的常见计算题目总结
小宇y的博客
07-09 3325
答：首先设next[1]=，next[2]=（要注意这里的数组是从1开始的，而不是0），如下表：当j=3时，k=next[j-1]=next[2]=1， 此时看S[j-1]=S[2]='b’与S[k]=S[1]='a’是否相等， 由于不相等，所以继续向前查找next值对应的字符来与前一位进行比较，由于通过查找至第一位仍未找到相等的字符，直接将其赋值，即next[i]=；当j=4时，k=next[j-1]=next[3]=1， 此时看S[j-1]=S[3]='a’与S[k]=S[1]='a’是否相等， 由于相
KMP 题单
choice__的博客
01-24 314
https://ac.nowcoder.com/acm/contest/27589 A.[模板]KMP字符串匹配 题意 输出s2s2s2在s1s1s1出现过的位置和s2s2s2的nextnextnext数组。 题解 KMP板子题 代码 #include<bits/stdc++.h> #define ll long long using namespace std; const int maxn = 1e6 + 10; char s[maxn], t[maxn]; int nxt[maxn.
KMP算法题集
逆境出勇者
10-07 1202
模板 caioj 1177 KMP模板 #include&lt;bits/stdc++.h&gt; #define REP(i, a, b) for(register int i = (a); i &lt; (b); i++) #define _for(i, a, b) for(register int i = (a); i &lt;= (b); i++) using namespace s...
template-kmp-library:Kotlin多平台库模板
04-06
模板-kmp-库 Kotlin多平台库模板。 有一个针对多平台库的基线设置，该库支持除弃用的wasm32之外的所有kotlin。 特征 本机目标分组和共享sourceSet 包装程序库模块，它声明对所有lib模块的依赖关系 通过allprojects统一配置 共享测试实用程序的本地test模块（一个帮助程序功能，用于在公用sourceSet中运行协程测试） 本地sandbox模块，可轻松进行库用户方面的检查 发布控制可避免针对可在多个主机上构建的目标进行多次发布 具有自动git-hooks ktlint插件 refreshVersions插件，用于更好的版本控制 可以通过gradle.properties#project.mainOS属性更改发布的主要主机
KMP-suanfa.rar_kmp string
09-14
ＫＭＰ算法　字符串匹配算法　The KMP algorithm string matching algorithm
D-KMP-sample:D-KMP官方样本
03-25
D-KMP体系结构-官方样本 这是D-KMP架构的官方示例，展示了一个适用于Android和iOS的简单主/详细应用程序。 有关D-KMP体系结构的更多信息，请阅读相关的。 D-KMP体系结构的主要功能： 它使用最新的声明性UI工具包：适用于Android的JetpackCompose和适用于iOS的SwiftUI 它通过Kotlin MultiPlatform完全共享ViewModel （和DataLayer ） 它为UI层提供了两种类型的函数：事件函数和StateProvider函数 它实现了MVI模式和单向数据流 它使用Kotlin的StateFlow进行多平台可观察的机制 此样本使用的数据源： webservices （使用 ） 本地设置（使用 ） 其他流行的KMP库，用于连接到不同的数据源： 本地数据库（使用 ） 实时数据库（使用 ） graphQL （使用 ）
kmp算法kmp-algorithm-master.zip
03-22
kmp算法kmp-algorithm-master.zip
kmp算法，kmp-algorithm-master (1).zip
03-22
kmp算法，kmp-algorithm-master (1).zip
模式匹配，KMP算法，string-match-kmp-master.zip
最新发布
03-22
模式匹配，KMP算法，string-match-kmp-master.zip
kmp习题大全
AI_xue
02-19 3524
http://acm.hust.edu.cn/vjudge/contest/view.action?cid=70325#overview kuangbin带你飞专题十六kmp&扩展kmp&manacher A. 题意：给T组数据，每组有长度为n和m的母串和模式串。判断模式串是否是母串的子串，如果是输出最先匹配完成的位置，否则输出-1. 做法：直接套用模板。把char改成int。kmp函数中
KMP算法详解附带练习题
袁君
05-21 3766
KMP算法 1. 简单介绍 KMP算法用作字符串匹配返回匹配成功字符串的起始位置，时间复杂度O(N) Java中自带indexOf函数，indexOf函数是KMP的优化版本，只优化了常数时间。 2.next数组 作用 可以加速匹配的过程，不必暴力匹配 next数组保存的是前缀字符串和后缀字符串最大匹配长度（不包含字符串本身） 实现过程 next[0]默认值为-1，人为规定，用于后续做判断 next[1]=0，当i=1的时候，[0,i-1]范围内只有一个字符，所以前缀长度与后缀长度为0，因为前缀
力扣28. 实现 strStr()（KMP算法，JavaScript）
csD_Dscnnnnnnn的博客
02-10 342
力扣28. 实现 strStr()（KMP算法，JavaScript）
7-1 【模板】kmp字符串匹配 (20 分)
06-28
### 回答1： 题目描述 给定两个字符串 S 和 T，要求在 S 中找到 T 出现的所有位置。 输入格式 第一行输入一个整数 N，表示字符串 S 的长度。 第二行输入字符串 S。 第三行输入一个整数 M，表示字符串 T 的长度。 第四行输入字符串 T。 输出格式 输出所有匹配的位置，每个位置占一行。 如果不存在匹配的位置，输出 -1。 样例 输入样例： 13 ababcabcacbab 3 abc 输出样例： 2 5 8 算法1 (暴力枚举) $O(nm)$ 暴力枚举，时间复杂度 $O(nm)$。 时间复杂度 参考文献 python3 代码 C++ 代码 算法2 (KMP) $O(n+m)$ 时间复杂度 参考文献 C++ 代码 ### 回答2： KMP算法是字符串匹配的经典算法之一，在实际应用中具有非常广泛的应用，尤其是在文本处理、搜索引擎、数据挖掘等领域中都占有非常重要的地位。 KMP算法的核心思想是，当在匹配字符串中发现不匹配的字符时，可以利用已经匹配的部分信息来避免不必要的回溯，从而提高匹配效率。其具体实现的步骤如下： 1. 对于模式串P，求出其每个位置i对应的最长前缀后缀匹配长度next[i]，即next[i]表示P[0:i-1]中最长的既是P的前缀又是P的后缀的子串长度。 2. 在匹配过程中，当主串T与模式串P的某个位置不匹配时，利用已经匹配的部分信息，将模式串向后移动j-next[j]个字符，再次进行匹配。 3. 如果模式串P已经完全匹配了主串T，则表示在T中找到了P，返回匹配的位置。 KMP算法的时间复杂度为O(n+m)，其中n和m分别是主串T和模式串P的长度。相比经典的暴力匹配算法，KMP算法显著提高了匹配的效率，其核心思想也为其他字符串匹配算法的优化提供了宝贵的思路。 ### 回答3： kmp字符串匹配算法是一种高效的字符串匹配算法，它可以在O(n+m)的时间内完成字符串匹配，其中n为文本串的长度，m为模式串的长度。 kmp算法的实现是基于一个模式串前缀数组next数组的构建，next数组表示每个前缀的最长公共前后缀的长度。在匹配文本串和模式串的时候，通过比较匹配过程中的next值来实现跳过多余的比较操作，从而提高匹配效率。 具体的kmp算法实现步骤如下： 1. 构建模式串的前缀数组next数组 2. 在文本串上匹配模式串，比较过程中利用next数组进行跳过多余比较操作。 构建next数组的方法是通过对模式串本身进行遍历，求解每个前缀的最长公共前后缀长度。以模式串“ABABC”的前缀数组为例，其可以表示为： - A的前缀为空集，所以next[0]=-1 - AB的前缀为A，不存在公共前后缀，所以next[1]=0 - ABA的前缀为A和AB，不存在公共前后缀，所以next[2]=0 - ABAB的前缀为A、AB和ABA，前两个前缀没有公共前后缀，最后一个前缀的公共前后缀为A，所以next[3]=1 - ABABC的前缀为A、AB、ABA和ABAB，前三个前缀没有公共前后缀，最后一个前缀的公共前后缀为AB，所以next[4]=2 在匹配文本串和模式串的时候，可以利用next数组来跳过多余的比较操作。当匹配过程中发现模式串与文本串不匹配时，可以根据next数组的值进行模式串的移动，移动的长度为失配字符对应的next值。例如，在文本串“ABABABABC”和模式串“ABABC”匹配过程中，当发现模式串的第三个字符B与文本串的第六个字符C不匹配时，可以根据next[2]的值2将模式串的位置移动到第三个字符B处，而不需要将模式串从头开始进行匹配。 总之，kmp算法的主要思想是通过构建模式串的前缀数组来实现跳过多余的比较操作，在匹配过程中提高效率。其时间复杂度为O(n+m)，是一种常用的字符串匹配算法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值