KMP+MANACHER题目总结

最新推荐文章于 2024-02-20 19:38:50 发布
最新推荐文章于 2024-02-20 19:38:50 发布
阅读量211 收藏
点赞数
分类专栏： ACM KMP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanshan1111/article/details/102309936
版权

给出两个串S T，A操作S，B操作T。A先手，两人必须选择一种操作：翻转 23000->32  、  /10。S包含T了A胜利。

思路：先将T串末尾的0去掉，然后用T去匹配S和S的反串。

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include <queue>
#define maxs 2020202
#define mme(i,j) memset(i,j,sizeof(i))
using namespace std;
char s[1000005],s2[1000005];
int nexts[maxs];
 
void getn()
{
    int len=strlen(s2);
    int i=0,j;
    j=nexts[0]=-1;
    for(i=0;i<len;)
    {
        if(j==-1 || s2[i]==s2[j])
            nexts[++i]=++j;
        else
            j=nexts[j];
    }
}
 
bool kmp()
{
    getn();
    int len1=strlen(s),len2=strlen(s2);
    int i=0,j=0;
    for(i=0;i<len1;)
    {
        if(j==-1||s[i]==s2[j])
        {
            i++;
            j++;
        }
        else
            j=nexts[j];
        if(j>=len2)
            return 1;
    }
    if(j>=len2)
        return 1;
    return 0;
}
 
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%s%s",s,s2);
        int flag = 1;
        for(int i=0;s2[i];i++){
            if(s2[i]=='0') continue;
            flag = 0 ;break;
        }
 
        int l2 = strlen(s2);
        for(int i=l2-1;i>=0;i--){
            if(s2[i]=='0')
                s2[i]='\0';
            else break;
        }
        if(flag||kmp())
        {
            printf("Alice\n");
        }
        else
        {
            reverse(s2,s2+strlen(s2));
 
            if(kmp())
            {
                printf("Alice\n");
            }
            else printf("Bob\n");
 
        }
    }
}

给出两个数组，让你在任意一个数组中取任意一段连续子序列，让其是另外一个数组的子串，求这个合法子段的最长长度。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
struct node
{
    int x,y;
}now,nex;
char mp[505][505];
int step[505][505];
int numa[505];
int numb[505];
int fx[4]={0,0,1,-1};
int fy[4]={1,-1,0,0};
int a[500];
int b[500];
int naxt[2500];
int conta,contb,n,m;
int lena,lenb;
int Bfs()
{
    queue<node >s;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            step[i][j]=0x3f3f3f3f;
            if((i==0&&j==0)||(i==n-1&&j==m-1)||(i==n-1&&j==0)||(i==0&&j==m-1))
            {
                now.x=i;
                now.y=j;
                step[i][j]=0;
                s.push(now);
            }
        }
    }
    while(!s.empty())
    {
        now=s.front();
        s.pop();
        for(int i=0;i<4;i++)
        {
            nex.x=now.x+fx[i];
            nex.y=now.y+fy[i];
            if(nex.x>=0&&nex.x<n&&nex.y>=0&&nex.y<m&&mp[nex.x][nex.y]!='#')
            {
                if(step[nex.x][nex.y]>step[now.x][now.y]+1)
                {
                    step[nex.x][nex.y]=step[now.x][now.y]+1;
                    s.push(nex);
                }
            }
        }
    }
    return 0;
}
void set_naxt()//子串的naxt数组
{
    int i=0,j=-1;
    naxt[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            naxt[i]=j;
        }
        else
        j=naxt[j];
    }
}
 
