hdu2475 Box splay || 动态树

最新推荐文章于 2019-01-08 08:28:44 发布
最新推荐文章于 2019-01-08 08:28:44 发布
阅读量771 收藏
点赞数
分类专栏： Link-Cut Tree ----------数据结构----------- splay 文章标签： splay 动态树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011645923/article/details/43877373
版权
这篇博客探讨了在HDU2475问题中如何利用splay树和动态树来解决关于盒子嵌套关系的操作。介绍了两种方法，一是通过splay+括号序，解释了如何进行MOVE和QUERY操作，确保括号序列的正确性并保持树的平衡。二是应用Link-Cut Tree，提到了可能导致TLE的问题和解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题意：一开始给定n个盒子的摆的嵌套关系。有两种操作，1.MOVE x y：把编号x的箱子及其包含的箱子放进编号为y的箱子；

2.QUERY x :查询编号x的箱子所在的最靠外的箱子。

方法一：splay+括号序

思路：将全部的树逐个dfs，这样对于每一棵树都可以得到一个括号序列，对于MOVE操作，我们将那个根所在的左右括号的一整段

取出，连接到新的结点的左括号右边，这么做我们可以保证得到的一定也是一个括号序列。我们将x和x+n分别旋根，这样我们可以得到一个x和x+n，x+n是根，x是其左子树的某一个结点，这样x的左子树和x+n的右子树是无效的，我们剪掉它们，并且将x+n的右子树接到x的左子树最后，接着把x+n旋根，保证平衡性。对于QUERY操作，我们直接去找其结点所在的括号序列靠最左边的是谁就可以了。详见代码：

