『后缀自动机和后缀树』

最新推荐文章于 2019-09-13 13:33:54 发布
最新推荐文章于 2019-09-13 13:33:54 发布
阅读量310 收藏 2
点赞数
原文链接：http://www.cnblogs.com/Parsnip/p/11378130.html
版权

前言

本博客仅记录个人对后缀自动机的一些理解，没有入门详细推导等内容。

可以参考这两篇博客：
后缀自动机 (SAM) 学习笔记
后缀自动机 (SAM)

理解

后缀自动机到底记录了什么？由于一个字符串的任意一个子串可以表达为某个前缀的后缀这样的形式，所以后缀自动机其实以一种高度压缩的形式保存了字符串所有子串的信息。

一点性质，后缀自动机最多只有\(2*n-1\)个状态，\(3n-4\)条转移，这可能在开数组大小，或者多组测试数据清空的时候要注意到。

回顾一些知识：

\(1.\) \(SAM\)的状态和转移构成了一张有向无环图，称为\(DAWG\)。

\(2.\) \(SAM\)的状态和后缀链接构成了一棵树，称为\(parent\)树。

\(3.\) 后缀自动机有唯一一个起始节点\(s\)，代表空串，起始节点\(s\)到任意一个终止状态路径上的所有转移恰好可以表示原串的一个后缀，原串的每一个后缀同样都可以被表示。

\(4.\) 后缀自动机每一个状态本质上代表了一个\(endpos\)等价类，又称为\(right\)集合。

\(5.\) 引理： 两个非空子串\(|u|\)和\(|w|\) (假设\(|u|<|w|\))的\(endpos\)相同，当且仅当字符串\(u\)是\(w\)的后缀。

\(6.\) 引理： 两个非空子串\(|u|\)和\(|w|\) (假设\(|u|<|w|\))，要么\(endpos(u)\cap endpos(w)=\emptyset\)，要么\(endpos(w)\subseteq endpos(u)\)，取决于\(u\)是否为\(w\)的一个后缀。

\(7.\) 考虑一个\(endpos\)等价类，将类中的所有子串按长度非递增的顺序排序。每个子串都不会比它前一个子串长，与此同时每个子串也是它前一个子串的后缀。换句话说，对于同一等价类的任一两子串，较短者为较长者的后缀，且该等价类中的子串长度恰好覆盖一段联系的区间。

\(8.\) 一个 后缀链接 \(link\)连接到对应于\(w\)的最长后缀的另一个\(endpos\)等价类的状态。也就是说后缀链接连接的状态所代表的的子串集是上一个区间的相邻区间，同样也是连续区间。

\(9.\) 从节点\(v\)通过后缀链接到根的路径中每一个状态的\(substrings\)恰好不重不漏地表示了节点\(v\)所代表的最长子串的每一个后缀。

好了，如果这些知识在脑中都已经有了印象，那么我们就已经对后缀自动机初步理解了。

后缀自动机的实际运用

统计实质不同的子串个数 (HihoCoder1445)

只要统计每个状态包含的子串总数就可以了，不用担心普通统计中重复的问题。

答案就是\(\sum maxlen[i]-minlen[i]+1\)。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6+20;
struct SuffixAutomation
{
    int maxlen[N*2],link[N*2],trans[N*2][26],tot,last;
    SuffixAutomation () { tot = last = 1; }
    inline void extend(int c)
    {
        int cur = ++tot , p;
        maxlen[cur] = maxlen[last] + 1;
        for (p=last;p&&!trans[p][c];p=link[p])
            trans[p][c] = cur;
        if ( p == 0 ) link[cur] = 1;
        else
        {
            int q = trans[p][c];
            if ( maxlen[q] == maxlen[p] + 1 ) link[cur] = q;
            else
            {
                int cl = ++tot;
                maxlen[cl] = maxlen[p] + 1;
                memcpy( trans[cl] , trans[q] , sizeof trans[q] );
                link[cl] = link[q];
                for (;p&&trans[p][c]==q;p=link[p])
                    trans[p][c] = cl;
                link[cur] = link[q] = cl;
            }
        }
        last = cur;
    }
};
SuffixAutomation T;
char s[N]; int n;
long long ans;
int main(void)
{
    scanf("%s",s+1);
    n = strlen( s + 1 );
    for (int i=1;i<=n;i++)
        T.extend( s[i] - 'a' );
    for (int i=2;i<=T.tot;i++)
        ans += T.maxlen[i] - T.maxlen[T.link[i]];
    printf("%lld\n",ans);
    return 0;
}

