[JZOJ5072]【GDOI2017第三轮模拟day1】单旋

最新推荐文章于 2025-12-07 16:00:00 发布

原创最新推荐文章于 2025-12-07 16:00:00 发布 · 553 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

线段树、树状数组

平衡树

本文介绍了一种特殊的Splay树实现及其操作方法，包括插入、查找最小值、查找最大值等，并通过实例详细分析了每种操作的具体实现过程及节点深度的变化。

题目描述

有一颗spaly，就是只有单旋的splay，现在有5种操作：

插入一个点x
把最小值旋到根
把最大值旋到根
2之后删掉最小值
3之后删掉最大值

问每次操作涉及的那个点的深度，后面几个操作的深度为没旋时的深度。

100%的数据满足：1<=m<=10^5；1<=key<=10^9。所有出现的关键码互不相同。任何一个非插入操作，一定保证树非空。在未执行任何操作之前，树为空。

分析

暴力肯定就是打一棵spaly啦···
先考虑2操作，发现最小值为spaly中一直往左子树走，旋到根会发生什么呢？先设这个点为x，对应最小值为mn，x的原父亲为y，权值数组val[]。

深度变化，我们发现dis[x]变为0，x的右子树深度不变，其他点，即值属于[val[y],+无限]的点深度都-1。
边的变化，原来的根父亲变为x，x右子树变为原根；x原右子树父亲变为y，y的左子树变为y。

这跟LCT有什么区别嘛····当然了，我的辣鸡做法是打一棵真正的splay，维护dis，然后也维护spaly的树边···即两颗树。维护dis的时候需要在splay找出值区间边界的点编号。
那么3操作只需要反过来就是了，即左子树变为右子树等。
4,5就是这两个操作执行之后把根换一换，把点扔一扔，dis–。
现在考虑操作1。考虑插入权值为x的点。我们可以把值的桶画出来，那么插入x这个点，左边和右边最近的未被删除的点之中，深度较大肯定是x的父亲了，为什么呢？看看二叉搜索树的过程，从根走到一个点，实际上限定了一个权值的区间，而当前走到的点要不就是区间的左边界，要么是右边界。那么我们打个set，存储存在的点值，到时候lowerbound之类的就可以弄出权值最靠近的两点是谁，然后比较dis，然后插入就好了。删除的时候set记得删掉。

嗯，这样就做完了，需要注意的一点是做任何操作都要先splay！不splay很容易提取出错误的信息。特别是后面debug的时候，改代码最容易漏掉splay。
另外，splay的lowerbound需要维护最大最小值，这题我是顺便用了那个set来lowerbound，然后建立权值和点编号的一一映射来找到splay中某个点的编号。然后再提取区间，打标记。

代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<set>
using namespace std;
typedef long long ll;
typedef double db;
#define fo(i,j,k) for(i=j;i<=k;i++)
#define fd(i,j,k) for(i=j;i>=k;i--)
const int N=100005;
set<int> :: iterator it;
set<int> tree;
struct rec
{
    int id,val;
}c[N];
int tc;
struct que
{
    int kase,val;
}q[N];
int fa[N],rev[N],root0,otr[N][2];// for the original one
int tval[N],tr[N][2],up[N],dis[N],tag[N],root; // all number for splay 
int le,ri,tt,x,n,tot,y,m,i,yy;
bool cmp(rec a,rec b)
{
    return a.val<b.val;
}
void lsh()
{
    sort(c+1,c+1+tc,cmp);
    m=0;
    fo(i,1,tc)
    {
        if (c[i].val!=c[i-1].val) m++;
        q[c[i].id].val=m;
    }
}
void down(int x)
{
    dis[x]+=tag[x];
    if (tr[x][0]) tag[tr[x][0]]+=tag[x];
    if (tr[x][1]) tag[tr[x][1]]+=tag[x];
    tag[x]=0;
}
int find(int sig)
{
    int x=root;
    while (tr[x][sig]!=0) x=tr[x][sig];
    return x;
}
int pd(int x) {return tr[up[x]][1]==x;}

