算法详解——后缀自动机

DFA

---

DFA，即确定性有限状态自动机，由一个五元组$M=(\Sigma ,Q,q_s,F,tr)$组成，其中：

$\Sigma$为一个有限字符集，其中每个字符$c$称为一个输入符号；

$Q$为一个有限状态集合；

$q_s\in Q$为初始状态；

$F\subseteq Q$称为终结状态集合；

$tr\in Q\times \Sigma \to Q$称为状态转换函数。

$tr(q,c)=q^{\prime }$表示当前状态为$q$，输入符号为$c$时，自动机$M$将自动转换成下一个状态$q^{\prime }$，此时称$q^{\prime }$为$q$的一个后继状态。

---

以上全是废话。

大家应该都知道AC自动机吧，如果不知道可以去看这一篇博客：http://blog.youkuaiyun.com/wang3312362136/article/details/78659403

一个DFA，就是一个有向图，有一个起点，有一些标有字符的边，有一个或多个终点，从这个起点，按照一个字符串上的字符，按顺序走与字符串的字符相同的边，最终走到了终点，就说明这个DFA能够识别这个字符；如果走到了非法状态$q_{\varphi }$，或者走到了一个不是终点的状态，那么说明这个DFA不能识别这个字符串。

对于一个状态$p$和$q$，如果任何一个能够从$p$转换到终点的字符串都可以从$q$转换到终点，反之也成立，那么就说明$p$和$q$是等价状态，记为KaTeX parse error: Unexpected character: '' at position 2: p̲~q。

如果一个DFA中没有等价状态，那么这个自动机叫做最小状态自动机。

SAM

即后缀自动机，是能识别一个串所有后缀的最小状态自动机。

SAM的性质

它有哪些性质呢？

---

Theorem 1
对于任意一个$T\in {\Sigma }^{\ast }$，$tr(q_s,T)̸=q_{\varphi }$当且仅当$T$是$S$的一个字串。
Lemma 2
设$T\in {\Sigma }^{\ast }$是一个非空字符串，$right(T)$表示$T$在$S$中所有结束位置的集合，则有 L ( t r ( q s , T ) ) = { s u f r + 1 ∣ r ∈ r i g h t ( T ) } L(tr(q_s,T))=\{suf_{r+1}\mid r\in right(T)\} L(tr(qs​,T))={sufr+1​∣r∈right(T)}。
Theorem 3
设$T_1$，$T_2$是$S$的两个非空字符串，则$tr(q_s,T_1)=tr(q_s,T_2)$的充要条件是$right(T_1)=right(T_2)$。
Theorem 3.5
记一个状态$q$的$right$集合为$R_q$，则$right$集合恰好为$R_q$的串，其长度一定在一个区间内，称之为$q$的合法长度区间，记为$[min{l}_q,max{l}_q]$，对应从初始状态到这个状态的最短长度和最长长度。
Lemma 4
任取两个不同的状态$p,q$，则下列三式中必有一式成立：
(1)$R_p\bigcap R_q=\varphi$ (2)$R_p\subseteq R_q$ (3)$R_q\subseteq R_p$
Lemma 5
若一个状态$p$是状态$p$的$parent$状态，当且仅当$R_q$是最小真包含$R_p$的集合，那么 q ∈ Q   { q ϕ } q\in Q\text{\ }\{q_\phi\} q∈Q {qϕ​}的$parent$状态存在且唯一。
Theorem 6
设 q ∈ Q   { q ϕ } q\in Q\text{\ }\{q_\phi\} q∈Q {qϕ​}，$p$是$q$的$parent$状态，则有$max{l}_p=min{l}_q-1$，此时$p$对应的所有字串都是$q$的后缀。
所以，我们在后缀自动机中只需要存储每个节点$parent$状态，和$maxl$值即可。
Theorem 7
对串$S$构建后缀自动机$M$，则有$M$的状态数$|Q|\le 2|S|+1$。
Theorem 8
对串$S$构建后缀自动机$M$，则合法状态转换边的数量不超过$3|S|$。

---

1. 后缀自动机中只需存储$S$的字串对应的状态；
2. 一个状态对应的字串，它们的$right$集合相等，且长度取值必定对应一个区间；
3. 每个状态与$parent$状态的关系必定构成一棵$parent$树；
4. 一个状态的最小合法长度恰好比$parent$状态的最大合法长度多$1$；
5. 后缀自动机是一个线性结构。

证明？

由自己的感觉可得

自己参阅资料吧。（其实可以背结论的）

SAM的构建

增量法，每次在后缀自动机中添加一个字符，然后对当前的SAM进行更新。

---

显然，添加一个字符并不会造成状态的合并，但有可能造成状态的分离，而分离的状态只有可能是在添加前后缀状态和非后缀状态都可以转换到它，此时，这个状态需要分裂成只能被后缀状态转换的状态和只能被非后缀状态转换的状态。（这个情况之后再讲）

设添加前这个串是$S$，添加的字符为$c$，设$tr(q_s,S)=p$，由于所有后缀节点在$parent$树上都是祖先关系，因此把它们记为$v_1=p,v_2,v_3,\cdots ,v_k=q_s$。

