HDU 5343 MZL's Circle Zhou【后缀自动机】

最新推荐文章于 2019-07-23 00:04:20 发布
最新推荐文章于 2019-07-23 00:04:20 发布
阅读量681 收藏 1
点赞数
分类专栏： 前缀 & 后缀
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013007900/article/details/47415845
版权

对于a串可能和b串重复的部分，我们总能找到一个位置将该串分成前半段和后半段，同时使得前半段属于a串的部分达到最长，即在该串划分的位置后面的那个字母在属于a串的部分的后继为空（也就是说不能找到更长的前半段划分方式了），所以我们只要预处理以字符x为开头的b串的个数即可。
然后在A的每一个子串枚举算后面有没有以字符x为开的后继。

新建图

//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=90010;
const int MAXC=27;
struct SAM
{
    int len[MAXN<<1],next[MAXN<<1][MAXC],fa[MAXN<<1],L,last;
    SAM()
    {
        init();
    }
    void init()
    {
        L=0;
        last=newnode(0,-1);
    }
    int newnode(int l,int pre)
    {
        fa[L]=pre;
        for(int i=0; i<MAXC; i++)    next[L][i]=-1;
        len[L]=l;
        return L++;
    }
    void build(char *p)
    {
        int le=strlen(p);
        for(int i=0; i<le; i++)
            add(p[i]-'a',i);
    }
    void add(int x,int l)
    {
        int pre=last,now=newnode(len[pre]+1,-1);
        last=now;
        while(~pre && next[pre][x]==-1)
        {
            next[pre][x]=now;
            pre=fa[pre];
        }
        if(pre==-1)
        {
            fa[now]=0;
        }
        else
        {
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1)
            {
                fa[now]=bro;
            }
            else
            {
                int fail=newnode(len[pre]+1,fa[bro]);
                for(int i=0; i<MAXC; i++)next[fail][i]=next[bro][i];
                fa[bro]=fail,fa[now]=fail;
                while(~pre&&next[pre][x]==bro)
                {
                    next[pre][x]=fail;
                    pre=fa[pre];
                }
            }
        }
    }
} A,B;

char stra[MAXN],strb[MAXN];
int lena,lenb;
vi G[MAXN<<1];
ll dp[MAXN<<1],num[MAXN<<1];
ull len[27];
bool vis[MAXN<<1];

ll rdfs(int u)
{
    if(~dp[u])    return dp[u];
    dp[u]=0;
    for(int i=G[u].size()-1; i>=0; i--)
        dp[u]+=rdfs(G[u][i]);
    return dp[u];
}

ll dfs(int u)
{
    if(~num[u])    return num[u];
    num[u]=1;
    for(int i=0; i<26; i++)
        if(~B.next[u][i])
            num[u]+=dfs(B.next[u][i]);
    return num[u];
}

void getans(int u)
{
    if(vis[u])return ;
    vis[u]=true;
    bool flag=false;
    for(int i=0; i<26; i++)
    {
        if(~A.next[u][i])
            getans(A.next[u][i]);
        else if(dp[u])
        {
            len[i]+=dp[u];
            if(!flag)
            {
                flag=true;
                len[26]+=dp[u];
            }
        }
    }
}


int main()
{
    //freopen("data.txt","r",stdin);
    int T;
    read(T);
    while(T--)
    {
        CLR(dp,-1);
        CLR(num,-1);
        CLR(len,0);
        CLR(G,0);
        CLR(vis,0);
        scanf("%s %s",stra,strb);
        lena=strlen(stra);
        lenb=strlen(strb);
        A.init();
        B.init();
        A.build(stra);
        B.build(strb);
        for(int i=0; i<A.L; i++)
            for(int j=0; j<26; j++)
                if(~A.next[i][j])
                    G[A.next[i][j]].pb(i);
        dp[0]=1;
        for(int i=0; i<A.L; i++)    if(dp[i]==-1)
                rdfs(i);
        dfs(0);
        getans(0);
        ull ans=0;
        for(int i=0; i<26; i++)
            if(~B.next[0][i])
                ans+=num[B.next[0][i]]*len[i];
        ans+=len[26];
        write(ans),putchar('\n');
    }
    return 0;
}

拓扑排列

//      whn6325689
//      Mr.Phoebe
//      http://blog.csdn.net/u013007900
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>
#include <functional>
#include <numeric>
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;

#define eps 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LLINF 1LL<<62
#define speed std::ios::sync_with_stdio(false);

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef complex<ld> point;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<int> vi;

