后缀自动机入门题集

最新推荐文章于 2021-10-20 17:30:03 发布
最新推荐文章于 2021-10-20 17:30:03 发布
阅读量94 收藏 1
点赞数
原文链接：http://www.cnblogs.com/mrclr/p/10450821.html
版权

学了好几天后缀自动机，总算是真正搞懂了，才敢来发博客。

后缀自动机是啥以及怎么构造就不说了，毕竟有很多博客比我讲的好多了。
还是按照国际惯例，推荐几发：
hiho一下 127~132周
后缀自动机入门
史上最通俗的后缀自动机详解

先谈谈我对parent tree的理解：
首先由后缀链接构成的树就叫做parent tree（也叫后缀链接树）。
但是我们存的是反边，所以想dfs的时候就很不舒服，有两种解决办法：
1.倒着存正边（没见人用过）。
2.根据SAM的性质，子节点所代表的最长的字符串的长度一定大于父亲节点的，所以根据len的大小排序，然后从大往小更新即可。排序的时候用桶排序，可以省去一个log。
后缀链接的父亲节点的endpos完全包含子节点的endpos，且父亲节点所代表的字符串是子节点的后缀。
关于每一个节点存的endpos的数量，父亲节点的不一定恰好比子节点多1，而是子节点的endpos数量之和等于父亲节点的。

接下来是入门题：
luogu P3804 【模板】后缀自动机
确实是模板，我们建完后缀自动机后，求出每一个节点的endpos的数量，做法就是插入的同时标记一下这个节点是一个endpos。然后递归求一遍子树的endpos之和就是这个节点的endpos个数咯。之后如果siz[i] > 1，就用siz[i] * len[i]更新答案。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e6 + 5;
const int maxs = 30;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

char s[maxn];
struct Sam
{
  int las, cnt;
  int tra[maxn << 1][maxs], link[maxn << 1], len[maxn << 1];
  int siz[maxn << 1];
  In void init()
  {
    link[las = 0] = -1, len[cnt = 0] = 0;
  }
  In void insert(int c)
  {
    int now = ++cnt;
    len[now] = len[las] + 1;
    int p = las;
    while(p != -1 && !tra[p][c]) tra[p][c] = now, p = link[p];
    if(p == -1) link[now] = 0;
    else
      {
    int q = tra[p][c];
    if(len[q] == len[p] + 1) link[now] = q;
    else
      {
        int clo = ++cnt;
        len[clo] = len[p] + 1;
        memcpy(tra[clo], tra[q], sizeof(tra[q]));
        link[clo] = link[q];
        link[q] = link[now] = clo;
        while(p != -1 && tra[p][c] == q) tra[p][c] = clo, p = link[p];
      }
      }
    siz[las = now] = 1;
  }
  int buc[maxn << 1], pos[maxn << 1];
  In int dfs()
  {
    int ret = 0;
    for(int i = 1; i <= cnt; ++i) ++buc[len[i]];
    for(int i = 1; i <= cnt; ++i) buc[i] += buc[i - 1];
    for(int i = 1; i <= cnt; ++i) pos[buc[len[i]]--] = i;
    for(int i = cnt; i; --i)
      {
    int now = pos[i];
    siz[link[now]] += siz[now];
    if(siz[now] > 1) ret = max(ret, siz[now] * len[now]);
      }
    return ret;
  }
}S;

int main()
{
  scanf("%s", s);
  int n = strlen(s); S.init();
  for(int i = 0; i < n; ++i) S.insert(s[i] - 'a');
  write(S.dfs()), enter;
  return 0;
}


SP1811 LCS
求两个串的lcs。
把一个串建成后缀自动机，然后另一个串在上面跑，相当于枚举另一个串的前缀，看每一个前缀的后缀最多能和原串匹配多少。每成功匹配一个节点，就用当前匹配的长度更新答案。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 2.5e5 + 5;
const int maxs = 30;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

