后缀自动机合集 I

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

简介


有关后缀自动机的理论和证明各路大神的博客多如牛毛，就不细说。

贴图太占载入速度了，还是去看原版的解析吧  http://hi.baidu.com/myidea/item/142c5cd45901a51820e25039

对于每个State点，father指向与该节点可接收相同后缀的节点，其表示的字串通常是当前节点表示字串的后面部分，

因此State->step - Sate->father->step 代表从任一后缀串起始走到该状态的路径数


hdu 4622 Reincarnation

对每个状态点减去父状态的步骤数的和就是字符串所有字串的数量

#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 2010;
int ans[MAXN][MAXN];
char s[MAXN];
struct node
{
    node*nxt[26], *fa;
    int step;
    void clear()
    {
        fa = 0, step = 0;
        memset ( nxt, 0, sizeof nxt );
    }
    int calc()
    {
        if ( !fa ) { return 0; }
        return step - fa->step;
    }
} *root, *tail, nodePool[MAXN * 2], *cur;
void init()
{
    cur = nodePool;
    root = tail = cur++;
    root->clear();
}
int tot;
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;
        tot += np->calc();
    }
    else
    {
        if ( p->nxt[w]->step == p->step + 1 )
        {
            np->fa = p->nxt[w];
            tot += np->calc();
        }
        else
        {
            node *q = p->nxt[w], *r = cur++;
            *r = *q;
            tot -= q->calc();
            r->step = p->step + 1;
            q->fa = np->fa = r;
            tot += q->calc() + r->calc() + np->calc();
            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__
    int t;
    scanf ( "%d", &t );
    while ( t-- )
    {
        scanf ( "%s", s );
        int n = strlen ( s );
        for ( int i = 0; i < n; ++i )
        {
            init();
            tot = 0;
            for ( int j = i; j < n; ++j )
            {
                Insert ( s[j] - 'a' );
                ans[i][j] = tot;
            }
        }
        
        int q;
        scanf ( "%d", &q );
        while ( q-- )
        {
            int l, r;
            scanf ( "%d%d", &l, &r );
            l--, r--;
            printf ( "%d\n", ans[l][r] );
        }
    }
    return 0;
}

hdu 1403 Longest Common Substring

每个step姑且认为是转移到该状态时可接收的最大字符串

最长公共子串 
#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 100010;
char s[MAXN];
struct node
{
    node*nxt[26], *fa;
    int step;
    void clear()
    {
        fa = 0, step = 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 solve()
{
	int l = strlen(s), w, res = 0, sum= 0;
	node *p = root;
	for (int i = 0; i< l; ++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== NULL)
			{
				sum = 0;
				p = root;
			}
			else
			{
				sum = p->step + 1;
				p = p->nxt[w];
			}
		}
		res = max(sum, res);
	}
	return res;
}
int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    while ( scanf("%s", s) != EOF)
    {
        init();
        int l = strlen(s);
        for (int i = 0; i< l; ++i)
		{
			Insert(s[i]-'a'); 
		}
		scanf("%s", s);
		printf("%d\n", solve());
    }
    return 0;
}


hdu 4416 Good Article Good sentence

菜鸟对SAM的理解还是太弱了，借鉴了别人的代码才搞懂

本题用SAM来做，核心是记录下到达每个State时能得到Bi字串的最大长度。

再此还要解释下，引入father指针的目的是最大化状态的重用性，每个状态的父节点表示的串 == 当前状态所表示的字符串最后几位

因此，父节点的deep要更新为自身及子节点deep的最大值

每个节点deep - step 就表示为除去不符合要求串数量的后的值 

#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MAXN = 100010;
char s[MAXN];
struct node
{
    node*nxt[26], *fa;
    int step;
    int deep;
    void clear()
    {
        fa = 0, step = 0; deep = 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;
}
void update()
{
    int l = strlen ( s ), w, sum = 0;
    node *p = root;
    for ( int i = 0; i < l; ++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 == NULL )
            {
                sum = 0;
                p = root;
            }
            else
            {
                sum = p->step + 1;
                p = p->nxt[w];
            }
        }
        p->deep = max ( p->deep, sum );
    }
}
int p[MAXN << 1]; node *op[MAXN << 1];
int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    int t, cs = 0;
    int n;
    scanf ( "%d", &t );
    
    while ( t-- )
    {
        printf ( "Case %d: ", ++cs );
        scanf ( "%d", &n );
        scanf ( "%s", s );
        init();
        int l = strlen ( s );
        for ( int i = 0; i < l; ++i ) { Insert ( s[i] - 'a' ); }
        for ( int i = 0; i < n; ++i )
        {
            scanf ( "%s", s );
            update();
        }
        LL res = 0;
        memset ( p, 0, sizeof p );
        for ( int i = 0; i < cur - root; ++i ) { p[nodePool[i].step]++; }
        for ( int i = 1; i <= tail->step; ++i ) { p[i] += p[i - 1]; }
        for ( int i = 0; i < cur - root; ++i ) { op[--p[nodePool[i].step]] = nodePool + i; }
        for ( int i = cur - root - 1; i > 0; --i )
        {
            node *u = op[i];
            if ( u->deep > 0 )	
            {
                u->fa->deep = max ( u->fa->deep, u->deep );
                if ( u->deep < u->step )
                {
                    res += u->step - u->deep ;
                }
            }
            else
            {
                res += u->step - u->fa->step;
            }
        }
#ifdef __GNUC__
        printf ( "%lld\n", res );
#else
        printf ( "%I64d\n", res );
#endif
    }
    return 0;
}