#define CLR(x,y) memset(x,y,sizeof(x))
#define CPY(x,y) memcpy(x,y,sizeof(x))
#define clr(a,x,size) memset(a,x,sizeof(a[0])*(size))
#define cpy(a,x,size) memcpy(a,x,sizeof(a[0])*(size))

#define mp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define lowbit(x) (x&(-x))

#define MID(x,y) (x+((y-x)>>1))
#define ls (idx<<1)
#define rs (idx<<1|1)
#define lson ls,l,mid
#define rson rs,mid+1,r
#define root 1,1,n

template<class T>
inline bool read(T &n)
{
    T x = 0, tmp = 1;
    char c = getchar();
    while((c < '0' || c > '9') && c != '-' && c != EOF) c = getchar();
    if(c == EOF) return false;
    if(c == '-') c = getchar(), tmp = -1;
    while(c >= '0' && c <= '9') x *= 10, x += (c - '0'),c = getchar();
    n = x*tmp;
    return true;
}
template <class T>
inline void write(T n)
{
    if(n < 0)
    {
        putchar('-');
        n = -n;
    }
    int len = 0,data[20];
    while(n)
    {
        data[len++] = n%10;
        n /= 10;
    }
    if(!len) data[len++] = 0;
    while(len--) putchar(data[len]+48);
}
//-----------------------------------

const int MAXN=90010;
const int MAXC=27;
struct SAM
{
    int len[MAXN<<1],next[MAXN<<1][MAXC],fa[MAXN<<1],L,last;
    int num[MAXN<<1];
    SAM()
    {
        init();
    }
    void init()
    {
        L=0;
        last=newnode(0,-1);
    }
    int newnode(int l,int pre)
    {
        fa[L]=pre;
        for(int i=0; i<MAXC; i++)    next[L][i]=-1;
        len[L]=l;num[L]=1;
        return L++;
    }
    void build(char *p)
    {
        int le=strlen(p);
        for(int i=0; i<le; i++)
            add(p[i]-'a',i);
    }
    void add(int x,int l)
    {
        int pre=last,now=newnode(len[pre]+1,-1);
        last=now;
        while(~pre && next[pre][x]==-1)
        {
            next[pre][x]=now;
            pre=fa[pre];
        }
        if(pre==-1)
            fa[now]=0;
        else
        {
            int bro=next[pre][x];
            if(len[bro]==len[pre]+1)
                fa[now]=bro;
            else
            {
                int fail=newnode(len[pre]+1,fa[bro]);
                for(int i=0; i<MAXC; i++)next[fail][i]=next[bro][i];
                fa[bro]=fail,fa[now]=fail;
                while(~pre&&next[pre][x]==bro)
                {
                    next[pre][x]=fail;
                    pre=fa[pre];
                }
            }
        }
    }

    int topxu[MAXN<<1],sum[MAXN<<1];
    void topsort()
    {
        CLR(sum,0);
        for(int i=0; i<L; i++)    sum[len[i]]++;
        for(int i=1; i<L; i++)    sum[i]+=sum[i-1];
        for(int i=0; i<L; i++)    topxu[sum[len[i]]--]=i;
        for(int i=L-1; i>=0; i--)
        {
            int u=topxu[i];
            for(int j=0; j<26; j++)
                if(~next[u][j])
                    num[u]+=num[next[u][j]];
        }

    }
} A,B;

char stra[MAXN],strb[MAXN];
ull len[27];


