「SDOI2016」生成魔咒【后缀自动机link树讲解】

题目链接

---

  题意：每放入一个点，求此时的已经生成的串中有多少个不同的子串。

  思路：我们可以利用SAM的和来做，众所周知，，我们想知道最终形成的串中有多少个完全不同的子串，肯定是SAM的1~size的所有的点的之和。

  但是，这道题是求的是插入到当前情况的时候的不同的子串的个数，那么我们还是可以类似这么做。我们可以用当前点的来累加这个贡献，为什么呢？

  如果不生成一个clone的节点，那么它的正确性无容置疑；但是如果生成了一个clone节点，那么又会发生什么呢？

，

，

又，

并且，

于是有现在的，

就会变成了从原来的变成，

又有，

所以，相互抵消之后，其实对总的贡献并不是影响的。

#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
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 10;
ll ans = 0;
int N, pos[maxN];
int ch[maxN], Lsan[maxN];
struct SAM
{
    struct state
    {
        int len, link;
        unordered_map<int, int> next;
    } st[maxN << 1];
    int siz = 1, last;
    void init()
    {
        siz = 1;
        st[1].len = 0;
        st[1].link = 0;
        siz++;
        last = 1;
    }
    int extend(int c)
    {
        int cur = siz++;
        st[cur].len = st[last].len + 1;
        int p = last;
        while (p != 0 && !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 = siz++;
                st[clone].len = st[p].len + 1;
//                memcpy(st[clone].next, st[q].next, sizeof(st[q].next));
                st[clone].next = st[q].next;
                st[clone].link = st[q].link;
                while (p != 0 && st[p].next[c] == q)
                {
                    st[p].next[c] = clone;
                    p = st[p].link;
                }
                st[q].link = st[cur].link = clone;
            }
        }
        ans += st[cur].len - st[st[cur].link].len;
        return last = cur;
    }
    
} sam;
int main()
{
    scanf("%d", &N);
    for(int i=1; i<=N; i++) { scanf("%d", &ch[i]); Lsan[i] = ch[i]; }
    sort(Lsan + 1, Lsan + N + 1);
    int _UP = (int)(unique(Lsan + 1, Lsan + N + 1) - Lsan - 1);
    for(int i=1; i<=ch[i]; i++) ch[i] = (int)(lower_bound(Lsan + 1, Lsan + _UP + 1, ch[i]) - Lsan);
    sam.init(); ans = 0;
    for(int i=1; i<=N; i++)
    {
        pos[i] = sam.extend(ch[i]);
        printf("%lld\n", ans);
    }
    return 0;
}