/*********************************************************
  file name: hdu2475.cpp
  author : kereo
  create time:  2015年02月18日 星期三 14时29分43秒
*********************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<cmath>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
const int sigma_size=26;
const int N=100+50;
const int MAXN=100000+50;
const int inf=0x3fffffff;
const double eps=1e-8;
const int mod=1000000000+7;
#define L(x) (x->ch[0])
#define R(x) (x->ch[1])
#define PII pair<int, int>
#define mk(x,y) make_pair((x),(y))
int n,m,edge_cnt,cnt;
char str[N];
int head[MAXN],seq[MAXN],vis[MAXN];
struct Edge{
    int v,next;
}edge[MAXN];
struct node{
    node *fa,*ch[2];
}nod[MAXN],*root,*null;
struct Splay{
    void rotate(node *x,int d){
        node *y=x->fa;
        //push_down(y); push_down(x);
        y->ch[d^1]=x->ch[d];
        if(x->ch[d]!=null)
            x->ch[d]->fa=y;
        x->fa=y->fa;
        if(y->fa!=null){
            int d=y->fa->ch[0] == y ? 0 : 1;
            y->fa->ch[d]=x;
        }
        y->fa=x; x->ch[d]=y;
        //push_up(y);
    }
    void splay(node *x,node *fa){
        while(x->fa!=fa){
            //push_down(x);
            node *y=x->fa;
            if(y->fa == fa){
                int d=y->ch[0] == x ? 1 : 0;
                rotate(x,d);
            }
            else{
                int d=y->fa->ch[0] == y ? 1 : 0;
                if(y->ch[d] == x){
                    rotate(x,d^1); rotate(x,d);
                }
                else{
                    rotate(y,d); rotate(x,d);
                }
            }
        }
        //push_up(x);
        if(fa == null)
            root=x;
    }
    void newnode(node *&x,node *fa,int pos){
        x=&nod[pos];
        x->fa=fa; L(x)=R(x)=null;
    }
    void build(node *&rt,node *fa,int l,int r){
        if(l>r)
            return ;
        int mid=(l+r)>>1;
        newnode(rt,fa,seq[mid]);
        build(L(rt),rt,l,mid-1); build(R(rt),rt,mid+1,r);
        //push_up(rt);
    }
    void init(){
        null=&nod[0];  root=null;
        L(null)=R(null)=null->fa=null;
    }
    void MOVE(int x,int y){
        if(x == y)
            return ;
        splay(&nod[x],null);
        splay(&nod[x+n],&nod[x]);
        node *tmp;
        for(tmp=&nod[y];tmp!=null;tmp=tmp->fa){
            if((&nod[x+n])->ch[0] == tmp)
                return ;
        }
        node *pre=(&nod[x])->ch[0],*suf=(&nod[x+n])->ch[1];
        (&nod[x])->ch[0]=(&nod[x+n])->ch[1]=pre->fa=suf->fa=null;
        if(pre!=null && suf!=null){
            while(L(suf)!=null)
                suf=L(suf);
            pre->fa=suf; L(suf)=pre;
        }
        if(y == 0)
            return ;
        splay(&nod[y],null);
        for(tmp=(&nod[y])->ch[1];L(tmp)!=null;tmp=L(tmp)) ;
        splay(tmp,&nod[y]);
        L(tmp)=&nod[x]; (&nod[x])->fa=tmp;
    }
    int QUERY(int x){
        node *tmp=&nod[x];
        splay(tmp,null);
        for(;L(tmp)!=null;tmp=L(tmp)) ;
        return tmp-nod;
    }
}spt;
void init(){
    edge_cnt=0;
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v){
    edge[edge_cnt].v=v;
    edge[edge_cnt].next=head[u]; head[u]=edge_cnt++;
}
void dfs(int u){
    seq[++cnt]=u;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].v;
        dfs(v);
    }
    seq[++cnt]=u+n;
}
int main(){
    int flag=1;
    //freopen("in.txt","r",stdin);
    while(~scanf("%d",&n)){
        init();
        spt.init();
        if(flag)
            flag=0;
        else 
            printf("\n");
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            if(x == 0)
                vis[i]=1;
            else 
                addedge(x,i);
        }
        for(int i=1;i<=n;i++){
            if(!vis[i])
                continue;
            cnt=0;
            dfs(i);
            spt.build(root,null,1,cnt);
        }
        scanf("%d",&m);
        while(m--){
            scanf("%s",str);
            if(strcmp(str,"MOVE") == 0){
                int x,y;
                scanf("%d%d",&x,&y);
                spt.MOVE(x,y);
            }
            else if(strcmp(str,"QUERY") == 0){
                int x;
                scanf("%d",&x);
                int ans=spt.QUERY(x);
                printf("%d\n",ans);
            }
        }
    }
	return 0;
}


方法二：Link-Cut Tree

思路：参阅《QTREE的一些研究》。tip:注释掉的部分导致TLE的原因：y=x->fa,恰好根是y->fa，且x,y,y->fa为“一字型”,那么会先把根

转下去，那么更新x->par的时候就会出现问题。详见代码：

/*********************************************************
  file name: hdu2475.cpp
  author : kereo
  create time:  2015年02月21日 星期六 10时23分07秒
*********************************************************/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<cmath>
#include<string>
#include<algorithm>
using namespace std;
typedef long long ll;
const int sigma_size=26;
const int N=100+50;
const int MAXN=100000+50;
const int inf=0x3fffffff;
const double eps=1e-8;
const int mod=1000000000+7;
#define L(x) (x->ch[0])
#define R(x) (x->ch[1])
#define PII pair<int, int>
#define mk(x,y) make_pair((x),(y))
int n,m;
char str[N];
struct node{
    node *ch[2],*par,*fa;
}nod[MAXN],*null,*root;
struct LCT{
    void rotate(node *x,int d){
        node *y=x->fa;
        //push_down(y); push_down(x);
        y->ch[d^1]=x->ch[d];
        x->ch[d]->fa=y;
        x->fa=y->fa;
        if(y->fa!=null){
            int d=y->fa->ch[0] == y ? 0 : 1;
            y->fa->ch[d]=x;
        }
        y->fa=x; x->ch[d]=y;
        //push_up(y);
    }
    /*void splay(node *x,node *fa){
        while(x->fa!=fa){
            node *y=x->fa;
            if(y->fa == fa){
                x->par=y->par; y->par=null;
                int d=y->ch[0] == x ? 1 : 0;
                rotate(x,d);
            }
            else{
                int d=y->fa->ch[0] == y ? 1 : 0;
                if(y->ch[d] == x){
                    rotate(x,d^1); rotate(x,d);
                }
                else{
                    rotate(y,d); rotate(x,d);
                }
            }      
        }
        if(fa == null)
            root=x;
    }*/
    node* findroot(node *x){
        while(x->fa!=null)
            x=x->fa;
        return x;
    }
    void splay(node *x,node *fa){
        node *tmp=findroot(x);
        if(x == tmp)
            return ;
        x->par=tmp->par; tmp->par=null;
        while(x->fa!=fa){
            node *y=x->fa;
            if(y->fa == fa){
                int d=y->ch[0] == x ? 1 : 0;
                rotate(x,d);
            }
            else{
                int d=y->fa->ch[0] == y ? 1 : 0;
                if(y->ch[d] == x){
                    rotate(x,d^1); rotate(x,d);
                }
                else{
                    rotate(y,d); rotate(x,d);
                }
            }   
        }
    }
    void Access(node *x){
        node *tmp=null;
        while(x!=null){
            splay(x,null);
            if(R(x)!=null){
                R(x)->fa=null; R(x)->par=x;
            }
            R(x)=tmp;
            if(tmp!=null){
                tmp->fa=x; tmp->par=null;
            }
            tmp=x; x=x->par;
        }
    }
    void Cut(node *x){
        Access(x); splay(x,null);
        if(L(x)!=null){
            L(x)->par=x->par; x->par=null; 
            L(x)->fa=null; L(x)=null;
        }
    }
    void Link(node *x,node *y){
        if(y == null)
            Cut(x);
        else{
            Access(y); splay(y,null);
            node *tmp=findroot(x);
            if(tmp == y)
                return ;
            Cut(x); x->par=y;
            Access(x);
        }
    }
    void init(){
        null=&nod[0]; root=null;
        L(root)=R(root)=root->fa=null;
    }
    void newnode(node *&x,node *fa,node *par,int pos){
        x=&nod[pos];
        x->fa=fa; x->par=par; L(x)=R(x)=null;
    }
    int query(node *x){
        Access(x); splay(x,null);
        while(L(x)!=null)
            x=L(x);
        return x-nod;
    }
}lct;
int main(){
    int flag=1;
    //freopen("in.txt","r",stdin);
    while(~scanf("%d",&n)){
        if(flag)
            flag=0;
        else 
            printf("\n");
        lct.init();
        for(int i=1;i<=n;i++){
            int x;
            scanf("%d",&x);
            lct.newnode(root,null,&nod[x],i);
        }
        //for(int i=1;i<=n;i++)
           // printf("i=%d par=%d fa=%d\n",i,(&nod[i])->par-nod,(&nod[i])->fa-nod);
        scanf("%d",&m);
        while(m--){
            scanf("%s",str);
            if(strcmp(str,"MOVE") == 0){
                int x,y;
                scanf("%d%d",&x,&y);
                lct.Link(&nod[x],&nod[y]);
            }
            else if(strcmp(str,"QUERY") == 0){
                int x;
                scanf("%d",&x);
                int ans=lct.query(&nod[x]);
                printf("%d\n",ans);
            }
        }
    }
	return 0;
}


