BZOJ4864: [BeiJing 2017 Wc]神秘物质(Splay)

Description

21ZZ 年，冬。

小诚退休以后， 不知为何重新燃起了对物理学的兴趣。 他从研究所借了些实验仪器，整天研究各种微观粒子。这

一天， 小诚刚从研究所得到了一块奇异的陨石样本， 便迫不及待地开始观测。 在精密仪器的视野下，构成陨石

的每个原子都无比清晰。 小诚发现， 这些原子排成若干列， 每一列的结构具有高度相似性。于是，他决定对单

独一列原子进行测量和测试。被选中的这列共有 N 个顺序排列的原子。 最初， 第 i 个原子具有能量 Ei。 随着

时间推移和人为测试， 这列原子在观测上会产生两种变化：

merge x e 当前第 x 个原子和第 x+1 个原子合并，得到能量为 e 的新原子；

insert x e 在当前第 x 个原子和第 x+1 个原子之间插入一个能量为 e 的新原子。

对于一列原子，小诚关心的是相邻一段中能量最大和能量最小的两个原子的能量差值，

称为区间极差。 因此， 除了观测变化外，小诚还要经常统计这列原子的两类数据：

max x y 当前第 x 到第 y 个原子之间的任意子区间中区间极差的最大值；

min x y 当前第 x 到第 y 个原子之间的任意子区间中区间极差的最小值。

其中， 子区间指的是长度至少是 2 的子区间。

小诚坚信这项研究可以获得诺贝尔物理学奖。为了让小诚早日了结心愿，你能否帮助他实现上述的观测和测量呢？

Input

第一行， 两个整数 N， M， 分别表示最初的原子数目和事件总数。

第二行， N 个整数 E1, E2, …, EN， 由空格隔开。依次表示每个原子的能量。

接下来 M 行， 每行为一个字符串和两个整数， 描述一次事件，格式见题目描述。

N<=100,000,M<=100,000

1 ≤ e, Ei ≤ 109。 设 N’ 为当前时刻原子数目。

对于 merge 类事件， 1 ≤ x ≤ N’-1；

对于 insert 类事件， 1 ≤ x ≤ N’；

对于 max 和 min 类事件， 1 ≤ x < y ≤ N’。

任何时刻，保证 N’ ≥ 2。

Output

输出若干行， 按顺序依次表示每次 max 和 min 类事件的测量结果。

Sample Input

4 3
5 8 10 2
max 1 3
min 1 3
max 2 4

Sample Output

5 2 8

解题思路：

Splay维护插入，删除，区间统计答案。

极差最大值为区间最值差，最小值为相邻元素之差。

然后愉快地AC

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll tr[spc].ch[0]
 #define rrr tr[spc].ch[1]
 #define ls ch[0]
 #define rs ch[1]
 const int N=;
 struct trnt{
     int ch[];
     int fa;
     int E;
     int wgt;
     int maxval;
     int minval;
     int abst;
     int minab;
 }tr[N];
 int siz;
 int root;
 int n,m;
 int energy[N];
 char cmd[];
 bool whc(int spc)
 {
     return tr[tr[spc].fa].rs==spc;
 }
 void pushup(int spc)
 {
     tr[spc].wgt=;
     tr[spc].maxval=tr[spc].minval=tr[spc].E;
     tr[spc].minab=tr[spc].abst;
     if(lll)
     {
         tr[spc].wgt+=tr[lll].wgt;
         tr[spc].maxval=std::max(tr[spc].maxval,tr[lll].maxval);
         tr[spc].minval=std::min(tr[spc].minval,tr[lll].minval);
         tr[spc].minab=std::min(tr[spc].minab,tr[lll].minab);
     }
     if(rrr)
     {
         tr[spc].wgt+=tr[rrr].wgt;
         tr[spc].maxval=std::max(tr[spc].maxval,tr[rrr].maxval);
         tr[spc].minval=std::min(tr[spc].minval,tr[rrr].minval);
         tr[spc].minab=std::min(tr[spc].minab,tr[rrr].minab);
     }
     return ;
 }
 void rotate(int spc)
 {
     int f=tr[spc].fa;
     bool k=whc(spc);
     tr[f].ch[k]=tr[spc].ch[!k];
     tr[spc].ch[!k]=f;
     tr[tr[f].fa].ch[whc(f)]=spc;
     tr[spc].fa=tr[f].fa;
     tr[f].fa=spc;
     tr[tr[f].ch[k]].fa=f;
     pushup(f);
     pushup(spc);
     return ;
 }
 void splay(int spc,int f)
 {
     while(tr[spc].fa!=f)
     {
         int ft=tr[spc].fa;
         if(tr[ft].fa==f)
         {
             rotate(spc);
             break;
         }
         if(whc(spc)^whc(ft))
             rotate(spc);
         else
             rotate(ft);
         rotate(spc);
     }
     if(!f)
         root=spc;
     return ;
 }
 void Build(int l,int r,int &spc,int f)
 {
     if(l>r)
         return ;
     int mid=(l+r)>>;
     spc=++siz;
     tr[spc].fa=f;
     tr[spc].E=energy[mid];
     tr[spc].abst=std::abs(energy[mid]-energy[mid+]);
     Build(l,mid-,lll,spc);
     Build(mid+,r,rrr,spc);
     pushup(spc);
     return ;
 }
 int plc(int spc,int v)
 {
     if(tr[lll].wgt>=v)
         return plc(lll,v);
     if(tr[lll].wgt+==v)
         return spc;
     return plc(rrr,v-tr[lll].wgt-);
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++)
         scanf("%d",&energy[i]);
     Build(,n+,root,);
     while(m--)
     {
         int x,y;
         scanf("%s",cmd+);
         scanf("%d%d",&x,&y);
         if(cmd[]=='i')
         {
             int spc1=plc(root,x+);
             int spc2=plc(root,x+);
             int spc=++siz;
             splay(spc1,);
             splay(spc2,root);
             tr[spc1].abst=std::abs(tr[spc1].E-y);
             tr[spc].abst=std::abs(tr[spc2].E-y);
             tr[spc].fa=spc2;
             tr[spc].E=y;
             tr[spc2].ls=spc;
             pushup(spc);
             pushup(spc2);
             pushup(root);
         }else if(cmd[]=='e')
         {
             int spc1=plc(root,x),spc2=plc(root,x+);
             splay(spc1,);
             splay(spc2,root);
             tr[spc1].abst=std::abs(y-tr[spc1].E);
             int spc=++siz;
             tr[spc].fa=tr[root].rs;
             tr[spc].E=y;
             tr[spc].abst=std::abs(y-tr[spc2].E);
             tr[tr[root].rs].ls=spc;
             pushup(spc);
             pushup(spc2);
             pushup(root);
         }else if(cmd[]=='i')
         {
             int spc1=plc(root,x),spc2=plc(root,y+);
             splay(spc1,);
             splay(spc2,root);
             int ans=tr[tr[tr[root].rs].ls].minab;
             printf("%d\n",ans);
         }else{
             int spc1=plc(root,x),spc2=plc(root,y+);
             splay(spc1,);
             splay(spc2,root);
             int ans=tr[tr[tr[root].rs].ls].maxval-tr[tr[tr[root].rs].ls].minval;
             printf("%d\n",tr[tr[tr[root].rs].ls].maxval-tr[tr[tr[root].rs].ls].minval);
         }
     }
     return ;
 }