int main()
{
    freopen("data.txt","r",stdin);
    int T;
    read(T);
    while(T--)
    {
        CLR(len,0);
        scanf("%s %s",stra,strb);
        A.init();B.init();
        A.build(stra);B.build(strb);
        B.topsort();
        ull ans=1;
        for(int i=0; i<26; i++)
            if(~B.next[0][i])
                len[i]=B.num[B.next[0][i]];
        for(int i=0; i<26; i++)
            if(A.next[0][i]==-1)
                ans+=len[i];
        for(int i=1; i<A.L; i++)
        {
            ull l=A.len[i]-A.len[A.fa[i]];
            for(int j=0; j<26; j++)
                if(A.next[i][j]==-1)
                    ans+=l*len[j];
            ans+=l;
        }
        write(ans),putchar('\n');
    }
    return 0;
}
HDU4622- Reincarnation（后缀自动机）
weixin_43880485的博客
03-29 150
Description Now you are back,and have a task to do: Given you a string s consist of lower-case English letters only,denote f(s) as the number of distinct sub-string of s. And you have some query,each ...
K-th occurrence 2019CCPC网络赛+HDU6704（后缀自动机+主席树）
UniverseofHK的博客
11-05 345
K-th occurrence 之前网络赛跟队友合体出的题，当时我写的后缀自动机，他写的主席树，hhh！ 现在我会写主席树，他会写后缀数组，于是各自独立的A了！并且我跟之前网络赛时的解法还不完全一样 巨佬队友bxd的后缀数组+主席树解法 题意： 给定一个串SSS，有QQQ个询问：求子串S[l,r]S[l,r]S[l,r]在SSS中的第kkk次出现位置。 思路： 由于后缀自动机可以知道某个子串的e...
HDU 5343 MZL's Circle Zhou（后缀自动机+记忆化搜索）
alpc_qleonardo
03-25 345
大致题意，给你两个字符串，然后从第一个字符串里面取出一个子串X，从第二个字符串里面取出一个子串Y，两个拼接在一起组成新的字符串，其中X、Y都可以是空串，问有多少个这样不同的串。 如果整体来思考不同的X+Y的个数，会发现找不到突破口。我们可以考虑X+Y为什么会有重复的。举个例子ababc，可以由ab+abc或则a+babc组成。重复的原因在于在第一个串中可以找到ab，也可以找到a，而如果a可以构成这个拼接串，那么ab也构成这个拼接串。所以说，为了避免重复，我们可以在第一个串中找最长的点，即
Hdu 5343 MZL's Circle Zhou 后缀自动机
J. Cole
11-14 226
MZL's Circle Zhou Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 448    Accepted Submission(s): 180 Problem Description MZL's Ci
hdu5343 MZL's Circle Zhou（SAM+dp）
Coco_T的博客
02-12 306
题目链接 分析： 这道题是今天hu测T3的精简版 （先来搞简单一点的，hu测的题目太难了。。。） 题意：给定两个长度不超过a，b（1 &lt;= |a|，|b| &lt;= 90000） x为a的连续子串，b为y的连续子串（x和y均可以是空串） 问x+y形成的不同串的个数？ 这时候出现了一个问题 对于一个合法解，有可能中间存在一段即是A的子串，又是B的子串 那么此合法解就有多...
hdu 5343 MZL's Circle Zhou(后缀自动机)
weixin_30752377的博客
09-25 105
题目链接：hdu 5343 MZL's Circle Zhou 题意： 给你两个串A，B，问从A,B中选子串x,y，问x+y可以组成多少个不同的串，x和y可以为空。 题解： 贴一个官方的题解 1 #include<bits/stdc++.h> 2 #define mst(a,b) memset(a,b,sizeof(a)) 3 #define F(...
HDU 5343 MZL's Circle Zhou 后缀自动机+DP
weixin_30815469的博客
10-02 104
MZL's Circle Zhou Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 131072/131072 K (Java/Others) Problem Description MZL's Circle Zhou is good at solving some counting problems. One day, ...
后缀自动机SAM
ZigZagK的博客
07-05 1806
后缀自动机SAM总结。
HDU 6583 Typewriter 后缀自动机优化DP
lifelike
07-23 706
Typewriter Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 108 Accepted Submission(s): 22 Problem Description One day, Jerry found a stran...
hdu4436(后缀自动机)
Soul
07-18 544
题解：求多个字符串能够构成多少种数然后把这些数去重后加起来，后缀自动机有个性质就是路径数就等于不同子串个数，然后怎么把多个字符串拼接呢，两个字符串中间加入一个你不会用的字符，因为这样可以保证我到时候路径不会走这条 #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;queu...
Twosigma在线笔试 substring
Mr.Phoebe的专栏
09-19 2596
题意 给你一个字符串，让你找出这个字符串以元音字母开头（a，e，i，o，u），辅音字母结尾的所有子串，中的字典序最大串和最小串。 思路 虽然是面试题，但是我觉得这是我见过的最难的面试题 暴力解 #include&lt;iostream&gt; #include&lt;unordered_set&gt; #include&lt;string&gt; using namespace std; ...
HDU 3518 && HDU 4416【后缀自动机len的使用】
Mr.Phoebe的专栏
08-28 1414
max：即代码中 len 变量，它表示该状态能够接受的最长的字符串长度。 min：表示该状态能够接受的最短的字符串长度。实际上等于该状态的 fail 指针指向的结点的 len + 1。 max-min+1：表示该状态能够接受的不同的字符串数。那么在HDU 3518 中。 求的是，不相交且出现次数大于2的子串个数。 我们这么想，如果你把一个串直接塞进后缀自动机里面，比较难以处理（不是没有办法，
Codeforces Round #327 (Div. 1) E. Birthday【AC自动机+网络流】
Mr.Phoebe的专栏
10-27 1139
先用AC自动机处理子串的问题 这是简单的处理，和沈阳站的B题简直异曲同工。 然后形成了一个DAG图用网络流Dinic处理最大独立集的问题，胡伯涛的论文有提及二分图的最大独立集做法。 方案直接用bfs在Dinic最大流跑完之后的残留网络上面询问，能够访问到的点就是方案。// whn6325689 // Mr.Phoebe // http://blog.csdn.ne
最长公共子串问题的后缀数组解法
Mr.Phoebe的专栏
01-28 1059
二分枚举答案A，假设N个串可以有长度为A的公共字串，并对A的可行性进行验证。如果验证A可行，A'(A' 于是问题就集中到了，如何验证给定的长度A是否为可行解。方法是，找出在Height数组中找出连续的一段Height[i..j]，使得i=A，并且i-1 具体查找i..j时，可以先从前到后枚举i的位置，如果发现Height[i]>=A，则开始从i向后枚举j的位置，直到找到了Height[j+1]
HDU 4117 GRE Words【AC自动机+线段树】
Mr.Phoebe的专栏
09-23 931
和这题有些类似。AC自动机。 字符串匹配算法，大概就是kmp，ac自动机，后缀数组，后缀自动机这么几种了。对于这题，我们很容易想到暴力dp，用kmp去匹配，总复杂度可以做到o(n2+2∗m)o(n^2+2*m)（n为字符串个数，m为所有字符串的总长），但这样还不够，超时妥妥的。 那就要考虑怎么维护这个dp了。 把自动机建好后，从前往后一个个的，去匹配。在自动机上匹配的过程中，我们可以发现，这个
POJ 3415 Common Substrings【后缀自动机】
Mr.Phoebe的专栏
09-18 891
max：即代码中 len 变量，它表示该状态能够接受的最长的字符串长度。 min：表示该状态能够接受的最短的字符串长度。实际上等于该状态的 fail 指针指向的结点的 len + 1。 max-min+1：表示该状态能够接受的不同的字符串数。 right：表示节点u所能够接受的字符，在原字符串中出现过多少次 right*(max-min+1)就是节点u能够接受的字符串在原字符串中出现的次数。
Codeforces Round #305 (Div. 1)E. Mike and Friends【后缀数组+线段树】
Mr.Phoebe的专栏
05-31 878
传送门：Codeforces Round #305 (Div. 1)E. Mike and Friends这题既然求得是子串，就可以用后缀数组来做（也可以用后缀自动机balabala） 我的方法是O(nlog2n)O(nlog2n)，O(nlogn)O(nlogn)的方法就是把线段树换成主席树来实现，但是我并不会高冷的主席树。 首先用类似于求N个串的最长公共子串那样，将所有串接在一起，然后用后缀
Poj 3691 & Hdu 2457 DNA repair
Mr.Phoebe的专栏
08-11 806
解题思路： AC自动机+DP dp[ i ][ j ]表示主串匹配到了第 i 个位置，然后到达的是AC自动机上的 j 状态（可以理解为Trie树的节点位置）时最少修改字符的个数，我们保证 j 状态不是模式串（ DNA病毒串）的结束节点，然后不断地往后走选出一条匹配完主串，并且修改字符串数最少的的一条。 状态转移为dp[ i ][ j ] = min( dp[ i ][ j ],
BZOJ 3530 数数【AC自动机+数位dp】
Mr.Phoebe的专栏
10-02 788
[Sdoi2014]数数简单数位dp+简单AC自动机 反正数位DP是队友写的 AC自动机要记录两个值，一个是是否为一个串的结束，即不合法状态，一个是前缀零的情况。// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #include <algorithm> #include <iostream>
Phoebe implementation invitational for 2014 tiro 3.0 部分题解
Mr.Phoebe的专栏
12-23 760
A。 给出两个非负整数a，b，求出符合这个等式      的所有x，并输出 x 的数量，如果 x 有无限多个，那么输出 infinity。 a mod x == b，等价于  a = k*x + b。设 mul = a - b，那么 k*x = mul，然后就不断枚举 mul 的因子，即 kx = mul。由于 mod 出来的结果为 b，那么 k 或 x 至少有一个比 b 大，如果两个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值