字 符 串 全 家 桶
字符串
Trie
基础的内容，但是当然要会。
哈希
没什么好说的。哈希算法和大部分的字符串算法似乎不是一个体系的。使用的时候注意尽量双哈希即可。
KMP 与 border
border 的定义：如果 \(i\) 满足 \(s[1\cdots i]=s[|s|-i+1\cdots |s|]\)，则称 \(i\) 是 \(s\) 的一个 border。
\(s\) 的所有 border 构成的集合记为 \(Border(s)\)。一般不认为 \(|s|\in Border(s)\)。
KMP 算法可以在 \(O(n)\) 的时间内求出字符串 \(s\) 的所有前缀的最长 border。若记 \(s[1\cdots i]\) 的最长 border 为 \(f_i\)（不存在则为 \(0\)），则有结论：\(s[1\cdots i]\) 的所有 border 是 \(f_i,f_{f_i},f_{f_{f_i}},\cdots\)。因此求 \(f_{i+1}\) 时只要在这些 border 里面尝试就可以了。
结论的证明是容易的，画出图来就很直观。
for(int i=2,j=0;i<=n;i++){
while(j&&s[j+1]!=s[i])j=f[j];
if(s[j+1]==s[i])++j;f[i]=j;
}
border 还有一个重要性质，称为 border 引理：\(s\) 的所有 border 可以划分为不超过 \(\lceil \log_2|s| \rceil\) 个等差数列。更进一步地，对任何 \(k\)，\([k,2k)\) 内的所有 border 构成等差数列。
至于 KMP 解决模式匹配问题就略过了。
AC 自动机
AC 自动机是 以 Trie 的结构为基础，结合 KMP 的思想 建立的自动机，用于解决多模式匹配等任务。——摘自 OI Wiki。
要建立 AC 自动机，首先建一个 Trie。然后添加一些 fail 指针，状态 \(u\) 的 fail 指针指向的状态 \(v\) 是 \(u\) 的（出现过的）最长后缀。fail 指针的添加要按照深度处理，也就是需要做一遍拓扑排序。假设要求 \(x\) 的 fail 指针，\(x\) 的 父结点是 \(u\)，\(x\) 是在 \(u\) 后面添加了一个字符 \(c\) 得到的。类似 KMP，从 fail[u] 开始不断跳 fail 指针，直到添加一个 \(c\) 之后的状态存在，就把 \(x\) 的 fail 指针指向这个状态。
实际实现时可以更简单一点，不用一直跳 fail，可以预先记下从这个点开始跳，后面增加 \(c\)，最终会跳到哪个点。
queue<int> Q;
for(int i=0;i<26;i++)
if(trie[0][i])Q.push(trie[0][i]);
while(!Q.empty()){
int u=Q.front();Q.pop();
for(int i=0;i<26;++i){
if(trie[u][i]){
fail[trie[u][i]]=trie[fail[u]][i];
Q.push(trie[u][i]);
}
else trie[u][i]=trie[fail[u]][i];
}
}
事实上会发现 KMP 就相当于是只有一个串时的 AC 自动机。既然 KMP 可以解决单模式串的匹配问题，AC 自动机就可以解决多模式串的匹配问题了。
一般的应用方法是把 fail 指针单拿出来看作一棵树去处理。比如说在状态 \(u\) 的子树内的所有状态都包含 \(u\) 对应的字符串作为子串。或许还可以在这棵树上 DP。
回文树
又叫回文自动机，可以简写为 PAM。它可以存储一个字符串中所有回文子串的信息。
首先容易知道 PAM 的状态数不超过 \(|s|\)。可以归纳证明这个结论。
PAM 的转移边表示在当前字符串前后各加一个相应字符，而 fail 指针指向最长的回文前缀（也就是最长后缀，还是最长 border）。另外每个状态上还要记下该回文串的长度。PAM 有两个初始状态，分别代表长度为 \(-1,0\) 的回文串，称为奇根，偶根。进行一个增量构造，假设已经构造了前 \(p-1\) 个字符的 PAM，添加 \(s_p\) 时，不断跳 fail 指针直到 \(s_p=s_{p-len-1}\)。然后如果新的状态存在就直接跳过去，否则新建一个状态，并且继续跳 fail 以获得这个状态的 fail 指针。
int tot,lst,trans[N][26],len[N],fail[N];
int node(int l){
tot++;for(int j=0;j<26;j++)trans[tot][j]=0;
len[tot]=l;fail[tot]=0;return tot;
}
void init(){tot=-1;lst=0;node(0);node(-1);fail[0]=1;}
int getfail(int x,int y){
while(s[x-len[y]-1]!=s[x])y=fail[y];
return y;
}
void build(char *s){
int Len=strlen(s+1);
for(int i=1;i<=Len;i++){
int now=getfail(i,lst),c=s[i]-'a';
if(!trans[now][c]){
int x=node(len[now]+2);
fail[x]=trans[getfail(i,fail[now])][c];
trans[now][c]=x;
}
lst=trans[now][c];
}
}
与回文串有关的问题都可以考虑使用 PAM。
Z函数，Manacher
这两个放到一起是因为它们真的很像。
Z 函数（或称为扩展 KMP）要解决的问题是：对所有 \(i\)，求 \(s\) 与 \(s[i\cdots |s|]\) 的最长公共前缀的长度 \(z_i\)。Manacher 要解决的问题是：对所有 \(i\)，求以 \(i\) 为中心的最长回文串的长度 \(a_i\)，这里 \(i\) 可能是某个字符或者某个缝隙。
二者都有线性解法，思路都是利用已有信息减少比较量。对于 Z 函数而言，如果有一个段 \(s[l,r]\) 和 \(s\) 的前缀匹配了，那么在求 \(z_i\) 的时候，如果 \(i\le r\)，可以知道要么 \(z_i=z_{i-l}\)（当 \(z_{i-l}\lt r-i+1\) 时），要么 \(z_i\ge r-l+1\)。因此维护最右边的这样的段，然后暴力往后扩展即可。会发现右端点是不降的，所以时间复杂度就是线性。
for(int i=2,l=1,r=1;i<=m;i++){
if(i<=r&&z[i-l+1]<r-i+1)z[i]=z[i-l+1];
else{
z[i]=max(0,r-i+1);
while(i+z[i]<=m&&b[z[i]+1]==b[i+z[i]])++z[i];
l=i;r=i+z[i]-1;
}
}
Manacher 也类似。以 \(i\) 是字符的情况为例，如果有一个回文段 \(s[l\cdots r]\)，那么在求 \(a_i\) 的时候，如果 \(i\le r\)，可以知道要么 \(a_i=a_{l+r-i}\)（当 \(a_{l+r-i}\lt r-i+1\) 时），要么 \(a_i\ge r-l+1\)。同样维护最右边的段，然后暴力往后扩展。同样右端点是不降的。一个小技巧是给原字符串的每两个字符之间加一个特殊字符，这样就可以避免掉 \(i\) 是缝隙的情况。
for(int i=1,l=1,r=0;i<=n;i++){
int k=i>r?1:min(a[l+r-i],r-i+1);
while(i-k>=1&&i+k<=n&&s[i-k]==s[i+k])++k;
a[i]=k;--k;ans=max(ans,a[i]);
if(i+k>r)l=i-k,r=i+k;
}
后缀数组
后缀数组要解决的问题是把 \(s\) 的所有后缀按照字典序排序。排序得到的结果记为 \(sa\) 数组，同时用 \(rk\) 数组表示每个位置的排名。
\(O(n\log^2n)\) 做法：熟知比较两个字符串的字典序可以通过二分+哈希的方法在 \(O(\log)\) 的时间内完成，再套一个 sort 就可以做到 \(O(n\log^2n)\)。
\(O(n\log n)\) 做法：运用倍增的思想。
设 \(suf_{j,i}\) 表示字符串 \(s[i\cdots \min(n,i+2^j-1)]\)，当 \(sa_j\) 表示对 \(suf_{j,i}\) 的排序结果，\(rk_j\) 表示相应的排名。显然当 \(j\) 达到 \(\lceil \log_2 n\rceil\) 时就得到了需要的 \(sa\)。\(j=0\) 的边界情况是容易的。对于从 \(j-1\) 到 \(j\)，要比较 \(suf_{j,i_1}\) 和 \(suf_{j,i_2}\)，需要先比较 \(suf_{j-1,i_1}\) 和 \(suf_{j-1,i_2}\)，再比较 \(suf_{j-1,i_1+2^{j-1}}\) 和 \(suf_{j-1,i_2+2^{j-1}}\)。这个比较用的是 \(rk_{j-1}\)。所以这里就需要一个双关键字的排序，使用双关键字基数排序完成即可。
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
int n,m,rk[N],y[N],c[N],sa[N];
//sa[i]表示排名为i的后缀
//c数组是桶，基数排序的辅助数组
//rk=x,y分别表示两个关键字
char s[N];
int main(){
scanf("%s",s+1);
n=strlen(s+1);m=300;
for(int i=1;i<=n;i++){rk[i]=s[i];++c[rk[i]];}//得到第一关键字并计入桶中
for(int i=2;i<=m;i++)c[i]+=c[i-1];//对桶做前缀和，则字典序越大，对应的c越大
for(int i=n;i>=1;i--)sa[c[rk[i]]--]=i;
for(int k=1;k<=n;k<<=1){
int num=0;
//确定第二关键字，y[i]表示第二关键字排名为i的数
for(int i=n-k+1;i<=n;i++)y[++num]=i;//不存在第二关键字的当作极小值
for(int i=1;i<=n;i++)if(sa[i]>k)y[++num]=sa[i]-k;
for(int i=1;i<=m;i++)c[i]=0;
for(int i=1;i<=n;i++)++c[rk[i]];
for(int i=2;i<=m;i++)c[i]+=c[i-1];
for(int i=n;i>=1;i--){sa[c[rk[y[i]]]--]=y[i];y[i]=0;}
//又一遍基数排序，在第二关键字已经排序完成的基础上
//对第一关键字进行排序，所以只用把开头的i换成y[i]
swap(rk,y);num=1;rk[sa[1]]=1;
//现在y不是用作第二关键字了，它记下了原来的第一关键字，即长为k的排序结果
for(int i=2;i<=n;i++){
if(y[sa[i]]==y[sa[i-1]]&&y[sa[i]+k]==y[sa[i-1]+k])
rk[sa[i]]=num;
else rk[sa[i]]=++num;
}//x[i]表示i的排名
if(num==n)break;m=num;//m是字符集大小
}
for(int i=1;i<=n;i++)printf("%d ",sa[i]);
return 0;
}
涉及到子串比较大小的问题可以考虑后缀数组。
后缀数组可以引申出 height 数组，简记为 h，它的定义是 h[i]=LCP(suf[sa[i-1]],suf[sa[i]])，这里 LCP 表示最长公共前缀（的长度）。h 数组可以 \(O(n)\) 求，因为有结论：h[rk[i]]>=h[rk[i-1]]-1。然后就可以暴力跳了。
for(int i=1,k=0;i<=n;i++){
if(rk[i]==0)continue;if(k)--k;
while(s[i+k]==s[sa[rk[i]-1]+k])++k;
h[rk[i]]=k;
}
有结论：LCP(suf[sa[i]],suf[sa[j]])=min h[i+1...j],i<j。感性理解是容易的。因此在 ST 表预处理后可以 \(O(1)\) 求任意两个后缀的 LCP。
后缀树
考虑把 \(s\) 的所有后缀插入到一个 Trie 中。这个 Trie 有一个优越的性质：它的每一个非根结点恰好对应一个 \(s\) 的非空子串。但是这个 Trie 就很大，所以考虑压缩：如果某个点只有一个儿子，那么就把它和子结点缩起来。特别的，如果一个结点作为某个后缀的终止结点，也将其保留下来。这样得到的树称为后缀树。
后缀树就是反串的后缀自动机的 slink 建出的树。
后缀自动机
十级算法，先咕咕咕了。进省队了，不咕了！
字符串 \(S\) 的后缀自动机（简称 SAM），是一个可以接受 \(S\) 的所有后缀的最小自动机。SAM 最重要的是它包含了 \(S\) 的所有子串的信息——一个子串对应一条从初始状态 \(u_0\) 出发的路径。
对 SAM 很重要的概念有两个。其一是结束位置 endpos。对 \(s\) 的任意子串 \(t\)，用 \(\text{endpos}(t)\) 表示 \(t\) 在 \(s\) 中所有出现的末尾。根据 \(\text{endpos}\)，所有子串可以分为若干等价类，它们在 SAM 中被存储在同一个结点内。同时我们还可以得到一些重要推论：
- 如果 \(\text{endpos}(u)=\text{endpos}(v),|u|\le |v|\)，则 \(u\) 在 \(s\) 中的每次出现都是 \(v\) 的后缀。
- 如果 \(|u|\le |v|\)，要么 \(\text{endpos}(u)\cap \text{endpos}(v)=\O\)，要么 \(\text{endpos}(u)\subseteq \text{endpos}(v)\)。
- 一个 \(\text{endpos}\) 等价类内的所有子串的长度互不相同，且恰好构成一段区间。根据这个结论，只用在结点上记录这个等价类的最长字符串长度
maxlen或者简记为len，以及最短字符串长度minlen。
其二是后缀链接 slink。对于一个 \(\text{endpos}\) 等价类 \(v\)（也就是 SAM 中的一个结点 \(v\)），\(\text{slink}(v)\) 连接到对应于 \(v\) 中最短的字符串 \(w\) 删掉第一个字符后（即最长真后缀）所在的 \(\text{endpos}\) 等价类。特别的，如果 \(w\) 只有一个字符，那么连接到 \(u_0\)。方便起见，令 \(\text{endpos}(u_0)=\{0,1,2,\cdots,|S|\},\text{slink}(u_0)=-1\)。实际上会发现 \(\text{slink}(v)\) 对应的 \(\text{endpos}\) 集合包含了 \(v\) 对应的 \(\text{endpos}\) 集合，于是后缀链接会构成一棵根结点为 \(u_0\) 的树，表示了 \(\text{endpos}\) 集合的包含关系。这棵树一般称为 \(\text{parent}\) 树。同时会有 \(\text{minlen}(v)=\text{maxlen}(\text{slink}(v))+1\)（所以就不用记 \(\text{minlen}\) 了。
SAM 的构建就是增加一个字符 \(c\)，然后进行一些分类讨论：
- 令 \(lst\) 为添加 \(c\) 之前整个串对应的状态。创建一个新的状态 \(cur\)，令 \(\text{len}(cur)=\text{len}(lst)+1\)，然后将 \(lst\) 的值更新为 \(cur\)。
- 如果 \(lst\) 没有字符 \(c\) 对应的转移，添加到 \(cur\) 的转移。遍历后缀链接，将所有没有字符 \(c\) 转移的结点的这个转移定向到 \(cur\)，直到找到第一个存在字符 \(c\) 的转移的结点，设为 \(p\)。
- 如果 \(p\) 不存在，也就是到达了 \(-1\)，相当于说 \(c\) 是一个新出现的字符，将 \(\text{slink}(cur)\) 赋值为 \(0\) 并退出。
- 否则，设 \(p\) 通过 \(c\) 转移到的状态为 \(q\)。如果 \(\text{len}(p)+1=\text{len}(q)\)，直接将 \(\text{slink}(cur)\) 赋值为 \(q\) 并退出。事实上，\(\text{slink}(cur)\) 要连接到的状态包含了整个字符串在加入 \(c\) 前就出现过的当前最长后缀，也就是以 \(c\) 结尾且长度为 \(\text{len}(p)+1\) 的字符串。
- 否则，我们要从 \(q\) 中拆出一部分 \(r\) 作为 \(\text{slink}(v)\)。这时 \(\text{slink}(r)\) 等于原来的 \(\text{slink}(q)\)，\(\text{slink}(q)\) 变成了 \(r\)；\(\text{len}(r)=\text{len}(p)+1\)。然后从 \(p\) 遍历后缀链接往前跳，对所有字符 \(c\) 转移到 \(q\) 的结点，将这个转移重定向到 \(r\)。
根据构造方式可以知道 SAM 是线性的。具体的，点数最大为 \(2|S|-1\)，边数最大为 \(3|S|-4\)。
void insert(int c){
int cur=++tot;len[cur]=len[lst]+1;
int p=lst;lst=cur;
while(p!=-1&&!trans[p][c])trans[p][c]=cur,p=slink[p];
if(p==-1){slink[cur]=0;return;}
int q=trans[p][c];
if(len[q]==len[p]+1){slink[cur]=q;return;}
int r=++tot;len[r]=len[p]+1;slink[r]=slink[q];
for(int i=0;i<26;i++)trans[r][i]=trans[q][i];
slink[q]=slink[cur]=r;
while(p!=-1&&trans[p][c]==q)trans[p][c]=r,p=slink[p];
}
