hdu2475Box(splay树形转线性）

链接

推荐一篇帖子

http://blog.csdn.net/lyhypacm/article/details/6734748

这题暴力不可行主要是因为这颗树可能极度不平衡，不能用并查集是不能路径压缩，这样时间复杂度是很高的。

可以用伸展树主要是因为它的伸展性，每次操作后可以通过伸展使这棵树更好的保持平衡。

这题还是值得记录一下的，从早上做到了晚上，

第一次错误，定义了全局的n以及局部的n使得取得结果不正确，以后还是统一习惯，要么写在全局要么写在局部。

第二次错误，vector初始化没有初始到0导致后面的数据跑不动，以后初始化的操作都从0开始。

第三次错误，debug了n久，建树的时候误把根节点的父亲节点写成了根，应该是0，自以为不会出错的地方也要认真检查。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
#include<stack>
using namespace std;
#define N 100010
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
int n,po[N];
vector<int>ed[N];
vector<int>dd;

struct splay_tree
{
    int pre[N];
    int ch[N][2];
    int root,tot,num;
    int key[N];
//    void dfs(int x)
//    {
//        if(x)
//        {
//            dfs(ch[x][0]);
//            printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size=%2d,key=%2d
",
//                   x,ch[x][0],ch[x][1],pre[x],size[x],key[x]);
//            dfs(ch[x][1]);
//        }
//    }
//    void debug()
//    {
//        printf("root:%d
",root);
//        dfs(root);
//    }
//以上用于debug*/
    void newnode(int &x,int v,int fa)//新建一结点
    {
        x = ++tot;
        ch[x][0]=ch[x][1] = 0;
        pre[x] = fa;
        key[x] = v;
        po[v] = x;
    }
    void pushup(int w)//由儿子更新其父亲
    {
    }
    void rotate(int r,int kind)//旋转操作，根据kind进行左旋和右旋
    {
        int y = pre[r];
        ch[y][!kind] = ch[r][kind];
        pre[ch[r][kind]] = y;
        if(pre[y])
        {
            ch[pre[y]][ch[pre[y]][1]==y] = r;
        }
        pre[r] = pre[y];
        ch[r][kind] = y;
        pre[y] = r;
        pushup(y);
        pushup(r);
    }
    void splay(int r,int goal)//将r结点旋至goal下
    {
        while(pre[r]!=goal)
        {
            if(pre[pre[r]]==goal)
            {
                rotate(r,ch[pre[r]][0]==r);
            }
            else
            {
                int y = pre[r];
                int kind = (ch[pre[y]][0]==y);
                if(ch[y][kind]==r)
                {
                    rotate(r,!kind);
                    rotate(r,kind);
                }
                else
                {
                    rotate(y,kind);
                    rotate(r,kind);
                }
            }
        }
        pushup(r);
        if(goal==0) root = r;
    }
    int get_min(int x)
    {
        while(ch[x][0])
            x =  ch[x][0];
        return x;
    }
    int get_max(int x)
    {
        while(ch[x][1])
            x = ch[x][1];
        return x;
    }
    void update(int x,int y) //更新区间信息
    {
        int l = po[x],r = po[x+n];
        splay(l,0);
        splay(r,0);
        int ll = ch[l][0];
        int rr = ch[r][1];
        pre[ll] = pre[rr] = 0;
        ch[r][1] = ch[l][0] = 0;

        int tll = get_max(ll);
        if(tll!=0)
            ch[tll][1] = rr;
        pre[rr] = tll;

        if(y==0) return ;
        if(query(y)==x)
        {
            ch[r][1] = rr;
            ch[l][0] = ll;
            pre[ll] = l;
            pre[rr] = r;
            ch[tll][1] = 0;
            pre[0] = 0;
            return ;
        }

        if(rr!=0) splay(rr,0);
        int tt = po[y];
        splay(tt,0);
        int tq = get_min(ch[tt][1]);
        splay(tq,tt);
        ch[tq][0] = r;
        pre[r] = tq;
    }
    int query(int x)//询问l,r区间，将第l-1个结点旋自根，第r+1个结点旋自根的有儿子，
    {
        splay(po[x],0);
        int k = get_min(po[x]);
        return key[k];
    }
    void build(int &x,int l,int r,int fa)
    {
        int m = (l+r)>>1;
        if(l>r) return ;
        newnode(x,dd[m],fa);
        build(ch[x][0],l,m-1,x);
        build(ch[x][1],m+1,r,x);
        pushup(x);
    }
    void init()
    {
        root = tot = 0;
        memset(ch,0,sizeof(ch));
        memset(pre,0,sizeof(pre));
        memset(key,0,sizeof(key));
        memset(po,0,sizeof(po));
    }
} SP;
void dfs(int u)
{
    int i;
    dd.push_back(u);
    for(i = 0; i  < ed[u].size(); i++)
    {
        int v = ed[u][i];
        dfs(v);
    }
    dd.push_back(u+n);
}
int main()
{
    int i;
    int q;
    int mark = false;
    while(scanf("%d",&n)!=EOF)
    {
        if(mark)
            puts("");
        else
            mark = true;
        SP.init();
        for(i = 0; i <= n; i++)
        {
            ed[i].clear();
        }
        dd.clear();
        for(i = 1; i <= n; i++)
        {
            int x;
            scanf("%d",&x);
            ed[x].push_back(i);
        }
        dfs(0);
        int o = 1;
        scanf("%d",&q);
        stack<int>st;
        for(i = 1 ; i < dd.size()-1 ; i++)
        {
            int x = dd[i];
            if(x<=n) st.push(x);
            else st.pop();
            if(st.empty())
            {
                SP.build(SP.root,o,i,0);
                o = i+1;
            }
        }
        int stt = 1;
        while(q--)
        {
            char sq[100];
            int x,y;
            scanf("%s",sq);
            if(sq[0]=='Q')
            {
                scanf("%d",&x);
                printf("%d
",SP.query(x));
            }
            else
            {
                scanf("%d%d",&x,&y);
                SP.update(x,y);
            }
        }
    }
    return 0;
}