目录
后缀数组
后缀数组(suffix-array)的前置知识是基数排序,而基数排序基于稳定的计数排序,基数排序的本质是:按照关键字的反优先顺序,对相应关键字进行计数排序,然后更新排名函数 。 记录了当前排名为 的数据在原数组中的下标。
接下来关于后缀数组的所有算法的下标都从1开始。
后缀数组
表示按字典序排名为
的后缀的下标,其中后缀的下标代表以该下标开始的文本串的后缀。比如说对于字符串banana
,我们称后缀3为nana
,后缀6为a
,该字符串的后缀数组为6 4 2 1 5 3
。
构造后缀数组的过程可以用下面一张图形象地解释:
其中红色箭头指向的数组就是下面代码中每次倍增需要的 数组,也就是每个后缀的排名,而 和 数组用于中间的双关键字基数排序(代码中 数组记录了第二个关键字排序后的排名),其中 数组的意义就如同一开始介绍的基数排序中的排名函数 ,可以看出它就是我们需要的后缀数组。
const int maxn=1e6+5;
char s[maxn];
int n,sa[maxn],c[maxn],t1[maxn],t2[maxn]; //一定注意n要赋值为s的长度,s从1开始
void get_sa(int m)
{
int *x=t1,*y=t2;
REP(i,0,m) c[i]=0;
REP(i,1,n) c[x[i]=s[i]]++;
REP(i,1,m) c[i]+=c[i-1];
REP_(i,n,1) sa[c[x[i]]--]=i;
for(int k=1;k<=n;k<<=1)
{
int p=0;
REP(i,n-k+1,n) y[++p]=i;
REP(i,1,n) if(sa[i]>k) y[++p]=sa[i]-k;
REP(i,0,m) c[i]=0;
REP(i,1,n) c[x[y[i]]]++;
REP(i,1,m) c[i]+=c[i-1];
REP_(i,n,1) sa[c[x[y[i]]]--]=y[i];
swap(x,y);
p=1,x[sa[1]]=p;
REP(i,2,n) x[sa[i]]=(max(sa[i],sa[i-1])+k<=n && y[sa[i]]==y[sa[i-1]] && y[sa[i]+k]==y[sa[i-1]+k])?p:++p;
m=p;
if(p>=n) break;
}
}
代码中判断 max(sa[i],sa[i-1])+k<=n 是为了防止多组数据互相影响(HDU4691)。
LCP(最长公共前缀)
定义两个新数组:
:表示后缀 的排名;
:表示后缀 和后缀 的LCP,
那么我们求任意两个后缀的LCP相当于只用维护height数组的RMQ就可以了,比如说假设 ,那么 。
数组就是 的逆,而 数组的求解首先需要一个结论 ,然后就可以从小到大在 O(n) 时间内求解。
这个结论的证明见下图所示:
构造完 height 数组之后就可以用 st 表维护 height 的 RMQ,从而方便地计算出任意两个后缀的最长公共前缀。代码如下:
int rk[maxn],height[maxn],st[maxn][22],lg2[maxn];
void get_height()
{
REP(i,1,n) rk[sa[i]]=i;
int k=0;
REP(i,1,n)
{
if(k) k--;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k]) k++;
height[rk[i]]=k;
}
}
void get_st_height()
{
REP(i,2,maxn-1) lg2[i]=lg2[i-1]+(1<<(lg2[i-1]+1)==i);
REP(i,1,n) st[i][0]=height[i];
REP(j,1,lg2[n]) REP(i,1,n+1-(1<<j))
st[i][j]=min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
}
int RMQ(int l,int r)
{
int k=lg2[r-l+1];
return min(st[l][k],st[r-(1<<k)+1][k]);
}
int LCP(int x,int y)
{
if(x==y) return n-x+1;
if(rk[x]>rk[y]) swap(x,y);
return RMQ(rk[x]+1,rk[y]);
}
- height分组:这是一种思想,也就是说我们求出height数组之后,可以得出,对于一个后缀sa[i],排名离它越远的后缀与它的LCP一定越小。所以如果我们指定一个常数M,那么可以根据 height[i] M 来将height数组分组,这有利于一些其他处理(比如二分)。
后缀自动机
后缀自动机(suffix-automaton, SAM)用一种高压缩的方式存储了文本串的所有子串信息,其中最重要的信息是状态结点,转移和后缀连接。下图表示字符串banana
的后缀自动机,其中红色虚线代表后缀连接。
关于后缀自动机的一些性质可以从上面的实例中得以体现:
-
每条从 S 开始到任意结点结束的路径都构成了文本串的一个子串,所有从 S 开始的路径构成了文本串的所有子串集。
-
每条从 S 开始到终点结点(图中蓝色结点)的路径构成了文本串的一个后缀,同样的,所有这种路径构成了文本串的所有后缀集。
-
每个结点代表了唯一的一种 endpos等价类,其意义是:该结点包含的所有子串(也即从 S 开始到该结点的路径组成的所有子串)在原文本串中有相同的结束位置集。比如图中对于 8 号结点,endpos(“an”) = endpos(“n”) = {3,5}。
-
每个结点包含的子串构成了一个连续的长度区间。我们令 maxlen(u) 表示结点 u 的子串中最长的长度,longest(u) 表示最长的子串,则 u 中所有的子串都是 longest(u) 的后缀。
-
后缀连接的意义如下:结点 u 的后缀连接为不在 u 中的 longest(u) 的最长的后缀所在的结点。也就是说设 minlen(u) 为结点 u 的子串中最短的长度,那么 longest(u) 的长度为 minlen(u)-1 的后缀就不在 u 中了,假设在 v 中,那么 u 的后缀连接 link[u]=v 。显然有 minlen(u) = maxlen(link[u]) +1 (这个非常重要)。
-
沿着一个结点 u 的后缀路径遍历所有该路径上的结点,可以遍历到 longest(u) 的所有后缀。
-
沿着最后一个建立的结点的后缀路径遍历所有该路径上的结点,可以得到所有的终点结点。
接下来说一下后缀自动机的构造方法。
假设当前已经构造好了 S[1…n] 的后缀自动机,当我们新增添 c=S[n+1] 的时候,需要考虑 n+1 个新的后缀。设上一次新增字符增添的结点为 last,这次肯定要新增加一个新的结点 cur,否则字符串 S[1…n+1] 就无法表示。令 p 沿着 last 的后缀路径遍历,如果 trans[p][c](转移)不存在,那么令 trans[p][c]=cur,否则跳出。如果一直到 S 仍然转移不存在,最后令 link[cur]=S,否则假设第一个存在 trans[p][c] 的结点是 u,trans[u][c]=v,就要分两种情况讨论了:
- 如果 maxlen(u) + 1 = maxlen(v),说明 v 中所有子串都是 S[1…n+1] 的后缀,故直接令 link[cur] = v;
- 否则,新增添一个结点 clone,令 trans[clone] = trans[v],然后把从 u 开始的后缀路径上所有 trans[p][c] == v 的转移都改成 trans[p][c] = clone(保证 clone 的所有子串都是 S[1…n+1] 的后缀),clone 继承 v 的后缀连接,link[v] = link[cur] =clone。
构造代码如下(构造仅仅是 extend 那一部分,所有数组从1开始):
// 1号是S结点
namespace suffix_automaton
{
const int maxn=1e6+5;
int maxlen[maxn<<1],trans[maxn<<1][26],link[maxn<<1],tot=1,last=1;
int endnum[maxn<<1],c[maxn<<1],a[maxn<<1];
int e[maxn<<1];
void extend(int c)
{
int cur=++tot,p; endnum[cur]=1;
maxlen[cur]=maxlen[last]+1;
for(p=last;p && !trans[p][c];p=link[p]) trans[p][c]=cur;
if(!p) link[cur]=1;
else
{
int q=trans[p][c];
if(maxlen[q]==maxlen[p]+1) link[cur]=q;
else
{
int clone=++tot;
maxlen[clone]=maxlen[p]+1;
memcpy(trans[clone],trans[q],sizeof(trans[q]));
for(;p && trans[p][c]==q;p=link[p]) trans[p][c]=clone;
link[clone]=link[q];
link[q]=link[cur]=clone;
}
}
last=cur;
}
void get_endpos_num() // count the end-position number of every node(state)
{
REP(i,1,tot) c[maxlen[i]]++;
REP(i,1,tot) c[i]+=c[i-1];
REP(i,1,tot) a[c[maxlen[i]]--]=i;
REP_(i,tot,1) endnum[link[a[i]]]+=endnum[a[i]];
}
void get_end() // get the end node(state)
{
for(int i=last;i!=1;i=link[i]) e[i]=1;
}
void build(char *s,char minc)
{
for(int i=0;s[i];i++) extend(s[i]-minc);
get_endpos_num();
//get_end();
}
}
后缀自动机的时间复杂度和空间复杂度都是 O(n) 。
关于后缀自动机的一些常见应用:
- 完美取代AC自动机,多模式匹配问题直接对文本串建后缀自动机,然后每个模式串从S开始跑一遍就知道是不是子串了。
- 子串出现次数。我们需要计算每个结点对应结束位置的个数 endnum,每一个长的子串出现时,都对其更短的后缀有贡献,故(一定要忽略clone的结点)对每次新建结点出现次数赋值为1,然后在后缀连接图上拓扑序累加即可,或者可以按照每个结点的 maxlen 排个序,然后从大到小累加也可(可以说明这样子满足拓扑序)。
- 本质不同子串个数 = 。
回文树
回文树又称回文自动机,也是一种有限状态机,它的每个状态(结点)代表了一个本质不同的回文串。
下图即为字符串 banana
的回文树:
回文树有两个根节点(0,1),分别为偶回文串和奇回文串。其中蓝色实现的转移表示将当前回文串两边同时加上一个字符,红色虚线(这里同样称之为后缀连接)指向当前回文串的最长回文后缀。
构建回文树的过程非常简单。和后缀自动机类似,每次添加新的字符时,我们找到上一个结点last的最长回文后缀,并且这个回文后缀的前一个字符和当前字符一样(这个过程就是下面代码中的get_suffix),这样就可以从这个状态进行扩展;而新的结点的后缀连接,又可以从其父节点的后缀连接开始get_suffix。
在构建过程中令0结点的后缀连接为1结点,1的初始长度为-1,s[0]=-1(或者任意一个没出现的字符)。
代码如下:
// s为扩展的所有字符,n为s的长度,p为结点个数(p-2为本质不同回文串个数,1,2,...,p-2号结点都表示回文串)
// link为后缀连接,len为回文串长度,cnt为相同回文串个数,last为上一次扩展的结点。
namespace palindromic_tree
{
const int maxn=3e5+5;
int t[maxn][26],link[maxn],cnt[maxn],len[maxn];
int s[maxn],last,n,p;
int new_node(int L) {len[p]=L; return p++;}
int get_suffix(int x) {while(s[n-len[x]-1]!=s[n]) x=link[x]; return x;}
void extend(int c)
{
s[++n]=c;
int u=get_suffix(last);
if(!t[u][c])
{
int v=new_node(len[u]+2);
link[v]=t[get_suffix(link[u])][c];
t[u][c]=v;
}
last=t[u][c]; cnt[last]++;
}
void build(char *ss)
{
s[0]=-1, link[0]=1;
new_node(0); new_node(-1);
for(int i=0;ss[i];i++) extend(ss[i]-'a');
REP_(i,p-1,0) cnt[link[i]]+=cnt[i];
}
}
注意cnt统计的时候,我们一开始实际上只算了每个结点的出现次数,但是这个结点的所有回文后缀实际上也出现了,所以要拓扑序累加。