Cartesian tree with array

#include <cstdlib>
#include <stdio.h>
#include <math.h>
#include <time.h>

struct segment{
    int y;
    int left;
    int right;
    int size;
    bool rev;
    long long summ;
};

struct splited_segments{
    int id_left;
    int id_right;
};

struct count_out{
    int head;
    long long summ;
};

using namespace std;

int n,m,h,k,a,b,c;
struct segment T[200006];
struct splited_segments U;
struct count_out P;

int merge(int id1, int id2){
    if (id1==0){
        return id2;
    }
    if (id2==0){
        return id1;
    }
    if (T[id1].y>T[id2].y){//id1 - новая вершина
        T[id1].size+=T[id2].size;
        T[id1].summ+=T[id2].summ;
        if (T[id1].rev==true){
            T[id1].rev=false;
            k=T[id1].left;
            T[id1].left=T[id1].right;
            T[id1].right=k;
            T[T[id1].left].rev= !T[T[id1].left].rev;
            T[T[id1].right].rev= !T[T[id1].right].rev;
        }
        T[id1].right=merge(T[id1].right,id2);

       return id1;
    }else{      //id2 - новая вершина
        T[id2].size+=T[id1].size;
        T[id2].summ+=T[id1].summ;
        if (T[id2].rev==true){
            T[id2].rev=false;
            k=T[id2].left;
            T[id2].left=T[id2].right;
            T[id2].right=k;
            T[T[id2].left].rev= !T[T[id2].left].rev;
            T[T[id2].right].rev= !T[T[id2].right].rev;
        }
        T[id2].left=merge(id1,T[id2].left);
        return id2;
    }
}

struct splited_segments split(int id, int x){
    struct splited_segments temp,temp2;

    if (id==0){
        temp.id_left=0;
        temp.id_right=0;
        return temp;
    }
    if (T[id].rev==true){
            T[id].rev=false;
            k=T[id].left;
            T[id].left=T[id].right;
            T[id].right=k;
            T[T[id].left].rev= !T[T[id].left].rev;
            T[T[id].right].rev= !T[T[id].right].rev;
        }

    if (x<=T[T[id].left].size){
        T[id].size-=T[T[id].left].size;
        T[id].summ-=T[T[id].left].summ;
        temp=split(T[id].left,x);
        T[id].left=0;
        temp2.id_left=temp.id_left;
        temp2.id_right=merge(temp.id_right,id);
    }else{
        T[id].size-=T[T[id].right].size;
        T[id].summ-=T[T[id].right].summ;
        temp=split(T[id].right,x-T[T[id].left].size-1);
        T[id].right=0;
        temp2.id_right=temp.id_right;
        temp2.id_left=merge(id,temp.id_left);
    }
    return temp2;
}

void draw_tree(int id, int l){
    if (T[id].right>0){
        draw_tree(T[id].right,l+1);
    }
    for (int i=0; i<l*5; i++){
        printf(" ");
    }
    printf("%I64d\n",T[id].summ);
    if (T[id].left>0){
        draw_tree(T[id].left,l+1);
    }
}

int revers(int id, int l, int r){
    struct splited_segments temp, temp2;
    temp=split(id,r);
    temp2=split(temp.id_left,l);
    T[temp2.id_right].rev=!T[temp2.id_right].rev;
    return merge(merge(temp2.id_left,temp2.id_right),temp.id_right);
}

struct count_out count(int id, int l, int r){
    struct splited_segments temp, temp2;
    struct count_out output;
    temp=split(id,r);
    temp2=split(temp.id_left,l);
    output.summ=T[temp2.id_right].summ;
    output.head=merge(merge(temp2.id_left,temp2.id_right),temp.id_right);
    return output;
}

int main(int argc, char** argv) {
    freopen("reverse.in","rt",stdin);
    freopen("reverse.out","wt",stdout);
    scanf("%d %d",&n,&m);
    srand(time(NULL)*time(NULL));
    for (int i=1; i<=n; i++){
        scanf("%I64d",&T[i].summ);
        T[i].y=rand();
        T[i].size=1;
        h=merge(h,i);
    }
    for (int i=0; i<m; i++){
        scanf("%d %d %d",&a,&b,&c);
        b--;
        if (a==0){
            P=count(h,b,c);
            printf("%I64d\n",P.summ);
            h=P.head;
        }else{
            h=revers(h,b,c);
        }
    }
    return 0;
}