后缀自动机合集 II

最新推荐文章于 2021-09-14 16:59:17 发布
最新推荐文章于 2021-09-14 16:59:17 发布
阅读量731 收藏
点赞数
分类专栏： 后缀自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/11538133
版权

补充

在SAM中，state_Ai->nxt[w] == stateB ( w: const )

stateB->fa->step <= state_Ai->step ( state_Ai->nxt[w] == stateB )

利用拓扑排序，可构建所有子串在原串中出现的次数

hdu 3518 Boring counting

SAM中的每个状态点都表示为从root出发走到该点所构成的子串，若其作为其他状态的父节点，则说明该子串被其他子串共享。

求出现两次以上且不重复的子串数量只要对每个点记录最早最晚出现的位置

两位置间距大于所表示的串长，res += p->step - p->fa->step

否则，取其中的部分

#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 1010;
char s[MAXN ];
struct node
{
    node*nxt[26], *fa;
    int step;
    int pos;
    int fst, lst;
    int num;
    void clear()
    {
        fa = 0, step = 0;
        fst = lst = 0;
        num = 0;
        memset ( nxt, 0, sizeof nxt );
    }
} *root, *tail, nodePool[MAXN << 1], *cur, *cnt;
void init()
{
    cur = nodePool;
    root = tail = cur++;
    root->clear();
    root->pos = 0;
}
void Insert ( int w )
{
    node *p = tail, *np = cur++;
    np->clear();
    np->step = p->step + 1;
    np->pos = np->step;
    for ( ; p && !p->nxt[w]; p = p->fa ) { p->nxt[w] = np; }
    if ( !p )
    {
        np->fa = root;
    }
    else
    {
        if ( p->nxt[w]->step == p->step + 1 )
        {
            np->fa = p->nxt[w];
        }
        else
        {
            node *q = p->nxt[w], *r = cur++;
            *r = *q;
            r->step = p->step + 1;
            q->fa = np->fa = r;
            for ( ; p && p->nxt[w] == q; p = p->fa ) { p->nxt[w] = r; }
        }
    }
    tail = np;
}
int c[MAXN]; node *seq[MAXN << 1];
void solve()
{
    node *a = nodePool;
    node *p;
    for ( char *p = s; *p; ++p )
    {
        int w = *p - 'a';
        a = a->nxt[w];
        a->fst = a->lst = a->pos;
        a->num = 1;
    }
    memset ( c, 0, sizeof c );
    for ( int i = 0; i < cur - nodePool; ++i ) { c[nodePool[i].pos]++; }
    for ( int i = 1; i <= tail->pos; ++i ) { c[i] += c[i - 1]; }
    for ( int i = 0; i < cur - nodePool; ++i ) { seq[--c[nodePool[i].pos]] = nodePool + i; }
    for ( int i = cur - nodePool - 1; i >= 0; --i )
    {
        p = seq[i];
        if ( p->fst == 0 && p->lst == 0 ) { p->fst = p->lst = p->pos; }
        if ( p->fa )
        {
            node *q = p->fa;
            q->num += p->num;
            if ( q->fst == 0 || q->fst > p->fst ) { q->fst = p->fst; }
            if ( q->lst == 0 || q->lst < p->lst ) { q->lst = p->lst; }
        }
    }
    int res = 0;
    for ( p= root+1; p< cur; ++p)
	{
		if (p->num > 1)
		{
			if ( p->lst - p->fst >= p->step)
				res += p->step - p->fa->step;
			else if (p->lst - p->fst > p->fa->step)
				res += p->lst - p->fst - p->fa->step;
		}
	}
	printf("%d\n", res);
}
int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    while ( scanf ( "%s", s ) != EOF && s[0] != '#' )
    {
        init();
        for ( char *p = s; *p; ++p ) { Insert ( *p - 'a'); }
        solve();
    }
    return 0;
}

CF 235C. Cyclical Quest

菜鸟从未碰过CF，通过大神们的博客找到这题

开始还一直卡在如何确定当前已匹配长度串在SAM中的位置，果然理解还是不够