int KMP()
{
    int maxnlen=0;
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
            maxnlen=max(j,maxnlen);
        }
        else
        {
            maxnlen=max(j,maxnlen);
            j=naxt[j];
        }
        if(j==lenb)
        {
            return lenb;
        }
    }
    return maxnlen;
}
int main()
{
    while(~scanf("%d%d%d%d",&conta,&contb,&m,&n))
    {
        for(int i=0;i<n;i++)scanf("%s",mp[i]);
        Bfs();
        for(int i=0;i<conta;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            numa[i]=step[x][y];
        }
        for(int i=0;i<contb;i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            numb[i]=step[x][y];
        }
        sort(numa,numa+conta);
        sort(numb,numb+contb);
        for(int i=0;i<conta;i++)
        {
            if(numa[i]==0x3f3f3f3f)
            {
                conta=i;
                break;
            }
        }
        for(int i=0;i<contb;i++)
        {
            if(numb[i]==0x3f3f3f3f)
            {
                contb=i;
                break;
            }
        }
        int output=0;
        if(conta<contb)
        {
            lena=contb;
            for(int i=0;i<contb;i++)
            {
                a[i]=numb[i];
            }
            for(int i=0;i<conta;i++)
            {
                lenb=0;
                for(int j=i;j<conta;j++)
                {
                    b[lenb++]=numa[j];
                }
                output=max(KMP(),output);
            }
        }
        else
        {
            lena=conta;
            for(int i=0;i<conta;i++)
            {
                a[i]=numa[i];
            }
            for(int i=0;i<contb;i++)
            {
                lenb=0;
                for(int j=i;j<contb;j++)
                {
                    b[lenb++]=numb[j];
                }
                output=max(KMP(),output);
            }
        }
        printf("%d\n",output);
    }
}

给出两个串S T，可以任意次使得T串减去X（>=0或<0）问有多少个修改过的T串出现在S串中

求出差值，然后进行KMP匹配

#include<stdio.h>
#include<string.h>
using namespace std;
int tmpa[2500050];
int tmpb[2500050];
int a[250050];
int b[250050];
int next[250050];
int n,m;
int lena;
int lenb;
int output;
void set_naxt()//子串的next数组
{
    int i=0,j=-1;
    next[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            next[i]=j;
        }
        else
        j=next[j];
    }
}
 
int kmp()
{
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        j=next[j];
        if(j==lenb)
        {
            output++;
            j=next[j];
            //printf("%d\n",j);
        }
    }
    return -1;
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=0;i<n;i++)scanf("%d",&tmpa[i]);
        for(int i=0;i<m;i++)scanf("%d",&tmpb[i]);
        if(m==1)
        {
            printf("%d\n",n);
            continue;
        }
        for(int i=0;i<n-1;i++)tmpa[i]=tmpa[i]-tmpa[i+1];
        for(int i=0;i<m-1;i++)tmpb[i]=tmpb[i]-tmpb[i+1];
        lena=n-1;
        lenb=m-1;
        for(int i=0;i<n-1;i++)a[i]=tmpa[i];
        for(int i=0;i<m-1;i++)b[i]=tmpb[i];
        output=0;
        kmp();
        printf("%d\n",output);
    }
}

给出N个字符串，求最大的I使得在I之前至少有一个字符串不是I的子串

枚举第i个字符串，第二重设置个l，若有满足题意的情况直接跳出，否则l一直左移，因为若xj<i，且xj都是i的子串，那么不必再判断xj与i+1的关系

AA

AAA

AAAB

AAABBB讨论这个的时候，只需要和AAAB比较，不必和以前的比了。

#include<string.h>
#include<stdio.h>
using namespace std;
char aa[600][5000];
char a[200005];
char b[2005];
int next[2005];
int lena;
int lenb;
void set_naxt()//子串的next数组
{
    int i=0,j=-1;
    next[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            next[i]=j;
        }
        else
        j=next[j];
    }
}
 
int kmp()
{
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        j=next[j];
        if(j==lenb)
        return 1;
    }
    return 0;
}
int main()
{
    int t;
    int kase=0;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%s",aa[i]);
        }
        int l=0;
        int ans=-1;
        printf("Case #%d: ",++kase);
        for(int i=1;i<n;i++)
        {
            while(l<i)
            {
                strcpy(a,aa[i]);
                strcpy(b,aa[l]);
                lena=strlen(a);
                lenb=strlen(b);
                if(kmp()==1)
                {
                    l++;
                }
                else
                {
                    ans=i+1;
                    break;
                }
            }
        }
        printf("%d\n",ans);
    }
}

给出S串和T串，求最少的分解使得分解的子串可以顺序或逆序出现在S中，并求位置。

