【模板】AC自动机

题目链接

---

  有N个模式串，再给出一个文本串，现在我们想知道有多少个模式串在文本串中出现过？

  这就是一个AC自动机的模板题了，我们可以将AC自动机建立出来，在上面建立fail指针，然后建立fail树这样的做法来解决这个问题。

  具体的说一下，我们可以先建立Trie树，然后利用bfs建立AC自动机，然后再建立fail树，然后我们利用文本串在AC自动机上进行fail的跳转，我们可以知道它可以表示哪些节点，然后我们就可以利用这样的前缀匹配算法来进行计算贡献了。

  注意，这里用的是前缀匹配算法！

  好了，那么问题来了，今天我突发奇想，我想用后缀匹配该怎么做呢？反过来建立AC自动机？？？啊这……

  于是，我想，我们可以在SAM的link树上做手脚，我们不妨建立一棵GSAM来解决这个问题。

  于是的于是，问题就变成了对于每个后缀，找有多少个后缀出现过了，这就可以放在广义后缀自动机上跑了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define pii pair<int, int>
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 2e6 + 7;
const int maxP = maxN << 1;
int N, ans;
char s[maxN];
struct SAM
{
    struct state
    {
        int len, link, next[26];
    } st[maxP];
    int siz = 1, last;
    void init()
    {
        siz = last = 1;
        st[1].len = 0;
        st[1].link = 0;
        siz++;
    }
    int dp[maxP];
    bool quest[maxP] = {false};
    int extend(int c, int val, bool question)
    {
        if(st[last].next[c] && st[last].len + 1 == st[st[last].next[c]].len)
        {
            last = st[last].next[c];
            dp[last] += val;
            quest[last] |= question;
            return last;
        }
        int cur = siz++;
        st[cur].len = st[last].len + 1;
        dp[cur] += val;
        quest[cur] |= question;
        int p = last;
        while (p && !st[p].next[c])
        {
            st[p].next[c] = cur;
            p = st[p].link;
        }
        if (p == 0)
        {
            st[cur].link = 1;
        }
        else
        {
            int q = st[p].next[c];
            if (st[p].len + 1 == st[q].len)
            {
                st[cur].link = q;
            }
            else
            {
                int clone;
                if(p == last)
                {
                    clone = cur;
                }
                else
                {
                    clone = siz++;
                    st[cur].link = clone;
                }
                st[clone] = st[q];
                st[q].link = clone;
                st[clone].len = st[p].len + 1;
                while (p != 0 && st[p].next[c] == q)
                {
                    st[p].next[c] = clone;
                    p = st[p].link;
                }
            }
        }
        return last = cur;
    }
    vector<int> to[maxP];
    void bfs()
    {
        for(int i=2; i<siz; i++) to[st[i].link].push_back(i);
    }
    void dfs(int u)
    {
        for(int v : to[u])
        {
            dfs(v);
            quest[u] |= quest[v];
        }
        if((u ^ 1) && quest[u]) ans += dp[u];
    }
} sam;
int main()
{
    scanf("%d", &N);
    sam.init();
    for(int i=1, len; i<=N; i++)
    {
        scanf("%s", s);
        len = (int)strlen(s);
        sam.last = 1;
        for(int j=0; j<len; j++) sam.extend(s[j] - 'a', j == len - 1 ? 1 : 0, 0);
    }
    scanf("%s", s);
    int len = (int)strlen(s);
    sam.last = 1;
    for(int i=0; i<len; i++) sam.extend(s[i] - 'a', 0, 1);
    sam.bfs();
    ans = 0;
    sam.dfs(1);
    printf("%d\n", ans);
    return 0;
}
/*
3
ac
aba
aa
abaaa
ans:2
*/