HDU 2475 Box

最新推荐文章于 2021-04-24 22:26:03 发布
最新推荐文章于 2021-04-24 22:26:03 发布
阅读量1.0k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： HDU ----Splay ----dfs 文章标签： HDU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jtjy568805874/article/details/50722166

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 “MOVE x y” operation to the boxes: take out box x; if y = 0, put it on the ground; Otherwise, put it inside box y. All the boxes inside box x remain the same. It is possible that an operation is illegal, that is, if box y is contained (directly or indirectly) by box x, or if y is equal to x. 
In the following picture, box 2 and 4 are directly inside box 6, box 3 is directly inside box 4, box 5 is directly inside box 1, box 1 and 6 are on the ground. 

The picture below shows the state after Jack performs “MOVE 4 1”: 

Then he performs “MOVE 3 0”, the state becomes: 

During a sequence of MOVE operations, Jack wants to know the root box of a specified box. The root box of box x is defined as the most outside box which contains box x. In the last picture, the root box of box 5 is box 1, and box 3’s root box is itself.
 

Input

Input contains several test cases. 
For each test case, the first line has an integer N (1 <= N <= 50000), representing the number of boxes. 
Next line has N integers: a1, a2, a3, ... , aN (0 <= ai <= N), describing the initial state of the boxes. If ai is 0, box i is on the ground, it is not contained by any box; Otherwise, box i is directly inside box ai. It is guaranteed that the input state is always correct (No loop exists).
Next line has an integer M (1 <= M <= 100000), representing the number of MOVE operations and queries. 
On the next M lines, each line contains a MOVE operation or a query: 
1.  MOVE x y, 1 <= x <= N, 0 <= y <= N, which is described above. If an operation is illegal, just ignore it. 
2.  QUERY x, 1 <= x <= N, output the root box of box x. 
 

Output

For each query, output the result on a single line. Use a blank line to separate each test case.
 

Sample Input

2
0 1
5
QUERY 1
QUERY 2
MOVE 2 0
MOVE 1 2
QUERY 1
6
0 6 4 6 1 0
4
MOVE 4 1
QUERY 3
MOVE 1 4
QUERY 1
 

Sample Output

1
1
2

1
1

 

树形转线形，巧妙的利用dfs序列，然后就是splay维护序列的删除和插入问题了，好题啊。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<functional>
using namespace std;
typedef unsigned long long ull;
typedef long long LL;
const int maxn = 1e5 + 10;
int n, m, l, r, L[maxn], R[maxn], x, root;
char s[20];
vector<int> t[maxn], dfs;

void Scan(int &x)
{
	char ch;
	while ((ch = getchar()) > '9' || ch < '0');
	int res = ch - '0';
	while ((ch = getchar()) <= '9'&&ch >= '0') res = res * 10 + ch - '0';
	x = res;
}