void rotate(int x)
{
    int y=up[x],z=pd(x);
    down(y);down(x);
    up[x]=up[y];
    if (up[x]) tr[up[x]][pd(y)]=x;
    tr[y][z]=tr[x][1-z];
    if (tr[y][z]) up[tr[y][z]]=y;
    tr[x][1-z]=y;
    up[y]=x;
    if (root==y) root=x;
}
void splay(int x,int y)
{
    while (up[x]!=y)
    {
        if (up[up[x]]!=y)
        {
            if (pd(x)==pd(up[x])) rotate(up[x]);else rotate(x);
        }
        rotate(x);
    }
}
int upper(int val)
{
    it=tree.lower_bound(val);
    if (it==tree.end())  return 0;
    return rev[*it];
}
int lower(int val)
{
    it=tree.lower_bound(val+1);
    if (it==tree.begin()) return 0;
    return rev[(*(--it))];
}
void tagit(int l,int r,int val)
{
    int le,ri,ll,rr,z;
    le=upper(l);
    ri=lower(r);
    ll=lower(tval[le]-1);
    rr=upper(tval[ri]+1);
    if (ll) splay(ll,0);
    if (rr) splay(rr,ll);
    if (!rr) tag[tr[ll][1]]+=val;else
    tag[tr[rr][0]]+=val;
}
void ins(int val)
{
    tt++;
    tval[tt]=x;
    rev[x]=tt;
    if (!root)
        root=tt;
    else
    {
        int x=root,z;
        while (tr[x][(z=(val>tval[x]))]) x=tr[x][z];
        tr[x][z]=tt;
        up[tt]=x;
    }
    splay(tt,0);
}
int main()
{
    freopen("splay.in","r",stdin);
    freopen("splay.out","w",stdout);
    scanf("%d",&n);
    fo(i,1,n)
    {
        scanf("%d",&q[i].kase);
        if (q[i].kase==1) 
        {
            scanf("%d",&q[i].val);
            c[++tc].id=i;
            c[tc].val=q[i].val;
        }
    }
    lsh();// m
    //ins(0);ins(m+1);
    tot=0;
    fo(i,1,n)
    {
        if (q[i].kase==1)
        {
            x=q[i].val;
            ins(x);
            if (!tot)
                root0=tt;
            else
            {
                le=lower(x);
                splay(le,0);
                ri=upper(x);
                splay(ri,0);
                if (!le||dis[le]<dis[ri])
                {
                    fa[tt]=ri;
                    otr[ri][0]=tt;
                }else
                {
                    fa[tt]=le;
                    otr[le][1]=tt;
                }
                dis[tt]=dis[fa[tt]]+1;
            }
            tree.insert(x);
            tot++;
            printf("%d\n",dis[tt]+1);
        }
        else
        {
            // splay,值为关键字。
            yy=q[i].kase;
            x=find(yy%2);// we have root0
            splay(x,0);
            printf("%d\n",dis[x]+1);
            if (yy%2==0)
            {
                if (fa[x]) 
                {   
                    tagit(tval[fa[x]],m,+1);
                    dis[x]=0;
                    y=fa[x];
                    otr[y][0]=otr[x][1];
                    if (otr[x][1]) fa[otr[x][1]]=y;
                    otr[x][1]=root0;
                    fa[root0]=x;
                    fa[x]=0;
                    root0=x;
                }
                if (yy==4)
                {
                    tree.erase(tree.find(tval[x]));
                    splay(x,0);
                    // for origin
                    root0=otr[x][1];
                    if (root0) fa[root0]=0;
                    // for splay
                    root=tr[x][1];
                    if (root) up[root]=0;
                    if (root)
                    {
                        tag[root]-=1;
                        down(root);
                    }
                    tot--;
                }
            }else
            {
                if (fa[x])
                {
                    tagit(1,tval[fa[x]],+1);
                    dis[x]=0;
                    y=fa[x];
                    otr[y][1]=otr[x][0];
                    if (otr[x][0]) fa[otr[x][0]]=y;
                    otr[x][0]=root0;
                    fa[root0]=x;
                    fa[x]=0;
                    root0=x;
                }
                if (yy==5)
                {
                    tree.erase(tree.find(tval[x]));
                    splay(x,0);
                    root0=otr[x][0];
                    if (root0) fa[root0]=0;
                    //
                    root=tr[x][0];
                    if (root) up[root]=0;
                    //tagit(1,m,-1);
                    if (root)
                    {
                        tag[root]-=1;
                        down(root);
                    }
                    tot--;
                }
            }
        }
    }
    return 0;
}