算法复习6.5FHQ

struct NODE{
  int val,cnt,rev,prio,size,ch[2];
};
struct FHQ{
  int root,size,NODE node[maxn];
}
pair<int, int> split_by_val (int t,int val){
if(!t){return{0,0};}
check_rev(t);
if(node[t].val<=val){
  auto tmp=split_by_val(node[t]0p.ch[1],val);
  node[t].ch[1]=tmp.first;
  update_size(t);
  return(t,tmp.second);
}else{
  auto tmp=split_by_val(node[t].ch[0],val);
  node[1].ch[0]=tmp.second;
  update_size;
  return {tmp.first,t};
}
}
tuple<int,int,int>split_by_rank(int t,int k){
  if(!t){return{0,0,0};}

check_rev(t);
int lt,mt,rt;
if(k<=node[node[t].ch[0]].size){
  tie(lt,mt,rt)=split_by_rank(node[t].ch[0].k);
  node[t].ch[0]=rt
  update_size(t);
  return{lt,mt,rt};
}else if(k>node[node[t].ch[0]].size+node[t].cnt){
  tie(lt,mt,rt)=split_by_rank(node[t].ch[1],k-node[node[t].ch[0]].size-node[t].cnt)];
  node[t].ch[1]=lt;
  update_size(t);
  return(t,mt,rt);
}else{
  lt=node[t].ch[0];
  rt=node[t].ch[1];
  check_rev(lt);
  check_rev(rt);
  update_size;
  return{lt,t,rt};
}
}
merge(int lt,int rt){
  if(!t){
    return rt;
  }else if(!rt){
    return lt;
  }
  check_rev(lt);
  check_rev(rt);
  if(node[lt].prio<node[rt].prio){
    node[lt].ch[1]=merge(node[lt].ch[1],rt);
    update_size(lt);
    return lt;

  }else{
    node[rt].ch[0]=merge(lt,node[rt.ch[0]);
    update_size(rt);
    return rt;
  }
}
void insert(int val){
  int lt,mt,rt;
  tie(lt,rt)=split_by_val(root,val);
  tie(lt,mt)=split_by_val(lt,val-1);
  if(!mt){
    mt=new_node(val);
  }else{
    node[mt].cnt++;
    update_size(mt);
  }
  root=merge(merge(lt,mt,rt));
}
void del(int val){
  int lt,mt,rt;
  tie(lt,rt)=split_by_val(root,val);
  tie(lt,mt)=split_by_val(lt,val-1);
  node[mt].cnt--;
  update_size(mt);
  if(node[mt].cnt==0){
    clear(mt);

  }else{
    lt=merge(lt,mt);
  }
  root=merge(lt,rt);

}
void reverse(int l,int r){
  int t1,t2,t3,t4,t5;
  tie(t1,t2,t3)=split_by_rank(root,l-1);
  tie(t3,t4,t5)=split_by_rank(t3,r-l+2);
  node[t3].rev=1;
  root=merge(merge(merge(merge(t1,t2),t3),t4),t5);
}
void check_rev(int t){
  if(node[t].rev){
    swap(node[t].ch[0],node[t].ch[1]);
    node[node[t].ch[0]].rev^=1;
        node[node[t].ch[1]].rev^=1;
node[t].rev=0
  }
}
int rank(int val){
  auto tmp=split_by_val(root,val-1);
  int k =node[tmp.first].size+1;
  root=merge(tmp.first,tmp.second);
  return k;
  }
  int kth(int &t,int k){
    int lt,mt,rt;
    tie(lt,mt,rt)=split_by_rank(t,k);
    int val=node[mt].val;
    t=merge(merge(lt,mt),rt);
    return val;
  }
  int pre(int val){
    auto tmp=split_by_rank(root,val-1);
    int k=kth(tmp.first,node[tmp.first].size);
    root=merge(tmp.first,tmp,second);
    return k;
  }
  int nxt(int val){
    auto tmp=split_by_val(root,val);
    int k=kth(tmp.second,1);
    root=merge(tmp.first,tmp.second);
    return k;
  }