struct Splays
{
	const static int maxn = 2e5 + 10;			//节点个数
	const static int INF = 0x7FFFFFFF;			//int最大值
	int ch[maxn][2], F[maxn], sz;				//左右儿子，父亲节点和节点总个数
	int A[maxn];
	int Node(int f, int a) { A[sz] = a; ch[sz][0] = ch[sz][1] = 0; F[sz] = f; return sz++; }//申请一个新节点
	void clear(){ sz = 1; ch[0][0] = ch[0][1] = F[0] = 0; }//清空操作
	void rotate(int x, int k)
	{
		int y = F[x]; ch[y][!k] = ch[x][k]; 
		if (ch[x][k]) F[ch[x][k]] = y;
		if (F[y]) ch[F[y]][y == ch[F[y]][1]] = x;
		F[x] = F[y];    F[y] = x;	ch[x][k] = y;
	}
	void Splay(int x, int r)
	{
		while (F[x] != r)
		{
			if (F[F[x]] == r) { rotate(x, x == ch[F[x]][0]); return; }
			int y = x == ch[F[x]][0], z = F[x] == ch[F[F[x]]][0];
			y^z ? (rotate(x, y), rotate(x, z)) : (rotate(F[x], z), rotate(x, y));
		}
	}
	void Dfs(int x)
	{
		if (x) dfs.push_back(x);
		for (int i = 0; i < t[x].size(); i++) Dfs(t[x][i]);
		if (x) dfs.push_back(-x);
	}
	void build(int fa, int &x, int l, int r)
	{
		if (l>r) return;
		int mid = l + r >> 1;
		x = Node(fa, dfs[mid]);
		if (dfs[mid] > 0) L[dfs[mid]] = x; else R[-dfs[mid]] = x;
		build(x, ch[x][0], l, mid - 1);
		build(x, ch[x][1], mid + 1, r);
	}
	void build()
	{
		Dfs(0);
		int root;
		for (int i = 0, j = 0, k = 0; i < dfs.size(); i++)
		{
			k += dfs[i]>0 ? 1 : -1;
			if (!k) build(0, root, j, i), j = i + 1;
		}
	}
	int find(int x)
	{
		Splay(L[x], 0);
		for (int i = L[x]; i; i = ch[i][0]) if (!ch[i][0]) { return A[i]; }
	}
	void remove(int x, int y)
	{
		if (x == y) return;
		int l = L[x], r = R[x];
		Splay(l, 0);	Splay(r, l);

		int ll = ch[l][0], rr = ch[r][1], z = 0;
		for (int i = ll; i; i = ch[i][1]) if (!ch[i][1]) { z = i; break; }
		ch[l][0] = ch[r][1] = 0;
		F[ll] = F[rr] = 0;
		if (z) ch[z][1] = rr;	F[rr] = z;
		if (!y) return;
		if (find(y) == x) { ch[l][0] = ll;	ch[r][1] = rr; F[ll] = l; F[rr] = r; ch[z][1] = 0; return; }
		
		Splay(L[y], 0);	for (int i = ch[L[y]][1]; i; i = ch[i][0]) if (!ch[i][0]) { Splay(i, L[y]); break; }
		ch[ch[L[y]][1]][0] = l;	F[l] = ch[L[y]][1];
	}
}solve;


int main()
{
	int tt = 0;
	while (scanf("%d", &n) != EOF)
	{
		if (tt++) printf("\n");
		solve.clear();	dfs.clear();
		for (int i = 0; i <= n; i++) t[i].clear();
		for (int i = 1; i <= n; i++) Scan(x),t[x].push_back(i);
		solve.build();
		scanf("%d", &m);
		while (m--)
		{
			scanf("%s", s);
			if (s[0] == 'Q') Scan(x), printf("%d\n", solve.find(x));
			else Scan(l), Scan(r), solve.remove(l, r);
		}
	}
	return 0;
}

此题对于splay删除的处理有挺多坑的，调了好久终于算是理清楚了，一定要注意细节。。这两个版本删除操作不同
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<functional>
using namespace std;
typedef unsigned long long ull;
typedef long long LL;
const int maxn = 1e5 + 10;
int n, m, l, r, L[maxn], R[maxn], x, root;
char s[20];
vector<int> t[maxn], dfs;

void Scan(int &x)
{
	char ch;
	while ((ch = getchar()) > '9' || ch < '0');
	int res = ch - '0';
	while ((ch = getchar()) <= '9'&&ch >= '0') res = res * 10 + ch - '0';
	x = res;
}

