求助：MLE k-dtree求调

为啥这种写法的空间开销这么大啊，感觉好像不是特别大才对吧/kk/kk/kk

路过大佬能不能帮忙看看

#include <iostream>
#include <algorithm>
using namespace std ;

inline int read ( ) {
    char ch = getchar ( ) ;
    int x = 0 ;
    while ( ch < '0' || ch > '9' )
        ch = getchar ( ) ;
    while ( ch >= '0' && ch <= '9' )
        x = x * 10 + ch - 48 , ch = getchar ( ) ;
    return x ;
}

const int N = 200005 , K = 2 ;
const double A = 0.75 ;
int n , rt , tot , p[K][N] , val[N] , tax[K][N] , tin[K][N] , pax[K] , pin[K] ;
int dt , g[N] , d[N] , siz[N] , sum[N] , ls[N] , rs[N] , lans ;

int D ;
inline bool cmp ( int u , int v ) {
    return p [ D ] [ u ] < p [ D ] [ v ] ;
}

inline bool comp ( int x , int y ) {
    return x > y ;
}

void pushup ( int k ) {
    siz [ k ] = siz [ ls [ k ] ] + siz [ rs [ k ] ] + 1 ;
    sum [ k ] = sum [ ls [ k ] ] + sum [ rs [ k ] ] + val [ k ] ;
    for ( int i = 0 ; i < K ; ++ i )
        tin [ i ] [ k ] = tax [ i ] [ k ] = p [ i ] [ k ] ;
    if ( ls [ k ] ) {
        for ( int i = 0 ; i < K ; ++ i )
            tin [ i ] [ k ] = min ( tin [ i ] [ k ] , tin [ i ] [ ls [ k ] ] ) ,
            tax [ i ] [ k ] = max ( tax [ i ] [ k ] , tax [ i ] [ ls [ k ] ] ) ;
    }
    else {
        for ( int i = 0 ; i < K ; ++ i )
            tin [ i ] [ k ] = min ( tin [ i ] [ k ] , tin [ i ] [ rs [ k ] ] ) ,
            tax [ i ] [ k ] = max ( tax [ i ] [ k ] , tax [ i ] [ rs [ k ] ] ) ;
    }
}

int build ( int l , int r ) {
    if ( l > r ) return 0 ;
    int mid = ( l + r ) >> 1 ;
    double a[K] , b[K] , axx = 0 ;
    for ( int i = 0 ; i < K ; ++ i ) a [ i ] = 0 ;
    for ( int i = l ; i <= r ; ++ i )
        for ( int j = 0 ; j < K ; ++ j )
            a [ j ] += p [ j ] [ g [ i ] ] ;
    for ( int i = 0 ; i < K ; ++ i )
        a [ i ] /= 1.0 * ( r - l + 1 ) ;
    for ( int i = l ; i <= r ; ++ i )
        for ( int j = 0 ; j < K ; ++ j )
            b [ j ] += ( p [ j ] [ g [ i ] ] - a [ j ] ) * ( p [ j ] [ g [ i ] ] - a [ j ] ) ;
    for ( int i = 0 ; i < K ; ++ i )
        if ( b [ i ] > axx )
            D = i , axx = b [ i ] ;
    nth_element ( g + 1 , g + mid , g + r + 1 , cmp ) ;
    d [ g [ mid ] ] = D ;
    ls [ g [ mid ] ] = build ( l , mid - 1 ) ;
    rs [ g [ mid ] ] = build ( mid + 1 , r ) ;
    pushup ( g [ mid ] ) ;
    return g [ mid ] ;
}

void dfs ( int k ) {
    if ( ! k ) return ;
    dfs ( ls [ k ] ) ;
    g [ ++ dt ] = k ;
    dfs ( rs [ k ] ) ;
}

void rebuild ( int &k ) {
    dt = 0 ;
    dfs ( k ) ;
    k = build ( 1 , dt ) ;
}

inline bool Bad ( int k ) {
    return A * siz [ k ] <= ( double ) max ( siz [ ls [ k ] ] , siz [ rs [ k ] ] ) ;
}

void insert ( int &k , int v ) {
    if ( ! k ) {
        k = v ;
        pushup ( k ) ;
        return ;
    }
    if ( p [ d [ k ] ] [ v ] <= p [ d [ k ] ] [ k ] )
        insert ( ls [ k ] , v ) ;
    else insert ( rs [ k ] , v ) ;
    pushup ( k ) ;
    if ( Bad ( k ) ) rebuild ( k ) ;
}

inline bool out ( int k ) {
    for ( int i = 0 ; i < K ; ++ i )
        if ( tin [ i ] [ k ] > pax [ i ] || tax [ i ] [ k ] < pin [ i ] )
            return 1 ;
    return 0 ;
}

inline bool in ( int k ) {
    for ( int i = 0 ; i < K ; ++ i )
        if ( tin [ i ] [ k ] > pin [ i ] || tax [ i ] [ k ] < pax [ i ] )
            return 0 ;
    return 1 ;
}

int query ( int k ) {
    if ( ! k || out ( k ) ) return 0 ;
    if ( in ( k ) ) return sum [ k ] ;
    int ret = 1 ;
    for ( int i = 0 ; i < K ; ++ i )
        if ( p [ i ] [ k ] < pin [ i ] || p [ i ] [ k ] > pax [ i ] )
            ret = 0 ;
    return query ( ls [ k ] ) + query ( rs [ k ] ) + ret * val [ k ] ;
}

int main ( ) {
    n = read ( ) ;
    while ( 1 ) {
        int opt = read ( ) ;
        if ( opt == 3 ) break ;
        if ( opt == 1 ) {
            ++ tot ;
            for ( int i = 0 ; i < K ; ++ i )
                p [ i ] [ tot ] = read ( ) ^ lans ;
            val [ tot ] = read ( ) ^ lans ;
            insert ( rt , tot ) ;
        }
        else {
            for ( int i = 0 ; i < K ; ++ i )
                pin [ i ] = read ( ) ^ lans ;
            for ( int i = 0 ; i < K ; ++ i ) {
                pax [ i ] = read ( ) ^ lans ;
                if ( pin [ i ] > pax [ i ] )
                    swap ( pin [ i ] , pax [ i ] ) ;
            }
            lans = query ( rt ) ;
            cout << lans << "\n" ;
        }
    }
    return 0 ;
}