hdu 4270 Dynamic Lover

关键问题是后缀自动机状态删除，可行的办法就是设置标记表示该状态是否被删除，且同一状态的拷贝点也指向相同的标记 

#include <stdio.h>
#include <vector>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 200020;
char s[MAXN ];
int isDel[MAXN], delCnt;
struct node
{
    node*nxt[26], *fa;
    int step;
    int *isdel;
    int pos;
    node *flg;
    void clear()
    {
        fa = 0, step = 0; isdel = 0; flg = 0;
        memset ( nxt, 0, sizeof nxt );
    }
} *root, *tail, nodePool[MAXN << 1], *cur, *mseq[MAXN], *cnt;
void init()
{
    memset ( isDel, 0, sizeof isDel );    
    cur = nodePool;
    root = tail = cur++;
    root->clear();
    mseq[0] = root;
    root->isdel = isDel;
    delCnt = 1;
}
int judge ( node *x )
{
    return x == NULL || *x->isdel;
}
void Insert ( int w )
{
    node *p = tail, *np = cur++;
    np->clear();
    np->step = p->step + 1;
    np->pos = np->step;
    mseq[np->pos] = np;
    np->isdel = isDel + delCnt++;
    for ( ; p && judge ( 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 flag, tl;
void dfs ( node *k, int l )
{
    if ( flag ) { return; }
    if ( l == tl ) {flag = k->pos - l + 1; return; }
    if ( k->flg == cnt )
    {
        flag = cnt->pos - l + 1;
        return;
    }
    for ( int i = 0; !flag && i < 26; ++i )
    {
        if ( k->nxt[i] && !*k->nxt[i]->isdel )
        {
            dfs ( k->nxt[i], l + 1 );
        }
    }

}

int main()
{
#ifdef  __GNUC__
    freopen ( "in.txt", "r", stdin );
#endif // __GNUC__
    int n, c, k;
    char *p;
    while ( scanf ( "%s", s ) != EOF )
    {
        init();
        for ( p = s; *p; ++p ) { Insert ( *p - 'a' ); }
        scanf ( "%d", &n );
        while ( n-- )
        {
            scanf ( "%d", &c );
            if ( c == 1 )
            {
                scanf ( "%s", s );
                char *p = s;
                for ( ; *p; ++p ) { Insert ( *p - 'a' ); }
            }
            else if ( c == 2 )
            {
                cnt = tail;
                for ( node *as = tail; as != root ; as = as->fa )
                {
                    as->flg = cnt;
                }
                scanf ( "%d", &k );
                flag = 0; tl = k;
                dfs ( root, 0 );
                printf ( "%d\n", flag );
            }
            else
            {
                scanf ( "%d", &k );
                while ( k-- )
                {
                    *tail->isdel = 1;
                    tail = mseq[tail->step - 1];
                }
            }
        }
    }
    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) 的...
后缀自动机基础
qq_42852687的博客
01-26 1099
文章目录引入：二，自动机思维1，SAM结点的具体信息2，SAM图的特点 引入： 一、SAM的性质: SAM是个状态机。一个起点，若干终点。原串的所有子串和从SAM起点开始的所有路径一一对应，不重不漏。所以终点就是包含后缀的点。 每个点包含若干子串，每个子串都一一对应一条从起点到该点的路径。且这些子串一定是里面最长子串的连续后缀。 SAM问题中经常考虑两种边： (1) 普通边，类似于Trie。表示在某个状态所表示的所有子串的后面添加一个字符。 (2) Link、Father。表示将某个状态所表示的最短子串的首
HDU 4270 Dynamic Lover 后缀自动机
Gatevin的专栏
04-27 1257
题目大意： 就是现在初始有一个字符串, 然后接下来有m (m 大致思路： 首先用后缀自动机的话对于添加操作和询问操作都很容易解决, 但是对于删除操作就不太好办了 对于删除操作需要对于SAM中的每个节点都添加一个del指针, 表示是否已经被删除, 然后由于每次添加新字符的时候最多只会添加2个节点, 将有同一次插入字符新生成的结点的del指针指向同一个bool的域, 那么删除操作的时
后缀自动机的构造
clover_hxy的博客
12-20 2317
后缀自动机的构造 最近看了一些后缀自动机的论文，对于后缀自动机的构造过程有了些许了解。 首先后缀自动机顾名思义就是一颗包含了原串s所有后缀的字母树。如果直接像构建trie树的方式构建节点数应该是|S|^2，这个空间显然承受不住。 观察上图可以发现有很多的节点都只有一个儿子，并且相同的部分非常多，所以后缀自动机就是用增量法进行构造，使最终的状态数变成|s|。在后缀自动机中每个节点可能会
[后缀自动机] BZOJ5084. hashit
CE玩家
01-28 573
陈老师神题 考虑怎么删除，每次插入最多增加两个节点，那么删除只要删除两个节点就好了 加入字符时会改变两个值，一个是nxt一个是fail 当我们删除节点 u" role="presentation">uuu 时，如果一个点 v" role="presentation">vvv 的fail是 u" role="presentation">uuu，那么要把 failv" role="present
【学习笔记】后缀自动机SAM
七代目鸽影
12-30 3985
学了 24 个小时都没学懂……
后缀自动机 AC自动机
qq_62539009的博客
05-10 806
ps：这两个自动机算是字符串算法里最抽象的了。AC自动机还好学会了，后缀自动机断断续续学了两天没学会，只搞懂了大概。关于构造后缀自动机的第三种情况拆点总觉得似懂非懂。先给个板子，以后再补详解。（希望不咕~） void ex_sam(int c){ int p=las,np=las=++cnt;num[cnt]=1; tre[np].len=tre[p].len+1; for(;p&&!tre[p].ch[c];p=tre[p].fa)tre[p].ch[c]=np
后缀自动机（SAM）
qq_51274548的博客
09-01 2120
后缀自动机
后缀自动机
Top_xiao的博客
12-13 345
在解决问题的应用 简便起见，我们假设字母表的大小k为常数。 存在性查询 问题 给定文本T，询问格式如下：给定字符串P，问P是否是T的子串。 复杂度要求.预处理O(length(T))，每次询问O§。 算法.我们对文本T用O(length(T))建立后缀自动机。 现在回答单次询问。假设状态——变量v，最初是初始状态T_0.我们沿字符串P给出的路径走，因此从当前状态经转移来到新的状态v 。如果在某时刻...
后缀自动机的模板
beckyUp的博客
10-15 271
后缀自动机真是个好东西 #include &lt;bits/stdc++.h&gt; #define cl(a) memset(a,0,sizeof(a)) #define ll long long #define pb(i) push_back(i) #define sc(x) scanf("%d",&amp;x) using namespace std; const int maxn=2010...
后缀自动机例题精讲
lleozhang的博客
04-20 576
这一篇是后缀自动机的一些例题题解及总结： 例： bzoj 3998 题意：求一个字符串中第k小子串，t=0表示子串仅区别字典序，t=1表示子串区分起止位置 解析：建起后缀自动机，构造parent树，利用后缀自动机有向无环累计子串个数查询即可 具体解析：https://blog.csdn.net/lleozhang/article/details/89413818 bzoj 2780 ...
后缀自动机_陈立杰.pptx
09-14
后缀自动机（Suffix Automaton）是一种特殊类型的有限状态自动机，主要被用于字符串处理，特别是在计算机科学的算法中，特别是在解决与字符串模式匹配、最长公共子串等问题相关的任务时非常有用。它能够识别给定字符...
后缀自动机算法代码 C++
05-09
后缀自动机C++实现, 将后缀自动机写成了结构体, 配有详细的注释内容
udp分片报文pcap文件
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
计算机教学导案.doc
07-18
计算机
摩根：2024年大市前瞻.pdf
最新发布
07-18
摩根：2024年大市前瞻
计算机控制专业技术专题实习任务书温度控制.doc
07-18
计算机
利用后缀自动机解决字符串问题
"后缀自动机实现与应用" 后缀自动机（Suffix Automaton），也称为后缀自动机，是由杭州外国语学校的陈立杰所讲解的一种数据结构，它在字符串处理中有着重要的应用。陈立杰提到，后缀自动机在解决特定的字符串问题时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值