洛谷P1117 优秀的拆分

题意：求一个字符串中有多少形如AABB的子串。

解：嗯...我首先极度SB的想了一个后缀自动机套线段树启发式合并的做法，想必会TLE。

然后跑去看题解，发现实在是妙不可言...

显然要对每个位置求出向左有多少个AA，向右有多少个BB。

我的想法是对于每个前缀，两两求lca，如果lca的len大于他们的位置之差，显然就有一组了。

这时候把贡献加到其中较长的前缀上。然后反着来一遍就行了。

怎么批量求lca和贡献呢？

考虑计算每个点作为lca时的贡献，显然线段树维护子树内有哪些前缀。合并的时候好像没啥好的办法...但是我们有启发式合并！

每次取出小的线段树中的所有元素，依次加入大的线段树中。对于大的线段树中比它小的一段区间内的元素，我们要给它自己加上贡献。对于比它大的一段区间中的元素，要给那些大的元素每个+1贡献。我们就在每次需要插入元素的时候往下推。推到底的时候加贡献即可。(应该支持吧...)

比较菜没写代码...感觉实现起来毒瘤的紧。

然后说正解。

考虑枚举AA串的长度。

对于一个长为2len的AA串，如果我们每隔len放一个点，那么这样的串将会且仅会覆盖两个连续的点。

对于每两个连续的点，我们求它们的最长公共前/后缀长度，分别设为x，y。

如果x + y >= len的话就是存在这样的AA串经过这两点。然后就是个线段树区间+1

最后遍历线段树统计答案即可。

求lcp不就是SAM的fail树上lca嘛，我会倍增！

Tnlog²n成功T飞...

然后就O(1)lca过了...果然O(1)lca还是有用的。

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef long long LL;
const int N = 80010;

char str[N];
int pos[N], pos2[N], pw[N * 2], n;

struct SAM {

    struct Edge {
        int nex, v;
    }edge[N]; int top;
    
    int tr[N][26], fail[N], len[N], tot, last;
    int ST[N * 2][20], pos[N * 2], num, e[N], d[N];
    
    SAM() {
        tot = last = 1;
    }

    inline void add(int x, int y) {
        top++;
        edge[top].v = y;
        edge[top].nex = e[x];
        e[x] = top;
        return;
    }

    inline void insert(char c) {
        int f = c - 'a';
        int p = last, np = ++tot;
        last = np;
        len[np] = len[p] + 1;
        while(p && !tr[p][f]) {
            tr[p][f] = np;
            p = fail[p];
        }
        if(!p) {
            fail[np] = 1;
        }
        else {
            int Q = tr[p][f];
            if(len[Q] == len[p] + 1) {
                fail[np] = Q;
            }
            else {
                int nQ = ++tot;
                len[nQ] = len[p] + 1;
                fail[nQ] = fail[Q];
                fail[Q] = fail[np] = nQ;
                memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
                while(tr[p][f] == Q) {
                    tr[p][f] = nQ;
                    p = fail[p];
                }
            }
        }
    }
    
    void DFS(int x) {
        pos[x] = ++num;
        ST[num][0] = x;
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            d[y] = d[x] + 1;
            DFS(y);
            ST[++num][0] = x;
        }
        return;
    }

    inline void prework() {
        for(int i = 2; i <= tot; i++) {
            add(fail[i], i);
        }
        d[1] = 1;
        DFS(1);
        for(int j = 1; j <= pw[num]; j++) {
            for(int i = 1; i + (1 << j) - 1 <= num; i++) {
                if(d[ST[i][j - 1]] <= d[ST[i + (1 << (j - 1))][j - 1]]) {
                    ST[i][j] = ST[i][j - 1];
                }
                else {
                    ST[i][j] = ST[i + (1 << (j  - 1))][j - 1];
                }
            }
        }
        return;
    }

    inline int lca(int x, int y) {
        x = pos[x];
        y = pos[y];
        if(x > y) {
            std::swap(x, y);
        }
        int t = pw[y - x + 1];
        if(d[ST[x][t]] <= d[ST[y - (1 << t) + 1][t]]) {
            return ST[x][t];
        }
        return ST[y - (1 << t) + 1][t];
    }

    inline void clear() {
        for(int i = 1; i <= tot; i++) {
            d[i] = e[i] = 0;
            for(int f = 0; f < 26; f++) {
                tr[i][f] = 0;
            }
        }
        tot = last = 1;
        top = num = 0;
        return;
    }

    inline int lcp(int x, int y) {
        return std::min(std::min(len[x], len[y]), len[lca(x, y)]);
    }

}sam, sam2;