#include <stdio.h>
#include <iostream>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 1000010;
typedef long long LL;
char s[MAXN << 1];
struct node
{
    node*nxt[26], *fa;
    int step;
    int flg;
    int num;
    void clear()
    {
        fa = 0, step = 0;
        flg = -1; num = 0;
        memset ( nxt, 0, sizeof nxt );
    }
} *root, *tail, nodePool[MAXN << 1], *cur;
void init()
{
    cur = nodePool;
    root = tail = cur++;
    root->clear();
}
void Insert ( int w )
{
    node *p = tail, *np = cur++;
    np->clear();
    np->step = p->step + 1;
    for ( ; p && !p->nxt[w]; p = p->fa ) { p->nxt[w] = np; }
    if ( !p )
    {
        np->fa = root;
    }
    else
    {
        if ( p->nxt[w]->step == p->step + 1 )
        {
            np->fa = p->nxt[w];
        }
        else
        {
            node *q = p->nxt[w], *r = cur++;
            *r = *q;
            r->step = p->step + 1;
            q->fa = np->fa = r;
            for ( ; p && p->nxt[w] == q; p = p->fa ) { p->nxt[w] = r; }
        }
    }
    tail = np;
}
int c[MAXN]; node *seq[MAXN << 1];
void preInit()
{
    node *a;
    memset ( c, 0, sizeof c );
    for ( int i = 0; i < cur - nodePool; ++i ) { c[nodePool[i].step]++; }
    for ( int i = 1; i <= tail->step; ++i ) { c[i] += c[i - 1]; }
    for ( int i = 0; i < cur - nodePool; ++i ) { seq[--c[nodePool[i].step]] = nodePool + i; }
    a = root;
    for ( char *st = s; *st; ++st )
    {
        a = a->nxt[*st - 'a'];
        a->num = 1;
    }
    for ( int i = cur - nodePool - 1; i >= 0; --i )
    {
        a = seq[i];
        if ( a->fa )
        {
            a->fa->num += a->num;
        }
    }
}
void solve ( int cao )
{
    int len = strlen ( s ), w, l;
    LL res = 0;
    node *p = root;
    int sum = 0;
    memcpy ( s + len, s, ( len - 1 ) );
    l = len;
    len = len * 2 - 1;
    * ( s + len ) = 0;
    for ( int i = 0; i < len; ++i )
    {
        w = s[i] - 'a';
        if ( p->nxt[w] )
        {
            sum++, p = p->nxt[w];
        }
        else
        {
            while ( p && p->nxt[w] == NULL ) { p = p->fa; }
            if ( !p )
            {
                sum = 0, p = root;
            }
            else
            {
                sum = p->step + 1, p = p->nxt[w];
            }
        }
        if ( i >= l - 1 && sum >= l )
        {
            node *q = p;
            while ( 1 )
            {
                if ( l > q->fa->step && p->step >= l ) { break; }
                q = q->fa;
            }
            if ( q->flg != cao )
            {
                res += q->num;
                q->flg = cao;
            }
        }
    }
    cout << res << endl;
}
int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    int n;
    scanf ( "%s", s );
    init();
    for ( char *p = s; *p; ++p ) { Insert ( *p - 'a' ); }
    preInit();
    scanf ( "%d", &n );
    for ( int i = 1; i <= n; ++i )
    {
        scanf ( "%s", s );
        solve ( i );
    }
    return 0;
}

hdu 4641 K-string

主要考对SAM基础的理解，还有些烦到死的优化

