字符串（长期更新）

设字符串$s$长度为$n$，以下简记$pr{e}_{s,i}=s_{1\dots i},su{f}_{s,i}=s_{n-i+1\dots n}$

字符串Hash

Hash

Border理论

Border理论

KMP

border：若字符串$s$的真前缀$pre$与真后缀$suf$满足$pre=suf$，则称之为$s$的一个border。

周期：对于整数$p=1,2,3,\dots ,|s|$，若对于$\mathrm{\forall }i\in [1,|s|-p]$都有$s_i=s_{i+p}$，就称$p$为$s$的周期。

重点在于重复利用已经求出的信息来降低复杂度。

定义$fai{l}_i$表示前缀$pr{e}_{s,i}$的最长border的长度。

显然若$t$是$s$的border，那么$t$的border也是$s$的border。

现在考虑递推地求$fai{l}_i$。观察到$pr{e}_{s,i}$的最长的border是$pr{e}_{s,i-1}$的某一个border加上$s_i$。那么就可以想到不断跳$pr{e}_{s,i-1}$的border并检查加上$s_i$后是否为$pr{e}_{s,i}$的border。这样就求出了$fai{l}_i$。

可以证明这是$O(n)$的，但我不会证。

那么得到$fai{l}_i$后做各种事情就很方便了。

$fai{l}_i$也告诉了我们第$i$位失配后应该跳到哪里。

void getfail(){
  fail[0]=fail[1]=0;
  for(int i=2,j=0;s[i];++i){
    while(j&&s[i]!=s[j+1]) j=fail[j];
    if(s[i]==s[j+1]) j++;
    fail[i]=j;
  }
}

Z函数

也有人叫它扩展KMP，但其实和KMP没有太大关系。

对于字符串$s$，定义$z_i$表示$su{f}_{s,i}$与$s$的最长公共前缀（LCP）的长度。我们可以$O(n)$求出$z_i$。

类似KMP，我们同样递推，利用已经求出的信息降低复杂度。

根据定义，对于任意的$i$都有$s_{1\dots z_i}=s_{i\dots i+z_i-1}$。这类似于border，可以用来加速。

考虑维护最靠右的匹配段$s_{i\dots i+z_i-1}$，记作$[l,r]$。特别地，$z_1=|s|$没有意义，不算入匹配段中。于是从$2$开始，初始化$l=r=0$。

计算$z_i$时，讨论一下：

• 若$i\le r$，$s_{1\dots r-l+1}=s_{l\dots r}\Rightarrow s_{i-l+1,r-l+1}=s_{i,r}$，那么就有$z_i\ge min(r-i+1,z_{i-l+1})$，初始化后再暴力拓展。

• 若$i>r$，直接暴力拓展。

计算结束后更新$[l,r]$即可。

看起来很暴力，但分析一下可以知道是$O(n)$的：

• $i>r$时，暴力拓展一定使$r$变大。

• $i\le r\wedge z_{i-l+1}>r-i+1$时，暴力拓展也会让$r$变大。

• $i\le r\wedge z_{i-l+1}\le r-i+1$时，不会暴力拓展。

由于$r$最多从$0$变大到$|s|$，所以复杂度是$O(n)$的。

• 对于这道题luogu Z函数模板的第二问，用推导$z$函数的思路推一下即可。

• 循环移位后与原串比大小：首先想到$s$与$t$比大小只需比$LCP(s,t)$后的第一个字符即可。循环移位可以将字符串复制一份接在后面，然后上$z$函数推即可。

Trie

是各种自动机的基础。

数据结构里也会讲。这里只讲Trie作为字典使用的情形。

板子：

inline void ins(string s,int v){
	int u=0;
	for(int i=0;s[i];++i){
		int c=idx(s[i]);
		if(!ch[u][c]){
			memset(ch[sz],0,sizeof(ch[sz]));
			ch[u][c]=sz++;
		}
		u=ch[u][c];
		val[u]+=v;
	}
}

其他操作是类似的。理解如何在Trie上跳即可。$ch[u][i]$表示$u$节点经过代表字符$i$的边后到达的儿子节点。

