UVA 10829 L-Gap Substrings

题意：

形如UVU这种字符串，其中U、V都是字符串，V的长度为L，那么称此种字符串为L-Gap String，要求的是一个字符串中有多少个子串为L-Gap String。

题解：

网上有很多关于此题的题解，但是都只是说了怎么做的，并没有说为什么是这样。

开始其实也不懂，后面写出来就好像懂了。

大概说一下思路，首先用后缀数组求出lcp是很容易想到的，

我们可以每次枚举U的长度L，那么就可以得到一个区间[i,i+L+G]，这里的G是UVU中V的长度，

每次的长度G就只从此区间中取，就可以避免重复计算答案，

如果区间[i,i+L+G]的lcp的长度大于等于L是不是就一种可能，至于大于L就看成L就可以了，因为要保证G在区间内，但是这里i怎么办，直接枚举肯定会TLE,

假设当前L为4，G为1，i为5，在计算区间[5,10]时，如果i每次直接移动L，其实在区间[5+j,10-j]，j<=L是没有计算的，如果将这段没计算的区间计算出来，那么i就可以移动L复杂度为nlogn，那么时间就没问题了，

问题其实就相当于求出5~0和10~0的公共前缀，那么就可以求出j为多少，即可以求出U长度为L，间隔为G的方案种数，

因为假设[i,i+L+G]的公共前缀为X<=L，那么j可以向前移动Y次（相当于i-Y和i+L+G-Y的前缀为Y），那么他们的总前缀长度为X+Y，枚举U的长度为L，所以方案数为X+Y-L+1。

求5~0和10~0的公共前缀就可以通过反转求后缀数组，不就可以求出最长公共前缀了。

#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <utility>
#include <map>
#include <set>
#include <queue>
#include <vector>
#include <iostream>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-6
#define CLR( a, v ) memset ( a, v, sizeof ( a ) )
#define LL long long
#define DBUG printf ( "here!!!" )
#define rep( i, a, b ) for ( int i = ( a ); i < ( b ); i ++ )
#define PB push_back
#define ULL unsigned long long
#define PI acos ( -1.0 )
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1
#define lowbit( x ) ( ( x )&( -x ) )
typedef pair < int, int > Pii;
typedef pair < double, double > Pdd;
const int maxn = 50005*4;
int read_int ( )
{
    int res = 0;
    int ch;
    while ( ( ch = getchar ( ) ) && ! ( ch >= '0' && ch <= '9' ) )
    {
        if ( ch == -1 )
            return -1;
    }
    while ( ch >= '0' && ch <= '9' )
    {
        res = res*10+( ch-'0' );
        ch = getchar ( );
    }
    return res;
}
char str[maxn];
int t1[maxn], t2[maxn], rk[maxn], sa[maxn];
int lcp[maxn], cnt[maxn];
void build_sa ( int n, int m )
{
    int * x = t1, * y = t2;
    for ( int i = 0; i < m; i ++ )
        cnt[i] = 0;
    for ( int i = 0; i < n; i ++ )
        cnt[ x[i] = str[i] ] ++;
    for ( int i = 1; i < m; i ++ )
        cnt[i] += cnt[i-1];
    for ( int i = n-1; i >= 0; i -- )
        sa[ --cnt[ x[i] ] ] = i;
    for ( int k = 1; k <= n; k <<= 1 )
    {
        int p = 0;
        for ( int i = n-k; i < n; i ++ )
            y[p ++] = i;
        for ( int i = 0; i < n; i ++ )
            if ( sa[i] >= k )
                y[p ++] = sa[i]-k;
        for ( int i = 0; i < m; i ++ )
            cnt[i] = 0;
        for ( int i = 0; i < n; i ++ )
            cnt[ x[ y[i] ] ] ++;
        for ( int i = 1; i < m; i ++ )
            cnt[i] += cnt[i-1];
        for ( int i = n-1; i >= 0; i -- )
            sa[ --cnt[ x[ y[i] ] ] ] = y[i];
        swap ( x, y );
        x[ sa[0] ] = 0;
        p = 1;
        for ( int i = 1; i < n; i ++ )
            x[ sa[i] ] = y[ sa[i-1] ] == y[ sa[i] ] &&
                        y[ sa[i-1]+k ] == y[ sa[i]+k ] ? p-1 : p ++;
        if ( p >= n )
            break ;
        m = p;
    }
}
void build_lcp ( int n )
{
    for ( int i = 0; i <= n; i ++ )
        rk[ sa[i] ] = i;
    int h = 0;
    lcp[0] = 0;
    for ( int i = 0; i < n; i ++ )
    {
        int j = sa[ rk[i]-1 ];
        if ( h )    h --;
        while ( j+h < n && i+h < n )
        {
            if ( str[j+h] != str[i+h] )
                break ;
            h ++;
        }
        lcp[ rk[i] ] = h;
    }
}
int mn[maxn][25];
void RMQ ( int n )
{
    for ( int i = 1; i <= n; i ++ )
        mn[i][0] = lcp[i];
    for ( int j = 1; ( 1 << j ) <= n; j ++ )
        for ( int i = 1; i+( 1 << ( j-1 ) ) <= n; i ++ )
            mn[i][j] = min ( mn[i][j-1], mn[ i+( 1 << ( j-1 ) ) ][j-1] );
}
int query ( int l, int r )
{
    int x = rk[l], y = rk[r];
    if ( x > y )
        swap ( x, y );
    x ++;
    int k = log2 ( y-x+1 ); //注意
    return min ( mn[x][k], mn[ y-( 1 << k )+1 ][k] );
}
void solve ( )
{
    int T, g, cas = 1;
    scanf ( "%d", &T );
    while ( T -- )
    {
        scanf ( "%d%s", &g, str );
        int len = strlen ( str );
        str[len] = 125;
        for ( int i = len-1; i >= 0; i -- )
            str[len+len-i] = str[i];
        str[len+len+1] = '\0';
        int n = 2*len+1;
        build_sa ( n+1, 200 );
        build_lcp ( n );
        RMQ ( n );
        LL ans = 0;
        for ( int L = 1; L < len/2; L ++ )
        {
            for ( int i = 0; i < len; i += L )
            {
                int j = i+L+g;
                if ( str[i] != str[j] )
                    continue ;
                int s = 0;
                if ( j < len )
                    s += min ( query ( i, j ), L );
                if ( i > 0 )
                    s += min ( query ( n-i, n-j ), L-1 );//往前最长为L-1
                ans += max ( 0, s-L+1 );
            }
        }
        printf ( "Case %d: %lld\n", cas ++, ans );
    }
}
int main ( )
{
    solve ( );
    return 0;
}