[NOI2016]优秀的拆分 后缀数组

题面：洛谷

题解：

　　因为对于原串的每个长度不一定等于len的拆分而言，如果合法，它将只会被对应的子串统计贡献。

　　所以子串这个限制相当于是没有的。

　　所以我们只需要对于每个位置i求出f[i]表示以i为开头的形如BB这样的串的个数，g[i]表示以i为结尾的形如AA这样的串的个数即可。

　　考虑分别处理这2个数组。

　　我们可以枚举AA（BB）这样的串中A(B)的长度l，然后把原串每l个字符放在一个块中，在考虑统计答案。

　　先考虑这样一个问题：

　　　　假如固定一个串的结尾，再枚举这个串A的长度，怎样可以判断是否合法？

　　　　实际上我们只需要判断我们假定的这个AA串的开头和中间位置（结尾向前走A的长度)的LCP是否可以覆盖开头到中间即可。

　　然后如果我们已经把原串对于当前枚举的长度l分成了很多块，其实我们就已经可以对与每个块的开头结尾所代表的点对(i, j)判断是否可以产生贡献了。

　　但是怎么统计 其他没有刚好对应在某个块的开头结尾的点对 的贡献呢？

　　表示并没有想出来，，，但是感觉有个blog写的很好，，，

　　推荐一下：[BZOJ]4650 优秀的拆分(Noi2016)

　　以后彻底搞懂了再来填坑吧。

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define AC 301000
 #define ac 602000
 #define LL long long
 #define rev reverse
 #define mem(x) memset(x, 0, sizeof(x))

 int T, n, m;
 int h[ac], sa[ac], p1[ac], p2[ac], b[ac], d[ac];
 int rk[ac], p[AC], t[AC], rk1[ac];
 int st1[AC][], st2[AC][];
 int f[AC], g[AC];
 LL ans;
 char s[AC];

 void init()
 {
     for(R i = ; i <= n; i ++) f[i] = g[i] = rk[i] = ;//因为有多组数据，所以要全部清空
 }//mem这么多次还不如for

 inline void upmax(int &a, int b){
     if(b > a) a = b;
 }

 inline int Min(int a, int b){
     return (a < b) ? a : b;
 }

 void pre()
 {
     scanf("%s", s + ), n = strlen(s + ), m = ;
 }

 void ssort()
 {
     for(R i = ; i <= n; i ++) ++ d[p2[i]];
     for(R i = ; i <= m; i ++) d[i] += d[i - ];
     for(R i = ; i <= n; i ++) b[d[p2[i]] --] = i;//给i分配d[p2[i]]的排名
     for(R i = ; i <= m; i ++) d[i] = ;

     for(R i = ; i <= n; i ++) ++ d[p1[i]];
     for(R i = ; i <= m; i ++) d[i] += d[i - ];
     for(R i = n; i; -- i) sa[d[p1[b[i]]] --] = b[i];//给b[i]分配d[p1[b[i]]]的排名
     for(R i = ; i <= m; i ++) d[i] = ;
 }

 void get_sa()
 {
     for(R i = ; i <= n; i ++) sa[i] = i, rk[i] = s[i];//初始化
     m = ;//这个也要重置
     for(R k = ; k <= n; k <<= )
     {
         for(R i = ; i <= n; i ++) p1[i] = rk[i], p2[i] = rk[i + k];
         ssort();
         int tmp = ;
         rk[sa[]] = ;
         for(R i = ; i <= n; i ++)
             rk[sa[i]] = (p1[sa[i]] == p1[sa[i - ]] && p2[sa[i]] == p2[sa[i - ]]) ? tmp : ++ tmp;
         if(tmp >= n) break;
         m = tmp;//忘了，，，
     }
 }

 void build()//获取h数组
 {
     //memset(h, 0, sizeof(h));
     for(R i = , k = ; i <= n; i ++)
     {
         if(k) -- k;
         int j = sa[rk[i] - ];
         while(s[i + k] == s[j + k]) ++ k;
         h[rk[i]] = k;
     }
 }

 #define st st1
 void build1()//建st1(维护LCP)
 {
     int tmp = , cnt = ;
     memcpy(rk1, rk, sizeof(rk));
     for(R i = ; i <= n; i ++)
     {
         st[i][] = h[i];
         if(i == tmp << ) tmp <<= , ++ cnt;
         p[i] = tmp, t[i] = cnt;
     }
 }
 #undef st

 void build2()//建st2(维护LCS)改成st1, st2一起建了。。。。
 {
     for(R i = ; i <= n; i ++) st2[i][] = h[i];
     int tmp = ;
     for(R i = ; i <= ; i ++)
     {
         for(R j = ; j <= n; j ++)
         {
             st1[j][i] = Min(st1[j][i - ], st1[j + tmp][i - ]);
             st2[j][i] = Min(st2[j][i - ], st2[j + tmp][i - ]);
         }
         tmp <<= ;
     }
 }

 inline void swap(int &l, int &r)
 {
     int x = l;
     l = r, r = x;
 }

 int get1(int l, int r)//查询串l和串r的LCP
 {
     l = rk1[l], r = rk1[r];
     if(l > r) swap(l, r);
     ++ l;
     int len = r - l + ;
     return Min(st1[l][t[len]], st1[r - p[len] + ][t[len]]);
 }

 int get2(int l, int r)//查询串l和串r的LCS
 {//因为是翻转过来求的，所以查询要翻转一下
     l = n - l + , r = n - r + ;
     l = rk[l], r = rk[r];
     if(l > r) swap(l, r);
     ++ l;
     int len = r - l + ;
     return Min(st2[l][t[len]], st2[r - p[len] + ][t[len]]);
 }

 void get()
 {
     int lim = n << ;
     for(R k = ; k < lim; k ++)//枚举A的长度
     {
         int maxn = , maxn2 = ;
         for(R i = ; i <= n; i += k)
         {
             int j = i + k;//j为下一段开头
             if(j > n) break;
             if(i > maxn)
             {
                 int lcp = get1(i, j), lcs = get2(i, j);
                 maxn = i + lcp - ;
                 int l = i - lcs + , r = j + lcp -  * k;
                 if(lcp + lcs > k) ++ f[l], -- f[r + ];
             }
             if(i > maxn2)
             {
                 int lcp = get2(n - i + , n - j + ), lcs = get1(n - i + , n - j + );
                 maxn2 = i + lcp - ;
                 int l = i - lcs + , r = j + lcp -  * k;
                 if(lcp + lcs > k) ++ g[l], -- g[r + ];
             }
         }
     }
     for(R i = ; i <= n; i ++) f[i] += f[i - ], g[i] += g[i - ];
     rev(g + , g + n + );
 }

 void work()
 {
     ans = ;//f是开头
     for(R i = ; i <= n; i += )
         ans += 1LL * f[i] * g[i - ] + ((i +  > n) ?  : 1LL * f[i + ] * g[i]);
     printf("%lld\n", ans);
 }

 int main()
 {
 //    freopen("in.in", "r", stdin);
     scanf("%d", &T);
     while(T --)
     {
         init();
         pre();
         get_sa();
         build();
         build1();//建st(维护LCP)
         rev(s + , s + n + );//翻转
     //    memset(rk, 0, sizeof(rk));//因为对于单组数据而言，长度不变，所以rk不必再次清空
         get_sa();
         build();
         build2();//建st2(维护LCS)
         get();
         work();
     }
 //    fclose(stdin);
     return ;
 }