暴力枚举T的子串，设置L=0 R=0  若在S顺序串或逆序串中匹配，其不断使得RR++。不能匹配后设置L=R，然后继续找下一个子串。

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int nextt[40000];
char raa[40000];
char aa[40000];
char bb[40000];
char cc[40000];
char a[40000];
char b[4000];
int ans[400000][2];
int lena,lenb,contz,flagr,lenaa,lenbb;
void set_naxt()//子串的nextt数组
{
    int i=0,j=-1;
    nextt[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            nextt[i]=j;
        }
        else
        j=nextt[j];
    }
}
 
int KMP()
{
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        j=nextt[j];
        if(j==lenb)
        {
            if(flagr==0)
            {
                ans[contz][0]=i-lenb+1;
                ans[contz][1]=i;
            }
            else
            {
                ans[contz][0]=lenaa-(i-lenb+1)+1;
                ans[contz][1]=lenaa-i+1;
            }
            return 1;
        }
    }
    return -1;
}
//b匹配a
int main()
{
    while(~scanf("%s%s",raa,bb))
    {
        contz=0;
        lenaa=strlen(raa);
        lenbb=strlen(bb);
        strcpy(aa,raa);
        reverse(raa,raa+lenaa);
        int ll=0;
        int rr=0;
        while(ll<lenbb)
        {
            int flag=0;
            while(rr<lenbb)
            {
                strcpy(a,aa);
                flagr=0;
                int cont=0;
                for(int j=ll;j<=rr;j++)
                {
                    b[cont++]=bb[j];
                }
                b[cont]='\0';
                lena=lenaa;
                lenb=rr-ll+1;
                if(KMP()==1)
                {
                    flag=1;
                    rr++;
                    continue;
                }
                else
                {
                    strcpy(a,raa);
                    flagr=1;
                    int cont=0;
                    lena=lenaa;
                    lenb=rr-ll+1;
                    for(int j=ll;j<=rr;j++)
                    {
                        b[cont++]=bb[j];
                    }
                    b[cont]='\0';
                    if(KMP()==1)
                    {
                        flag=1;
                        rr++;
                        continue;
                    }
                    else  break;
                }
                if(flag==0)break;
            }
            if(flag==0)break;
            contz++;
            ll=rr;
        }
        if(ll==lenbb)
        {
            printf("%d\n",contz);
            for(int i=0;i<contz;i++)
            {
                printf("%d %d\n",ans[i][0],ans[i][1]);
            }
        }
        else printf("-1\n");
    }
}

看A串是否包含B串

#include<stdio.h>
#include<string.h>
using namespace std;
char a[200005];
char b[2005];
int next[2005];
int lena;
int lenb;
void set_naxt()//子串的next数组
{
    int i=0,j=-1;
    next[0]=-1;
    while(i<lenb)
    {
        if(j==-1||b[i]==b[j])
        {
            i++; j++;
            next[i]=j;
        }
        else
        j=next[j];
    }
}
 
int kmp()
{
    int i=0,j=0;
    set_naxt();
    while(i<lena)
    {
        if(j==-1||a[i]==b[j])
        {
            i++;j++;
        }
        else
        j=next[j];
        if(j==lenb)
        return 1;
    }
    return 0;
}
int main()
{
    while(~scanf("%s%s",a,b))
    {
        memset(next,0,sizeof(next));
        lena=strlen(a);
        lenb=strlen(b);
        if(kmp()==1)printf("yes\n");
        else printf("no\n");
    }
}

统计所有前缀中字符长度的总和

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
#define ll long long int
#define mod 10007
char a[1500000];
ll nex[1500000];
ll dp[1500000];
ll len;
void Set_next()
{
    ll i=0,j=-1;
    nex[0]=-1;
    while(i<=len)
    {
        if(j==-1||a[i]==a[j])
        {
            i++,j++;
            nex[i]=j;
        }
        else
            j=nex[j];
    }
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>len;
        scanf("%s",a);
        memset(nex,0,sizeof(nex));
        memset(dp,0,sizeof(dp));
        len=strlen(a);
        Set_next();
        for(ll i=len; i>=1; i--)
        {
            dp[i]++;
            dp[nex[i]]+=dp[i];
            dp[nex[i]]%=mod;
            dp[i]%=mod;
        }
        ll output=0;
        for(ll i=1; i<=len; i++)
        {
            //cout<<dp[i]<<endl;
            output+=dp[i];
            output%=mod;
        }
        printf("%lld\n",output%mod);
    }
}