任意子串出现次数 (HihoCoder1449)

任意子串的出现次数其实就是对应子串状态的\(endpos\)集合大小。考虑在构建\(SAM\)时维护，只需每次跳完所有的后缀链接，直到跳到根，并沿路累加\(endpos\)集合大小即可。

但是这样的时间复杂度是\(O(|S|^2)\)的，我们考虑先把\(SAM\)构出来，然后\(dfs\)一遍\(parent\)树，把贡献都算上就可以了。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6+20;
struct edge { int ver,next; } e[N*2];
struct SuffixAutomation
{
    int maxlen[N*2],link[N*2],trans[N*2][26],cnt[N*2],tot,last;
    SuffixAutomation () { tot = last = 1; }
    inline void extend(int c)
    {
        int cur = ++tot , p;
        maxlen[cur] = maxlen[last] + 1;
        cnt[cur] = 1;
        for (p=last;p&&!trans[p][c];p=link[p])
            trans[p][c] = cur;
        if ( p == 0 ) link[cur] = 1;
        else
        {
            int q = trans[p][c];
            if ( maxlen[q] == maxlen[p] + 1 ) link[cur] = q;
            else
            {
                int cl = ++tot;
                maxlen[cl] = maxlen[p] + 1;
                memcpy( trans[cl] , trans[q] , sizeof trans[q] );
                link[cl] = link[q];
                for (;p&&trans[p][c]==q;p=link[p])
                    trans[p][c] = cl;
                link[cur] = link[q] = cl;
            }
        }
        last = cur;
    }
};
SuffixAutomation T;
char s[N];
int n,t,Head[N*2],ans[N];
inline void insert(int x,int y) { e[++t] = (edge){y,Head[x]} , Head[x] = t; }
inline void dfs(int x)
{
    for (int i=Head[x];i;i=e[i].next)
    {
        int y = e[i].ver;
        dfs( y );
        T.cnt[x] += T.cnt[y];
    }
    ans[T.maxlen[x]] = max( ans[T.maxlen[x]] , T.cnt[x] );
}
int main(void)
{
    scanf("%s",s+1);
    n = strlen( s + 1 );
    for (int i=1;i<=n;i++)
        T.extend( s[i] - 'a' );
    for (int i=2;i<=T.tot;i++)
        insert( T.link[i] , i );
    dfs( 1 );
    for (int i=n;i>=1;i--)
        ans[i] = max( ans[i] , ans[i+1] );
    for (int i=1;i<=n;i++)
        printf("%d\n",ans[i]);
    return 0;
}

统计所有本质不同子串的权值和 (HihoCoder1457)

考虑在\(DAWG\)上\(dp\)，令\(f_i\)代表\(i\)状态所有子串的权值和，\(tot_i\)代表状态\(i\)的子串个数，\(topsort\)转移即可。

\[tot_i=\sum_{trans[x][id]=i}tot_x\ ,\ f_i=\sum_{trans[x][id]=i}f_x\times 10+id\times tot_x\]

由于本题对多个字符串同时询问，我们使用广义后缀自动机解决。