hdu2846（动态字典树||静态字典树 模板）Repository
.
07-18 2万+
Repository Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 5464    Accepted Submission(s): 1832 Problem Description When you go sho
双调欧几里得旅行商问题 hdu 2224 |hdu 4824 [动态规划]
Tabris的博客
01-16 600
欧几里得旅行商问题是对平面上给定的n个点确定一条连接各点的最短闭合旅程的问题。图a给出了7个点问题的解，这个问题的一般形式是NP完全的,故其解需要多于多项式的时间。　　J.K.Bentley建议通过只考虑双调旅程来简化问题，这种旅程即为从最左点开始，严格从左到最右点，再严格地从最右点回到最左点。图b显示了同样的7个点的问题的最短双调路线，在这种情况下，多项式的时间的算法是有可能的。　　描述一个确定最
HDOJ 题目2475 Box（link cut tree去点找祖先）
Jogging_Clown
08-17 1057
Box Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2374    Accepted Submission(s): 718 Problem Description There are N boxes on t
[HDU2475]Box
Q882199的博客
10-06 193
Problem 先告诉你每个盒子在哪个盒子的内部 接下来有M个操作： 可以把一个盒子及里面的盒子移到另外一个盒子的内部 或者询问你某个盒子最外面的盒子是哪个 Solution 首先可以建成一个图，然后先dfs一遍，用dfs序加入多棵splay 然后移动操作就是区间切割，询问操作就是这棵splay中最小的值 Notice 注意，因为有多棵splay，用0这个虚点连接起来。所以细节非常难处理...
HDU 2475 Box 树型转线型 + 伸展树
weixin_34186950的博客
06-21 145
树型转线型。第一次听说这个概念. . . , 可是曾经已经接触过了，如LCA的预处理部分和树链剖分等。可是没想到还能这么用，三者虽说有不同可是大体思想还是非常相近的，学习了。 推荐博客http://blog.youkuaiyun.com/lyhypacm/article/details/6734748 转成线型之后。就变成了伸展树的模板题。 另外要注意，伸展树的特点是平均时间复杂度接近log(n...
HDU 2475 Box
Occult
02-23 1094
Description There are N boxes on the ground, which are labeled by numbers from 1 to N. The boxes are magical, the size of each one can be enlarged or reduced arbitrarily.  Jack can perform the “MO
hdu2475 Box
生活不易，多才多艺
03-03 411
lct splay lct hdu2475 题意就是有一些盒子相互嵌套 两个操作：move x y： 把x插入到y下面（y等于0就放入最外面）（还要注意非法情况…例如y在x里） query x：查询x所在盒子最大的盒子 就说说lct的做法吧…感觉网上都是splay..然而我还没有仔细看【捂脸】 就把嵌套在一起的盒子建成一棵树...
DP.rar_DP_hdu_动态规划_动态规划 C++
09-20
2. **动态规划分类**：了解常见类型的动态规划问题，如最短路径问题（Floyd-Warshall，Dijkstra，Bellman-Ford等）、背包问题（完全背包，0-1背包，多重背包等）、图论问题（最小生成树，最长路径等）。 3. **C++...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
hdu.rar_hdu
09-23
3. **数据结构**：数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图（邻接矩阵、邻接表、最小生成树、拓扑排序等）。 4. **字符串处理**：KMP算法、Manacher's Algorithm、Rabin-Karp算法等。 5. **...
hdu 2475 Box(伸展树)
绝望的乐园
03-05 890
题意：有一些盒子，盒子里可以放盒子，给出最初的盒子的状态，有两种操作，第一种是将某一个盒子移动到另一个盒子，第二种是查询某个盒子最外边的盒子的编号。 思路:这题看题解看了好久，终于理解了，我真是好弱。。。将给出的盒子建成一些树，盒子中的盒子是它的子树，然后通过dfs可以对每个点编号，第一次访问时为x，第二次为x+n，这样最后就形成了一个序列，[x,x+n]之间为盒子x里的盒子的状况，移动盒子就相
HDU 2475 Box(splay)
weixin_34099526的博客
01-08 147
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2475 题意：给出一棵树，两种操作：（1）修改某棵子树的父节点；（2）查询某个节点的根节点。 思路：每个题目中的箱子看做两个箱子i和i+n，(i,i+n)之间的为在i箱子中的。对于第一种操作，比如将u的父节点改为v，首先将u转到根节点，然后将u+n根节点右孩子，然后u子树就可以被整体切下。然后将另外...
hdu 2475 Box (splay tree)
0o恋蓝o0的专栏
10-09 1076
不错的一道题， 自己怎么也写不出来， 于是去问了风神。 把每个箱子看成一个括号， 箱子a在箱子b里面， 就是括号b在括号a里面。 这样第一组样例就变成了(【1】(【2】)【4】)【3】       (【x】表示第x个节点)， 这样就有序了， 然后装进splay形成一个森林。 0 1 就变成了 (  (  )  ) 1 2 4 3 0 6 4 6 1 0就变成了 (  (    )  )
hdu2475 LCT
江上白衣凌云
09-16 821
题意：给出一堆的盒子和他们的包含关系 ran
hdu2475 Box（splay/lct）
Icefox的博客
03-04 367
这题好神呀。lct做法参见：传送门 这里说说splay做法。我们考虑一棵树的dfs序。进点x的时候记下x，出点x的时候记下x+n。则x的子树就是区间[x,x+n]。则操作1就相当于删除一个区间的数，然后把这一整个区间的数插入一个数的后面。x节点所在的根就是dfs序最前面的那个节点。然后就可以做了，不过需要奇怪的splay姿势【再见】
【hdu2475】Box
wang_sj的博客
04-07 444
There are N boxes on the ground, which are labeled by numbers from 1 to N. The boxes are magical, the size of each one can be enlarged or reduced arbitrarily. Jack can perform the “MOVE x y” operatio
hdu-2475-Box-splay
青竹梦
06-12 1926
伸展树是那么的迷人，总是让你在希望的时候WA，在绝望的时候AC。。。。。 做这个题没有之前，首先要了解树形结构转线性的做法。 推荐连接：http://blog.youkuaiyun.com/lyhypacm/article/details/6734748 本题做法： 对于本题的每一个最外层的盒子建立一颗伸展树。 对于move x y操作： （1）把x为根的子树切下来。 （2）然后把切下来的子树放
HDU 2475 Box [dfs序+splay]
Asuna_acmer
10-23 791
子树操作转DFS序，进而用splay解决。此题TLE了140+发，orz
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值