由于$tr(q_s,Sc)=q_{\varphi }$，那么我们需要新建一个节点$np=tr(q_s,Sc)$（这个是显然的）
那么$max{l}_{np}=|S|+1$， R n p ′ = { n + 1 } R'_{np}=\{n+1\} Rnp′​={n+1}。

对于一个后缀状态$v$，如果$tr(v,c)=q_{\varphi }$（即$v$没有符号为$c$的合法转换边），那么将$tr(v,c)=np$即可，正确性显然。

设$v_p$是$v_1,v_2,v_3,\cdots ,v_k$中第一个存在符号为$c$的合法转换边的状态，那么记$q$为$tr(v_p,c)$，取$r=R_q$中的最小值，此时记$Q_1=S[r,r],Q_2=S[r-1,r],\cdots ,Q_r=S[1,r]$，下标就是串的长度。

由于$S[r]$显然为$c$，那么记$Q_1=P_{0}c,Q_2=P_{1}c,\cdots ,Q_r=P_{r-1}c$，显然，$P_i=S[r-i,r-1]$。那么状态$q$对应的串就是$Q_{min{l}_q},\cdots ,Q_{max{l}_q}$，所有能转换到$q$的状态$p$对应的串就是 S Q = { P m i n l q − 1 , ⋯   , P m a x l q − 1 } S_Q=\{P_{minl_{q}-1},\cdots,P_{maxl_q-1}\} SQ​={Pminlq​−1​,⋯,Pmaxlq​−1​}。

又由于$v_p$对应的后缀串只有 S P = { P 0 , ⋯   , P m a x l v p } S_P=\{P_{0},\cdots,P_{maxl_{v_p}}\} SP​={P0​,⋯,Pmaxlvp​​​}；

讨论$q$的状态：

1. 当$max{l}_{v_p}=max{l}_q-1$时，显然有$S_Q\subseteq S_P$，那么，所有能通过输入符号$c$转换到$q$的状态都是后缀状态，此时$q$不会发生状态的分裂。而对于$v_p$在$parent$树上的祖先，显然$tr(v_p,c)$更不可能发生分裂。
2. 当$max{l}_{v_p}<max{l}_q-1$时，$q$的合法长度区间可以分成两个部分：$[min{l}_q,max{l}_{v_p}+1]$以及$[max{l}_{v_p}+2,max{l}_q]$。前者只有后缀状态能转移到它，后者只有非后缀状态能转移到它。
   那么新建一个状态$nq$，对应前者，新图中的$q^{\prime }$对应后者。由于$R_{nq}$显然只比$R_q$多一个$|S|+1$，而$|S|+1$之后并没有字符，没有状态能通过这个转移，那么$nq$的状态转换边与$q$完全相同。
   而对于$v_p$在$parent$树上的祖先，显然，如果$tr(v_p,c)=q$则指向$nq$，否则不变。
   对于$np$的$parent$：当$v_{[1,n]}$都不存在$c$的转换边，说明$np$是第一次出现，$parent$是$q_s$。否则，$np$的$parent$是$q$或者$nq$，取决于是否建立了$nq$这个状态。
   对于$q^{\prime }$和$nq$的$parent$：如果没有发生分裂，则不改变。如果发生了分裂，设原图中$q$的$parent$为$pa{r}_q$，则$pa{r}_q$，$q$和$nq$这三个状态在$parent$树上构成祖孙关系，进一步推理得$pa{r}_{n}q=pa{r}_q,pa{r}_{q^{\prime }}=nq$。

代码

struct samnode
{
  samnode* tr[26];
  samnode* par;
  int maxl;

  int init(int l=0)
  {
    memset(tr,0,sizeof tr);
    par=NULL;
    maxl=l;
    return 0;
  }
};

struct suffix_automaton
{
  samnode* qs;
  samnode* qlast;
  samnode node[maxn*3];
  int cntnode;

  inline int clear()
  {
    delete qs;
    delete qlast;
    qs=new samnode;
    qlast=new samnode;
    qs->init();
    qlast=qs;
    cntnode=0;
    return 0;
  }

  inline int addchr(int ch)
  {
    samnode* p=qlast;
    samnode* np=&node[++cntnode];
    np->init(p->maxl+1);
    qlast=np;
    while((p!=NULL)&&(p->tr[ch]==NULL))
      {
        p->tr[ch]=np;
        p=p->par;
      }
    if(p==NULL)
      {
        np->par=qs;
        return 0;
      }
    samnode* q=p->tr[ch];
    if(p->maxl+1!=q->maxl)
      {
        samnode* nq=&node[++cntnode];
        nq->init(p->maxl+1);
        memcpy(nq->tr,q->tr,sizeof q->tr);
        nq->par=q->par;
        q->par=nq;
        np->par=nq;
        while((p!=NULL)&&(p->tr[ch]==q))
          {
            p->tr[ch]=nq;
            p=p->par;
          }
      }
    else
      {
        np->par=q;
      }
    return 0;
  }
};