所谓广义后缀自动机，就是把多个字符串用一些间隔符并成一个字符串，然后在同一个后缀自动机中操作，当然，那些间隔符是不参与\(dp\)计算的。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 2e6+20 , Mod = 1e9+7;
struct SuffixAutomation
{
    int maxlen[N*2],link[N*2],trans[N*2][11],tot,last;
    SuffixAutomation () { tot = last = 1; }
    inline void extend(int c)
    {
        int cur = ++tot , p;
        maxlen[cur] = maxlen[last] + 1;
        for (p=last;p&&!trans[p][c];p=link[p]) 
            trans[p][c] = cur;
        if ( p == 0 ) link[cur] = 1;
        else
        {
            int q = trans[p][c];
            if ( maxlen[q] == maxlen[p] + 1 ) link[cur] = q;
            else
            {
                int cl = ++tot;
                maxlen[cl] = maxlen[p] + 1;
                memcpy( trans[cl] , trans[q] , sizeof trans[q] );
                link[cl] = link[q];
                for (;p&&trans[p][c]==q;p=link[p])
                    trans[p][c] = cl;
                link[cur] = link[q] = cl;
            }
        }
        last = cur;
    }
};
SuffixAutomation T;
int m,len,deg[2*N];
long long tot[N*2],f[N*2],ans; 
char s[N];
inline void Topsort(void)
{
    queue <int> q;
    q.push( 1 ) , tot[1] = 1;
    for (int i=1;i<=T.tot;i++)
        for (int j=0;j<=10;j++)
            ++deg[ T.trans[i][j] ];
    while ( !q.empty() )
    {
        int x = q.front(); q.pop();
        for (int i=0;i<=10;i++)
        {
            int y = T.trans[x][i];
            if ( y == 0 ) continue;
            if ( i != 10 )
            {
                tot[y] = ( tot[y] + tot[x] ) % Mod;
                f[y] = ( f[y] + f[x] * 10 % Mod + 1LL * i * tot[x] % Mod ) % Mod;
            }
            if ( !--deg[y] ) q.push( y );
        }
    }
}
int main(void)
{
    scanf("%d",&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%s",s+1);
        len = strlen( s + 1 );
        for (int j=1;j<=len;j++)
            T.extend( s[j] - '0' );
        if ( i != m ) T.extend( 10 );
    }
    Topsort();
    for (int i=1;i<=T.tot;i++)
        ans = ( ans + f[i] ) % Mod;
    printf("%lld\n",ans);
    return 0;
}

普通LCP (ZROI902)

这道题要用后缀自动机先构建出后缀树，然后计算。

不妨假设我们已经有方法线性地用后缀自动机构建后缀树了，我们显然可以贪心地计算答案：在后缀树上，两个叶结点的\(LCA\)就是这两个后缀的最长公共前缀，那么我们就可以枚举每一个点作为\(LCA\)，找最小的两个点来当\((i,j)\)来贡献答案即可。

为了保证字典序最小，我们在后缀树上按字典序倒叙枚举即可，这样最小字典序的答案会最后把答案覆盖。

现在问题就变成了如何构建后缀树，我们不妨回忆一下后缀链接和\(parent\)树的性质，还有后缀树的定义，其实可以发现倒序把字符串插入后缀自动机，得到的\(parent\)树就是后缀树。

还有一个问题就是我们需要知道后缀树上压缩边的首字符，方便按字典序查找，这个首字符是可以直接计算的，即\(e(link_i,i)_c=s[pos_i+maxlen_{link_i}]\)。

如何理解，节点\(link_i\)到\(i\)的压缩边的首字符就是字符串中第\(pos_i+maxlen_{link_i}\)个字符。我们再看\(pos_i+maxlen_{link_i}\)是什么：\(pos_i\)就是状态\(i\)被建立时的字符位置，而\(maxlen_{link_i}\)就代表了其后缀树上父亲节点自己的最大\(endpos\)集合位置，相加了就是后缀树压缩边上第一个字符，也就是后缀\(i\)和其父亲节点代表子串相异的第一个字符。