struct Splays
{
	const static int maxn = 2e5 + 10;			//节点个数
	const static int INF = 0x7FFFFFFF;			//int最大值
	int ch[maxn][2], F[maxn], sz;				//左右儿子，父亲节点和节点总个数
	int A[maxn];
	int Node(int f, int a) { A[sz] = a; ch[sz][0] = ch[sz][1] = 0; F[sz] = f; return sz++; }//申请一个新节点
	void clear(){ sz = 1; ch[0][0] = ch[0][1] = F[0] = 0; }//清空操作
	void rotate(int x, int k)
	{
		int y = F[x]; ch[y][!k] = ch[x][k]; 
		if (ch[x][k]) F[ch[x][k]] = y;
		if (F[y]) ch[F[y]][y == ch[F[y]][1]] = x;
		F[x] = F[y];    F[y] = x;	ch[x][k] = y;
	}
	void Splay(int x, int r)
	{
		while (F[x] != r)
		{
			if (F[F[x]] == r) { rotate(x, x == ch[F[x]][0]); return; }
			int y = x == ch[F[x]][0], z = F[x] == ch[F[F[x]]][0];
			y^z ? (rotate(x, y), rotate(x, z)) : (rotate(F[x], z), rotate(x, y));
		}
	}
	void Dfs(int x)
	{
		if (x) dfs.push_back(x);
		for (int i = 0; i < t[x].size(); i++) Dfs(t[x][i]);
		if (x) dfs.push_back(-x);
	}
	void build(int fa, int &x, int l, int r)
	{
		if (l>r) return;
		int mid = l + r >> 1;
		x = Node(fa, dfs[mid]);
		if (dfs[mid] > 0) L[dfs[mid]] = x; else R[-dfs[mid]] = x;
		build(x, ch[x][0], l, mid - 1);
		build(x, ch[x][1], mid + 1, r);
	}
	void build()
	{
		Dfs(0);
		int root;
		for (int i = 0, j = 0, k = 0; i < dfs.size(); i++)
		{
			k += dfs[i]>0 ? 1 : -1;
			if (!k) build(0, root, j, i), j = i + 1;
		}
	}
	int find(int x)
	{
		Splay(L[x], 0);
		for (int i = L[x]; i; i = ch[i][0]) if (!ch[i][0]) { return A[i]; }
	}
	void remove(int x, int y)
	{
		if (x == y) return;
		int l = L[x], r = R[x];
		Splay(l, 0);	Splay(r, l);

		int ll = ch[l][0], rr = ch[r][1], lr = 0, rl = 0;

		for (int i = ll; i; i = ch[i][1]) if (!ch[i][1]) { lr = i; break; }
		for (int i = rr; i; i = ch[i][0]) if (!ch[i][0]) { rl = i; break; }
		
		int g = l;
		if (lr) { Splay(lr, 0);	Splay(rl, lr); g = ch[rl][0]; F[g] = ch[rl][0] = 0; }
		if (!y) return;
		if (find(y) == x){ Splay(g, 0); F[g] = rl;	ch[rl][0] = g; return; }
		Splay(L[y], 0);	for (int i = ch[L[y]][1]; i; i = ch[i][0]) if (!ch[i][0]) { Splay(i, L[y]); break; }
		ch[ch[L[y]][1]][0] = g;	F[g] = ch[L[y]][1];
	}
}solve;


int main()
{
	int tt = 0;
	while (scanf("%d", &n) != EOF)
	{
		if (tt++) printf("\n");
		solve.clear();	dfs.clear();
		for (int i = 0; i <= n; i++) t[i].clear();
		for (int i = 1; i <= n; i++) Scan(x),t[x].push_back(i);
		solve.build();
		scanf("%d", &m);
		while (m--)
		{
			scanf("%s", s);
			if (s[0] == 'Q') Scan(x), printf("%d\n", solve.find(x));
			else Scan(l), Scan(r), solve.remove(l, r);
		}
	}
	return 0;
}
先建树的速度要快很多，如果连初始状态也模拟的话不加读入挂就超时了
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<functional>
using namespace std;
typedef unsigned long long ull;
typedef long long LL;
const int maxn = 1e5 + 10;
int n, m, l, r, L[maxn], R[maxn], x, root;
char s[20];

void Scan(int &x)
{
	char ch;
	while ((ch = getchar()) > '9' || ch < '0');
	int res = ch - '0';
	while ((ch = getchar()) <= '9'&&ch >= '0') res = res * 10 + ch - '0';
	x = res;
}

