Splay_Tree 模板（区间修改，旋转操作）

1.旋转操作

#define MAXN 100100

bool Add[MAXN];//延迟标记

struct Splay_Tree

{

    int cnt, rt;//cnt为节点数，rt == root

    struct Tree{

        int key;//关键字

        int num, size;//num是这个节点有多少重复，size是以这个节点为根的子树大小。

        int fa, son[];

    }T[MAXN];

    inline void init()

    {

        cnt = ;//初始化超级根节点（标记为0的节点）

        T[].size = ;

        rt = ;

        memset(Add,,sizeof(Add));//开始初始化0

    }

    inline void PushUp(int x)

    {

        T[x].size=T[T[x].son[]].size+T[T[x].son[]].size+T[x].num;

    }

    inline void PushDown(int x)

    {

        //翻转操作，这一步最为关键

        if(Add[x])

        {

            swap(T[x].son[],T[x].son[]);

            Add[T[x].son[]] ^= ;

            Add[T[x].son[]] ^= ;

            Add[x] = ;

        }

    }

    inline int Newnode(int key, int fa) //新建一个节点并返回

    {

        ++cnt;

        T[cnt].key=key;

        T[cnt].num=T[cnt].size=;

        T[cnt].fa=fa;

        T[cnt].son[]=T[cnt].son[]=;

        return cnt;

    }

    inline void Rotate(int x, int p) //0左旋 1右旋

    {

        int y=T[x].fa;

        PushDown(y);//你是说这个有问题。

        PushDown(x);

        T[y].son[!p]=T[x].son[p];

        T[T[x].son[p]].fa=y;

        T[x].fa=T[y].fa;

        if(T[x].fa)

            T[T[x].fa].son[T[T[x].fa].son[] == y]=x;

        T[x].son[p]=y;

        T[y].fa=x;

        PushUp(y);

        PushUp(x);

    }

    void Splay(int x, int To) //将x节点移动到To的子节点中

    {

        while(T[x].fa != To)

        {

            if(T[T[x].fa].fa == To)

            {

                //在这里面得

                PushDown(T[x].fa);

                PushDown(x);

                Rotate(x, T[T[x].fa].son[] == x);

            }

            else

            {

                int y=T[x].fa, z=T[y].fa;

                PushDown(z);

                PushDown(y);

                PushDown(x);

                int p=(T[z].son[] == y);

                if(T[y].son[p] == x)

                    Rotate(x, !p), Rotate(x, p); //之字旋

                else

                    Rotate(y, p), Rotate(x, p); //一字旋

            }

        }

        if(To == ) rt=x;

    }

    int GetPth(int p, int To) //返回第p小的节点 并移动到To的子节点中

    {

        if(!rt || p > T[rt].size) return ;

        int x=rt;

        while(x)

        {

            PushDown(x);

            if(p >= T[T[x].son[]].size+ && p <= T[T[x].son[]].size+T[x].num)

                break;

            if(p > T[T[x].son[]].size+T[x].num)

            {

                p-=T[T[x].son[]].size+T[x].num;

                x=T[x].son[];

            }

            else

                x=T[x].son[];

        }

        Splay(x, );

        return x;

    }

    int Find(int key) //返回值为key的节点 若无返回0 若有将其转移到根处

    {

        if(!rt) return ;

        int x=rt;

        while(x)

        {

            PushDown(x);

            if(T[x].key == key) break;

            x=T[x].son[key > T[x].key];

        }

        if(x) Splay(x, );

        return x;

    }

    int Prev() //返回根节点的前驱 非重点

    {

        if(!rt || !T[rt].son[]) return ;

        int x=T[rt].son[];

        PushDown(x);

        while(T[x].son[])

        {

            x=T[x].son[];

            PushDown(x);

        }

        Splay(x, );

        return x;

    }

    int next() //返回根结点的后继 非重点

    {

        if(!rt || !T[rt].son[]) return ;

        int x=T[rt].son[];

        PushDown(x);

        while(T[x].son[])

        {

            x=T[x].son[];

            PushDown(x);

        }

        Splay(x, );

        return x;

    }

    void Insert(int key) //插入key值

