伸展树基本概念基本题目

Posted 2020-09-20 Billyshuai

http://blog.csdn.net/discreeter/article/details/51524210   //基本概念详见这里

 

例题HDU4453 代码来源http://blog.csdn.net/auto_ac/article/details/12318809

 

伸展树我个人理解就是每次查询或更改都要将其移动至根节点 另外伸展树有单点操作和区间操作 维护的是一个中序遍历（这点很重要）

旋转操作的话结合概念和代码还是很清晰的，有左旋（当要进行旋转操作的是其根节点的右节点），右旋（当要进行旋转操作的是其根节点的左节点），还有一字型旋转和之字形旋转，详见基本概念

情况一：节点x的父节点y是根节点。这时，如果x是y的左孩子，我们进行一次Zig（右旋）操作；如果x 是y 的右孩子，则我们进行一次Zag（左旋）操作。经过旋转，x成为二叉查找树S的根节点，调整结束。即：如果当前结点父结点即为根结点，那么我们只需要进行一次简单旋转即可完成任务，我们称这种旋转为单旋转。如图1所示

 

 

（图1）

情况二：节点x 的父节点y 不是根节点，y 的父节点为z，且x 与y 同时是各自父节点的左孩子或者同时是各自父节点的右孩子。这时，我们进行一次Zig-Zig操作或者Zag-Zag操作。即：设当前结点为X ， X 的父结点为Y ，Y 的父结点为Z ，如果Y 和X 同为其父亲的左孩子或右孩子，那么我们先旋转Y ，再旋转X 。我们称这种旋转为一字形旋转。如图2所示

 

（图2）

情况三：节点x的父节点y不是根节点，y的父节点为z，x与y中一个是其父节点的左孩子而另一个是其父节点的右孩子。这时，我们进行一次Zig-Zag操作或者Zag-Zig 操作。即：这时我们连续旋转两次X 。我们称这种旋转为之字形旋转。如图3所示

 

(图3)

如图4所示，执行Splay(1,S)，我们将元素1 调整到了伸展树S 的根部。再执行Splay(2,S)，如图5 所示，我们从直观上可以看出在经过调整后，伸展树比原来“平衡”了许多。而伸展操作的过程并不复杂，只需要根据情况进行旋转就可以了，而三种旋转都是由基本得左旋和右旋组成的，实现较为简单。

 

（图4）

（图5）

区间操作的图解原网站也很清晰：

首先我们认为伸展树的中序遍历即为我们维护的数列，那么很重要的一个操作就是怎么在伸展树中表示任意一个区间。比如我们要提取区间a,b]，那么我们将a前面一个数对应的结点转到树根，将b 后面一个结点对应的结点转到树根的右边，那么根右边的左子树就对应了区间[a,b]。其中的道理也是很简单的，将a 前面一个数对应的结点转到树根后， a 及a 后面的数就在根的右子树上，然后又将b后面一个结点对应的结点转到树根的右边，那么[a,b]这个区间就是图8中*所示的子树。

利用这个，我们就可以实现线段树的一些功能，比如回答对区间的询问。我们在每个结点上记录关于以这个结点为根的子树的信息，然后询问时先提取区间，再直接读取子树的相关信息。还可以对区间进行整体修改，这也要用到和线段树类似的延迟标记技术，就是对于每个结点，再额外记录一个或多个标记，表示以这个结点为根的子树是否被进行了某种操作，并且这种操作影响其子结点的信息值。当然，既然记录了标记，那么旋转和其他一些操作中也就要相应地将标记向下传递。

 

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define KT ch[ ch[root][1] ][0]
#define L ch[x][0]
#define R ch[x][1]
const int maxn = 300005;
int num[maxn], n, m;
int k1, k2;
typedef long long ll;
struct splayTree {
    int ch[maxn][2], sz[maxn], pre[maxn];
    int root, tot, all; // all：节点总数， tot：最大标号