输出所有前缀中字符长度与出现次数的乘积的最大值

设dpi状态，则 dpi++ dp[next[i]]+=dp[i]

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
#define ll long long int
char a[1500000];
ll nex[1500000];
ll dp[1500000];
ll len;
void Set_next()
{
    ll i=0,j=-1;
    nex[0]=-1;
    while(i<=len)
    {
        if(j==-1||a[i]==a[j])
        {
            i++,j++;
            nex[i]=j;
        }
        else j=nex[j];
    }
}
int main()
{
    while(~scanf("%s",a))
    {
        memset(nex,0,sizeof(nex));
        memset(dp,0,sizeof(dp));
        len=strlen(a);
        Set_next();
        for(ll i=len;i>1;i--)
        {
            dp[i]++;
            dp[nex[i]]+=dp[i];
        }
        ll output=0;
        for(ll i=1;i<=len;i++)
        {
            output=max(output,dp[i]*i);
        }
        printf("%lld\n",output);
    }
}

二维哈希

//核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
//小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果
//如果超时改为unsigned int
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ULL;
const int N=1e3+5;
ULL hashv[N][N], power[N*N]; // hashv[k]存储字符串前k个字母的哈希值, power[k]存储 P^k mod 2^64
char str[N][N],str1[N];
int n,m,A,B;
int P;
// 初始化
void calHash()
{
    P=131;
   
    for (int i = 1; i <= n; i++ )
    {
        for(int j=1; j <= m; j++)
        {
            hashv[i][j] = hashv[i][j-1] * P + (str[i][j]-'0');
        }
    }
    
	power[0] = 1;
    for(int i=1; i<=n*m; i++)
    {
        power[i] = power[i - 1] * P;
    }
}
// 计算子串 str[l ~ r] 的哈希值
ULL get(ULL f[],int l, int r)
{
    return f[r] - f[l - 1] * power[r - l + 1];
}
 
int main()
{
 
    scanf("%d%d%d%d",&n,&m,&A,&B);
    for(int i=1; i<=n; i++)
    {
        scanf("%s",str[i]+1);
    }
 
    calHash();
    //将大小为A*B的矩阵Hash保存到Hash中
    unordered_set<ULL> Hash;
    for(int i=B; i<=m; i++)
    {
        ULL s=0;
        int l=i-B+1,r=i;
        for(int j=1; j<=n; j++)
        {
            s=s*power[B]+get(hashv[j],l,r);
            if(j-A>0)
                s-=get(hashv[j-A],l,r)*power[A*B];
            if(j>=A)
                Hash.insert(s);
        }
 
    }
 
    int Q;
    scanf("%d",&Q);
    while(Q--)
    {
        ULL s=0;
        for(int i=1; i<=A; i++)
        {
            scanf("%s",str1+1);
            for(int j=1; j<=B; j++)
            {
                s=s*P+str1[j]-'0';
            }
        }
        if(Hash.count(s))
            printf("1\n");
        else
            printf("0\n");
    }
 
 
 
    return 0;
}

求出所有的子串长度使得既是S的前缀也是S的后缀

利用NEXT数组，例如ABADABA  先求出NEXT[7]=3，然后NEXT3=1 都能满足条件。

不断递推NEXT数组即可

求出至少补充

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
const int MAXN=400000+1000;
char P[MAXN];
int m,next[MAXN];
void getFail()
{
    next[0]=next[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=next[i];
        while(j && P[i]!=P[j]) j=next[j];
        next[i+1] = (P[i]==P[j])?j+1:0;
    }
}
int main()
{
    while(scanf("%s",P)==1)
    {
        vector<int> vc;
        m = strlen(P);
        getFail();
        vc.push_back(m);
        int i=m;
        while(next[i])
        {
            i=next[i];
            vc.push_back(i);
        }
        for(int i=vc.size()-1;i>0;i--)
            printf("%d ",vc[i]);
        printf("%d\n",vc[0]);
    }
    return 0;
}