struct Splays
{
	const static int maxn = 2e5 + 10;			//节点个数
	const static int INF = 0x7FFFFFFF;			//int最大值
	int ch[maxn][2], F[maxn], sz;				//左右儿子，父亲节点和节点总个数
	int A[maxn];
	int Node(int f, int a) { A[sz] = a; ch[sz][0] = ch[sz][1] = 0; F[sz] = f; return sz++; }//申请一个新节点
	void clear(){ sz = 1; ch[0][0] = ch[0][1] = F[0] = 0; }//清空操作
	void rotate(int x, int k)
	{
		int y = F[x]; ch[y][!k] = ch[x][k];
		if (ch[x][k]) F[ch[x][k]] = y;
		if (F[y]) ch[F[y]][y == ch[F[y]][1]] = x;
		F[x] = F[y];    F[y] = x;	ch[x][k] = y;
	}
	void Splay(int x, int r)
	{
		while (F[x] != r)
		{
			if (F[F[x]] == r) { rotate(x, x == ch[F[x]][0]); return; }
			int y = x == ch[F[x]][0], z = F[x] == ch[F[F[x]]][0];
			y^z ? (rotate(x, y), rotate(x, z)) : (rotate(F[x], z), rotate(x, y));
		}
	}
	void build(int x)
	{
		L[x] = Node(0, x);
		R[x] = ch[L[x]][1] = Node(L[x], x);
	}
	int find(int x)
	{
		Splay(L[x], 0);
		for (int i = L[x]; i; i = ch[i][0]) if (!ch[i][0]) { return A[i]; }
	}
	void remove(int x, int y)
	{
		if (x == y) return;
		int l = L[x], r = R[x];
		Splay(l, 0);	Splay(r, l);

		int ll = ch[l][0], rr = ch[r][1], lr = 0, rl = 0;

		for (int i = ll; i; i = ch[i][1]) if (!ch[i][1]) { lr = i; break; }
		for (int i = rr; i; i = ch[i][0]) if (!ch[i][0]) { rl = i; break; }

		int g = l;
		if (lr) { Splay(lr, 0);	Splay(rl, lr); g = ch[rl][0]; F[g] = ch[rl][0] = 0; }
		if (!y) return;
		if (find(y) == x){ Splay(g, 0); F[g] = rl;	ch[rl][0] = g; return; }
		Splay(L[y], 0);	for (int i = ch[L[y]][1]; i; i = ch[i][0]) if (!ch[i][0]) { Splay(i, L[y]); break; }
		ch[ch[L[y]][1]][0] = g;	F[g] = ch[L[y]][1];
	}
}solve;


int main()
{
	int tt = 0;
	while (scanf("%d", &n) != EOF)
	{
		if (tt++) printf("\n");
		solve.clear();	
		for (int i = 1; i <= n; i++) solve.build(i);
		for (int i = 1; i <= n; i++) Scan(x), solve.remove(i, x);
		scanf("%d", &m);
		while (m--)
		{
			scanf("%s", s);
			if (s[0] == 'Q') Scan(x), printf("%d\n", solve.find(x));
			else Scan(l), Scan(r), solve.remove(l, r);
		}
	}
	return 0;
}


