【codeforces】Codeforces Round #305 (Div. 1)E. Mike and Friends【后缀数组+线段树】

传送门：【codeforces】Codeforces Round #305 (Div. 1)E. Mike and Friends

题目分析：

这题用后缀数组来做，十分直观（另一个原因是我后缀自动机并不会，只做过一道模板题，性质都不知道）。

我的方法是 O(nlog2n) ， O(nlogn) 的方法就是把线段树换成主席树来实现（不想再改了）。

首先将串接在一起，然后用后缀数组得到sa数组。我们知道连接起来的串，每个下标都属于一个串，或者是分隔符，然后我们以sa数组作为下标建立线段树，线段树每个节点代表的区间，都把这个区间内所有的下标属于的串的编号提取出来，排个序，以待之后使用。

对于一个询问包含的串K，找到K的起点在sa上的位置，我们可以二分其在sa数组上能延伸的最左端点以及最右端点，使得这之间的所有串与K的lcp都大于等于K的串长。然后我们只要在线段树内统计编号大于等于i且小于等于j的数个数就好了，这个我们只要在每个被完全包含的区间内二分答案，然后累加即可。

用后缀数组来思考，这题还是很容易做的……后缀自动机暂时还不会，也不想继续想了，先预习，不挂科要紧啊！！

my  code:

#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )
#define cpy( a , x ) memcpy ( a , x , sizeof a )
#define clrs( a , x , size ) memset ( a , x , sizeof ( a[0] ) * ( size ) )
#define cpys( a , x , size ) memcpy ( a , x , sizeof ( a[0] ) * ( size ) )
#define ls ( o << 1 )
#define rs ( o << 1 | 1 )
#define lson ls , l , m
#define rson rs , m + 1 , r
#define mid ( ( l + r ) >> 1 )
#define root 1 , 1 , n1 

const int MAXN = 500005 ;
const int LOGF = 20 ;

vector < int > T[MAXN << 2] ;
int sa[MAXN] , rank[MAXN] , height[MAXN] ;
int t1[MAXN] , t2[MAXN] , xy[MAXN] , c[MAXN] ;

int len[MAXN] , belong[MAXN] , start[MAXN] ;
char buf[MAXN] ;
int s[MAXN] ;
int dp[MAXN][LOGF] , logn[MAXN] ;
int n , m ;

int cmp ( int* r , int a , int b , int d ) {
    return r[a] == r[b] && r[a + d] == r[b + d] ;
}

void get_height ( int n , int k = 0 ) {
    for ( int i = 0 ; i <= n ; ++ i ) rank[sa[i]] = i ;
    for ( int i = 0 ; i < n ; ++ i ) {
        if ( k ) -- k ;
        int j = sa[rank[i] - 1] ;
        while ( s[i + k] == s[j + k] ) ++ k ;
        height[rank[i]] = k ;
    }
}

void da ( int n , int m ) {
    int *x = t1 , *y = t2 ;
    for ( int i = 0 ; i < m ; ++ i ) c[i] = 0 ;
    for ( int i = 0 ; i < n ; ++ i ) c[x[i] = s[i]] ++ ;
    for ( int i = 1 ; i < m ; ++ i ) c[i] += c[i - 1] ;
    for ( int i = n - 1 ; i >= 0 ; -- i ) sa[-- c[x[i]]] = i ;
    for ( int d = 1 , p = 0 ; p < n ; d <<= 1 , m = p ) {
        p = 0 ;
        for ( int i = n - d ; i < n ; ++ i ) y[p ++] = i ;
        for ( int i = 0 ; i < n ; ++ i ) if ( sa[i] >= d ) y[p ++] = sa[i] - d ;
        for ( int i = 0 ; i < m ; ++ i ) c[i] = 0 ;
        for ( int i = 0 ; i < n ; ++ i ) c[xy[i] = x[y[i]]] ++ ;
        for ( int i = 1 ; i < m ; ++ i ) c[i] += c[i - 1] ;
        for ( int i = n - 1 ; i >= 0 ; -- i ) sa[-- c[xy[i]]] = y[i] ;
        swap ( x , y ) ;
        p = 0 ;
        x[sa[0]] = p ++ ;
        for ( int i = 1 ; i < n ; ++ i ) x[sa[i]] = cmp ( y , sa[i - 1] , sa[i] , d ) ? p - 1 : p ++ ;
    }
    get_height ( n - 1 ) ;
}

