kmp算法（字符串匹配 next应用 hdu题目集合）

最新推荐文章于 2022-09-02 18:41:01 发布
最新推荐文章于 2022-09-02 18:41:01 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： ××××××算法学习×××××× ------字符串处理------- 字符串------kmp算法 文章标签： kmp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_GSir/article/details/52259378
版权

关于kmp算法的有关解释百度中有很多，可以自己查询更详细部分，其实最主要的就是next数组（以下题目我用的是on，因为hdu中直接用next变量或编译出错），当无法匹配时匹配字串跳转到前串中类似的位置（即是从无法匹配的前一个字符结束的类似字串）


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1686

题意：最简单的kmp应用，模板题，就是给你两个字符串，问你第二串种包含多少个第一个串，可以重叠，只要起始和结束位置不完全一样

题解：kmp算法

代码：

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

using namespace std;
int nexton[10050];
char sons[10050];
char fathers[1000500];
int sum;
void getnext(char *c)
{
    int len=strlen(c);
    int j=-1,i=0;
    nexton[i]=j;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;nexton[i]=j;
        }
        else
        {
            j=nexton[j];
        }
    }
}
int kmp(char *son,char *father)
{
    int slen=strlen(son),flen=strlen(father);
    int i=0,j=0;
    while(i<slen&&j<flen)
    {
        if(i==-1||son[i]==father[j])
        {
            i++;j++;
        }
        else
        {
            i=nexton[i];
        }
        if(i==slen)
        {
            i=nexton[i];
            sum++;
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        sum=0;
        scanf("%s %s",sons,fathers);
        getnext(sons);
        kmp(sons,fathers);
        printf("%d\n",sum);
    }
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=2087

题意：给你两个字符串，找出第一个字符串中包含多少个第二个字符串，不能重叠

题解：kmp算法，区别在于注释部分

代码：

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

using namespace std;
char a[1005];
char b[1005];
int Next[1006];
int sum;
void getNext()
{
    int i=0,j=-1;
    Next[0]=j;
    int len=strlen(a);
    while(i<=len)
    {
        if(j==-1||a[j]==a[i])
        {
            Next[++i]=++j;
        }
        else
        {
            j=Next[j];
        }
    }
    /*for(int i0=0;i0<=len;i0++)
    {
        cout<<next[i0]<<"   ";
    }
    cout<<endl;*/

}
void kmp()
{
    int lena=strlen(a);
    int lenb=strlen(b);
    int i=0,j=0;
    while(i<=lena&&j<=lenb)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        {
            j=Next[j];
        }
        if(j==lenb)//当完全匹配时j要求置零，即是重新开始找
        {
            j=0;
            sum++;
        }
    }
}
int main()
{
    while(~scanf("%s",a)&&a[0]!='#')
    {
        scanf("%s",b);
        getNext();
        sum=0;
        kmp();
        printf("%d\n",sum);
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1867

题意：给你两个字符串，让你把他们合成一个字符串，并且要求字符串中要包含他们（连续），即是若一个字符串前缀和另一个字符串的后缀相同，则把后缀的那个字符串放到前面就可省略另一个字符串的前缀，并且要求保证长度最短，字典序最小

题解：kmp算法，进行两次模式匹配，最后返回的就是第一个字符串的后缀和第二个匹配字符串的前缀的最大匹配，从而进行判断两次哪次最大，选择最大的。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define N 100050

using namespace std;
char a[N];
char b[N];
int on[N];
void  getNext(char *c,int len)
{
    int i=0,j=-1;
    on[0]=-1;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int kmp(char *c,int lenc,char *p,int lenp)
{
    getNext(p,lenp);
    int i=0,j=0;
    while(i<lenc)
    {
        if(j==-1||c[i]==p[j])
        {
            i++;j++;
        }
        else
        {
            j=on[j];
        }
    }
    return j==-1?0:j;
}
int main()
{
    while(~scanf("%s %s",a,b))
    {
        int lena=strlen(a),lenb=strlen(b);
        int da=kmp(b,lenb,a,lena);
        int db=kmp(a,lena,b,lenb);
        if(da<db)
        {
            a[lena-db]='\0';
            printf("%s%s\n",a,b);
        }
        else if(da>db)
        {
            b[lenb-da]='\0';
            printf("%s%s\n",b,a);
        }
        else if(da==0)
        {
            int d=strcmp(a,b);
            if(d>=0)
            {
                b[lenb-db]='\0';
                printf("%s%s\n",b,a);
            }
            else
            {
                a[lena-da]='\0';
                printf("%s%s\n",a,b);
            }
        }
        else
        {
            char t1;
            t1 = a[lena-da];
            a[lena-da] = '\0';
            //printf("%s\n",a);
            string str1(a);
            str1 += b;
            a[lena-da] = t1;
            b[lenb-db] = '\0';
            //printf("%s\n",b);
            string str2(b);
            str2 += a;
            printf("%s\n",min(str1,str2).c_str());
        }
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1358

题意：给你字符串，求从哪个字符为止前面有循环节，若有则输出该字符所在的位置和循环节个数

题解：先求出nexton数组，根据nexton数组（就是kmp中的next数组）的含义求循环节，若满足len%(len-next[i+1])==0&&len!=len-next[i+1]则必存在循环节，并且循环节个数为len/(len-next[i+1])

代码:

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

using namespace std;
int nexton[1000005];
char fathers[1000005];
void getnext(char *c,int len)
{
    int j=-1,i=0;
    nexton[i]=j;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;nexton[i]=j;
        }
        else
        {
            j=nexton[j];
        }
    }
}
int main()
{
    int t;
    int n=1;
    while(scanf("%d",&t)!=EOF&&t)
    {
        scanf("%s",fathers);
        getnext(fathers,t);
        printf("Test case #%d\n",n++);
        for(int i=2;i<=t;i++)
        {
            int d=i-nexton[i];
            if(i%d==0&&nexton[i]!=0)
            {
                printf("%d %d\n",i,i/d);
            }
        }
        printf("\n");
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=2594

题意：给你两个字符串，求一个字符串的前缀和另一个字符串的后缀匹配的最大长度，输出匹配的前缀或后缀

题解：与上面的一道题类似，题解见上

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define N 50000+5

using namespace std;
int nexton[N];
char a[N];
char b[N];
void getnext(char *c,int len)
{
    int i=0;int j=-1;
    nexton[i]=j;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;nexton[i]=j;
        }
        else
        {
            j=nexton[j];
        }
    }
}
int kmp(char *s,int slen,char *f,int flen)
{
    int i=0;int j=0;
    getnext(s,slen);
    while(j<flen)
    {
        if(i==-1||s[i]==f[j])
        {
            i++;j++;
        }
        else
        {
            i=nexton[i];
        }
    }
    return i==-1?0:i;
}
int main()
{
    while(scanf("%s %s",a,b)!=EOF)
    {
        int alen=strlen(a);
        int blen=strlen(b);
        int da=kmp(a,alen,b,blen);
        if(da==0)
        {
            printf("0\n");
        }
        else
        {
            a[da]='\0';
            printf("%s %d\n",a,da);
        }
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1711

题意：给定两个数字数组，要求第二个数字数组在第一个数组中匹配的起始点，输出最小的起始点

题解：简单的kmp应用，返回第一个匹配即可

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
 #define N 1000050

using namespace std;
int on[N];
int father[N];
int son[N];
void getnext(int *s,int slen)
{
    int i=1,j=0;
    on[1]=j;
    while(i<=slen)
    {
        if(j==0||s[i]==s[j])
        {
            i++;j++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int kmp(int *s,int slen,int *f,int flen)
{
    int i=1,j=1;
    while(j<=flen)
    {
        if(i==0||s[i]==f[j])
        {
            i++;j++;
        }
        else
        {
            i=on[i];
        }
        if(i==slen+1)
        {
            return j-i+1;
        }
    }
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n,m;
        scanf("%d %d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&father[i]);
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&son[i]);
        }
        getnext(son,m);
        int d=kmp(son,m,father,n);
        if(!d){printf("-1\n");}
        else{printf("%d\n",d);}
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=3746

题意：给你一个字符串，求最小添加多少个字符就可完成循环

题解：先求出next数组，通过len%(len-next[len])==0&&len!=len-next[len]判断1-i是否已经构成不止一个的循环节，则直接输出0，不用再添加，若不满足，要通过(len-next[len])-len%(len-next[len])来求出要补充的循环节

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define N 100050

using namespace std;
int on[N];
char son[N];
void getNext(int slen)
{
    int i=0,j=-1;
    on[i]=j;
    while(i<=slen)
    {
        if(j==-1||son[i]==son[j])
        {
            i++;j++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s",son);
        int len=strlen(son);
        getNext(len);
        if(len%(len-on[len])==0&&len!=(len-on[len]))
        {
            printf("0\n");
        }
        else
        {
            printf("%d\n",(len-on[len])-len%(len-on[len]));
        }
    }
    return 0;
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=3336

题意：统计前缀值，包括与前缀相同但不再前缀而在字符串中的数量

题解：利用kmp中的next数组一个个进行判断，next数组就是相对于前缀求出的，方便统计数量

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define N  200050
using namespace std;
int  on[N];
char son[N];
void getnext(int len)
{
    int i=0,j=-1;
    on[i]=j;
    while(i<=len)
    {
        if(j==-1||son[i]==son[j])
        {
            j++;i++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        scanf("%s",son);
        getnext(n);
        int sum=0;
        for(int i=1;i<=n;i++)
        {
            int j=on[i];
            sum=(sum+1)%10007;
            while(j)
            {
                sum=(sum+1)%10007;
                j=on[j];
            }
        }
        printf("%d\n",sum);
    }
}


题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=1841

题意：给你两个字符串，要求合成一个字符串（包含两个字符串的内容）

题解：简单kmp应用

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<set>
#define N  1000050

using namespace std;
int on[N];
char a[N];
char b[N];

void getnext(char *c,int len)
{
    int i=0,j=-1;
    on[i]=j;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int kmp(char *s,int slen,char *f,int flen)
{
     getnext(s,slen);
     int i=0,j=0;
     while(j<slen&&i<flen)
     {
         if(j==-1||s[j]==f[i])
         {
             i++;j++;
         }
         else
         {
             j=on[j];
         }
     }
     return j==-1?0:j;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s %s",a,b);
        int lena=strlen(a);
        int lenb=strlen(b);
        int da=kmp(a,lena,b,lenb);
        int db=kmp(b,lenb,a,lena);
        printf("%d\n",lena+lenb-max(da,db));
    }
    return 0;
}

题目：http://acm.split.hdu.edu.cn/showproblem.php?pid=3613

题意：给定一个字符串和一个26个价值的数组(代表26字母对应的价值)，要求分成两段，其中如果一段满足回文，价值为价值和，否则为0

题解：求正反字符串的匹配，即求最长后缀的回文串和最长前缀的回文串，两者统一进行考虑

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<set>
#define N  500050

using namespace std;
int on[N];
char a[N];
char b[N];
int zi[28];
int first[N];//记录前缀的回文串标记
int last[N];//记录后缀的回文串标记
int sum[N];//记录左边有i个时的价值

void getnext(char *c,int len)
{
    int i=0,j=-1;
    on[i]=j;
    while(i<=len)
    {
        if(j==-1||c[i]==c[j])
        {
            i++;j++;on[i]=j;
        }
        else
        {
            j=on[j];
        }
    }
}
int kmp(char *s,int slen,char *f,int flen)
{
     getnext(s,slen);
     int i=0,j=0;
     while(j<slen&&i<flen)
     {
         if(j==-1||s[j]==f[i])
         {
             i++;j++;
         }
         else
         {
             j=on[j];
         }
     }
     return j;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        for(int i=0;i<26;i++) scanf("%d",&zi[i]);
        scanf("%s",a);
        int lena=strlen(a);
        sum[0]=0;
        for(int i=1;i<=lena;i++){b[lena-i]=a[i-1];sum[i]=sum[i-1]+zi[a[i-1]-'a'];}
        int da=kmp(a,lena,b,lena);//最大前串
        while(da){first[da]=t+1;da=on[da];}
        int db=kmp(b,lena,a,lena);
        while(db){last[db]=t+1;db=on[db];}
        int sum2=0;
        int ans=0;
        for(int i=1;i<lena;i++)
        {
            if(first[i]==t+1)sum2+=sum[i];
            if(last[lena-i]==t+1)sum2+=sum[lena]-sum[i];
            if(sum2>ans)ans=sum2;
            sum2=0;
        }
        printf("%d\n",ans);
    }
    return 0;
}



M_GSir
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KMP算法（next数组的详细理解和leetcode题目）
qq_45962712的博客
09-17 806
KMP算法 1.应用场景 1.1 介绍： KMP 算法（Knuth-Morris-Pratt 算法）是一个著名的字符串匹配算法，效率很高，但是确实有点复杂。 1.2 应用： 在实际生活中，字符串查找是非常常见的，在一段信息中匹配到你需要寻找的信息（就是在一段字符串找到需要匹配的字符串），那么怎样去寻找呢？ 1.2.1 与寻常的暴力匹配寻找，它有怎样的优化 我们运用暴力匹配的时候，每次都匹配了很多此无意义的字符，什么意思呢？ 请看： 我们从这里开始匹配 因为主串【i】和匹配串【j】一直不相等，所以主串右移 [
KMP算法 → 计算next数组
hnjzsyjyj的专栏
09-28 9956
若在KMP算法设计中，将模式串下标从0开始计数，则定义next[0]=-1，next[1]=0。那么求next数组的算法步骤为： （1）若第j-1位的字符与第x位的字符相等，则next[j]=x+1； （2）若直到第0位依然没有字符与第j-1位的字符相等，则next[j]=0。
Count the string
nankeyimeng的博客
12-24 1194
Total Submission(s) : 22   Accepted Submission(s) : 11 Problem Description It is well known that AekdyCoin is good at string problems as well as number theory problems. When given a string s, we
老大难的KMP
HFGD2019的博客
10-01 228
学习自，微信公众号，代码随想录，膜拜Carl大佬！ 文章地址 1.何为KMP 其实是三个人的名字缩写，分别为Knuth，Morris和Pratt。 KMP主要应用在字符串匹配上，主要思想是**当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了 那么如何记录这些信息呢？？？这是KMP的重点，也是next数组所包含的意义！所以在接下来的学习和应用中，要深刻理解next数组里的数字表示的是什么，为什么这么表示？ 2.前缀表 next数组其实就是一个前缀表，是用来回溯的
c语言 静态数组实现fifo 代码_KMP算法中next数组的求法及代码实现【C++】
weixin_39830175的博客
11-21 163
一直以来都对字符串匹配 kmp 算法的理解模棱两可，今天经过一个多小时的钻研算是有了比较深入的理解，顺便在这里记录一下。这里主要记录一下 kmp 算法中 next 数组的求法。简单地说，对于模式串的某一位置j，next[j]的值是该模式串从下标0到j - 1的子串最大相等前缀与后缀数，下面举个例子加以说明。模式串pattern及其对应的下标如下图所示：位置 0 上的元素 a 前面没有子串，因此这里...
KMP(字符串匹配)算法
08-20
程序开发过程中的字符串匹配算法很多，这里出了算法的程序源代码，包括C#，C++, Delphi代码,大家直接下载就可以拷贝到自己程序中使用。
KMP.rar_KMP_KMP算法_串 KMP算法_字符串匹配
09-24
《KMP算法详解——高效字符串匹配的秘密》 ...总的来说，KMP算法以其高效性和广泛的应用性，成为字符串匹配领域不可或缺的一部分。通过理解和掌握KMP算法，不仅可以提升编程技能，还能为解决实际问题提供有力的工具。
KMP算法字符串匹配算法介绍说明.zip
最新发布
05-23
**KMP算法字符串匹配算法** KMP算法，全称为Knuth-Morris-Pratt算法，是一种在文本中高效地寻找模式串（子串）在主串（目标串）中出现位置的字符串匹配算法。该算法由D.M. Knuth、J.H. Morris和V.R. Pratt于1970年...
Python实现字符串匹配的KMP算法
09-19
KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。这篇文章主要介绍了Python实现字符串匹配的KMP算法,需要的朋友可以参考下
kmp算法-基于Python+kmp算法实现模糊文本字符串匹配.zip
03-22
《Python实现KMP算法：模糊文本字符串匹配》 在信息技术领域，字符串匹配是常见的操作，尤其是在文本处理、数据挖掘和搜索引擎优化中。其中，KMP（Knuth-Morris-Pratt）算法是一种高效的字符串匹配算法，它能有效地...
KMP算法中的next数组求解
guishangppy的博客
09-02 9513
求解KMP算法中的next数组
HDU训练记录1：KMP
zyf2000
04-04 675
我可以接受失败，但绝对不能接受未奋斗过的自己。
hdu__KMP算法模板题【持续更新中】
Fighting!
08-22 4550
剪花布条                                                                           Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
KMP-hdu1711
WilliamSun0122的博客
07-20 2691
KMPKMP算法又称“看毛片”算法，是一种效率非常高的字符串匹配算法。kmp算法完成的任务是：给定两个字符串O和f，长度分别为n和m，判断f是否在O中出现，如果出现则返回出现的位置。常规方法是遍历a的每一个位置，然后从该位置开始和b进行匹配，但是这种方法的复杂度是O(nm)。kmp算法通过一个O(m)的预处理，使匹配的复杂度降为O(n+m)。思想：我们首先用一个图来描述kmp算法的思想。在字符串O中
KMP~~算法+HDU1686
gao506440410的博客
08-18 180
KMP算法主要应用于字符串的匹配。 对于正常的字符串模式匹配，主串长度为m，子串为n，时间复杂度会到达O（m*n），而如果用KMP算法，复杂度将会减少线型时间O（m+n）。   设主串为ptr="ababaaababaa";，要比较的子串为a=“aab”；   KMP算法用到了next数组，然后利用next数组的值来提高匹配速度，我首先讲一下next数组怎么求，之后再讲匹配方式。   ...
hdu4673（KMP）
小糊涂的博客
01-18 238
https://vjudge.net/contest/350701#problem/F 题目描述 给定一个字符串S，要求你找到一个最长的子串，它既是S的前缀，也是S的后缀，并且在S的内部也出现过(非端点) 题解 KMP的失配函数fail[i]的值就是s[0..i]的最长前缀且是后缀的长度~~~，因此我们从S的末尾位置开始沿着失配函数跑即可，对于当前fail[i],判断前缀...
HDU 2594 (KMP入门)
Phoenix
08-24 508
关于学习KMP的姿势，是通过这篇博文来的从头到尾彻底理解KMP 文章写得非常的详细，所以我这个弱渣就没必要再谈一遍辣~~(>_ 个人领悟的KMP就是保持主串不动，通过一个next数组来移动匹配串，最终达到高效率匹配字符作用的一种算法=。= 巨巨说KMP是纯模板题。。。。。。 ——————————————————————————————————————————————————————————
KMP hdu2594
qq_35539135的博客
11-21 240
#include #include #include using namespace std; char s1[100010],s2[50001]; int to[100010]; void getnext(char *a){ int i=-1,j=0,len=strlen(a); to[0]=-1; while(j<len){
经典KMP算法回顾
寻找&星空の孩子
09-11 1395
详细内容可以看百科：http://baike.sogou.com/v592179.htm  我主要讲自己的理解 KMP是字符串的模式匹配算法，时间复杂度为O(m+n)即O(n) 通过下面的代码进一步分析： #include #include #define MM 50005 int next[MM]; char s[MM];//模拟串 char t[MM];//匹配串 /*
34丨字符串匹配基础（下）：如何借助BM算法轻松理解KMP算法？1
08-03
本节课程中，王争老师以“34 | 字符串匹配基础（下）：如何借助BM算法轻松理解KMP算法？”为题，深入讲解了KMP算法的基本原理及其与BM算法的联系。在主串和模式串匹配的过程中，KMP算法通过寻找规律，实现快速滑动...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值