    {

        if(!rt)

            rt=Newnode(key, );

        else

        {

            int x=rt, y=;

            while(x)

            {

                PushDown(x);

                y=x;

                if(T[x].key == key)

                {

                    T[x].num++;

                    T[x].size++;

                    break;

                }

                T[x].size++;//既然一定调整

                x=T[x].son[key > T[x].key];

            }

            if(!x)

                x = T[y].son[key > T[y].key] = Newnode(key, y);

            Splay(x, );

        }

    }

    void Delete()//直接改成删除根节点

    {

        if(rt == ) return ;//已经没有节点了

        if(T[rt].num > )

        {

            T[rt].num --;

            T[rt].size --;

            return ;

        }

        if(T[rt].son[] == )

        {

            rt = T[rt].son[];

            T[rt].fa = ;

        }

        else

        {

            int preid = T[rt].son[];

            PushDown(preid);

            while(T[preid].son[])

            {

                preid = T[preid].son[];

                PushDown(preid);

            }

            Splay(preid, rt);

            T[preid].son[] = T[rt].son[];

            T[ T[rt].son[] ].fa = preid;

            rt = preid;

            T[rt].fa = ;

            PushUp(rt);

        }

    }

//    int GetRank(int key) //获得值<=key的节点个数 并将其转移到根处 若<key只需将<=换为<

//    {

//        //我没有写PUSH_UP 和 PUSH_DOWN

//        if(!rt) return 0;

//        int x=rt, ret=0, y=0;

//        while(x)

//        {

//            y=x;

//            if(T[x].key <= key)

//            {

//                ret += T[T[x].son[0]].size + T[x].num;

//                x=T[x].son[1];

//            }

//            else

//                x=T[x].son[0];

//        }

//        Splay(y, 0);

//        return ret;

//    }

//    这个删除太丑了

//    void Delete(int l, int r) //删除值在[l, r]中的所有节点 l!=r

//    {

//        if(!Find(l)) Insert(l);// 你这样写真的好吗？ 泥煤

//        int p=Prev();

//        if(!Find(r)) Insert(r);

//        int q=next();

//        if(!p && !q)

//        {

//            rt=0;

//            return;

//        }

//        if(!p)

//        {

//            T[rt].son[0]=0;

//            PushUp(rt);

//            return;

//        }

//        if(!q)

//        {

//            Splay(p, 0);

//            T[rt].son[1]=0;

//            PushUp(rt);

//            return;

//        }

//        Splay(p, q);

//        T[p].son[1]=0;

//        PushUp(p);

//        PushUp(q);

//    }

    void display(int x)

    {

        if(x==) return ;

        PushDown(x);

        display(T[x].son[]);

        printf("%d ",T[x].key);

        display(T[x].son[]);

    }

}spt;

//

//int main() {

//    //SPT 独特的旋转操作！

//    int n;

//    while(scanf("%d",&n) && n)

//    {

//        spt.init();

//        for(int i=1;i<=n;i++)

//        {

//            int tmp;

//            scanf("%d",&tmp);

//            g[i].key = tmp;

//            g[i].id = i;

//            spt.Insert(i);

//        }

//

//        sort(g+1,g+1+n,cmp);

//        for(int i=1;i<=n;i++)//开始旋转

//        {

//            //step one 将当前最小的点，移动到树根处

//            spt.Splay(g[i].id, 0);

//

//            //step two 将整个左子树旋转

//            int sonid = spt.T[g[i].id].son[0];

//            printf("%d",spt.T[sonid].size+i);

//            if(i!=n) printf(" ");

//            if(sonid != 0)

//            {

//                Add[sonid] ^= 1;//修改区间

//            }

//            spt.Delete();

//

//            //每次操作之后，都把结果打印一遍

//            //spt.display(spt.rt);

//            //printf("\n");

//        }

//        printf("\n");

//    }

//    return 0;

//}

2.成段更#define MAXN 200100



long long Add[MAXN];//延迟标记

struct Splay_Tree

{

    int cnt, rt;//cnt为节点数，rt == root

    struct Tree{

        long long K;

        long long sumk;

        int key;//关键字

        int num, size;//num是这个节点有多少重复，size是以这个节点为根的子树大小。

        int fa, son[];

    }T[MAXN];

    inline void init()

