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

最新推荐文章于 2024-05-07 20:40:21 发布
原创 最新推荐文章于 2024-05-07 20:40:21 发布 · 483 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #算法 #acm竞赛 #c++ #字符串

本文深入探讨了KMP算法在处理字符串模式匹配中的应用，包括计算Next数组、查找循环串、判断子串重复等。通过实例解析算法细节，并给出多个相关编程题目的解决方案。

模板

#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;

    }
}
数据结构学习笔记——KMP算法中的常见计算题目总结
小宇y的博客
07-09 4022
答：首先设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’是否相等， 由于相
831. KMP字符串（KMP，模板题，@next数组详解）
Landing_on_Mars的博客
04-17 894
给定一个字符串 S，以及一个模式串 P，所有字符串中只包含大小写英文字母以及阿拉伯数字。模式串 P 在字符串 S 中多次作为子串出现。求出模式串 P 在字符串 S 中所有出现的位置的起始下标。
kmp题目
weixin_30430169的博客
05-02 193
大神博客：博客一博客二博客三#include<cstdio>//自己学习了kmp之后打的一个kmp代码，希望有用 #include<cstring> #include<iostream> #include<algorithm> using namespace std; const int maxn = 1e5+5; ...
KMP算法题集
自强不息 厚德载物
10-07 1297
模板 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...
KMP 题单
choice__的博客
01-24 425
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题+KMP模版整理
weixin_30787531的博客
04-17 137
最近稍微看了下KMP，不是很懂他们大神的A题姿势，但是模版总该还是要去学的。 其中next数组的求法有两处区别。 第一种：求主串中模式串的个数。HDU2087 剪花布条和HDU4847Wow! Such Doge!。这两道都比较水可以暴力string::find函数过， 第一个代码： #include<iostream> #include<algorithm&gt...
最新北京大学ACM大学生程序设计竞赛在线题库精选题解 算法分析与设计习题解答
03-25
北京大学ACM大学生程序设计竞赛在线题库精选题解是一份宝贵的学习资源，旨在帮助参赛者提升算法分析与设计的能力。ACM（国际大学生程序设计竞赛）是全球极具影响力的编程比赛，它强调快速解决问题和高效算法的运用。...
USACO 题解及中文译题 1.1.1-2.4.5 C++
04-29
这份压缩包包含了USACO训练教程的部分题解及中文译题，覆盖了从基础到进阶的多个章节，帮助学习者逐步提升编程和算法技能。 1. **基础篇（1.1.1）** - **数据结构基础**：在这一部分，通常会介绍数组、链表、栈和...
leetcode分类-Leetcode:分门别类的Leetcode题解
06-30
- **排序与搜索**：包括快速排序、归并排序、二分查找等经典算法。排序算法是编程的基础，而搜索算法则帮助我们高效地在数据中寻找目标。 - **递归与回溯**：递归是解决问题的一种常用方法，而回溯则是解决组合...
leetcode分类-LeetCode:LeetCode分类题解
06-29
这个压缩包“LeetCode-master”很可能包含了某位开发者整理的LeetCode题目的分类解决方案，便于学习者按照不同的类别查阅和实践。让我们深入探讨一下LeetCode中的主要知识点及其重要性。 1. **基础算法**： - 排序...
KMP算法例题
someng的博客
02-26 1050
KMP算法 因为之前已写过KMP算法的总结，在这里就不介绍KMP算法了。借鉴的博客为KMP算法理解 例题一：Youhane Assembler 题目描述 详细描述见此链接 题目分析 本题大意是给出两个字符串s1,s2，要求求出最长公共s1的后缀和s2的前缀。本题主要是运用KMP的思想。将两个字符串链接起来，并且在他们中间加一个’#'作为分隔标志。这样只要求出Next数组，即可求出最长公共前后缀。...
KMP习题集
weixin_44412226的博客
05-01 461
模板题 剪花布条 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 868
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，长度
力扣28. 实现 strStr()（KMP算法，JavaScript）
csD_Dscnnnnnnn的博客
02-10 429
力扣28. 实现 strStr()（KMP算法，JavaScript）
kmp算法总结及题目
qq_40807366的博客
03-12 1734
KMP算法（看毛片算法）是一种改进的字符串匹配算法 KMP算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数，函数本身包含了模式串的局部匹配信息。时间复杂度O(m+n) kmp算法中最总要的是next数组，然后什么是next数组呢？ next数组就是优化“看毛片算法”的辅助数组，没有next数组kmp...
kmp （字符串匹配算法）题集
最新发布
2201_76011469的博客
05-07 546
（校赛的时候kmp已经忘的差不多了，暴力却没敢写，悔的肠子都青了QAQ）这道题真的很不错，做完以后对kmp的next数组有了更深的认识。（注意不用更新j，因为前面的i满足了那i+1也满足）利用next数组往前找，找到符合要求的答案个数。kmp的一个结论：|S|=border+T。注意这个代码的ans数组是包含重叠情况的。（截止了没法测试对不对，但样例都过了）想要T最小，就要找到最大border。可以利用next数组的原理。（还在整理，纯记录）
KMP算法详解附带练习题
袁君
05-21 4644
KMP算法 1. 简单介绍 KMP算法用作字符串匹配返回匹配成功字符串的起始位置，时间复杂度O(N) Java中自带indexOf函数，indexOf函数是KMP的优化版本，只优化了常数时间。 2.next数组 作用 可以加速匹配的过程，不必暴力匹配 next数组保存的是前缀字符串和后缀字符串最大匹配长度（不包含字符串本身） 实现过程 next[0]默认值为-1，人为规定，用于后续做判断 next[1]=0，当i=1的时候，[0,i-1]范围内只有一个字符，所以前缀长度与后缀长度为0，因为前缀
kmp习题大全
AI_xue
02-19 3653
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练习题集
帅比王的博客
09-30 1158
测试地址 剪花布条 题意简述 原题来自：HDU 2087 一块花布条，里面有些图案，另有一块直接可用的小饰条，里面也有一些图案。对于给定的花布条和小饰条，计算一下能从花布条中尽可能剪出几块小饰条来呢？ 解题思路 就是普通的kmp算法，只不过这里的两个模式串不能重叠，我们基于贪心策略遇到一个选一个即可。 代码示例 #include<bits/stdc++.h> using namespa...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值