char s1[maxn], s2[maxn];
struct Sam
{
  int las, cnt;
  int tra[maxn << 1][maxs], len[maxn << 1], link[maxn << 1];
  In void init() {link[las = cnt = 0] = -1;}
  In void insert(int c)
  {
    int now = ++cnt, p = las;
    len[now] = len[las] + 1;
    while(~p && !tra[p][c]) tra[p][c] = now, p = link[p];
    if(p == -1) link[now] = 0;
    else
      {
    int q = tra[p][c];
    if(len[q] == len[p] + 1) link[now] = q;
    else
      {
        int clo = ++cnt;
        memcpy(tra[clo], tra[q], sizeof(tra[q]));
        len[clo] = len[p] + 1;
        link[clo] = link[q]; link[q] = link[now] = clo;
        while(~p && tra[p][c] == q) tra[p][c] = clo, p = link[p];
      }
      }
    las = now;
  }
  In int lcs(char* s)
  {
    int n = strlen(s), ret = 0;
    for(int i = 0, p = 0, l = 0; i < n; ++i)
      {
    int c = s[i] - 'a';
    if(tra[p][c]) ++l, p = tra[p][c];
    else
      {
        while(~p && !tra[p][c]) p = link[p];
        if(p == -1) l = p = 0;
        else l = len[p] + 1, p = tra[p][c];
      }
    ret = max(ret, l);
      }
    return ret;
  }
}S;

int main()
{
  scanf("%s%s", s1, s2);
  int n = strlen(s1); S.init();
  for(int i = 0; i < n; ++i) S.insert(s1[i] - 'a');
  write(S.lcs(s2)), enter;
  return 0;
}


SP1812 LCS2
求多个串的lcs。
还是先把一个串建成后缀自动机。
然后对于每一个串，都放在后缀自动机上跑，记录在每一个节点能匹配的最大长度。然后这些长度取min，就是所有串在每一个节点能匹配的最大长度。最后答案遍历每一个节点取max即可。
不过还得想一想的是，如果这个节点成功匹配了，那么他的所有祖先节点显然也是匹配了的，但是却只标记了这个节点。所以在每一个串跑完后缀自动机后，从叶子节点把把标记在上传一遍，更新所有祖先节点的匹配情况。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e5 + 5;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

char s[maxn];
struct Sam
{
  int las, cnt;
  int tra[maxn << 1][30], len[maxn << 1], link[maxn << 1];
  In void init() {link[las = cnt = 0] = -1;}
  In void insert(int c)
  {
    int now = ++cnt, p = las;
    len[now] = len[las] + 1;
    while(~p && !tra[p][c]) tra[p][c] = now, p = link[p];
    if(p == -1) link[now] = 0;
    else
      {
    int q = tra[p][c];
    if(len[q] == len[p] + 1) link[now] = q;
    else
      {
        int clo = ++cnt;
        memcpy(tra[clo], tra[q], sizeof(tra[q]));
        len[clo] = len[p] + 1;
        link[clo] = link[q]; link[q] = link[now] = clo;
        while(~p && tra[p][c] == q) tra[p][c] = clo, p = link[p];
      }
      }
    las = now;
  }
  int buc[maxn << 1], pos[maxn << 1];
  In void sort()
  {
    for(int i = 1; i <= cnt; ++i) ++buc[len[i]];
    for(int i = 1; i <= cnt; ++i) buc[i] += buc[i - 1];
    for(int i = 1; i <= cnt; ++i) pos[buc[len[i]]--] = i;
  }
  int Max[maxn << 1], Min[maxn << 1];
  In void lcs(char* s)
  {
    int n = strlen(s);
    for(int i = 0, p = 0, l = 0; i < n; ++i)
      {
    int c = s[i] - 'a';
    while(~p && !tra[p][c]) p = link[p], l = len[p];
    if(p == -1) p = l = 0;
    else ++l, p = tra[p][c], Max[p] = max(Max[p], l);
      }
    for(int i = cnt; i; --i)
      {
    int now = pos[i], fa = link[now];
    Max[fa] = max(Max[fa], min(Max[now], len[fa]));
    Min[now] = min(Min[now], Max[now]); Max[now] = 0;
      }
  }
}S;

int main()
{
  //freopen("ha.in", "r", stdin);
  scanf("%s", s);
  int n = strlen(s); S.init();
  for(int i = 0; i < n; ++i) S.insert(s[i] - 'a');
  S.sort();
  Mem(S.Min, 0x3f); Mem(S.Max, 0);
  while(scanf("%s", s) != EOF) S.lcs(s);
  int ans = 0;
  for(int i = 1; i <= S.cnt; ++i) ans = max(ans, S.Min[i]);
  write(ans), enter;
  return 0;
}


[USACO06DEC]Milk Patterns
找出现了至少\(k\)次的最长的子串。
建完后缀自动机，求一遍子树大小，然后如果大于\(k\)就更新好了。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
#include<map>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 2e4 + 5;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int n, K;

