【HEOI2015】最短不公共子串

最新推荐文章于 2022-01-26 15:10:48 发布

StrideTG

最新推荐文章于 2022-01-26 15:10:48 发布

阅读量601

点赞数 2

CC 4.0 BY-SA版权

分类专栏：字符串 --------后缀自动机 --------序列自动机

本文链接：https://blog.youkuaiyun.com/TompsonGo/article/details/79512175

字符串同时被 3 个专栏收录

8 篇文章

订阅专栏

--------序列自动机

2 篇文章

订阅专栏

--------后缀自动机

1 篇文章

订阅专栏

这篇博客介绍了如何解决寻找两个小写字母串的最短不公共子串和子序列的问题。通过建立序列自动机和后缀自动机，并进行宽度优先搜索，找出满足条件的最短子串和子序列。在样例中，给出了具体的输入输出示例，以及解题思路和提示，强调了剪枝的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

时间限制 : 1000 MS 空间限制 : 265536 KB

问题描述

在虐各种最长公共子串、子序列的题虐的不耐烦了之后，你决定反其道而行之。
一个串的“子串”指的是它的连续的一段，例如bcd是abcdef的子串，但bde不是。
一个串的“子序列”指的是它的可以不连续的一段，例如bde是abcdef的子串，但bdd不是。
下面，给两个小写字母串A，B，请你计算：
(1) A的一个最短的子串，它不是B的子串
(2) A的一个最短的子串，它不是B的子序列
(3) A的一个最短的子序列，它不是B的子串
(4) A的一个最短的子序列，它不是B的子序列

输入格式

有两行，每行一个小写字母组成的字符串，分别代表A和B。

输出格式

输出4行，每行一个整数，表示以上4个问题的答案的长度。如果没有符合要求的答案，输出-1.

样例输入

aabbcc
abcabc

样例输出

2
4
2
4

提示

对于100%的数据，A和B的长度都不超过2000

题解

一道大板题……
对 $A,B$ 两字符串建序列自动机和后缀自动机。根据序列自动机与后缀自动机的性质，从自动机的根出发到自动机上任意一点为原字符串的一个子序列（序列自动机）或子串（后缀自动机）。因此对题目中的四个问都只需在两串的对应机子上跑宽搜。若某状态，串 $A$ 的机子能到达，而 $B$ 不能，即为答案。注意剪枝！！！

代码

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int maxn=4e3+5;
int n,m,vis[maxn][maxn];
char A[maxn],B[maxn];
struct Suffix_Automaton{
    int rt,tot,Last,par[maxn],maxx[maxn],son[maxn][30];
    void init()
    {
        memset(maxx,0,sizeof(maxx));
        memset(par,0,sizeof(par));
        memset(son,0,sizeof(son));
        rt=tot=Last=0;
    }
    int Add(int x)
    {
        maxx[++tot]=x;
        return tot;
    }
    void Insert(char c)
    {
        int t=c-'a',p,q,np,nq;
        p=Last,np=Add(maxx[p]+1);
        for(;p&&(!son[p][t]);p=par[p]) son[p][t]=np;
        if(!p) par[np]=rt;
        else
        {
            q=son[p][t];
            if(maxx[q]==maxx[p]+1) par[np]=q;
            else
            {
                nq=Add(maxx[p]+1);
                memcpy(son[nq],son[q],sizeof(son[q]));
                par[nq]=par[q],par[q]=par[np]=nq;
                for(;p&&son[p][t]==q;p=par[p]) son[p][t]=nq;
            }
        }
        Last=np;
    }
}SUA,SUB;
struct Squence_Automaton{
    int rt,tot,Last[30],par[maxn],son[maxn][30];
    void init()
    {
        memset(Last,0,sizeof(Last));
        memset(par,0,sizeof(par));
        memset(son,0,sizeof(son));
        rt=tot=1;
        for(int i=0;i<26;i++) Last[i]=rt;
    }
    void Insert(char c)
    {
        int t=c-'a';
        par[++tot]=Last[t];
        for(int i=0;i<26;i++)
            for(int j=Last[i];j&&!son[j][t];j=par[j]) son[j][t]=tot;
        Last[t]=tot;
    }
}SQA,SQB;
struct node{
    int a,b,c;
    node(int a,int b,int c):a(a),b(b),c(c){}
};
int BFS1()
{
    queue<node> q;
    q.push(node(SUA.rt,SUB.rt,0));
    while(!q.empty())
    {
        int pa=q.front().a,pb=q.front().b,step=q.front().c;
        q.pop();
        if(vis[pa][pb]==1) continue;
        vis[pa][pb]=1;
        for(int i=0;i<26;i++)
        {
            if(SUA.son[pa][i]&&SUB.son[pb][i]) q.push(node(SUA.son[pa][i],SUB.son[pb][i],step+1));
            if(SUA.son[pa][i]&&!SUB.son[pb][i]) return step+1;
        }
    }
    return -1;
}
int BFS2()
{
    queue<node> q;
    q.push(node(SUA.rt,SQB.rt,0));
    while(!q.empty())
    {
        int pa=q.front().a,pb=q.front().b,step=q.front().c;
        q.pop();
        if(vis[pa][pb]==2) continue;
        vis[pa][pb]=2;
        for(int i=0;i<26;i++)
        {
            if(SUA.son[pa][i]&&SQB.son[pb][i]) q.push(node(SUA.son[pa][i],SQB.son[pb][i],step+1));
            if(SUA.son[pa][i]&&!SQB.son[pb][i]) return step+1;
        }
    }
    return -1;
}
int BFS3()
{
    queue<node> q;
    q.push(node(SQA.rt,SUB.rt,0));
    while(!q.empty())
    {
        int pa=q.front().a,pb=q.front().b,step=q.front().c;
        q.pop();
        if(vis[pa][pb]==3) continue;
        vis[pa][pb]=3;
        for(int i=0;i<26;i++)
        {
            if(SQA.son[pa][i]&&SUB.son[pb][i]) q.push(node(SQA.son[pa][i],SUB.son[pb][i],step+1));
            if(SQA.son[pa][i]&&!SUB.son[pb][i]) return step+1;
        }
    }
    return -1;
}
int BFS4()
{
    queue<node> q;
    q.push(node(SQA.rt,SQB.rt,0));
    while(!q.empty())
    {
        int pa=q.front().a,pb=q.front().b,step=q.front().c;
        q.pop();
        if(vis[pa][pb]==4) continue;
        vis[pa][pb]=4;
        for(int i=0;i<26;i++)
        {
            if(SQA.son[pa][i]&&SQB.son[pb][i]) q.push(node(SQA.son[pa][i],SQB.son[pb][i],step+1));
            if(SQA.son[pa][i]&&!SQB.son[pb][i]) return step+1;
        }
    }
    return -1;
}
int main()
{
    scanf("%s%s",A+1,B+1),n=strlen(A+1),m=strlen(B+1);
    SQA.init(),SUA.init(),SUA.Last=SUA.rt=SUA.Add(0);
    SQB.init(),SUB.init(),SUB.Last=SUB.rt=SUB.Add(0);
    for(int i=1;i<=n;i++) SUA.Insert(A[i]),SQA.Insert(A[i]);
    for(int i=1;i<=m;i++) SUB.Insert(B[i]),SQB.Insert(B[i]);
    printf("%d\n%d\n%d\n%d\n",BFS1(),BFS2(),BFS3(),BFS4());
    return 0;
}