【GDOI2016模拟3.14】hashit

CLJ的题，本来是道后缀平衡树的裸题，先用广义后缀自动机艹过去，之后再补。

题目大意：

有一个字符串，每次要支持后端插入和后端删除，问操作完后该串不同子串的个数。

题解：

首先搞成一个trie，然后建广义SAM。

然后考虑利用SAM去求不同子串个数。

我们知道对于两个trie的两个前缀，它们的lcs就等于它们两个点在SAM上的结尾点在SAM上的lca的深度。

因此可以自上而下扫trie，现在相当于维护当前这个前缀 和 前面的前缀的lcs。

转换到SAM的fail树上相当于问深度最大的lca。

对SAM的fail反链树建出欧拉（dfs）序，那么根据欧拉序的性质，能产生最深lca的两个点只能是欧拉序上最近的两个点，这个可以用个线段树二分或者set去维护。

那么当前这个前缀能产生的不同子串个数=自己的长度-lcs的长度。

Code:

#include<set>
#include<cstdio>
#include<cstring>
#define ll long long
#define fo(i, x, y) for(int i = x; i <= y; i ++)
using namespace std;

const int N = 2e5 + 5;

struct SAM {
    int son[N][26], fa[N], dep[N], tot, ed[N], la;
    void B() { la = tot = 1;}
    #define push(x) dep[++ tot] = x
    void add(int c) {
        push(dep[la] + 1);
        int p = la, np = tot;
        for(; !son[p][c]; p = fa[p]) son[p][c] = np;
        if(!p) fa[np] = 1; else {
            int q = son[p][c];
            if(dep[q] > dep[p] + 1) {
                push(dep[p] + 1); int nq = tot;
                memcpy(son[nq], son[q], sizeof son[q]);
                fa[nq] = fa[q]; fa[np] = fa[q] = nq;
                for(; son[p][c] == q; p = fa[p]) son[p][c] = nq;
            } else fa[np] = q;
        } la = np;
    }
} suf;

char str[N]; int len;
int son[N][26], fa[N], tot, x, h[N];
int d[N], fi[N], to[N], nt[N], tt;
int dep[N], siz[N], S[N], top[N], dfn[N], td, F[N], nd[N];

void link(int x, int y) { nt[++ tt] = fi[x], to[tt] = y, fi[x] = tt;}

void dg(int x) {
    dfn[x] = ++ td; nd[td] = x; siz[x] = 1;
    for(int i = fi[x]; i; i = nt[i])
        dep[to[i]] = dep[x] + 1, F[to[i]] = x, dg(to[i]),
        siz[x] += siz[to[i]], S[x] = siz[to[i]] > siz[S[x]] ? to[i] : S[x];
}
void dfs(int x) {
	if(S[x]) top[S[x]] = top[x], dfs(S[x]);
	for(int i = fi[x]; i; i = nt[i]) if(to[i] != S[x])
		top[to[i]] = to[i], dfs(to[i]);
}

int lca(int x, int y) {
	while(top[x] != top[y])
		if(dep[top[x]] > dep[top[y]]) x = F[top[x]]; else y = F[top[y]];
	return dep[x] < dep[y] ? x : y;
}

multiset<int> s;
ll as[N];

void dd(int x) {
	int px, ans = 1; int z = suf.ed[x];
	if(s.size()) {
		if((*s.rbegin()) > dfn[z]) {
			px = lca(nd[*s.upper_bound(dfn[z])], z);
			if(dep[px] > dep[ans]) ans = px;
		}
		if((*s.begin()) < dfn[z]) {
			px = lca(nd[*(-- s.upper_bound(dfn[z]))], z);
			if(dep[px] > dep[ans]) ans = px;
		}
	}
	as[x] += suf.dep[z] - suf.dep[ans];
	s.insert(dfn[z]);
	fo(j, 0, 25) if(son[x][j]) as[son[x][j]] = as[x], dd(son[x][j]);
	s.erase(s.find(dfn[z]));
}

int main() {
    scanf("%s", str + 1); len = strlen(str + 1);
    x = tot = 1;
    fo(i, 1, len) {
        if(str[i] == '-') {
            x = fa[x];
        } else {
            int c = str[i] - 'a';
            if(!son[x][c]) fa[son[x][c] = ++ tot] = x;
            x = son[x][c];
        }
        h[i] = x;
    }
    suf.B(); d[d[0] = 1] = 1; suf.ed[1] = 1;
    fo(i, 1, d[0]) {
        x = d[i];
        fo(j, 0, 25) if(son[x][j]) {
            d[++ d[0]] = son[x][j];
            suf.la = suf.ed[x];
            suf.add(j);
            suf.ed[son[x][j]] = suf.la;
        }
    }
    fo(i, 2, suf.tot) link(suf.fa[i], i);
    dep[1] = 1; dg(1); top[1] = 1; dfs(1);
    dd(1);
    fo(i, 1, len) printf("%lld\n", as[h[i]]);
}