struct Sam
{
  int las, cnt;
  map<int, int> tra[maxn << 1];
  int len[maxn << 1], link[maxn << 1], siz[maxn << 1];
  In void init() {link[las = cnt = 0] = -1;}
  In void insert(int x)
  {
    int now = ++cnt, p = las;
    len[now] = len[las] + 1; siz[now] = 1;
    while(~p && !tra[p].count(x)) tra[p][x] = now, p = link[p];
    if(p == -1) link[now] = 0;
    else
      {
    int q = tra[p][x];
    if(len[q] == len[p] + 1) link[now] = q;
    else
      {
        int clo = ++cnt;
        tra[clo] = tra[q]; len[clo] = len[p] + 1;
        link[clo] = link[q];
        link[q] = link[now] = clo;
        while(~p && tra[p][x] == q) tra[p][x] = clo, p = link[p];
      }
      }
    las = now;
  }
  int pos[maxn << 1]; 
  In int dfs()
  {
    int ret = 0;
    for(int i = 1; i <= cnt; ++i) pos[i] = i;   //sort版，还用了lambda表达式……
    sort(pos + 1, pos + cnt + 1, [=](int& a, int& b) {return len[a] > len[b];});
    for(int i = 1; i <= cnt; ++i)
      {
    siz[link[pos[i]]] += siz[pos[i]];
    if(siz[pos[i]] >= K) ret = max(ret, len[pos[i]]);
      }
    return ret;
  }
}S;

int main()
{
  n = read(), K = read();
  S.init();
  for(int i = 1, x; i <= n; ++i) x = read(), S.insert(x);
  write(S.dfs()), enter;
  return 0;
}


[TJOI2015]弦论
求第\(k\)小的子串。
因为每一个子串代表一条路径，所以我们求出从每一个节点开始有多少条路径，然后像平衡树找第\(k\)大的方法找即可。
题目还分了两种情况：\(t\)为0的话，每一个节点的endpos数量显然就是0了；\(t\)为1的话，每一个节点的endpos数量就是子树大小了。
至于怎么求从每一个点开始的路径数量，上面第二篇博客有讲。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 5e5 + 5;
inline ll read()
{
  ll ans = 0;
  char ch = getchar(), last = ' ';
  while(!isdigit(ch)) last = ch, ch = getchar();
  while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
  if(last == '-') ans = -ans;
  return ans;
}
inline void write(ll x)
{
  if(x < 0) x = -x, putchar('-');
  if(x >= 10) write(x / 10);
  putchar(x % 10 + '0');
}

int Flg, K;
char s[maxn];
struct Sam
{
  int las, cnt;
  int tra[maxn << 1][30], len[maxn << 1], link[maxn << 1], siz[maxn << 1];
  In void init() {link[las = cnt = 1] = -1;}
  In void insert(int c)
  {
    int now = ++cnt, p = las;
    len[now] = len[las] + 1; siz[now] = 1;
    while(~p && !tra[p][c]) tra[p][c] = now, p = link[p];
    if(p == -1) link[now] = 1;
    else
      {
    int q = tra[p][c];
    if(len[q] == len[p] + 1) link[now] = q;
    else
      {
        int clo = ++cnt;
        memcpy(tra[clo], tra[q], sizeof(tra[q]));
        len[clo] = len[p] + 1;
        link[clo] = link[q], link[q] = link[now] = clo;
        while(~p && tra[p][c] == q) tra[p][c] = clo, p = link[p];
      }
      }
    las = now;
  }
  int buc[maxn << 1], pos[maxn << 1], sum[maxn << 1];
  In void dfs()
  {
    for(int i = 1; i <= cnt; ++i) ++buc[len[i]];
    for(int i = 1; i <= cnt; ++i) buc[i] += buc[i - 1];
    for(int i = 1; i <= cnt; ++i) pos[buc[len[i]]--] = i;
    for(int i = cnt; i; --i) siz[link[pos[i]]] += siz[pos[i]];
    for(int i = 1; i <= cnt; ++i)
      {
    if(!Flg) sum[i] = siz[i] = 1;
    else sum[i] = siz[i];
      }
    siz[1] = 0;
    for(int i = cnt; i; --i)
      for(int j = 0; j < 26; ++j)
    if(tra[pos[i]][j]) sum[pos[i]] += sum[tra[pos[i]][j]];
  }
  In void print(int k)
  {
    if(sum[1] < k) {write(-1); return;}
    int now = 1;
    k -= siz[now];
    while(k)
      {
    int c = 0;
    while(k > sum[tra[now][c]]) k -= sum[tra[now][c++]];
    now = tra[now][c];
    putchar('a' + c); k -= siz[now];
      }
  }
}S;