一般用于检索字符串是否出现。其他应用见数据结构篇。

AC自动机

AC自动机结合了Trie的结构和KMP失配的思想，解决的是多模式串匹配问题。

步骤：

1. 将所有模式串构成Trie

2. 对每个Trie上的节点构造失配指针$fail$。

之后就可以利用构建出的AC自动机解决各种问题。

这里的Trie的节点表示一种状态，状态是某个模式串的前缀（即从Trie上的节点走到根经过的前缀），边表示转移，即转移到在当前节点的状态下加上某个字符后的状态。记所有状态的集合为$Q$。

$fail$的构建

对于状态$u$，$fai{l}_u=v$，使得$v\in Q$且$v$是$u$的最长后缀。

考虑对于当前节点$u$，设其父亲为$p$，$p$通过字符$c$的边指向$u$即$tr[p,c]=u$。

我们假设现在深度小于$u$的节点的$fail$都已经求得。（深度小于$u$即状态的长度小于$u$,这是真正要限定的。）

• 若$tr[fai{l}_p,c]$存在，那么$fai{l}_u=tr[fai{l}_p,c]$。即在$p$后加上$c$的最长后缀就是在$fai{l}_p$后加上$c$。

• 若$tr[fai{l}_p,c]$不存在，就继续跳$fail$。

• 若$fail$跳到根之后也没找到，那么$fai{l}_u=0$

以上只是构建$fail$的基本思想。实际运用时，我们要对$fail$做路径压缩，即若$tr[u,c]$不存在，那么$tr[u,c]=tr[fai{l}_u,c]$。这样修改Trie的结构后，我们在跳边的时候可能会丢失前缀，但没关系，后缀能匹配那么原串就一定能匹配，并且$fail$其实也是在丢失前缀。

继续优化

对于$fail$连成的边，有一个性质：在AC自动机中只保留$fail$边，一定构成树。这是因为$fail$一定不成环，且深度比当前点小。

我们在统计答案时会沿着$fail$不断跳，那么原问题就变成了树上的链求和问题，可以拓扑排序优化建图，最后统计答案时按拓扑序递推过去。（不用真建$fail$树，只需记录入度。）

实现：

void ins(char s[],int idx){
	int u=0;
	for(int i=0;s[i];++i){
		if(!tr[u][s[i]-'a']) tr[u][s[i]-'a']=++sz;
		u=tr[u][s[i]-'a'];
	}
	if(!val[u]) val[u]=idx;
	rev[idx]=val[u];//或者换成其他操作
}

void build(){
	queue<int> q;
	for(int i=0;i<26;++i){
		if(tr[0][i]) ind[0]++,q.push(tr[0][i]);
	}
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=0;i<26;++i){
			if(tr[u][i]) fail[tr[u][i]]=tr[fail[u]][i],ind[tr[fail[u]][i]]++,q.push(tr[u][i]);
			else tr[u][i]=tr[fail[u]][i];
		}
	}
}

void qry(char s[]){
	int u=0;
	for(int i=0;s[i];++i){
		u=tr[u][s[i]-'a'];
		cnt[u]++;//或者换成其他操作
	}
}

void topu(){
	queue<int> q;
	for(int i=0;i<=sz;++i){
		if(!ind[i]) q.push(i);
	}
	while(!q.empty()){
		int u=q.front();
		q.pop();
		ans[val[u]]=cnt[u];
		int v=fail[u];
		cnt[v]+=cnt[u];//或者换成其他递推操作
		if(!--ind[v]) q.push(v);
	}
}

Manacher

可以求以位置$i$为中心的最长回文子串（其半径也等于以位置$i$为中心的回文子串个数。）

可以观察到一件事：奇回文串的回文中心为一个字符，偶回文串的回文中心为字符间的空隙。于是想办法统一奇偶回文子串。

我们可以在每两个字符的间隔中插入一个特殊字符（如#，首尾也要插入）。并且在构造好后再次在首尾插入两个不同的特殊字符以防越界（如$/@）。