于是对所有节点计算答案贡献只需一遍\(dfs\)同时计算即可，时间复杂度\(O(n)\)。

\(Code:\)

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6+20;
struct SuffixAutomation
{
    int maxlen[N*2],link[N*2],id[N*2],trans[N*2][4],tot,last;
    SuffixAutomation () { tot = last = 1; }
    inline void extend(int c,int pos)
    {
        int cur = ++tot , p;
        maxlen[cur] = maxlen[last] + 1;
        id[cur] = pos;
        for (p=last;p&&!trans[p][c];p=link[p])
            trans[p][c] = cur;
        if ( p == 0 ) link[cur] = 1;
        else
        {
            int q = trans[p][c];
            if ( maxlen[q] == maxlen[p] + 1 ) link[cur] = q;
            else
            {
                int cl = ++tot;
                maxlen[cl] = maxlen[p] + 1;
                memcpy( trans[cl] , trans[q] , sizeof trans[q] );
                link[cl] = link[q] , id[cl] = id[q];
                for (;p&&trans[p][c]==q;p=link[p])
                    trans[p][c] = cl;
                link[cur] = link[q] = cl;
            }
        }
        last = cur;
    }
};
SuffixAutomation T;
int n,son[N*2][4],a[N*2],b[N*2]; 
char s[N];
inline void insert(int x,int y,int c) { son[x][c] = y; }
inline void build(void)
{
    for (int i=2;i<=T.tot;i++)
        insert( T.link[i] , i , s[ T.id[i] + T.maxlen[T.link[i]] ] - 'a' );     
}
inline void dfs(int x)
{
    int A,B; A = B = T.id[x];
    for (int i=3;i>=0;i--)
    {
        int y = son[x][i];
        if ( y == 0 ) continue;
        dfs( y );
        if ( T.id[y] < A ) B = A , A = T.id[y];
        else if ( T.id[y] < B ) B = T.id[y];
    }
    a[T.maxlen[x]] = A , b[T.maxlen[x]] = B;
    for (int i=0;i<=3;i++)
        if ( son[x][i] )
            T.id[x] = min( T.id[x] , T.id[son[x][i]] );
}
inline void reset(void)
{
    T.tot = T.last = 1;
    for (int i=1;i<=2*n+1;i++)
    {
        T.id[i] = T.link[i] = T.maxlen[i] = 0;
        memset( T.trans[i] , 0 , sizeof T.trans[i] );
        memset( son[i] , 0 , sizeof son[i] );
    }
}
int main(void)
{
    int t; scanf("%d",&t);
    while ( t --> 0 )
    {
        reset();
        scanf("%s",s+1);
        n = strlen( s + 1 );
        for (int i=n;i>=1;i--) 
            T.extend( s[i] - 'a' , i );
        build();
        for (int i=1;i<=n;i++)
            a[i] = b[i] = n - i + 1;
        dfs( 1 );
        for (int i=1;i<=n;i++)
            printf("%d %d\n",a[i],b[i]);
    }
    return 0;
}

转载于:https://www.cnblogs.com/Parsnip/p/11378130.html

