BZOJ 2157: Туризм (депозитная структура переменных)

Структура переменной памяти, кажется, действительно улучшить скорость, так что после записи структуры данных

Код: 

# include <cstdio> 
#include <алгоритм> 
#include <CString> 
#define N 200003 
#define инф 100000 
#define LL долго долго   
#define lson т [х] .ch [0] 
#define rson т [х] .ch [ 1] 
#define setIO (ы) freopen (с ".в", "г", STDIN) с 
помощью патезрасе;  
INT STA [N], п;          
Узел структура 
{ 
    INT CH [2], е, Siz, об; 
    LL вал, сумма, мул, мин, не более; 
} т [Н << 1];  
рядный INT прибудет (целое х) 
{ 
    возвращение т [т [х] .f] .ch [1] == х; 
} 
Рядный INT isrt (целое х) 
{ 
    возвращение (! (Т [т [х] .f] .ch [0] == х || т [т [х] .f] .ch [1] == х) ) || (!Икс);     
}
рядный недействительными mark_rev (целое х) 
{ 
    подкачки (lson, rson), т [х] .rev ^ = 1; 
} 
Инлайн недействительными mark_mul (целое х, у LL) 
{ 
    т [х] .sum * = у, т [х] .val * = у, т [х] .mul * = у; 
    т [х] .min * = у, т [х] .max * = у, подкачки (т [х] .min, т [х] .max);                               
} 
Инлайн недействительными магазинный (целое х) 
{ 
    если (т [х] .rev) 
    { 
        если (lson) mark_rev (lson); 
        если (rson) mark_rev (rson); 
        т [х] .rev = 0; 
    } 
    Если (т [х] = 1 .mul!) 
    { 
        Если (lson) mark_mul (lson, т [х] .mul); 
        если (rson) mark_mul (rson, т [х] .mul); 
        т [х] .mul = 1; 
    }
} 
Инлайн недействительными отжимания (INT х) 
{ 
    T [х] = .siz т [lson] .siz + T [rson] .siz + 1; 
    т [х] = .sum т [lson] .sum + T [rson] .sum + T [х] .val;     
    т [х] = .max макс (т [lson] .max, т [rson] .max);    
    т [х] = .min мин (т [lson] .min, т [rson] .min);    
    если (х> п) 
    { 
        т [х] = .max макс (т [х] .max, т [х] .val);   
        т [х] = .min мин (т [х] .min, т [х] .val);     
    } 
} 
Инлайн недействительный поворот (целое х) 
{ 
    INT старый = т [х] .f, раз = Т [старый] .f, что = получает (х);  
    (! isrt (старый)) , если т [свернуть] .ch [T [свернуть] .ch [1] == старые] = х;  
    т [старый] .ch [который] = т [х] .ch [который ^ 1], т [т [старый] .ch [который]] е = старый.
    т [х] .ch [который ^ 1] = старый, т [старый] .f = х, т [х] = .f раза;      
    Pushup (старый), Pushup (х); 
}
рядный недействительные скошенный (целое х) 
{   
    INT V = 0, и = х, I; 
    для (STA [++ v] = и;! isrt (и), STA [++ v] = т [и] .f, и = т [и] .f); 
    для (и = т [и] .f, I = V; я; - я) магазинный (STA [I]);                                         
    для (INT фа; (FA = т [х] .f) ^ и, вращать (х)) , 
        если (т [фа] .f ^ и) 
            вращать (получить (фа) == получить (х) а :? х );        
} 
Инлайн недействительным доступа (INT х) 
{ 
    INT у = 0; 
    в то время как (х) 
    { 
        Splay (х), rson = у, отжимания (х), у = х, х = т [х] .f;    
    } 
} 
Инлайн пустот makeroot (INT х) 
{
    Доступ к (х), расширяемый (х), mark_rev (х);  
        т [г + п] = .val (LL) с, Pushup (я + N), ссылка (U, I + N), ссылка (I + N, V);           
}
рядный недействительное разделение (целое х, у INT) 
{ 
    makeroot (х), Доступ (у), расширяемый (у); 
} 
Инлайн аннулируются ссылка (целое х, у INT) 
{ 
    makeroot (х), т [х] .f = у;      
} 
INT основных () 
{ 
    Int I, J; 
    зсапЕ ( "% d", & п);   
    для (я = 0; я <N; ++ я) т [I] .mul = 1; 
    для (я = 0; г <= п; ++ я) т [I] = .min инф, т [г] .max = -inf;      
    для (я = 1; <п; ++ я) 
    { 
        Int U, V, с; 
        зсапЕ ( "% d% d% d", & и, & v, & с);   
        ++ и, ++ v;    
    }         
    INT Т, х, у;                         
    символ ул [9]; 
    зсапЕ ( "% d", & Т);
    для (INT КАС = 1; КАС <= Т; КАС ++) 
    { 
        зсапЕ ( "% s% d% d", ул, & х, & у);     
        если (ул [1] == 'I') , разделение (х + 1, у + 1), Е ( "% LLD \ п", т [у + 1] .min);  
        если (ул [1] == 'А') дробление (х + 1, у + 1), Е ( "% LLD \ п", т [у + 1] .max);   
        если (ул [0] == 'S') дробление (х + 1, у + 1), Е ( "% LLD \ п", т [у + 1] .sum);   
        если (ул [0] == 'N') дробление (х + 1, у + 1), mark_mul (у + 1, -1);             
        если (ул [0] == 'C') makeroot (х + п), т [х + п] = .val (LL) у, Pushup (х + п);      
    } 
    Возвращает 0;     
}