[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][19], st2[AC][19];
int f[AC], g[AC];
LL ans;
char s[AC];

void init()
{
    for(R i = 1; i <= n; i ++) f[i] = g[i] = rk[i] = 0;//因为有多组数据，所以要全部清空
}//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 + 1), n = strlen(s + 1), m = 127;
}

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

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

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

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

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

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

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 + 1;
    return Min(st1[l][t[len]], st1[r - p[len] + 1][t[len]]);
}

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

void get()
{
    int lim = n << 1;
    for(R k = 1; k < lim; k ++)//枚举A的长度
    {
        int maxn = 0, maxn2 = 0;
        for(R i = 1; 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 - 1; 
                int l = i - lcs + 1, r = j + lcp - 2 * k;
                if(lcp + lcs > k) ++ f[l], -- f[r + 1];
            }
            if(i > maxn2)
            {
                int lcp = get2(n - i + 1, n - j + 1), lcs = get1(n - i + 1, n - j + 1);
                maxn2 = i + lcp - 1; 
                int l = i - lcs + 1, r = j + lcp - 2 * k;
                if(lcp + lcs > k) ++ g[l], -- g[r + 1];
            }
        }    
    }
    for(R i = 1; i <= n; i ++) f[i] += f[i - 1], g[i] += g[i - 1];
    rev(g + 1, g + n + 1);
}

void work()
{
    ans = 0;//f是开头
    for(R i = 1; i <= n; i += 2) 
        ans += 1LL * f[i] * g[i - 1] + ((i + 1 > n) ? 0 : 1LL * f[i + 1] * 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 + 1, s + n + 1);//翻转
    //    memset(rk, 0, sizeof(rk));//因为对于单组数据而言，长度不变，所以rk不必再次清空
        get_sa();
        build();
        build2();//建st2(维护LCS)
        get();
        work();
    }
//    fclose(stdin);
    return 0;
}