struct SegmentTree {
    int tag[N * 2];
    int f[N];
    inline void pushdown(int o) {
        if(!tag[o]) {
            return;
        }
        tag[o << 1] += tag[o];
        tag[o << 1 | 1] += tag[o];
        tag[o] = 0;
        return;
    }

    void add(int L, int R, int l, int r, int o) {
        if(L <= l && r <= R) {
            tag[o]++;
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(o);
        if(L <= mid) {
            add(L, R, l, mid, o << 1);
        }
        if(mid < R) {
            add(L, R, mid + 1, r, o << 1 | 1);
        }
        return;
    }

    void solve(int l, int r, int o) {
        if(l == r) {
            f[r] = tag[o];
            return;
        }
        pushdown(o);
        int mid = (l + r) >> 1;
        solve(l, mid, o << 1);
        solve(mid + 1, r, o << 1 | 1);
        return;
    }
    void clear(int l, int r, int o) {
        tag[o] = 0;
        if(l == r) {
            return;
        }
        int mid = (l + r) >> 1;
        clear(l, mid, o << 1);
        clear(mid + 1, r, o << 1 | 1);
        return;
    }
}seg, seg2;

inline void solve() {
    scanf("%s", str);
    LL ans = 0;
    n = strlen(str);
    for(int i = 0; i < n; i++) {
        sam.insert(str[i]);
        sam2.insert(str[n - i - 1]);
        pos[i] = sam.last;
        pos2[n - i - 1] = sam2.last;
    }
    sam.prework();
    sam2.prework();
    //
    for(int len = 1; (len << 1) < n - 1; len++) {
        //printf("len = %d \n", len);
        for(int i = len; i < n; i += len) {
            // i i-len
            //printf(" > %d %d \n", i - len, i);
            int x = std::min(len, sam.lcp(pos[i], pos[i - len]));
            int y = std::min(len, sam2.lcp(pos2[i], pos2[i - len]));
            // x + y - len
            //printf(" > x = %d y = %d \n", x, y);
            if(x + y > len) {
                seg.add(i - len - x + 2, i - len * 2 + y + 1, 1, n, 1);
                //printf(" > > > 1 add %d %d \n", i - len - x + 2, i - len * 2 + y + 1);
                seg2.add(i + len - x + 1, i + y, 1, n, 1);
                //printf(" > > > 2 add %d %d \n", i + len - x + 1, i + y);
            }
        }
    }
    seg.solve(1, n, 1);
    seg2.solve(1, n, 1);
    for(int i = 2; i < n - 1; i++) {
        ans += 1ll * seg2.f[i] * seg.f[i + 1];
        //printf("ans += %d * %d \n", seg2.f[i], seg.f[i + 1]);
    }
    printf("%lld\n", ans);
    return;
}

int main() {

    for(int i = 2; i < N * 2; i++) {
        pw[i] = pw[i >> 1] + 1;
    }
    int T;
    scanf("%d", &T);
    while(T--) {
        solve();
        if(T) {
            sam.clear();
            sam2.clear();
            seg.clear(1, n, 1);
            seg2.clear(1, n, 1);
        }
    }
    return 0;
}