观察到新串的$R_i$表示原串的对应回文中心的最长回文串长度加$1$。

同Z函数一样考虑，维护最靠右的右端点$r$及其对应回文中心$c$，记回文半径为$R_c$。

考虑当前要计算的回文中心$i$：

• 若$i>r$，暴力尝试拓展。

• 若$i\le r$，由对称性可知$R_i\ge min(r-i+1,R_{2c-i})$。初始化后再尝试暴力拓展。

同Z函数分析，时间复杂度$O(n)$。

PAM

回文自动机高度压缩了字符串中所有回文子串的信息，维护了原串中所有本质不同的回文子串。

PAM的结构可以看作两棵树，但实际上是一棵。有两个根，分别是奇根$odd$和偶根$even$。$odd$上连着所有长度为奇数的回文子串，自身长度置为$-1$。$even$上连着所有长度为偶数的回文子串，自身长度置为$0$。

来说转移边，$u$的一条$c$的转移边指向$v$，表示$s_v$为$s_u$的前后都加上$c$所形成的回文串。特别的，$odd$连出来的边指向长度为$1$的回文子串。

来说$fail$边，对每个结点$u$，$fai{l}_u$指向它的最长回文后缀所代表的结点。显然$fail$边形成了类似树的结构。$even$的$fail$边指向$odd$，$odd$的$fail$边指向自身。

构建

构建PAM的复杂度是$O(n)$的。

有引理：长度为$|s|$的字符串$s$的本质不同回文子串至多有$|s|$个。

证明一下，上数归。$|s|=1$时显然成立。设已有的字符串$s=t+c$，假设该结论对$t$成立。设以$c$为右端点的回文子串的左端点分别为$l_1,l_2\dots l_k$，设$l_i<l_{i+1}$。于是在回文子串$s_{l_1\dots |s|}$中用一下回文的性质，可以发现以$l_2,l_3\dots l_k$为左端点且以$c$为右端点的回文子串已经在$t$中出现过，于是$s$中至多比$t$中新增一个本质不同回文子串。于是得证。

所以PAM的结点数是线性的，转移是唯一的，于是$O(n)$。

对每个结点要维护该结点对应回文子串长度$len$和$fail$边。

考虑增量法构建PAM。新增一个字符$c$，由以上引理，每次插入一个字符最多新增一个结点，即当前字符串的最长回文后缀。记$last$为上次插入后最长回文后缀对应的点。设新增的结点为$u$，当前下标为$i$，那么$u$从$x$转移过来，当且仅当$x$为$last$的一个回文后缀，且$s_{i-le{n}_x+1}=c$。$x$可以通过从$last$开始不断跳$fail$边来找到。这时要判断一下$x$的$c$转移边指向的点是否已经存在，如果还没有，那就新建结点，$le{n}_u=le{n}_x+2$。

考虑求出$u$的$fail$。可以发现$u$的$fail$一定是$x$的一个回文后缀在前后加上字符$c$。如果$x$为奇根，那么当前字符串的最长回文后缀为$c$，那么$u$的$fail$直接连到$0$。否则就从$fai{l}_x$开始跳，设现在跳到的点为$y$，直到$s_{i-le{n}_y+1}=c$，那么此时的$y$的$c$转移边指向的结点就是$u$的$fail$。显然这个点是已经建立过的，不必新建结点，因为由于$x$的回文性质且$x$的前后都为$c$，那么$y$在$x$中对应的与之回文的前缀一定也满足前后都为$c$，而这个点在PAM中已经有了。

来证明复杂度，除了跳$fail$的过程，其他显然是$O(n)$的。于是来分析跳$fail$的过程，上$fail$树。这里将$odd$和$even$视作深度为$0$。每次新加一个结点，在$fail$树上的动作表现为：先不断跳父亲，然后连边新建结点。跳一次父亲使深度$-1$，新建一个结点使深度$+1$，然后使用势能分析（？）或者人类智慧（？）可以知道跳$fail$的总次数不会超过$2n$，所以是$O(n)$的。