weixin_30952103
关注
算法学习：后缀自动机转后缀树转后缀数组
maxtir的博客
01-08 2916
算法学习：后缀自动机转后缀树转后缀数组 引入 其实这是一篇水文 想要学后缀自动机的话去查2012年noi冬令营陈立杰讲稿 顺便说一句，讲稿上有一些错误，多翻几篇博客加深理解。 今天这里主要要讲的是后缀自动机如何转后缀树和后缀数组 后缀树 这里首先需要提一下后缀树的概念 后缀树其实相当于把所有的后缀插入一颗Trie树 然而时空复杂度都是O(N^2)的 所以我们可以把这可T
从后缀自动机到广义后缀自动机——最详细攻略
AC不动机的博客
07-23 777
广义后缀自动机 前置知识 广义后缀自动机基于下面的知识点 字典树(Trie树) 后缀自动机 请务必对上述两个知识点非常熟悉之后，再来阅读本文，特别是对于后缀自动机中的后缀链接能够有一定的理解 起源 广义后缀自动机是由刘研绎在其2015 国家队论文《后缀自动机在字典树上的拓展》上提出的一种结构，即将后缀自动机直接建立在字典树上。 大部分可以用后缀自动机处理的字符串的问题均可扩展到 Trie 树上。——刘研绎 约定 参考字符串约定 约定字符串的下标为 [1,∣s∣][1, |s|][1,∣s∣]。 约定
后缀自动机转后缀树模板
dianning8393的博客
01-12 138
终于找到教程了，现在来写一发 题目：Jzoj4072(bzoj3998)弦论 第一问 其实非常好写，连空间都不需要多开一倍，只需要sa数组rank数组和height数组就好了，dfs一次可以求出 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<algori...
后缀树与后缀自动机
Lyra's DDF
07-13 1477
先学习的是后缀树向的后缀自动机QAQ介绍后缀树的定义： 把所有后缀插到Trie里 然而实际上是插到Trie里之后再压缩掉一些边，这样就是后缀树了。 但我们发现如果一个一个找的话复杂度是O(n2)O(n ^ 2)的，需要优化。 我们现在要学习在线性时间内构建后缀树。我们考虑倒着建立后缀树，即： 串S = a+S′a + S' 那么我们先建立S′S'的后缀树，然后建立a+S′a + S'的
后缀自动机与线性构造后缀树
Aiphis的博客
10-28 1628
LINK： http://fanhq666.blog.163.com/blog/static/8194342620123352232937/ 冬令营上我犯了最大的一个错误，就是在陈立杰讲后缀自动机的时候睡觉。 这导致了，我在冬令营之后只能花费好几个不眠之夜来思考后缀自动机到底是什么。 突然，在某天的梦里，我看到了一幅神奇的图景，我突然发现，一切都是那么的明晰了。     先说说
Codechef KILLKTH 后缀自动机+后缀树
beginend
06-11 444
题意 给一个长度为n的字符串，把这个串的所有子串按字典序排序后拼到一起组成一个新串，每次询问新串的某个字符是什么。 n≤200000n≤200000n\le200000，强制在线。 分析 先通过建反串的后缀自动机把原串的后缀树建出来，不难发现把子串按字典序排序等价于求出后缀树的dfs序。 那么我们只要在dfs序上二分出对应节点，然后在对应节点里面算一算就好了。 代码 #i...
后缀自动机_陈立杰.pptx
09-14
总结来说，后缀自动机是一种强大的字符串处理工具，它能够在处理字符串问题时提供高效的解决方案，特别是对于那些需要处理大量字符串后缀和子串的情况。通过构建最简状态后缀自动机，我们可以确保在时间和空间效率上...
后缀自动机模板
01-07
fa：后缀链接，简单来说就是与当前节点有相同的后缀，但是最大长度比当前节点小的结点 len：每个节点所储存的字串的最大长度 fa(i)结点与 i 结点的关系： 到达点 i 的所有字符串的长度都必然大于到达 fa(i) 的...
后缀自动机的详解
10-25
通过对关键概念的理解，如 Right 集合、Parent 树等，我们可以高效地构建和利用后缀自动机。此外，通过线性构造算法，我们可以在 \(O(N)\) 时间内完成后缀自动机的构建，这对于处理大规模数据集尤为重要。
关于后缀树的超牛B论文,有详细的图解
10-07
绝对值得下载,我找了N多网站才找到的.相信我没错.当然如果你不想学后缀树就没有用处了.
【后缀自动机】自动机<->后缀树<->后缀数组
huyuncong的专栏
03-27 2212
一直都说自动机建后缀树，一直没真正构出后缀树过... 其实建后缀树很简单，父亲边已经有了，关键是边代表的子串怎么求。从叶子一层一层向上，对于节点i，我们已经知道了它在原串的位置和逆序后缀长度，他的父亲的逆序后缀长度也知道，父亲又是i的逆序后缀的前缀，这就可以直接在原串定位了。 另外，通过父亲边还可以求出节点i可接受的最短子串，设i的最长子串长度为maxlen[i]，最短子串长度为minlen[
广义后缀自动机与后缀树
GEOTCBRL
03-20 4388
广义后缀自动机​ 就是给一堆字符串，把这些字符串插进一个trie之后，能够接收从某个trie节点走到叶子节点（也就是原来任意一个字符串的后缀）的字符串的自动机。​ 构造的时候有离线和在线的做法，dwj老司机的blog有code，2015年lyy的集训队论文有证明。
[后缀自动机 构建后缀树 树形DP] BZOJ 3238 [Ahoi2013]差异
雯舞
01-28 656
反串的parent树就是后缀树 lcp就是他们的lca的深度 也就是后缀自动机上的maxl 然后树形DP一下就好了#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std; typedef long long ll;inline char nc(){ static char buf[100000],*
后缀自动机构造后缀树
Elijahqi
07-12 1811
http://www.elijahqi.win/archives/3945 今天研究一天怎么构造始终想不明白 看到这篇blog之后顿悟 为了帮助其他人避免像蒟蒻我一样 想不明白感到难过 于是随便写一写 要是有错误 qwq麻烦指出 (emm退役之后不知道还会不会上blog) https://www.cnblogs.com/hehe54321/p/8694839.html 看上面两张...
【BZOJ 3238】[Ahoi2013]差异 后缀自动机构造后缀树
pbihao的博客
12-28 844
关于后缀自动机的学习网上有很多，所以我就只说说为什么后缀自动机可以转成后缀树。 个人觉得比较好的后缀自动机的博客：http://blog.sina.com.cn/s/blog_70811e1a01014dkz.html https://blog.csdn.net/litble/article/details/78997914 图片来源：http://blog.sina.com.cn/s/bl...
后缀树与后缀自动机（还没有完工）
547478006的博客
08-12 126
//为啥一个才写了一点点的文章阅读量这么大（SAM这么吸引人的嘛（（（ //因为本身就只是简单了解再加上我觉得这玩意儿对我用处不大还有工程量有点大 //所以这个文章无限期咕咕咕啦！ qwq 自动机 自动机就是如同这样的图 有向联通可有环图 每张图都有一个起点 其他点及称之为接收态 设最左上的点为起点来接收 , 接收一个字符串 "ada" 那么就有边权如...
后缀trie树 & 后缀自动机
weixin_44410512的博客
09-13 329
后缀trie树 后缀trie树 就是在一个字典树里有且只有一个单词的所有后缀 列出字符串MISSISSIPPIMISSISSIPPIMISSISSIPPI的所有后缀 MISSISSIPPI ISSISSIPPI SSISSIPPI SISSIPPI ISSIPPI SSIPPI SIPPI IPPI PPI ...
【后缀自动机-后缀树上的维护】hdu4641
huyuncong的专栏
11-09 1492
每次给字符串加一个字符，并询问当时出现至少k次的子串有多少 貌似数据特别水，看网上题解都是暴力过的，所以自然要给出一个不会超时的算法 当初考的时候，觉得很难维护，因为每次相当于在后缀树上拆一条边，并加点进去，并维护当根路径上的值，好像只能动态树之类的，即便离线，貌似也要用树链剖分，因此当时就没管了 回过头来看，其实还是挺好维护的，甚至只要离线在dfs序上处理就可以了 考虑先把后缀树建好，然
利用后缀自动机解决字符串问题
总结来说，后缀自动机是一种高效的数据结构，尤其适用于处理字符串的后缀和查找公共子串等问题。通过构建和利用后缀自动机，我们可以快速识别和处理大量字符串，提高算法的效率，避免在时限严格的比赛环境中出现超时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值