洛谷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 = ;

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

 struct SAM {

     struct Edge {
         int nex, v;
     }edge[N]; int top;

     int tr[N][], fail[N], len[N], tot, last;
     int ST[N * ][], pos[N * ], num, e[N], d[N];

     SAM() {
         tot = last = ;
     }

     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] + ;
         while(p && !tr[p][f]) {
             tr[p][f] = np;
             p = fail[p];
         }
         if(!p) {
             fail[np] = ;
         }
         else {
             int Q = tr[p][f];
             if(len[Q] == len[p] + ) {
                 fail[np] = Q;
             }
             else {
                 int nQ = ++tot;
                 len[nQ] = len[p] + ;
                 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][] = x;
         for(int i = e[x]; i; i = edge[i].nex) {
             int y = edge[i].v;
             d[y] = d[x] + ;
             DFS(y);
             ST[++num][] = x;
         }
         return;
     }

     inline void prework() {
         for(int i = ; i <= tot; i++) {
             add(fail[i], i);
         }
         d[] = ;
         DFS();
         for(int j = ; j <= pw[num]; j++) {
             for(int i = ; i + ( << j) -  <= num; i++) {
                 if(d[ST[i][j - ]] <= d[ST[i + ( << (j - ))][j - ]]) {
                     ST[i][j] = ST[i][j - ];
                 }
                 else {
                     ST[i][j] = ST[i + ( << (j  - ))][j - ];
                 }
             }
         }
         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 + ];
         if(d[ST[x][t]] <= d[ST[y - ( << t) + ][t]]) {
             return ST[x][t];
         }
         return ST[y - ( << t) + ][t];
     }

     inline void clear() {
         for(int i = ; i <= tot; i++) {
             d[i] = e[i] = ;
             for(int f = ; f < ; f++) {
                 tr[i][f] = ;
             }
         }
         tot = last = ;
         top = num = ;
         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 * ];
     int f[N];
     inline void pushdown(int o) {
         if(!tag[o]) {
             return;
         }
         tag[o << ] += tag[o];
         tag[o <<  | ] += tag[o];
         tag[o] = ;
         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) >> ;
         pushdown(o);
         if(L <= mid) {
             add(L, R, l, mid, o << );
         }
         if(mid < R) {
             add(L, R, mid + , r, o <<  | );
         }
         return;
     }

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

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

 int main() {

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

AC代码