    {

        cnt = ;//初始化超级根节点（标记为0的节点）

        T[].size = ;

        T[].sumk = ;

        T[].K = ;

        rt = ;

        memset(Add,,sizeof(Add));

    }

    inline void PushUp(int x)

    {

        T[x].size=T[T[x].son[]].size+T[T[x].son[]].size+T[x].num;

        T[x].sumk=T[T[x].son[]].sumk+T[T[x].son[]].sumk+T[x].K;

    }

    inline void PushDown(int x)

    {

        if(Add[x])

        {

            if(T[x].son[])//

            {

                T[T[x].son[]].K += Add[x];

                T[T[x].son[]].sumk += T[T[x].son[]].size*Add[x];

                Add[T[x].son[]]+=Add[x];

            }

            if(T[x].son[])

            {

                T[T[x].son[]].K+=Add[x];

                T[T[x].son[]].sumk += T[T[x].son[]].size*Add[x];

                Add[T[x].son[]]+=Add[x];

            }

            Add[x]=;//不管子节点有没有，这层一定往下推,没有子节点相当于标记无效。

        }

    }

    inline int Newnode(int key, int fa,int K) //新建一个节点并返回

    {

        ++cnt;

        T[cnt].K = T[cnt].sumk = K;

        T[cnt].key=key;

        T[cnt].num=T[cnt].size=;

        T[cnt].fa=fa;

        T[cnt].son[]=T[cnt].son[]=;

        return cnt;

    }

    inline void Rotate(int x, int p) //0左旋 1右旋

    {

        int y=T[x].fa;

        PushDown(y);//这里是不是必须的，我感觉从小往上不需要往上推

        PushDown(x);

        T[y].son[!p]=T[x].son[p];

        T[T[x].son[p]].fa=y;

        T[x].fa=T[y].fa;

        if(T[x].fa)

            T[T[x].fa].son[T[T[x].fa].son[] == y]=x;

        T[x].son[p]=y;

        T[y].fa=x;

        PushUp(y);

        PushUp(x);

    }

    void Splay(int x, int To) //将x节点移动到To的子节点中

    {

        while(T[x].fa != To)

        {

            if(T[T[x].fa].fa == To)

                Rotate(x, T[T[x].fa].son[] == x);

            else

            {

                int y=T[x].fa, z=T[y].fa;

                int p=(T[z].son[] == y);

                if(T[y].son[p] == x)

                    Rotate(x, !p), Rotate(x, p); //之字旋

                else

                    Rotate(y, p), Rotate(x, p); //一字旋

            }

        }

        if(To == ) rt=x;

    }

    int GetPth(int p, int To) //返回第p小的节点 并移动到To的子节点中

    {

        if(!rt || p > T[rt].size) return ;

        int x=rt;

        while(x)

        {

            PushDown(x);

            if(p >= T[T[x].son[]].size+ && p <= T[T[x].son[]].size+T[x].num)

                break;

            if(p > T[T[x].son[]].size+T[x].num)

            {

                p-=T[T[x].son[]].size+T[x].num;

                x=T[x].son[];

            }

            else

                x=T[x].son[];

        }

        Splay(x, );

        return x;

    }

    int Find(int key) //返回值为key的节点 若无返回0 若有将其转移到根处

    {

        if(!rt) return ;

        int x=rt;

        while(x)

        {

            PushDown(x);

            if(T[x].key == key) break;

            x=T[x].son[key > T[x].key];

        }

        if(x) Splay(x, );

        return x;

    }

    int Prev() //返回根节点的前驱 非重点

    {

        if(!rt || !T[rt].son[]) return ;

        int x=T[rt].son[];

        while(T[x].son[])

        {

            PushDown(x);

            x=T[x].son[];

        }

        Splay(x, );

        return x;

    }

    int next() //返回根结点的后继 非重点

    {

        if(!rt || !T[rt].son[]) return ;

        int x=T[rt].son[];

        while(T[x].son[])

        {

            PushDown(x);

            x=T[x].son[];

        }

        Splay(x, );

        return x;

    }

    void Insert(int key,int K) //插入key值