或许还有更好理解而不严谨的解释。每次加入一个字符后，最长回文后缀的长度至多$+2$，每次跳$fail$至少使最长回文后缀的长度$-1$，总共加入$n$次字符，所以至多跳$2n$次$fail$。

应用

本质不同回文子串个数

就是PAM的状态数$-2$（减去$odd$和$even$）。

求每个回文子串在原串中的出现次数

考虑增量法构建的过程。在加入一个字符后，当前字符串的所有回文后缀的出现次数都要$+1$，于是直接在最长回文后缀对应结点上打上$tag$，最后按拓扑序推平就好。而PAM的构建中本就有拓扑序（一个点的$fail$的编号肯定比它自己小），于是在PAM的结点中按编号从大到小扫一遍推平就行。

求前一半是偶回文串，后一半也是偶回文串的回文子串

显然这种回文子串的长度为$4$的倍数，但这个性质没什么用。

定义$trans$指针，指向长度不超过当前节点长度的一半的结点。那么此题就是要找$trans$指向的结点的长度恰好为当前节点长度的一半的结点。维护$trans$的手法与$fail$类似，若$fail\le 2$，那么$trans=fail$。否则设当前节点为$u$，$x$经过$c$转移边指向$u$，那么从$tran{s}_x$开始跳$fail$找到符合的结点即可。

其他待补

SA

后缀数组。要实现的是后缀排序，就是把$s$的所有后缀排序。包含两个数组（或者可以视作映射）：$s{a}_i$，第$i$小的后缀在原串中的开始位置；$r{k}_i$，在原串中开始位置为$i$的后缀（以下称之为后缀$i$）的排名。这两个互为反函数，复合一下就消了：$s{a}_{r{k}_i}=r{k}_{s{a}_i}=i$。

一般来说都用倍增求SA，$O(n\log n)$，在OI中已经够用了。有$O(n)$的求法，但不好写，所以一般不会卡$O(n\log n)$的写法。

于是学习倍增求SA就好。

倍增求SA

考虑依次比较后缀中的第$1,2,3\dots 2^k$位。

首先按第一个字符排序，即对原串中的每个字符排序。

然后开始倍增，考虑对$k=n$排序之后，对$k=2n$时排序。将每个子串拆成前$2^{k-1}$位和后$2^{k-1}$位，于是就是双关键字排序，使用基数排序即可一次$O(n)$排序，再加上倍增就是$O(n\log n)$。

具体说一下基数排序的过程。

这里$r{k}_i$尚有重复值，于是可以视作每个后缀的权值。

$m$表示$rk$的值域。

首先根据$rk$求出初始的$sa$，$bu{c}_i$表示$rk=i$的后缀的个数，做前缀和之后就表示$rk\le i$的后缀的个数。然后考虑往$sa$中填数，相同权值的后缀我们不关心其内部排名，于是直接令位置靠后的排名较大即可。

然后开始倍增，枚举$w$，每轮倍增之后更新一下$rk$的值域，是一点常数优化。

现在来看每一轮的过程。

首先求出$i{d}_i$表示第二关键字排名为$i$的后缀的开始位置。显然开始位置在$[n-w+1,n]$之间的后缀，其第二关键字为空，肯定靠前，于是直接加入。对于其余后缀，直接枚举第二关键字的排名$i$，然后$s{a}_i$就得到了第二关键字的起始位置，再$s{a}_i-w$就是整个的起始位置。

然后再进行基数排序，还是按$rk$放到桶里。这次权值相同的不能随便排序，而是要按第二关键字的大小排序。于是我们从大到小枚举第二关键字，这样先枚举到的第二关键字更加靠后，于是给这个子串更大的排名。一开始把$rk$扔到桶里已经保证了第一关键字是有序的，于是不用管了。

接下来$sa$已经求好了，我们要利用$sa$重新求出$rk$。我们会用到之前的$rk$，于是可以用$id$将$rk$保存下来。

首先对于$s{a}_1$，根据反函数的性质，$r{k}_{s{a}_1}=1$，并且利用$p$来记录$rk$当前的值域，现在$p=1$。