几个字符使得最小循环节个数>=2

最小循环节长度为X=len-f[len] ，那么不符合时需要补充 X-LEN%X

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXM=100000+100;
int f[MAXM],m;
char P[MAXM];
void getFail(char *P,int *f)
{
    f[0]=f[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=f[i];
        while(j && P[i]!=P[j]) j=f[j];
        f[i+1]= (P[i]==P[j])?j+1:0;
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",P);
        m=strlen(P);
        getFail(P,f);
        if(f[m]==0)
        {
            printf("%d\n",m);
            continue;
        }
        if(m%(m-f[m])==0) printf("0\n");
        else
        {
            int len1=m-f[m];
            printf("%d\n",len1-m%len1);
        }
    }
    return 0;
}

重要结论:不论串S是不是循环的,如果想要S是一个循环串的话,那么它的最小循环节长度一定是len-f[len]. 其中len是串S的长度

给出串S，输出最小循环节可数

<span style="font-size:18px;">#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int MAXN=1000000+100;
char P[MAXN];
int f[MAXN];
int m;
void getFail(char *P,int *f)
{
    f[0]=f[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=f[i];
        while(j && P[i]!=P[j]) j=f[j];
        f[i+1]= (P[i]==P[j])?j+1:0;
    }
}
int main()
{
    while(scanf("%s",P)==1)
    {
        m=strlen(P);
        if(m==1 && P[0]=='.')
            break;
        getFail(P,f);
        if(m%(m-f[m])==0)printf("%d\n",m/(m-f[m]));//注意条件
        else printf("1\n");
    }
    return 0;
}
</span>

给出串S，输出所有的循环节

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int MAXN=1000000+10;
int f[MAXN];
char P[MAXN];
int main()
{
    int n,kase=1;
    while(scanf("%d",&n)==1&&n)
    {
        scanf("%s",P);
        f[0]=f[1]=0;
        for(int i=1;i<n;i++)
        {
            int j=f[i];
            while(j && P[i]!=P[j]) j=f[j];
            f[i+1]= P[i]==P[j]?j+1:0;
        }
        printf("Test case #%d\n",kase++);
        for(int i=2;i<=n;i++)
            if(f[i]>0 && i%(i-f[i])==0) printf("%d %d\n",i,i/(i-f[i]) );
        printf("\n");
    }
    return 0;
}

给出两个串S1 S2，求S1的最长前缀且是S2的最长后缀

 用S1去匹配S2即可。

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int MAXN=50000+1000;
char T[MAXN],P[MAXN];
int f[MAXN],ex[MAXN];
int n,m;
void getFail()
{
    f[0]=f[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=f[i];
        while(j && P[i]!=P[j]) j=f[j];
        f[i+1] = (P[i]==P[j])?j+1:0;
    }
}
void find()
{
    int j=0;
    for(int i=0;i<n;i++)
    {
        while(j && T[i]!=P[j]) j=f[j];
        if(T[i]==P[j])j++;
        ex[i]=j;
    }
}
int main()
{
    while(scanf("%s %s",P,T)==2)
    {
        n=strlen(T);
        m=strlen(P);
        getFail();
        find();
        if(ex[n-1]==0)
            printf("0\n");
        else
        {
            for(int i=0;i<ex[n-1];i++)
                printf("%c",P[i]);
            printf(" %d\n",ex[n-1]);
        }
    }
    return 0;
}

求多个串前后缀合并之后的最终串