int main()
{
  scanf("%s", s);
  int n = strlen(s); S.init();
  for(int i = 0; i < n; ++i) S.insert(s[i] - 'a');
  Flg = read(), K = read();
  S.dfs();
  S.print(K), enter;
  return 0;
}

转载于:https://www.cnblogs.com/mrclr/p/10450821.html

weixin_30648963
关注
后缀数组&&后缀自动机题集
wangtao的博客
09-19 238
后缀数组: hdu-6704:https://vjudge.net/problem/HDU-6704 题意: 求(l,r)区间子串在母串中第k次出现的位置 解析: 一个子串必定是某个后缀的前缀 排序相邻的后缀他们的前缀一定最相似 => 一种子串必定是一些排序相邻的后缀的公共前缀 用后缀数组得到sa,height,rk等. 对于求子串(1,3)的第k个...
从后缀自动机到广义后缀自动机——最详细攻略
AC不动机的博客
07-23 777
广义后缀自动机 前置知识 广义后缀自动机基于下面的知识点 字典树(Trie树) 后缀自动机 请务必对上述两个知识点非常熟悉之后，再来阅读本文，特别是对于后缀自动机中的后缀链接能够有一定的理解 起源 广义后缀自动机是由刘研绎在其2015 国家队论文《后缀自动机在字典树上的拓展》上提出的一种结构，即将后缀自动机直接建立在字典树上。 大部分可以用后缀自动机处理的字符串的问题均可扩展到 Trie 树上。——刘研绎 约定 参考字符串约定 约定字符串的下标为 [1,∣s∣][1, |s|][1,∣s∣]。 约定
【后缀自动机】
weixin_33749131的博客
08-25 104
后缀自动机也是解决字符串问题的常用工具，犀利在O(N)的空间复杂度下存在给定串的后缀以及子串，而且支持在线的操作。 POJ-1509 Glass Beads 题意：求一个字符串的最小表示的开始下标。 分析：其实有一个O(N)的算法专门来解决这个问题，并且实现非常简单，不过后缀自动机同样能够解决这个问题。首先把这个串重复两次，然后从前往后一一将字符加入到后缀自动机中，最后从根开始向下遍历串的长...
后缀自动机 入门题集
axuhongbo的博客
09-03 223
#include &amp;lt;iostream&amp;gt; #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; string a,b; int main() { map&amp;lt;string,long long &amp;gt;dict; map&amp;lt;long long,string&amp;gt;longest,shortest;
后缀自动机经典模板题集合
kangdi的博客
10-26 1117
花了很久总结出来的基本操作 一次性全丢这里了 1：存在性查询 查询一个字符串是否是另一个字符串的子串 #include<bits/stdc++.h> using namespace std; const int maxn=5e4+5; char s[maxn]; int n; struct Suffix_Automation { int next[maxn*2][26]...
后缀自动机模板题hdu_后缀自动机习题合集
weixin_30230059的博客
01-17 184
constmaxn=400000;varson:array[0..maxn,0..25]oflongint;pre,step:array[0..maxn]oflongint;last,tot:longint;functionaddpoint:longint;vari:longint;begininc(tot);//pre[tot]:=-1;// for i:=0 to 25 do son[tot,...
后缀自动机_陈立杰.pptx
09-14
后缀自动机（Suffix Automaton）是一种特殊类型的有限状态自动机，主要被用于字符串处理，特别是在计算机科学的算法中，特别是在解决与字符串模式匹配、最长公共子串等问题相关的任务时非常有用。它能够识别给定字符...
后缀自动机模板
01-07
fa：后缀链接，简单来说就是与当前节点有相同的后缀，但是最大长度比当前节点小的结点 len：每个节点所储存的字串的最大长度 fa(i)结点与 i 结点的关系： 到达点 i 的所有字符串的长度都必然大于到达 fa(i) 的...
后缀自动机的详解
10-25
### 后缀自动机详解 #### 一、后缀自动机基本概念 **后缀自动机**（Suffix Automaton, SAM）是一种特殊的自动机，它主要用于处理字符串问题，特别是涉及字符串匹配的问题。对于一个给定的字符串 \(S\)，能够识别 \...
[后缀自动机 模板题] SPOJ 8222 Substrings
雯舞
01-28 704
题目大意：求某个长度的所有子串中出现次数最多的次数每个状态对应一段长度区间的子串 right集合的大小就是出现次数 那么我们用|right(x)|去更新f[maxs[x]]的值，最后从大到小用f[i]去更新f[i-1]的值即可#include<cstdio> #include<cstdlib> #include<algorithm> using namespace std;inline char
后缀自动机应用及题目
AcTarjan的博客
09-26 424
1、最长公共子串问题（LCS问题） 题目：SPOJ-LCS     SPOJ-LCS2 2、最长不公共子串问题 题目：4032 3、最小表示法问题 题目：落谷P1368 4、第k小子串问题 题目：bzoj-3998 5、后缀自动机+dp 题目：SPOJ-Substring      落谷P3804       4516      4566 6、后缀自动机+维护 题目：2555...
后缀自动机的一些简单题目
ctlchild的博客
09-20 633
对于后缀自动机的论文很多，这里记录一些比较简单的题目便于熟悉后缀自动机的基本应用 只有四道题目有一点少，今后会好好填坑 BZOJ4032: [HEOI2015]最短不公共子串 一句话题意：给两个串 A 和 B，求 A 最短子串且不是 B 的子串，A 最短子串且不是B的子序列，A 最短子序列且不是 B 的子串，A 最短子序列且不是 B 的子序列 做法：建出后缀自动机和序列自动机，自动机上每一条路径
专题训练2 后缀自动机题目清单
qq_39898877的博客
09-16 768
模板 void ins(int ch){ int p=last,np=++cnt;mx[np]=mx[p]+1;last=np;size[np]=1; while(p &amp;&amp; !son[p][ch]) son[p][ch]=np,p=fa[p]; if(!p) fa[np]=root; else{ int q=son[p][ch];...
后缀自动机模板（计蒜客24852题）
ACTerminate的博客
03-28 293
后缀自动机模板（计蒜客24852题）
后缀自动机
DancingZ的博客
06-02 324
听说后缀自动机是一个能帮助你轻松pku的神数据结构？既然这么神奇那没理由不学啊！可我盯着后缀自动机看了一个上午也没有头绪，（主要是看了后面忘了前面，结果后来直接手动模拟一遍就搞清楚怎么跑的了，当时一脸蒙bi啊），然而，我还是决定简要地证明一下后缀机！ 参考资料： https://blog.csdn.net/qq_35649707/article/details/66473069 2012no...
后缀自动机题目小结
tankche1的博客
10-01 807
作为一个傻叉，这两天才学了sam，做了几道题。 先是模版： //后缀自动机 //SAM //Suffix Automation struct State{     int len;     State *par,*go[26];     State(){     } }; State *root,*last; State seq[maxn*2];int se
后缀自动机专题练习
HeartWine的博客
10-20 400
一、SAM的性质: SAMSAMSAM是个状态机。一个起点，若干终点。原串的所有子串和从SAMSAMSAM起点开始的所有路径一一对应，不重不漏。所以终点就是包含后缀的点。 每个点包含若干子串，每个子串都一一对应一条从起点到该点的路径。且这些子串一定是里面最长子串的连续后缀。 SAMSAMSAM问题中经常考虑两种边： (1)(1)(1) 普通边，类似于TrieTrieTrie。表示在某个状态所表示的所有子串的后面添加一个字符。 (2)(2)(2) Link、FatherLink、FatherLink、Fath
后缀自动机入门/基本概念
平凡人Kalzn的博客
08-30 306
教程链接 （本文为适应自己的理解，对原文做出删改，建议到原文学习） 后缀自动机可以干啥？ 后缀自动机（SAM）可以解决许多字符串相关问题。是一个特别nb的数据结构。它可以： 1.在另一个字符串中搜索一个字符串的所有出现位置。 2.计算给定的字符串中有多少个不同的子串。 SAM是啥？ 》》SAM是一个有向无环图。节点被称为状态，边就是状态之间的转移。 》》图存在一个源点t0t_0t0​ ，称作...
利用后缀自动机解决字符串问题
"后缀自动机实现与应用" 后缀自动机（Suffix Automaton），也称为后缀自动机，是由杭州外国语学校的陈立杰所讲解的一种数据结构，它在字符串处理中有着重要的应用。陈立杰提到，后缀自动机在解决特定的字符串问题时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值