然后从$2$开始，扫各个$sa$。如果后缀$s{a}_i$与后缀$s{a}_{i-1}$的权值相同，并且后缀$s{a}_i+w$与后缀$s{a}_{i-1}+w$的权值相同，那么现在这两个后缀的权值就相等，$r{k}_{s{a}_i}=r{k}_{s{a}_{i-1}}=p$。否则就不相等，那么$s{a}_i$的权值比$s{a}_{i-1}$的权值大$1$，所以$r{k}_{s{a}_i}=r{k}_{s{a}_{i-1}}+1=p+1$，然后$p\leftarrow p+1$。

算好$rk$后，若值域为$n$，那么每个位置的$rk$互不相同，就可以结束了。

注意到判断中$s{a}_i+w$的值域其实是$2n$的，但是$rk$和$id$只用开到$n+1$。因为若$s{a}_i$和$s{a}_{i-1}$的权值不同，就不会进后面那个判断，若$s{a}_i$和$s{a}_{i-1}$的权值相同，则$[s{a}_i,s{a}_i+w-1]$与$[s{a}_{i-1},s{a}_{i-1}+w-1]$相同，那么$s{a}_i+w\le n+1$且$s{a}_{i-1}+w\le n+1$。

#include<bits/stdc++.h>

using namespace std;

const int maxn=1e6+10;
int n,m,p,rk[maxn],sa[maxn],id[maxn],buc[maxn];
char s[maxn];

void build(){
	n=strlen(s+1);
	m=128,p=0;
	for(int i=1;i<=n;++i) buc[rk[i]=s[i]]++;
	for(int i=1;i<=m;++i) buc[i]+=buc[i-1];
	for(int i=n;i;--i) sa[buc[rk[i]]--]=i;
	for(int w=1;;w<<=1,m=p,p=0){
		for(int i=n-w+1;i<=n;++i) id[++p]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++p]=sa[i]-w;
		for(int i=1;i<=m;++i) buc[i]=0;
		for(int i=1;i<=n;++i) buc[rk[i]]++;
		for(int i=1;i<=m;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i) sa[buc[rk[id[i]]]--]=id[i],id[i]=rk[i];
		rk[sa[1]]=1,p=1;
		for(int i=2;i<=n;++i) rk[sa[i]]=(id[sa[i]]==id[sa[i-1]]&&id[sa[i]+w]==id[sa[i-1]+w])?p:++p;
		if(p==n) break;
	}
	return;
}

int main(){
	scanf("%s",s+1);
	build();
	for(int i=1;i<=n;++i) printf("%d ",sa[i]);
	return 0;
} 

SA与LCP

定义$LCP(i,j)$表示后缀$s{a}_i$与$s{a}_j$的最长公共前缀的长度。

首先，有显然的式子$LCP(i,j)=LCP(j,i)$以及$LCP(i,i)=n-s{a}_i+1$。

然后就是不那么显然的式子：$\mathrm{\forall }1\le i\le k\le j\le n,LCP(i,j)=min\{LCP(i,k),LCP(k,j)\}$。

证明一下：设$t=min\{LCP(i,k),LCP(k,j)\}$，那么$LCP(i,k)\ge t$且$LCP(k,j)\ge t$。后缀$s{a}_i$的前$t$位与$s{a}_k$的前$t$位相同，$s{a}_k$的前$t$位与$s{a}_j$的前$t$位相同，于是$s{a}_i$的前$t$位与$s{a}_j$的前$t$位相同。所以$LCP(i,j)\ge t$。

假设$LCP(i,j)=r>t$，那么后缀$s{a}_i$的前$r$位与$s{a}_j$的前$r$位相同，于是$s{a}_i$的前$t+1$位与$s{a}_j$的前$t+1$位也必定相同。由$t$的定义以及$i\le k\le j$，可以得到后缀$s{a}_i$的第$t+1$位不大于$s{a}_k$的第$t+1$位，且$s{a}_j$的第$t+1$位不小于$s{a}_k$的第$t+1$位，且两边不能同时取得等号，所以$s{a}_i$的第$t+1$位不等于$s{a}_j$的第$t+1$位，与假设矛盾，所以原命题得证。