就是利用答案串不断去匹配新的串，注意匹配开始的位置。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1000000+66;
const ll mod=1e9+7;
int n;
string s[maxn];
string ans;
int nexts[maxn];
void getnexts(string t)
{
    int len=t.size();
    int i=0;
    int j=-1;
    nexts[0]=-1;
    while(i<len)
    {
        if(j==-1||t[i]==t[j])
        {
            i++;
            ++j;
            if(t[i]!=t[j])
                nexts[i]=j;
            else
                nexts[i]=nexts[j];
        }
        else
        {
            j=nexts[j];
        }
    }
}
int kmp(string &s,string &t,int pos)//s是答案串
{
    int i=pos;//
    int j=0;
    int sl=s.size();
    int tl=t.size();
    while(i<sl)
    {
        if(j==-1||s[i]==t[j])
        {
            ++i;
            ++j;
        }
        else
        {
            j=nexts[j];
        }
    }
    return j;
}
void add(string s)
{
    getnexts(s);
    int pos=kmp(ans,s,max(0,(int)ans.size()-(int)s.size()));
    for(int i=pos; i<s.size(); i++)
    {
        ans.push_back(s[i]);
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        cin>>s[i];
    }
    ans=s[1];
    for(int i=2; i<=n; i++)
    {
        add(s[i]);
    }
    cout<<ans;
}

求一个串的后缀和另一个串的前缀合并之后的串且使得合并后的字符串尽量短，其次是使得合并后的字符串字典序尽量小

利用KMP，求出P1的前缀和P2的后缀匹配长度LEN1 和 P2的前缀和P1的后缀匹配长度LEN2。

若LEN1>LEN2那么把P1放前面，否则比较一下。

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int MAXN=100000+1000;
char *S,*T;
char str1[MAXN],str2[MAXN];
int next[MAXN];
int n,m;
void getFail(char *T)
{
    next[0]=next[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=next[i];
        while(j && T[i]!=T[j]) j=next[j];
        next[i+1] = (T[i]==T[j])?j+1:0;
    }
}
int KMP(char *S,char *T)
{
    int j=0;
    n=strlen(S);
    m=strlen(T);
    getFail(T);
    for(int i=0;i<n;i++)
    {
        while(j && S[i]!=T[j]) j=next[j];
        if(S[i]==T[j]) j++;
        if(i==n-1) return j;
    }
}
int main()
{
    while(scanf("%s%s",str1,str2)==2)
    {
        int len1=KMP(str1,str2);
        int len2=KMP(str2,str1);
        if(len1==len2)
        {
            if(strcmp(str1,str2)<0)
            {
                printf("%s",str1);
                printf("%s\n",str2+len1);
            }
            else
            {
                printf("%s",str2);
                printf("%s\n",str1+len2);
            }
        }
        else if(len1<len2)
        {
            printf("%s",str2);
            printf("%s\n",str1+len2);
        }
        else
        {
            printf("%s",str1);
            printf("%s\n",str2+len1);
        }
    }
    return 0;
}

 

求一个串T在S串中出现次数

利用KMP，记录j==m（T串长度）有多少次。

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
char T[1000000+100],P[10000+100];
int f[10000+100];
int cnt;//统计出现的次数
void find(char *T,char *P,int *f)
{
    int n=strlen(T);
    int m=strlen(P);
    int j=0;
    for(int i=0;i<n;i++)
    {
        if(j && T[i]!=P[j]) j=f[j];
        if(T[i]==P[j]) j++;
        if(j==m) cnt++;
    }
}
void getFail(char *P,int *f)
{
    int m =strlen(P);
    f[0]=f[1]=0;
    for(int i=1;i<m;i++)
    {
        int j=f[i];
        while(j && P[i]!=P[j]) j=f[j];
        f[i+1] = P[i]==P[j]?j+1:0;
    }
}
int main()
{
    int K;
    scanf("%d",&K);
    while(K--)
    {
        cnt=0;
        scanf("%s %s",P,T);
        getFail(P,f);
        find(T,P,f);
        printf("%d\n",cnt);
    }
    return 0;
}

 