void init_rmq ( int n ) {
    for ( int i = 1 ; i <= n ; ++ i ) dp[i][0] = height[i] ;
    logn[1] = 0 ;
    for ( int i = 2 ; i <= n ; ++ i ) logn[i] = logn[i - 1] + ( i == ( i & -i ) ) ;
    for ( int j = 1 ; ( 1 << j ) < n ; ++ j ) {
        for ( int i = 1 ; i + ( 1 << j ) - 1 <= n ; ++ i ) {
            dp[i][j] = min ( dp[i][j - 1] , dp[i + ( 1 << ( j - 1 ) )][j - 1] ) ;
        }
    }
}

int rmq ( int L , int R ) {
    int k = logn[R - L + 1] ;
    return min ( dp[L][k] , dp[R - ( 1 << k ) + 1][k] ) ;
}

void build ( int o , int l , int r ) {
    T[o].clear () ;
    for ( int i = l ; i <= r ; ++ i ) T[o].push_back ( belong[sa[i]] ) ;
    T[o].push_back ( MAXN ) ;
    sort ( T[o].begin () , T[o].end () ) ;
    if ( l == r ) return ;
    int m = mid ;
    build ( lson ) ;
    build ( rson ) ;
}

int get_L ( int x , int l , int r ) {
    int R = r ;
    while ( l < r ) {
        int m = ( l + r ) >> 1 ;
        if ( rmq ( m + 1 , R ) >= x ) r = m ;
        else l = m + 1 ;
    }
    return l ;
}

int get_R ( int x , int l , int r ) {
    int L = l ;
    while ( l < r ) {
        int m = ( l + r + 1 ) >> 1 ;
        if ( rmq ( L + 1 , m ) >= x ) l = m ;
        else r = m - 1 ;
    }
    return r ;
}

int query ( int L , int R , int x , int y , int o , int l , int r ) {
    if ( L <= l && r <= R ) {
        int t1 = ( lower_bound ( T[o].begin () , T[o].end () , x ) - T[o].begin () ) - 1 ;
        int t2 = ( lower_bound ( T[o].begin () , T[o].end () , y + 1 ) - T[o].begin () ) - 1 ;
        return t2 - t1 ;
    }
    int m = mid , sum = 0 ;
    if ( L <= m ) sum += query ( L , R , x , y , lson ) ;
    if ( m <  R ) sum += query ( L , R , x , y , rson ) ;
    return sum ;
}

void solve () {
    int n1 = 0 , n2 = 27 ;
    for ( int i = 1 ; i <= n ; ++ i ) {
        scanf ( "%s" , buf ) ;
        len[i] = strlen ( buf ) ;
        start[i] = n1 ;
        for ( int j = 0 ; j < len[i] ; ++ j ) {
            belong[n1] = i ;
            s[n1 ++] = buf[j] - 'a' + 1 ;
        }
        belong[n1] = 0 ;
        s[n1 ++] = n2 ++ ;
    }
    s[-- n1] = 0 ;
    da ( n1 + 1 , n2 ) ;
    init_rmq ( n1 ) ;
    build ( root ) ;
    while ( m -- ) {
        int x , y , k ;
        scanf ( "%d%d%d" , &x , &y , &k ) ;
        int L = get_L ( len[k] , 1 , rank[start[k]] ) ;
        int R = get_R ( len[k] , rank[start[k]] , n1 ) ;
        //printf ( "%d %d\n" , L , R ) ;
        int ans = query ( L , R , x , y , root ) ;
        printf ( "%d\n" , ans ) ;
    }
}


int main () {
    while ( ~scanf ( "%d%d" , &n , &m ) ) solve () ;
    return 0 ;
}