#include <stdio.h>
#include <iostream>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 260000;
typedef long long LL;
char s[MAXN];
int n, m, k;
int res;
struct node
{
    node*nxt[26], *fa;
    int step;
    int num;
    int flag;
    void clear()
    {
        fa = 0, step = 0;
        num = 0; flag = 0;
        memset ( nxt, 0, sizeof nxt );
    }
} *root, *tail, nodePool[MAXN << 1], *cur;
void init()
{
    cur = nodePool;
    root = tail = cur++;
    root->clear();
    res = 0;
}
void Insert ( int w )
{
    node *p = tail, *np = cur++;
    np->clear();
    np->step = p->step + 1;
    for ( ; p && !p->nxt[w]; p = p->fa ) { p->nxt[w] = np; }
    if ( !p )
    {
        np->fa = root;
        np->num ++;
        if ( 1 >= k ) { res += np->step; np->flag = 1;}
    }
    else
    {
        if ( p->nxt[w]->step == p->step + 1 )
        {
            node *q = np;
            np->fa = p->nxt[w];
            while ( q != root && !q->flag )
            {
                q->num++;
                if ( q->num >= k )
                {
                    res += q->step - q->fa->step;
                    q->flag = 1;
                }
                q = q->fa;
            }
        }
        else
        {
            node *q = p->nxt[w], *r = cur++;
            node *wocao = q->fa;
            *r = *q;
            r->step = p->step + 1;
            np->num++;
            r->num = 1 + q->num;
            if ( r->num >= k ) { res += r->step - wocao->step; r->flag = 1;}
            for ( node *as = q->fa; as != root && !as->flag; as = as->fa )
            {
                as->num++;
                if ( as->num >= k )
                {
                    res += as->step - as->fa->step;
                    as->flag = 1;
                }
            }
            if ( q->num >= k ) { res -= q->step - wocao->step; }
            q->fa = np->fa = r;
            if ( q->num >= k ) { res += q->step - r->step; }
            if ( np->num >= k ) { res += np->step - r->step; np->flag = 1;}
            for ( ; p && p->nxt[w] == q; p = p->fa ) { p->nxt[w] = r; }
        }
    }
    tail = np;
}

int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    while ( scanf ( "%d%d%d", &n, &m, &k ) == 3 )
    {
        scanf ( "%s", s );
        init();
        for ( char *p = s; *p; ++p ) { Insert ( *p - 'a' ); }
        int a;
        while ( m-- )
        {
            scanf ( "%d", &a );
            if ( a == 1 )
            {
                scanf ( "%s", s );
                Insert ( s[0] - 'a' );
            }
            else
            {
                printf ( "%d\n", res );
            }
        }
    }
    return 0;
}