    {

        if(!rt)

            rt=Newnode(key, , K);

        else

        {

            int x=rt, y=;

            while(x)

            {

                PushDown(x);

                y=x;

                if(T[x].key == key)

                {

                    T[x].num++;

                    T[x].size++;

                    break;

                }

                T[x].size++;//既然一定调整

                x=T[x].son[key > T[x].key];

            }

            if(!x)

                x = T[y].son[key > T[y].key] = Newnode(key, y, K);

            Splay(x, );

        }

    }

// void Delete()//直接改成删除根节点

// {

// if(rt == 0) return ;//已经没有节点了

// if(T[rt].num > 1)

// {

// T[rt].num --;

// T[rt].size --;

// return ;

// }

// if(T[rt].son[0] == 0)

// {

// rt = T[rt].son[1];

// T[rt].fa = 0;

// }

// else

// {

// int preid = T[rt].son[0];

// PushDown(preid);

// while(T[preid].son[1])

// {

// preid = T[preid].son[1];

// PushDown(preid);

// }

// Splay(preid, rt);

// T[preid].son[1] = T[rt].son[1];

// T[ T[rt].son[1] ].fa = preid;

// rt = preid;

// T[rt].fa = 0;

// PushUp(rt);

// }

void Delete(int key) //删除值为key的节点1个,这个操作可能有问题。。。

    {

        int x=Find(key);

        if(!x) return;

        if(T[x].num>)

        {

            T[x].num--;

            PushUp(x);

            return;

        }

        int y=T[x].son[];

        while(T[y].son[])

            y=T[y].son[];

        int z=T[x].son[];

        while(T[z].son[])

            z=T[z].son[];

        if(!y && !z)

        {

            rt=;

            return;

        }

        if(!y)

        {

            Splay(z, );

            T[z].son[]=;

            PushUp(z);

            return;

        }

        if(!z)

        {

            Splay(y, );

            T[y].son[]=;

            PushUp(y);

            return;

        }

        Splay(y, );

        Splay(z, y);

        T[z].son[]=;

        PushUp(z);

        PushUp(y);

    }

    int GetRank(int key) //获得值<=key的节点个数 并将其转移到根处 若<key只需将<=换为<

    {

        if(!rt) return ;

        int x=rt, ret=, y=;

        while(x)

        {

            y=x;

            if(T[x].key <= key)

            {

                ret += T[T[x].son[]].size + T[x].num;

                x=T[x].son[];

            }

            else

                x=T[x].son[];

        }

        Splay(y, );

        return ret;

    }

//    这个删除太丑了

//    void Delete(int l, int r) //删除值在[l, r]中的所有节点 l!=r

//    {

//        if(!Find(l)) Insert(l);// 你这样写真的好吗？ 泥煤

//        int p=Prev();

//        if(!Find(r)) Insert(r);

//        int q=next();

//        if(!p && !q)

//        {

//            rt=0;

//            return;

//        }

//        if(!p)

//        {

//            T[rt].son[0]=0;

//            PushUp(rt);

//            return;

//        }

//        if(!q)

//        {

//            Splay(p, 0);

//            T[rt].son[1]=0;

//            PushUp(rt);

//            return;

//        }

//        Splay(p, q);

//        T[p].son[1]=0;

//        PushUp(p);

//        PushUp(q);

//    }

}spt;

Splay_Tree 模板（区间修改，旋转操作）的更多相关文章

