UVA_11922 Permutation Transformer 【splay树】

一、题目

UVA11922

二、分析

为什么会有伸展树？

伸展树与AVL的区别除了保持平衡的方式不同外，最重要的是在每次查找点时，让该点旋转到根结点，这里可以结合计算机里的局部性原理思考。

伸展树有什么优势？

有了伸展树，我们可以根据每次到根节点的值，根据二叉搜索树的性质，可以将整棵树划分成两个部分，左子树的值都比根结点值大，右子树的值都比根结点小。

该题除了伸展树还用到了什么？

该题还需要旋转，所以，需要像线段树的lazy标记一样标记是否需要旋转。

有什么需要注意的地方？

一定注意写法的不同，构建树的范围不同，如果没有定于null数组，则需要将建树范围从$[1,n]$扩为$[0,n]$，因为空指针的sum(表示以该结点为根的树的大小)是不清楚的。

三、AC代码

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

struct Node
{
    Node *ch[2];
    int sum, val;
    int flip;
    Node(int v = 0)
    {
        val = v;
        sum = 1; 
        flip = 0; 
        ch[0] = ch[1] = NULL;
    }
    int cmp(int x)
    {
        int d = x - (ch[0] == NULL ? 0 : ch[0]->sum);
        if(d == 1)  return -1;
        else    return d <= 0 ? 0 : 1;
    }
    void maintain()
    {
        sum = 1;
        if(ch[0] != NULL)   sum += ch[0]->sum;
        if(ch[1] != NULL)   sum += ch[1]->sum;
    }
    void pushdown()
    {
        if(flip) 
        {
            flip = 0;
            swap(ch[0], ch[1]);     //**
            if(ch[0] != NULL)
                ch[0]->flip = !ch[0]->flip;
            if(ch[1] != NULL)
                ch[1]->flip = !ch[1]->flip;
        }
    }
};

void build(Node* &o, int l, int r)
{
    if(l > r)
        return;
    int mid = (l + r) >> 1;
    o = new Node(mid);
    build(o->ch[0], l, mid - 1);
    build(o->ch[1], mid + 1, r);
    o->maintain();
}

void rotate(Node* &o, int d)
{
    Node *k = o->ch[d^1];
    o->ch[d^1] = k->ch[d];
    k->ch[d] = o;
    o->maintain();
    k->maintain();
    o = k;
}


void splay(Node* &o, int k)
{
    o->pushdown();
    int d = o->cmp(k);
    if(d == 1)
        k -= (o->ch[0] == NULL ? 0 : o->ch[0]->sum) + 1;
    //当前结点不是第k个，则需要往上伸展
    if(d != -1)
    {
        Node *p = o->ch[d];
        p->pushdown();

        int d2 = p->cmp(k);
        int k2 = (d2 == 0 ? k : k - (p->ch[0] == NULL ? 0 :p->ch[0]->sum)  - 1);
        if(d2 != -1)
        {
            splay(p->ch[d2], k2);
            //x,x的父节点,x祖父结点三点共线
            if(d == d2) rotate(o, d^1);
            //不共线
            else    rotate(o->ch[d], d);
        }
        rotate(o, d^1);
    }
}


void print(Node* &o)    //一定要传引用
{
    o->pushdown();
    if(o->ch[0] != NULL)    print(o->ch[0]);
    if(o->val)
        printf("%d
", o->val);
    if(o->ch[1] != NULL)    print(o->ch[1]);

    delete o;
    o = NULL;
}

Node* merge(Node* left, Node* right)
{
    //left不能为NULL
    //因为初始化了sum为1，对于空指针的sum，不清楚大小
    //如何避免：建树从0开始，即保证sum>0
    splay(left, left->sum);
    left->ch[1] = right;
    left->maintain();
    return left;
}


void split(Node *o,  int k, Node* &left, Node* &right)
{
    splay(o, k);
    left = o;
    right = o->ch[1];
    o->ch[1] = NULL;
    left->maintain();
}


int main()
{
    //freopen("input.txt", "r", stdin);
    //freopen("out.txt", "w", stdout);
    int N, M, a, b;
    while(scanf("%d %d", &N, &M)==2)
    {
        Node *root = NULL;
        Node *left, *mid, *right, *o;
        //上述模板注意不能用空指针
        //必须从0开始，不然会RE
        build(root, 0, N);

        for(int i = 0; i < M; i++)
        {
            scanf("%d %d", &a, &b);
            //树里面有0所以是a
            split(root, a, left, o);
            split(o, b - a + 1, mid, right);
            mid->flip ^= 1;
            root = merge(merge(left, right), mid);
        }
        print(root);
    }
    return 0;
}