bfs hdu 1732 push the box
Mr.CJ
02-26 662
http://acm.hdu.edu.cn/showproblem.php?pid=1732 #include #include #include #include using namespace std; /* 和hdu 1254相比这题虽然3个箱子，但是求人的最少路径只要一个bfs就可以， 只要标记量开8维数组，注意一下推箱子的过程就可以了 注意题意：虽说@表示hole，但是可
夜深人静写算法（十）- 广度优先搜索
热门推荐
英雄哪里出来
01-12 7万+
寻路算法的鼻祖---广度优先搜索
HDOJ 题目2475 Box（link cut tree去点找祖先）
Jogging_Clown
08-17 1061
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
wang_sj的博客
04-07 450
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
[HDU2475]Box
Q882199的博客
10-06 196
Problem 先告诉你每个盒子在哪个盒子的内部 接下来有M个操作： 可以把一个盒子及里面的盒子移到另外一个盒子的内部 或者询问你某个盒子最外面的盒子是哪个 Solution 首先可以建成一个图，然后先dfs一遍，用dfs序加入多棵splay 然后移动操作就是区间切割，询问操作就是这棵splay中最小的值 Notice 注意，因为有多棵splay，用0这个虚点连接起来。所以细节非常难处理...
hdu-2475-Box-splay
青竹梦
06-12 1931
伸展树是那么的迷人，总是让你在希望的时候WA，在绝望的时候AC。。。。。 做这个题没有之前，首先要了解树形结构转线性的做法。 推荐连接：http://blog.csdn.net/lyhypacm/article/details/6734748 本题做法： 对于本题的每一个最外层的盒子建立一颗伸展树。 对于move x y操作： （1）把x为根的子树切下来。 （2）然后把切下来的子树放
hdu2475 Box
生活不易，多才多艺
03-03 420
lct splay lct hdu2475 题意就是有一些盒子相互嵌套 两个操作：move x y： 把x插入到y下面（y等于0就放入最外面）（还要注意非法情况…例如y在x里） query x：查询x所在盒子最大的盒子 就说说lct的做法吧…感觉网上都是splay..然而我还没有仔细看【捂脸】 就把嵌套在一起的盒子建成一棵树...
3d camera hdu2693
05-15
You are given a 3D rectangular box. You are also given the location of a 3D camera, which is looking down onto the box. The camera can only view the box in 2D. More specifically, the camera can only ...
HDU-1560 DNA sequence【构造答案+IDA*剪枝】
qq_41201328的博客
04-24 284
题目大意: 给N个字符串，求一个最短序列能否将N个字符串包含。输出最短序列的长度。 思路： 可以构造一个最短序列，然后判断能否将所有序列包含进去。然后用IDA*剪枝（这到没错）。构造的过程并不复杂，因为只涉及4个碱基。再有就是回溯的问题，这里需要对每个字符串设置一个指针，用于判断包含关系。最后的包含关系肯定是所有字符串的指针都走到了最后一个元素。可以用数组来存每个字符串当前的指针位置，但是每个状态有不一样，这里可以用一个数组参数传递到下一个状态上，这样就避免了回溯麻烦的问题产生。 反思： 这个构造确实巧妙，
ACM-尼姆博弈之John——hdu1907
继续激情，继续奋斗。
05-02 4916
ACM 尼姆博弈 John hdu1907
hdu 2475 Box(伸展树)
绝望的乐园
03-05 894
题意：有一些盒子，盒子里可以放盒子，给出最初的盒子的状态，有两种操作，第一种是将某一个盒子移动到另一个盒子，第二种是查询某个盒子最外边的盒子的编号。 思路:这题看题解看了好久，终于理解了，我真是好弱。。。将给出的盒子建成一些树，盒子中的盒子是它的子树，然后通过dfs可以对每个点编号，第一次访问时为x，第二次为x+n，这样最后就形成了一个序列，[x,x+n]之间为盒子x里的盒子的状况，移动盒子就相
hdu2475 Box（splay/lct）
Icefox的博客
03-04 372
这题好神呀。lct做法参见：传送门 这里说说splay做法。我们考虑一棵树的dfs序。进点x的时候记下x，出点x的时候记下x+n。则x的子树就是区间[x,x+n]。则操作1就相当于删除一个区间的数，然后把这一整个区间的数插入一个数的后面。x节点所在的根就是dfs序最前面的那个节点。然后就可以做了，不过需要奇怪的splay姿势【再见】
HDU 2475 Box 树型转线型 + 伸展树
weixin_34186950的博客
06-21 149
树型转线型。第一次听说这个概念. . . , 可是曾经已经接触过了，如LCA的预处理部分和树链剖分等。可是没想到还能这么用，三者虽说有不同可是大体思想还是非常相近的，学习了。 推荐博客http://blog.csdn.net/lyhypacm/article/details/6734748 转成线型之后。就变成了伸展树的模板题。 另外要注意，伸展树的特点是平均时间复杂度接近log(n...
hdu 2475 Box (splay tree)
0o恋蓝o0的专栏
10-09 1082
不错的一道题， 自己怎么也写不出来， 于是去问了风神。 把每个箱子看成一个括号， 箱子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 827
题意：给出一堆的盒子和他们的包含关系 ran
HDU 2475 Box [dfs序+splay]
Asuna_acmer
10-23 795
子树操作转DFS序，进而用splay解决。此题TLE了140+发，orz
hdu2475 BOX(splay+dfs序)
Rec.的博客
11-09 348
hdu 2475 box
HDU 2475 Box(splay)
weixin_34099526的博客
01-08 150
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2475 题意：给出一棵树，两种操作：（1）修改某棵子树的父节点；（2）查询某个节点的根节点。 思路：每个题目中的箱子看做两个箱子i和i+n，(i,i+n)之间的为在i箱子中的。对于第一种操作，比如将u的父节点改为v，首先将u转到根节点，然后将u+n根节点右孩子，然后u子树就可以被整体切下。然后将另外...
ACM HDU题目分类概要
"该资源是关于ACM竞赛中HDU（杭州电子科技大学在线评测系统）题目的分类，包含了从1001到1087的题目简介，涵盖了各种算法和编程技巧，如搜索、动态规划、贪心、数学、字符串处理等。" 在ACM HDU题目分类中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值