再来一个不那么显然的式子：$LCP(i,j)=\underset{i<k\le j}{min}\{LCP(k,k-1)\}$

证明一下，通过上一个式子可知$LCP(i,j)=min\{LCP(i+1,i),LCP(i+1,j)\}$，然后继续拆后面那一项即可证明。或许可以用数归写成更严谨的形式。总之证完了。

令$heigh{t}_i=LCP(i,i-1)$，并且$heigh{t}_1=0$，那么求出$height$之后$LCP$就是区间求$min$。

再令$h_i=heigh{t}_{r{k}_i}$，那么$heigh{t}_i=h_{s{a}_i}$。

最后一个引理：$h_i\ge h_{i-1}-1$。

证明一下，先把两边写开，$heigh{t}_{r{k}_i}\ge heigh{t}_{r{k}_{i-1}}-1$，也即$LCP(r{k}_i,r{k}_i-1)\ge LCP(r{k}_{i-1},r{k}_{i-1}-1)-1$。设$x=s{a}_{r{k}_i-1},y=s{a}_{r{k}_{i-1}-1}$。那么就是要证$LCP(r{k}_i,r{k}_x)\ge LCP(r{k}_{i-1},r{k}_y)-1$。如果后缀$i-1$和$y$的首字母不同，那么显然成立。如果首字母相同，那么去掉首字母后可以得到后缀$y+1$和$i$，由于$r{k}_y<r{k}_{i-1}$，故而$r{k}_{y+1}<r{k}_i$，并且$LCP(r{k}_{y+1},r{k}_i)=LCP(r{k}_{i-1},r{k}_y)-1$。又$r{k}_x=r{k}_i-1$，所以$\mathrm{\forall }r{k}_k<r{k}_i,LCP(r{k}_i,r{k}_x)\ge LCP(r{k}_i,r{k}_k)$。那么综上，$LCP(r{k}_i,r{k}_x)\ge LCP(r{k}_i,r{k}_{k+1})=LCP(r{k}_{i-1},r{k}_y)-1$，即原命题成立，$h_i\ge h_{i-1}-1$。

于是求$h_i$时，最多进行$n$次$-1$，于是最多往后扫$2n$次，所以是$O(n)$的。

以上三个式子是SA中很重要的部分，还请熟记。

应用

求两个后缀的LCP

直接求出$height$，然后应用第二个式子（不妨$r{k}_i<r{k}_j$）：$LCP(r{k}_i,r{k}_j)=\underset{r{k}_i<k\le r{k}_j}{min}\{heigh{t}_k\}$，就是RMQ，随便做。

比较两个子串的大小

设$A=s[a\dots b],B=s[c\dots d]$。

先求出$L=LCP(r{k}_a,r{k}_c)$，若$L=min(|A|,|B|)$，则$A<B⟺|A|<|B|$。

否则$A<B⟺r{k}_a<r{k}_c$。

本质不同子串个数

可以考虑用所有子串数目$\frac{n(n+1)}{2}$减去重复的。

子串可以视作后缀的前缀，于是按$rk$递增的顺序枚举每个后缀，那么对于当前后缀，新增的部分就是整个长度减去与上一个前缀的$LCP$的差。于是重复的部分就是$\sum _{2\le k\le n}heigh{t}_k$，答案就是$\frac{n(n+1)}{2}-\sum _{2\le k\le n}heigh{t}_k$。

其实用增量的想法也可以导出答案，就是每次新增的量加在一起，于是答案为$\frac{n(n+1)}{2}-\sum _{1\le k\le n}heigh{t}_k$，而$heigh{t}_1=0$。

其他待补

后缀树

AC自动机中文本串未知而模式串已知，而后缀树与之相反，文本串已知而模式串未知，我们需要利用某种东西维护文本串所有子串的信息。

首先可以有暴力的想法，我们把文本串所有的后缀都扔进Trie。然而这样结点个数是$O(n^2)$的，我们需要继续压缩信息。

