后缀自动机

特征

1、对于每个节点，父节点的接受串是该节点的接受串的后缀，而且是最长的那个。用该节点的len减去父节点的fa.len，就是该节点表示的串中父节点不能表示的串个数。

同理，当插入这个节点，出现的新不同子串个数就是len-fa.len。

2、每个节点表示串出现的次数，是这个节点子树上有效节点的总数。（有效节点指插入该字符产生的那个节点，也就是代码中extend中的clone节点）。

这样我们初始化有效节点为1，然后拓扑排序dp，就可以O(n)得到每个节点出现次数。

3、后缀自动机是一张有向无环图，其中顶点是状态，而边代表了状态之间的转移。

4、任意路径“匹配”某一子串，该子串由路径中边的标记组成。

5、如果程序中所处理字符串的最大可能长度是MAXN，那么至多会占用2*MAXN-1个状态。

6、由长度为n的字符串s建立的后缀自动机中，转移的数量不超过3n-4（对于n>=3）。

模板

#include<iostream>
#include<cstring>
using namespace std;
const int maxn = 1e5 + 10;
struct node
{
    int ch[26], par,len;
}SA[maxn*2];
int sz, root, last;
void init()
{
    sz = root = last = 0;
    SA[0].len = 0;
    SA[0].par = -1;
    memset(SA[0].ch, 0, sizeof(SA[0].ch));
}

void extend(int c)
{//向当前字符串的尾部添加一个字符
    int p = last, cur = ++sz;
    SA[cur].len = SA[p].len + 1;
    for (; p!=-1 && !SA[p].ch[c]; p = SA[p].par) SA[p].ch[c] = cur;
    if (p == -1) SA[cur].par = root;
    else
    {
        int q = SA[p].ch[c];
        if (SA[q].len == SA[p].len + 1) SA[cur].par = q;
        else
        {
            int clone = ++sz;
            SA[clone] = SA[q];
            SA[clone].len = SA[p].len + 1;
            SA[q].par = SA[cur].par = clone;
            for (; p != -1 && SA[p].ch[c] == q; p = SA[p].par) SA[p].ch[c] = clone;
        }
    }
    last = cur;
}
int encode(char c)
{
    return c - 'a';
}
int Count_substrings()
{//不同子串的个数
    int ans = 0;
    for (int i = 1; i <= sz; i++)
    {
        ans += SA[i].len - SA[SA[i].par].len;
    }
    return ans;
}
bool find_substring(int*des, int n)
{//寻找子串是否存在
    int i=0, cur = SA[root].ch[des[0]];
    while (i < n&&cur)
    {
        i++;
        cur = SA[cur].ch[des[i]];
    }
    if (i == n) return true;
    else return false;
}
int r[maxn<<2],w[maxn];
void RadixSort(int n)
{//拓扑排序
    for(int i=0;i<=n;i++) w[i]=0; 
    for(int i=1;i<=sz;i++) w[SA[i].len]++;
    for(int i=1;i<=n;i++) w[i]+=w[i-1];
    for(int i=sz;i>=1;i--) r[w[SA[i].len]--]=i;
    r[0]=0;
}
int LCS(int*P,int lenP)
{//求串P与建立后缀自动机的串的最长公共子串
    int lcs=0,now=0,ans=0;
    for(int i=0;i<lenP;i++)
    {
        if(SA[now].ch[P[i]])
        {
            now=SA[now].ch[P[i]];
            lcs++;
        }
        else
        {
            while(now!=0&&SA[now].ch[P[i]]==0) now=SA[now].par;
            if(now==0) now=root,lcs=0;
            else lcs=SA[now].len+1,now=SA[now].ch[P[i]];
        }
        ans=max(ans,lcs);
    }
    return ans;
}
long long cal_k_strings()
{//寻找原串中出现次数为k的子串数目
    
    return 0;
}
char s[maxn],ss[maxn];
int tmp[maxn];
int main()
{
    scanf("%s", s);
    printf("%s
",s);
    int len = strlen(s);
    init();
    for (int i = 0; i < len; i++) extend(encode(s[i]));//对于多串，每次将last=root再插入新串
    printf("不同的子串个数：%d
", Count_substrings());
    RadixSort(len);
    printf("sz:%d
",sz);
    for(int i=0;i<=sz;i++) printf("%d ",r[i]);
    printf("
");
    scanf("%s", ss);
    len = strlen(ss);
    for (int i = 0; i < len; i++) tmp[i] = encode(ss[i]);
    if (find_substring(tmp, len)) printf("yes
");
    else printf("no
");
    return 0;
}