    int add[maxn], val[maxn];
    bool flip[maxn]; //翻转标记
    int sta[maxn], top;
    void rotate(int &x, int f) {//f等于一是右旋
           int y = pre[x], z = pre[y];
           down(y); down(x);
           ch[y][!f] = ch[x][f];
           pre[ch[x][f]] = y;
           pre[x] = pre[y];
           if(z) ch[z][ch[z][1] == y] = x;
           ch[x][f] = y;
           pre[y] = x;
           up(y);
       }
       void splay(int &x, int g) {
           down(x);
           while(pre[x] != g) {
               int y = pre[x], z = pre[y];
               down(z); down(y); down(x);
               if(z == g) {
                   rotate(x, ch[y][0] == x);
               }
               else {
                   int f = (ch[z][0] == y);
                   ch[y][!f] == x ? rotate(y, f) : rotate(x, !f);
                   rotate(x, f);
               }
           }
           if(!g) root = x;
           up(x);
       }
       void rto(int k, int g) {
           int x = root;
           while(1) {
               down(x);

               if(sz[L] == k) break;
               if(sz[L] > k) x = L;
               else {
                   k -= sz[L] + 1;
                   x = R;
               }
           }
           splay(x, g);
       }
    void down(int x){
        if(add[x]) {
            val[L] += add[x];
            val[R] += add[x];
            add[L] += add[x];
            add[R] += add[x];
            add[x] = 0;
        }
        if(flip[x]) {
            flip[L] ^= 1;
            flip[R] ^= 1;
            swap(L, R);
            flip[x] = 0;
        }
    }
    void up(int x) {
        sz[x] = sz[L] + sz[R] +1;
    }

    void build(int &x, int l, int r, int fa) {
        if(l > r) return;
        int m = (l+r) >> 1;
        newNode(x, num[m], fa);
        build(L, l, m-1, x);
        build(R, m+1, r, x);
        up(x);
    }
    void newNode(int &x, int v, int fa) {
        if(top) x = sta[top--]; //内存回收
        else x = ++tot;
        all++;
        pre[x] = fa;
        sz[x] = 1;
        L = R = 0;
        val[x] = v;
        add[x] = 0;
        flip[x] = 0;
    }
    void init(int n) {
        all = tot = top = 0;
        newNode(root, 0, 0);
        // all：节点总数， tot：最大标号
        newNode(ch[root][1], 0, root);
        for(int i = 0; i < n; i++)
            scanf("%d", &num[i]);
        build(KT, 0, n-1, ch[root][1]);
        up(ch[root][1]);
        up(root);
        debug();
    }
    ll erase(int k) { //删除第k个数
        rto(k, 0);
        rto(k-1, root);
        sta[++top] = root;
        all--;
        ll ret = val[root];
        int ls = ch[root][0], rs = ch[root][1];
        root = ls;
        pre[ls] = 0;
        ch[ls][1] = rs;
        if(rs)pre[rs] = ls;
        up(root);
        return ret;
    }
    void insert(int k, int v) { //在第k个数后面插入一个数v
        rto(k, 0);
        int x;
        int rs = ch[root][1];
        newNode(x, v, root);
        ch[root][1] = x;
        ch[x][1] = rs;
        if(rs) pre[ch[x][1]] = x;
        up(ch[root][1]);
        up(root);
    }
    void move1() {
        int v = erase(all-2);
        insert(0, v);
    }
    void move2() {
        int v = erase(1);
        insert(all-2, v);

    }
    void update(int l, int r, int v) {
        rto(l-1, 0);
        debug();
        rto(r+1, root);
        debug();
        val[KT] += v;
        add[KT] += v;
        up(ch[root][1]);
        up(root);
    }
    void reverse(int l, int r) {
        rto(l-1, 0);
        debug();
        rto(r+1, root);
        debug();
        flip[KT] ^= 1;
        up(ch[root][1]);
        up(root);
    }
    int query() {
        rto(1, 0);
        return val[root];
    }
    void print(int x) {
        printf("node %d: ls=%d rs=%d lsz = %d rsz = %d val = %d\n", x, L, R, sz[L], sz[R], val[x]);
        if(L)print(L);
        if(R)print(R);
    }
    void debug() {
        printf("root = %d\n", root);
         print(root);
    }
}spt;
int main() {
    int ca = 1;
    while(~scanf("%d%d%d%d", &n, &m, &k1, &k2)) {
        if(!m && !n && !k1 && !k2) break;
        char op[111];
        spt.init(n);
      //spt.debug();
        printf("Case #%d:\n", ca++);
        while(m--) {
            scanf("%s", op);
            if(op[0] == ‘q‘) {
                printf("%d\n", spt.query());
                spt.debug();
            }
            if(op[0] == ‘m‘) {
                int kd;
                scanf("%d", &kd);
                if(kd == 1) spt.move1();
                else spt.move2();
                spt.debug();
            }
            if(op[0] == ‘i‘) {
                int v;
                scanf("%d", &v);
                spt.insert(1, v);
                spt.debug();
            }
            if(op[0] == ‘d‘)
                {spt.erase(1);spt.debug();}
            if(op[0] == ‘a‘) {
                int v;
                scanf("%d", &v);
                spt.update(1, k2, v);
                spt.debug();
            }
            if(op[0] == ‘r‘)
                spt.reverse(1, k1);
        }
    }
    return 0;
}