标签：P1110 return val int 题解 tr Luogu tr1 inline

先声明，我好像是题解里写双fhq treap里唯一能过的...（最后两个点啊）

思路:首先看题目，MIN_GAP_SORT明显是求它的前驱与后继(可能有相同的)，所以就用平衡树，但是又要求两个相邻的数的差，就可以有再开一个平衡树存放差值

实现:抛开奇奇怪怪的的题面，主要考虑这三个操作：

1、INSERT i k:

这个很简单，用链表就行了（数组模拟的），但是要注意，插入的时候，要接着上一个在这插入的，还要做双向链表，数组要记得开两倍

最重要的是，插入了以后，这个数的前一个数与后一个数的差要在存放相邻两个数的差的fhq treap里删除，并插入这个数与前一个数的差和这个数与后一个数的差要存进去

2、MIN_GAP:

做完插入，就在存差的fhq treap查rank1好了(最左边的那个节点)

3、MIN_SORT_GAP:

为了避免查前驱与后继时出现自己(不是另一个与自己相同的数)，所以插入时(分裂后，合并前，这样正好符合查前驱与后继的标准)就比较取小，询问时直接输出就好了

P.S. 这道题写两个平衡树过后面两个点很关键的是卡常(O2也随你了)!原本T后面两个点的代码加上 register 与用 char而不用string 就过了，所以，卡常有的时候还是很重要的!(或者我人丑常数大吧)

附上AC代码:

#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<iostream>
using namespace std;

struct tree{//存每个值的数(不是差)
    int size,val,dat,l,r;
}tr[1000005];//数组记得开两倍

int s_tr,root,n,m,x,y,z,a[1000005],b[1000005],c[1000005];

int min_sort_gap;//MIN_SORT_GAP的答案

inline int abs(int a){
    return a<0?-a:a;
}

inline int min(int a,int b){
    return a<b?a:b;
}

//fhq treap常规操作

inline int new_tr(int val){
    tr[++s_tr].val=val;
    tr[s_tr].size=1;
    tr[s_tr].dat=rand();
    return s_tr;
}

inline void update(int p){
    tr[p].size=tr[tr[p].l].size+tr[tr[p].r].size+1;
}

void split(int p,int k,int &x,int &y){
    if(!p){
        x=y=0;
        return;
    }
    if(tr[p].val<=k)x=p,split(tr[p].r,k,tr[p].r,y);
    else y=p,split(tr[p].l,k,x,tr[p].l);
    update(p);
}

int merge(int x,int y){
    if(!x||!y)return x+y;
    if(tr[x].dat>tr[y].dat){
        tr[x].r=merge(tr[x].r,y);
        update(x);
        return x;
    }
    else {
        tr[y].l=merge(x,tr[y].l);
        update(y);
        return y;
    }
}

inline int Max(int x){//一棵fhq(可能是分裂后)中最大的
    while(tr[x].r)x=tr[x].r;
    return tr[x].val;
}

inline int Min(int y){//一棵fhq(可能是分裂后)中最大的
    while(tr[y].l)y=tr[y].l;
    return tr[y].val;
}

inline void insert(int val){
    split(root,val,x,y);
    if(tr[x].size)//要有才行
        min_sort_gap=min(min_sort_gap,abs(val-Max(x)));
    if(tr[y].size)//要有才行
        min_sort_gap=min(min_sort_gap,abs(Min(y)-val));
    root=merge(merge(x,new_tr(val)),y);
}

//存差值的fhq treap

struct tree1{
    int size,val,dat,l,r;
}tr1[1000005];

int s_tr1,root1;

inline int new_tr1(int val){
    tr1[++s_tr1].val=val;
    tr1[s_tr1].size=1;
    tr1[s_tr1].dat=rand();
    return s_tr1;
}

inline void update1(int p){
    tr1[p].size=tr1[tr1[p].l].size+tr1[tr1[p].r].size+1;
}

void split1(int p,int k,int &x,int &y){
    if(!p){
        x=y=0;
        return;
    }
    if(tr1[p].val<=k)x=p,split1(tr1[p].r,k,tr1[p].r,y);
    else y=p,split1(tr1[p].l,k,x,tr1[p].l);
    update1(p);
}

int merge1(int x,int y){
    if(!x||!y)return x+y;
    if(tr1[x].dat>tr1[y].dat){
        tr1[x].r=merge1(tr1[x].r,y);
        update1(x);
        return x;
    }
    else {
        tr1[y].l=merge1(x,tr1[y].l);
        update1(y);
        return y;
    }
}

inline void insert1(int val){
    split1(root1,val,x,y);
    root1=merge1(merge1(x,new_tr1(val)),y);
}

inline void delete_val(int val){//这棵fhq要能支持删除
    split1(root1,val,x,z);
    split1(x,val-1,x,y);
    y=merge1(tr1[y].l,tr1[y].r);
    root1=merge1(merge1(x,y),z);
}

inline int Min1(int y){
    while(tr1[y].l)y=tr1[y].l;
    return tr1[y].val;
}

char s[101];//卡常

inline int read(){//卡常
    int r=0,f=1;
    char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9')r=(r<<1)+(r<<3)+c-'0',c=getchar();
    return r*f;
}

int main(){
    srand(time(0));
    n=read(),m=read();
    min_sort_gap=1e9+10;
    for(register int i=1;i<=n;i++){//卡常
        a[i]=read();
        insert(a[i]);
    }
    for(register int i=1;i<n;i++)//卡常减少if
        insert1(abs(a[i+1]-a[i])),c[i]=i+1;
    for(register int i=2;i<=n;i++)//卡常减少if
        b[i]=i-1;
    int cnt=n;
    for(register int i=1;i<=m;i++){//卡常
        scanf("%s",s);
        if(s[0]=='I'){
            int j=read(),k=read();
            a[++cnt]=k;//放进数组
            b[cnt]=b[j+1];//数组模拟链表
            c[cnt]=j+1;
            delete_val(abs(a[j+1]-a[b[j+1]]));//因为插入后不在一起了，删除
            insert1(abs(a[b[j+1]]-k));//插入后多了两个差值(不算删除的)
            if(j<n)insert1(abs(k-a[j+1]));//可能插在第n个的后面
            c[b[j+1]]=cnt;//记得修改前一个与后一个的指向
            b[j+1]=cnt;
            insert(k);
        }
        else {
            if(s[4]=='G')printf("%d\n",Min1(root1));//整棵fhq里最小的
            else printf("%d\n",min_sort_gap);
        }
    }
    return 0;
}

完结偷偷撒花!(✿✿ヽ(°▽°)ノ✿)

标签：P1110,return,val,int,题解,tr,Luogu,tr1,inline
来源： https://www.cnblogs.com/wyzwyz/p/11236071.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。