桑榆207
关注
专栏目录
UVA 12378 Ball Blasting Game Manacher裸题
九野的博客
12-07 1万+
题目链接：点击打开链接 题意： 消除字符串游戏，选择一个字母，则会消除和该字母相同且连续的一段，然后左右两边合拢，若左右两边字母相同则再次消除掉。直到合拢时两边字母不相同。 问这样连续消除的最大次数。 思路： 先把连续相同的字母当成一个字母，然后求最长回文串， 则答案就是(最长长度+1)/;2 #pragma comment(linker, "/STACK:1024000000,10
KMP和Manacher
leigh的博客
04-17 362
KMP KMP算法用来确定一个字符串是不是另一个字符串的子串，如果是返回子串所在开始位置的下标，否则返回-1。 如果使用暴力方法，我们确定目标字符串是不是原字符串的子串的方法为：从源字符串下标为0的位置与目标字符串的每个字符比对，当到达目标字符串结尾时，说明目标字符串是源字符串的子串，否则从源字符串下标为1的位置继续与目标字符串比对，当源字符串的剩余字符数比目标字符串的长度小时，则说明目标字符...
Manacher练习题
SHIP&GOAT的博客
12-15 485
BZOJ: 对称轴osi 拉拉队排练 [Shoi2011]双倍回文 最长双回文串 [Apio2014]回文串 神奇项链 简单的字符串 时间：两周时间内做完。。。
Manacher 例题讲解
qq_35975367的博客
11-02 280
文章目录HDU 4513 吉哥系列故事——完美队形II题意：题解：代码：HDU 3613 Best Reward题意：题解：代码：HDU 3068 最长回文题意：题解：代码：HDU 5371 Hotaru's problem题意：题解：代码：ABB (2020牛客国庆集训派对day1)题意：题解：代码： HDU 4513 吉哥系列故事——完美队形II 题意： 求一个最长的完美队形，满足左右对称，从左到中间身高需保证不下降 题解： 在manacher模板的基础上增加改动， while(newStr[i-p[
Manacher模板基础题
qq_44293044的博客
08-06 222
吉哥系列故事——完美队形II HDU - 4513 【题目大意】 求最长回文队伍且队伍由中间向两边递减。 【思路】 和字符串一样的做法，在递推的时候增加判断条件：a[i-p[i]]<=a[i-p[i]+2]。 #include<iostream> #include<stdlib.h> #include<stdio.h> #include<cmath&...
(manacher)马拉车算法专题题目
weixin_52551400的博客
04-19 529
manacher算法用来求解回文串问题，时间复杂度为O(n). 不懂的先可以去练习下模板板子题，求最长回文串 传送门P3501 [POI2010]ANT-Antisymmetry 这一题他给的是一个新的定义“反对称”字符串： 如果将这个字符串0和1取反后，再将整个串反过来和原串一样，就称作“反对称”字符串。比如00001111和010101就是反对称的，1001就不是。 我们可以了利用0/1的性质，由于0/1始终不能与自己相反，故子串并不存在中央位置，我们只能从自己添加的特殊符号’#'的奇数位上找 ，差不多
kmp算法及manacher算法分析
weixin_43928720的博客
04-19 298
1.KMP算法 kmp算法主要用来解决字符串匹配的问题，即一个字符串是否是另外一个字符串的子串。 （1）暴力法 首先想到的方法就是暴力匹配法，即两个字符串按位进行匹配，如果遇到不相同的，则从从头开始的下一位开始匹配。 package algorithm.manacher.kmp; /** * @author chengzhengda * @version 1.0 * @date 2020-...
Gym - 101981 Problem M. Mediocre String Problem (扩展KMP + Manacher)
YOONGI
09-25 491
Problem M. Mediocre String Problem 题目链接：https://vjudge.net/problem/Gym-101981M 题目大意：给出两个串S，T，从S中选择 i~j 的子串，再从T中选择前缀 1~k 接在S的子串后面 组成一个新字符串，要求 j-i+1>k，问能构成的新串中是回文串的个数 思路：因为要求j-i+1>k，即S中选择的子串x比...
字符串匹配选讲（KMP Trie树 manacher）PPt
08-25
KMP（字符串匹配），Trie树（字典树），manacher（最长回文子串） 算法思想 代码 经典题目
左神算法进阶班笔记Part1：KMP、Manacher、BFPRT、窗口滑动问题
qq_40586164的博客
04-13 559
文章目录KMP算法最大回文子串Manacher算法 KMP算法 1.KMP详细 2.相关题目 1、【京东】给定一个字符串，要求在后面添加长度最短的字符，生成一个新的字符串，包含两个原始字符串。 【思路】将字符串最长前后缀匹配长度算出后，next数组再多求一位，即可得到一个最长前缀、最长后缀。然后第二个字符串只需要将前缀和原始字符串的后缀重合，补充完整即可。 2.判断树B是不是树A的某一子树 【思路...
ACM-PAT甲级题目总结及实现
03-24
4. **字符串处理**：PAT甲级中字符串问题频繁出现，包括KMP算法、Manacher's Algorithm、后缀自动机等，用于高效处理字符串匹配和模式查找。 5. **图论**：图的深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径...
数据结构与算法笔记五（哈希函数和哈希表，有序表并查集，KMP，manacher，窗口最值更新结构，单调栈）
prague6695的博客
07-06 363
哈希函数，哈希表，有序表，并查集，KMP
[kuangbin带你飞] - Manacher 小题合集
梦之城
05-02 319
Manacher 小题合集 Manacher 小题合集 X - 最长回文 题意 思路 V - 吉哥系列故事――完美队形II 题意 思路 W - Girls’ research 题意 思路 X - 最长回文 题目链接： X - 最长回文 HDU - 3068 题意 给出一个只由小写英文字符a,b,c…y,z组成的字符串S,求S中最长回文...
其他题目---Manacher算法
冰殇的博客
11-10 401
【题目】　　给定一个字符串str，返回str中最长回文子串的长度。要求时间复杂度O(N)。【进阶题目】　　给定一个字符串str，想通过添加字符的方式使得str整体都变成回文字符串，但要求只能在str的末尾添加字符，请返回在str后面添加的最短字符串。要求时间复杂度O(n)。【代码实现】#python3.5 #原问题 def manacherString(string): res = [0 f
manacher算法 +例题
CUCUC1的博客
10-14 362
目录Manacher参考博客 ~~(懒惰的我)~~:模板hdu3294hdu3068 Manacher 参考博客 (懒惰的我): 简单而有通俗的讲解,讲的太好了 证明 对于一些我的理解，我会以代码注释的形式写在代码里, 我不懒 模板 char str[maxn]; char temp[(maxn <<1) + 10];//扩展后的字符串 int Len[(maxn <<1 ) + 10];//扩展后字符串第i个位置回文串从中间到第有边界的长度 //相当于 回文子串长度 / 2 +
【POJ3974】Palindrome Manacher、模板题 裸题
辗转山河弋流歌
12-24 1777
Manacher裸题，模板题
Hotaru's problem（manacher+思维）好题！！
20164225的博客
08-05 392
Hotaru's problem Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 4234    Accepted Submission(s): 1384 Problem Description Hotaru Ichijou rec...
【字符串题目讲解】一文理解 Manacher Algoirth（马拉车算法）——以洛谷 P3805 和 P5446 为例
最新发布
Edward Shi的博客
02-20 957
马拉车算法的介绍，并讲解了 P3805 【模板】manacher 和 P5446 [THUPC2018] 绿绿和串串
Manacher(马拉车)算法详解、证明和练习题
qq_39579087的博客
12-27 679
给你一个字符串，让你在末尾添加最少数量的字符，使得添加后的字符串为回文串 关于这道题，可以用Manacher算法的思想来做。 首先找到以给出的字符串最后一个字符结尾的最长回文串，然后从头开始，遇见最长回文串的开头就停止，将这段字串逆序贴在整个字符串的末尾就是答案，举个例子： 假设给出的字符串是：abcxyzfzyx，可以看出以最后一个字符结尾的最长回文串是xyzfzyx，然后从字符串的头开始遍历，直到x的前一个位置，最后遍历得到的子串为abc，将abc逆序为cba贴在给出的字符串后面即为答案：abcxyz
华为机试历年编程题目精选
20. **最大回文子串**：动态规划或Manacher's Algorithm，寻找字符串中的最长回文子串。 21. **指数运算**：快速幂算法，高效地计算大数的指数。 22. **二进制位计数**：位操作，计算一个数字的二进制表示中1的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值