我们在每个后缀的最后加上一个特殊的结点（不妨叫它后缀结点）记录后缀的开始位置，然后建立Trie的关于$n$个后缀结点的虚树（这是压缩信息的利器），就得到了后缀树。

这棵树的性质很好。可以发现在给出一个模式串后，把它扔到这棵树上类似AC自动机一样跳，那么它可以匹配到的位置就是它最终跳到的结点的子树内的所有叶子结点记录的位置。在这棵树上DFS就可以得到后缀数组。求$LCP$就是求LCA的深度。

构建这棵树肯定不能直接插入然后建虚树，于是有了SAM。

SAM

SAM是一个能识别$s$的所有后缀的最小DFA，有以下性质：

• 是DAG，结点为状态，边为转移，转移上带一个字符（与AC自动机和PAM一样）。

• 存在一个初始状态，从这里出发可以到达每一个结点，所经转移上的字符写下来是$s$的一个子串。$s$的每个子串都可以这样表示出来。

• 存在若干终止状态，从初态出发到任意一个终态都可以得到$s$的一个后缀。$s$的每个后缀都可以这样表示出来。

• 状态数和转移数都是线性的。

构建

定义$endpos(t)$表示$t$在$s$中所有结束位置的集合。上文后缀树就是将$endpos$相同的结点合并在一起，SAM也可以利用这种思想来压缩信息。

可以发现$endpos$相同的子串有很多，并且对$endpos$相同的子串后面加上一个相同的字符，所得到的新子串的$endpos$仍然相同。于是可以对$endpos$等价类（就是$endpos$相同的子串的集合）建立SAM，一种转移只会对应一个状态，当然一个状态可以通过多种转移得到。

继续发掘$endpos$的性质。

引理1：对于字符串的任意子串$u$和$v$，若$endpos(u)=endpos(v)$且$|u|<|v|$，那么$u$是$v$的后缀。这一条是显然的。

引理2：对于字符串的任意子串$u$和$v$，若$|u|\le |v|$，那么$endpos(v)$与$endpos(u)$要么包含（$endpos(v)\subseteq endpos(u)$）要么无交。证明很简单，若$u$是$v$的子串，那么$u$出现是$v$出现的必要不充分条件；否则$u$和$v$一定不会同时出现。

由以上两条，启示我们可以将$s$的所有子串按$endpos$划分为若干等价类。

引理3：对于任意一个$endpos$等价类，其中的子串按大小排序，则一定是后一个子串是前一个子串的后缀，且长度减一，长度在值域上是连续的一段。证明很简单，设$u$是最短的，$v$是最长的。当$u=v$时一定成立，否则由引理1，$u$是$v$的子串，所以对于$v$的所有长度$\ge |u|$的后缀，由第二条性质，一定在这个等价类中。

现在我们设$v$是一个等价类中最长的一个子串，在$v$的前面加上一个字符后形成的新子串的$endpos$一定是$endpos(v)$的子集。而且显然的，在$v$的前面加上不同的字符会指向不同的$endpos$等价类，且这些等价类两两无交。于是我们相当于把这个$endpos$分割成若干部分。借这个关系可以建出一棵树。注意这棵树上的转移边表示在$endpos$等价类中的最长子串前面加上一个字符所得到的$endpos$。

这棵树被称作Parent Tree，实际上这棵树与后缀树的区别在于这棵树的转移是在前面加字符，于是这棵树可以视作反串的后缀树。根据分割关系可知，总结点数是$O(n)$的。

我们记等价类$x$中最长子串的长度为$le{n}_x$，最短子串长度为$minle{n}_x$，在Parent Tree上的父亲为$lin{k}_x$，于是由以上过程可知$minle{n}_x=le{n}_{lin{k}_x}+1$，因为$x$中的最短的一个是$lin{k}_x$中最长的一个在前面加上一个字符得到的。

但这还不是SAM，SAM的转移边应该是在子串的后面加上一个字符。我们希望在Parent Tree上增加上一些转移边使SAM满足其性质。

构建

考虑增量法构建SAM，新增一个字符后维护新增的子串（以新增字符结尾的子串）。