POJ 3468 A Simple Problem with Integers (伸展树区间更新求和操作，模板)
伸展数最基本操作的模板,区间求和,区间更新.为了方便理解,特定附上一自己搞的搓图这是样例中的数据输入后建成的树,其中的1,2是加入的边界顶点,数字代表节点编号,我们如果要对一段区间[l, r]进行操 ...
hdu1698 Just a Hook 【区间修改】（模板题）
题目链接:https://vjudge.net/contest/182746#problem/E 题目大意: 一段线段由n条小线段组成,每次操作把一个区间的小线段变成金银铜之一(金的价值为3,银为2, ...
P3368 【模板】树状数组 2 单点查询与区间修改
题目描述如题,已知一个数列,你需要进行下面两种操作: 1.将某区间每一个数数加上x 2.求出某一个数的和输入输出格式输入格式: 第一行包含两个整数N.M,分别表示该数列数字的个数和操作的总个数. ...
hdu 1890 Robotic SortI（splay区间旋转操作）
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1890 题解:splay又一高级的功能,区间旋转这个是用线段树这些实现不了的,这题可以学习splay的旋 ...
树状数组求区间和模板区间可修改参考题目：牛客小白月赛 I 区间
从前有个东西叫树状数组,它可以轻易实现一些简单的序列操作,比如单点修改,区间求和;区间修改,单点求值等. 但是我们经常需要更高级的操作,比如区间修改区间查询.这时候树状数组就不起作用了,只能选择写一个 ...
线段树：Segment Tree(单点修改/区间修改模板) C++
线段树是非常有效的数据结构,可以快速的维护单点修改,区域修改,查询最大值,最小值等功能. 同时,它也很重要.如果有一天比赛,你卡在了一道线段树模板题目上,这就真的尴尬了.不过,随着时代的进步,题目也越 ...
题解报告：Luogu P3368 【模板】树状数组 2（区间修改，单点查询）
题目描述如题,已知一个数列,你需要进行下面两种操作: 1.将某区间每一个数数加上x 2.求出某一个数的和输入输出格式输入格式: 第一行包含两个整数N.M,分别表示该数列数字的个数和操作的总个数. ...
POJ - 3468 线段树单点查询，单点修改区间查询，区间修改模板（求和）
题意: 给定一个数字n,表示这段区间的总长度.然后输入n个数,然后输入q,然后输入a,b,表示查询a,b,区间和,或者输入c 再输入三个数字a,b,c,更改a,b区间为c 思路: 线段树首先就是递归建 ...
splay tree旋转操作 hdu 1890
很神奇的旋转操作. 目前没看到其他数据结构能实现这个功能.平衡树不好处理区间操作,线段树很难旋转.splay tree搞这个就很简单了. 下面用的这个模板跑了700ms,好慢,估计是删除操作太费时了, ...

随机推荐

socket编程演示样例(多线程)
client代码例如以下: import java.io.*; import java.net.*; import java.util.Scanner; public class SimpleChat ...
Win7如何改变用户文件夹位置
现在装WIN7后第一件就是改变用户账户文件夹位置..因为里面存着一些软件的设定和信息等..不必要每次装后都手动改一次.. 已前用优化大师改.太麻烦.也不稳定有时有些目录不能完全改过来.. 通过命令mk ...
Selenium webdriver Java 封装与重用
目的 1. 简化调用 WebDriver对页面的操作,需要找到一个WebElement,然后再对其进行操作,比较繁琐: WebElement element =driver.findElement(B ...
Unity Android && Ant Automate Build 之一
这几天抽空研究下Android SDK 自动化打包.顺便温习下Unity 与 Android 交互机制. 一.Unity 与 Android 的消息传递机制 Example: 导出 Android ...
openerp wizard to tree view
从wizard跳转到tree视图最简单的方法 <act_window context="{'search_default_server_id': active_id, 'defau ...
JavaScript | 基础表单验证（纯Js）
———————————————————————————————————————————— 基础表单验证(纯js) - - - - - - - - - - - - - - - - - - - - - - ...
MongoDB密码设置（基于windows）
参考文档:http://www.cnblogs.com/zengen/archive/2011/04/23/2025722.html MongoDB部署到Windows上后是默认是无权限限制的的. ...
python with上下文的浅谈
python中的with一般用于上下文管理,什么是上下文管理,其实平时我们经常会用到,比如连接数据库查询数据,操作完成后关闭连接. 还比如打开文件写入数据等操作. 具体实例: class Myres ...
转FTP协议详解
转自:http://www.cnblogs.com/li0803/archive/2010/11/16/1878833.html FTP 是File Transfer Protocol(文件传输协议) ...
错误： ISO C++ 不同意在类内初始化很量静态成员
错误: ISO C++ 不同意在类内初始化很量静态成员今天開始学C++ primer,在牵扯到Sales_item.h头文件时.出现了一些问题(和C++11新特性相关),当前的编译器版本号 ...

Splay_Tree 模板（区间修改，旋转操作）

Splay_Tree 模板（区间修改，旋转操作）的更多相关文章

随机推荐

热门专题