deprecated_tzg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
后缀自动机 SAM
01-06
SAM 是 DFA 确定性有限状态自动机，是一张 DAG 有向无环图。结点为 状态 ，边被为状态间的 转移。 图存在一个虚拟结点 SSS ，称作 初始状态 ，其它各结点均可从 SSS 出发到达。 每个 转移 都标有一些字母。从一个...
后缀自动机模板
01-07
fa：后缀链接，简单来说就是与当前节点有相同的后缀，但是最大长度比当前节点小的结点 len：每个节点所储存的字串的最大长度 fa(i)结点与 i 结点的关系： 到达点 i 的所有字符串的长度都必然大于到达 fa(i) 的...
后缀自动机——所有子串个数
行走天涯的豆沙包的博客
06-14 266
传送门 题解： 背过题，sam构造理解还是好难，求子串个数一个是跑DAG，一个就是len[last]−len[fa[last]]len[last]-len[fa[last]]len[last]−len[fa[last]] #include <bits/stdc++.h> using namespace std; const int maxn = 1e5+10; long long res=0; struct SuffixAutoMation { int last=1,cnt=1;//cn
洛谷 P3804 【模板】后缀自动机 统计单词出现次数
EM LGH
01-19 313
洛谷 P3804 【模板】后缀自动机 统计单词出现次数 后缀自动机模板题. 关键时求解每个节点的 $right$ 大小. 由于后缀自动机在构建时会保证点和点的 $right$ 只可能没有交集，或者一个是另一个的真子集，我们可以不重复的对 $right$ 进行统计与更新. 从长度大的子串向前更新，沿着 $parent$ 跳即可. 最后再枚举一下. C...
#1449 : 后缀自动机三·重复旋律6 后缀自动机 某个长度的字串，在原串中出现的次数的最大值
bjfu170203101的博客
09-30 145
先用SAM建出的后缀树的性质，求出每个endpos集合的大小。 然后用线段树或线性更新求出每个长度出现次数的最大值即可。 #include <bits/stdc++.h> using namespace std; typedef long long ll; const int M = 1e6+7; int head[2*M],cnt=1;//点集大小是2被的字符串长度 void init(int n){cnt=1;for(int i=0;i<=n;i++)head[i]=0;}
统计每个长度 出现的最多次数 后缀自动机 板子
Hallelujah520的博客
09-12 328
描述小Hi平时的一大兴趣爱好就是演奏钢琴。我们知道一个音乐旋律被表示为一段数构成的数列。现在小Hi想知道一部作品中所有长度为K的旋律中出现次数最多的旋律的出现次数。但是K不是固定的，小Hi想知道对于所有的K的答案。解题方法提示输入共一行，包含一个由小写字母构成的字符串S。字符串长度不超过 1000000。输出共Length(S)行，每行一个整数，表示答案。样例输入 aab 样例输出 2 1
SPOJ8222(后缀自动机--出现次数最多的子串)
ACdreamer
09-01 3671
题目：http://www.spoj.com/problems/NSUBSTR/   题意：给一个字符串S，令F(x)表示S的所有长度为x的子串中，出现次数的最大值。求F(1)..F(Length(S))   #include #include #include #include using namespace std; const int N=250005;
后缀自动机_陈立杰.pptx
09-14
后缀自动机（Suffix Automaton）是一种特殊类型的有限状态自动机，主要被用于字符串处理，特别是在计算机科学的算法中，特别是在解决与字符串模式匹配、最长公共子串等问题相关的任务时非常有用。它能够识别给定字符...
后缀自动机算法代码 C++
05-09
后缀自动机C++实现, 将后缀自动机写成了结构体, 配有详细的注释内容
后缀自动机建树过程
01-29
SAM建树过程 AC自动机Trie 图的建立过程 详细的图示
后缀自动机
03-16
后缀自动机 陈立杰
后缀自动机ppt
02-09
2012年noi冬令营陈立杰的讲稿，内容是后缀自动机
后缀自动机的应用
03-16
后缀自动机的应用
后缀自动机的详解
10-25
关于后缀自动机的一系列讲解，包括（概念，原理，证明，代码，例题......）。
后缀自动机统计 子串长度出现次数 NSUBSTR - Substrings
xizi_ghq的博客
10-09 409
You are given a string S which consists of 250000 lowercase latin letters at most. We define F(x) as the maximal number of times that some string with length x appears in S. For example for string ...
后缀自动机 ---- P3804 【模板】后缀自动机(求每个等价类最长串的出现次数)
weixin_45630722的博客
09-14 197
后缀自动机一些关键点 首先后缀自动机上面每个节点都是一个等价类并且是最长的字符串的结尾 后缀自动机上的fail链反建就是parent tree，下面是SAM和Parent tree的构造 对于这道模板题我们先看看代码： 这里有一个关键点就是我们设num[i]num[i]num[i]为SAM中这个点是否为终止节点。我们根据parent  treeparent\;treeparenttree的定义，知道非终止节点的是会被下面全部终止节点所覆盖的！！ 因为我们根据SAM的构建我们知道之所以要分裂出一个非
【SPOJ - NSUBSTR】Substring（统计长度为x的子串最多出现的次数--后缀自动机）
Cassie_zkq的博客
10-06 546
题目地址：https://cn.vjudge.net/problem/SPOJ-NSUBSTR 解题思路： 建立SAM,先统计每个状态的最长子串出现的次数（应该是这个意思吧，这个状态substring中的每个子串也都出现了相同的次数），每个状态st的substring中的子串长度区间为[maxlen[link[st]]+1,maxlen[st]]。 对于状态st1，substring（st1...
后缀自动机 重复旋律 6（长度为K的旋律中出现次数最多的旋律的出现次数）
黑码
10-03 561
题目1 : 后缀自动机三·重复旋律6 时间限制:15000ms 单点时限:3000ms 内存限制:512MB 描述小Hi平时的一大兴趣爱好就是演奏钢琴。我们知道一个音乐旋律被表示为一段数构成的数列。现在小Hi想知道一部作品中所有长度为K的旋律中出现次数最多的旋律的出现次数。但是K不是固定的，小Hi想知道对于所有的K的答案。解题方法提示输入共一行，包含一个由小写字母构成的字符串S。字符串长度不

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值