设当前加入的字符在第$i$位，字符为$c$，第$1$位到第$i-1$位构成的字符串所在等价类的编号为$x$。设初始节点（代表着空串）的编号为$1$。

首先，出现了新的一个最大的子串$s_{1\dots i}$，于是新建一个点$cur$，并且有$le{n}_{cur}=le{n}_x+1$。

接下来考虑如何修改已有节点的$endpos$。发现需要修改$endpos$的点都是$s_{1\dots i-1}$的一个后缀通过$c$转移边指向的点。跳后缀只需从$x$开始不断跳$link$就好。可以发现这是在从大到小遍历后缀，所以一开始较大的后缀可能没有$c$转移边，也就是说这些后缀在后面加上$c$形成的子串没有在$s_{1\dots i-1}$中出现过，于是这些后缀通过$c$转移边直接指向$cur$。如果这样一直跳到了根，那么$cur$在Parent Tree上的父亲就是$1$。

否则现在跳到了$p$，$p$经过一条$c$转移边指向了$q$。那么现在$p$中最大的子串就是$s_{1\dots i-1}$的一个后缀，那么$q$中长度不大于$le{n}_p+1$的子串就是$s_{1\dots i}$的一个后缀，这些子串的$endpos$中新增了$i$。

如果$le{n}_q=le{n}_p+1$，那么是好处理的，整个$q$的$endpos$都新增了$i$，于是不用动$q$，并且将$lin{k}_{cur}=q$。

否则，我们需要将$q$分裂。设$q$分裂出来的节点为$np$，$np$中的所有子串的长度都不大于$le{n}_p+1$，那么$np$中最长的子串就是$s_{1\dots i}$的后缀，于是$le{n}_{np}=le{n}_p+1$。$np$的转移还是和$q$的转移是一样的，于是直接拿过来。来考虑$lin{k}_{np}$，原来$lin{k}_q$通过在前面加上一个字符得到了原来$q$中最短的子串，而这个子串一定在$np$中，所以$lin{k}_{np}\leftarrow lin{k}_q$，然后$lin{k}_q\leftarrow np$。

拆分完后，考虑对其他状态的转移的影响，一些指向$q$的转移应该指向$np$。从$p$开始继续跳$link$（这相当于在前面减去一些字符），跳到新的$p$，如果能通过$c$转移边指向$q$，那么就将这个转移改到$np$上。如果指向的不是$q$，那就是指向的$q$在Parent Tree上的祖先，整个的$endpos$都要增加$i$，就不用改了。

最后将$x\leftarrow cur$，就构建好了。

复杂度的证明：首先状态数就是Parent Tree的结点数，是$O(n)$的。现在来证转移数是$O(n)$的。我们找到SAM的一棵生成树，从一个终止结点开始走转移边跑到初始结点来找到对应的后缀。当走到一条非树边时，走过去，然后沿生成树上的路径走回初始状态。这样走出来的不一定是对应的后缀，但一定也是一个后缀，并且没有跑出来过。每次跑出来一个后缀，就把这个后缀划去，然后重复以上过程。因为后缀数量为$n$，于是非树边的数量为$O(n)$，然后树边的数量与状态数相关，也是$O(n)$的，于是转移数就是$O(n)$的。

然后来看构造部分的时间复杂度。对于跳$x$的$link$连向$cur$的转移和将$q$的转移拿到$np$上，都是增加了转移，而转移数是$O(n)$的，于是总的是$O(n)$的。对于跳$p$的$link$修改到$q$的转移，可以发现每条边只会被修改一次，因为已经满足了$le{n}_{np}=le{n}_p+1$，下一次遍历到它时不会进行修改转移的遍历，又因为边数是$O(n)$的，所以还是$O(n)$的，于是构造SAM的时间复杂度是$O(n)$的。

应用

判断子串

把文本串扔到SAM上，看能否找到对应节点。

访问后缀

直接从一个结点开始跳$link$。

求$endpos$

由Parent Tree的分割关系，可以在Parent Tree上线段树合并求出一个结点的$endpos$。

广义SAM

基本子串结构