HDU3436

最新推荐文章于 2016-09-19 00:32:13 发布
最新推荐文章于 2016-09-19 00:32:13 发布
阅读量775 收藏
点赞数
分类专栏： 数据结构_伸展树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scut_pein/article/details/18961423
版权 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#define N 100015
#define inf 1<<29
#define LL long long
#define Key_value ch[ch[root][1]][0]
using namespace std;
int n,q,p[N],cnt,s[2*N],e[2*N],ope[N];
int node[2*N];
char str[N][10];
int root,tot,size[2*N],key[2*N],pre[2*N],ch[2*N][2],num[2*N];
//debug部分COPY自HH
void Treaval(int x) {  
    if(x) {  
        Treaval(ch[x][0]);  
        printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d size = %2d ,key = %2d   num= %2d \n",x,ch[x][0],ch[x][1],pre[x],size[x],key[x],num[x]);  
        Treaval(ch[x][1]);  
    }  
}  
void debug() {printf("%d\n",root);Treaval(root);}   
void Push_Up(int r){
	size[r]=size[ch[r][0]]+size[ch[r][1]]+num[r];
}
void NewNode(int &r,int father,int k){
	r=++tot;
	pre[r]=father;
	size[r]=e[k]-s[k]+1;
	num[r]=e[k]-s[k]+1;
	key[r]=k;
	node[k]=r;
	ch[r][0]=ch[r][1]=0;
}
void Bulid(int &x,int l,int r,int father){
	if(l>r)
		return;
	int mid=(l+r)/2;
	NewNode(x,father,mid);
	Bulid(ch[x][0],l,mid-1,x);
	Bulid(ch[x][1],mid+1,r,x);
	Push_Up(x);
}
void Rotate(int x,int kind){  
	int y=pre[x];    
	ch[y][!kind]=ch[x][kind];   
	pre[ch[x][kind]]=y;  
	if(pre[y])  
		ch[pre[y]][ch[pre[y]][1]==y]=x;  
	pre[x]=pre[y];  
	ch[x][kind]=y;  
	pre[y]=x;  
	Push_Up(y);  
}   
void Splay(int r,int 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);  
			}  
		}  
	}  
	Push_Up(r);  
	if(goal==0) root=r;  
} 
int Bin(int x){   //离散化中，二分查找
	int low=0,high=cnt-1,mid;
	while(low<=high){
		mid=(low+high)>>1;
		if(s[mid]<=x&&e[mid]>=x)
			return mid;
		if(e[mid]<x)
			low=mid+1;
		else
			high=mid-1;
	}
}
int Get_Min(int r){
	while(ch[r][0]){
		r=ch[r][0];
	}
	return r;
}
void Delete(){
	int k=Get_Min(ch[root][1]);  //找到右孩子中最小的
	Splay(k,root);   //旋转过来，使得右子树没有左孩子
	ch[ch[root][1]][0]=ch[root][0];   //将原来的左孩子给右子树作为左孩子
	root=ch[root][1];   //让右孩子为根
	pre[ch[root][0]]=root;   
	pre[root]=0;
	Push_Up(root);
}
void Insert(int &r,int k,int father){
	if(r==0){
		NewNode(r,father,k);
		return;
	}
	Insert(ch[r][0],k,r);  //因为是插入到队首，担心一直往左子树找
	Push_Up(r);
}
void Top(int x){
	int k=Bin(x);
	int y=node[k];  //找到这个人所在区间的标号
	Splay(y,0);   //旋转至根部
	if(!ch[root][0]||!ch[root][1]){   //左右孩子不完整，直接将孩子拉到根部
		root=ch[root][0]+ch[root][1];
		pre[root]=0;
	}
	else
		Delete();  //删除节点
	Insert(root,k,0);  //再插入
	Splay(tot,0);   //旋转至根部,这步不加会TLE
}
int Get_Rank(int x){
	int k=Bin(x);
	int y=node[k];
	Splay(y,0);
	return size[ch[root][0]]+1;
}
int Get_Kth(int r,int k){
	int t=size[ch[r][0]];
	if(k<=t)
		return Get_Kth(ch[r][0],k);
	else if(k<=t+num[r])
		return s[key[r]]+(k-t)-1;
	else
		return Get_Kth(ch[r][1],k-t-num[r]);
}
void slove(){
	for(int i=0;i<q;i++){
		if(str[i][0]=='T')
			Top(ope[i]);
		else if(str[i][0]=='Q')
			printf("%d\n",Get_Rank(ope[i]));
		else
			printf("%d\n",Get_Kth(root,ope[i]));
	}
}
int main(){
	int t,cas=0;
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&q);
		//将所有TOP和QUERY操作的点进行离散化，将中间不变的区间缩成点
		int total=0;
		p[total++]=0;
		for(int i=0;i<q;i++){
			scanf("%s%d",str[i],&ope[i]);
			if(str[i][0]=='T'||str[i][0]=='Q')
				p[total++]=ope[i];
		}
		p[total++]=n;
		sort(p,p+total);
		cnt=0;
		//进行离散化，s[i]表示区间起点，e[i]表示区间终点
		for(int i=1;i<total;i++)
			if(p[i]!=p[i-1]){
				if(p[i]-p[i-1]>1){   //中间的区间
					s[cnt]=p[i-1]+1;
					e[cnt]=p[i]-1;
					cnt++;
				}
				s[cnt]=p[i];   //端点
				e[cnt]=p[i];
				cnt++;
			}
		root=tot=0;	
		ch[root][0]=ch[root][1]=pre[root]=size[root]=num[root]=key[root]=0;
		Bulid(root,0,cnt-1,0);  //建树
		printf("Case %d:\n",++cas);
		slove();
	}
	return 0;
}



风格更新后：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define inf 0x3f3f3f3f
#define maxn 200010
#define LL long long int
#define Key_value ch[ch[root][1]][0]
char str[maxn][10];
int ope[maxn],ccnt;

struct SplayTree
{
	int pre[maxn],ch[maxn][2],size[maxn],key[maxn],num[maxn],e[maxn],s[maxn],p[maxn],node[maxn],root,cnt;
	
	void init(int n,int q)
	{
		int total = 0;
		p[total++] = 0;
		for(int i = 0;i < q;i++)
		{
			scanf("%s%d",str[i],&ope[i]);
			if(str[i][0] == 'T' || str[i][0] == 'Q')
				p[total++] = ope[i];
		}
		p[total++] = n;
		sort(p,p+total);
		ccnt = 0;
		for(int i = 1;i < total;i++)
		{
			if(p[i] != p[i-1])
			{
				if(p[i] - p[i-1] > 1)
				{
					s[ccnt] = p[i-1] + 1;
					e[ccnt] = p[i] - 1;
					ccnt++;
				}
				s[ccnt] = p[i];
				e[ccnt] = p[i];
				ccnt++;
			}
		}

		root = cnt = 0;
		pre[0] = ch[0][0] = ch[0][1] = 0;
		size[0] = key[0] = num[0] = 0;
		BuildTree(root,0,ccnt-1,0);
	}
	
	void BuildTree(int & x,int l,int r,int father)
	{
		if(l > r)	return;
		int mid = (l+r) >> 1;
		NewNode(x,father,mid);
		if(l < mid)
			BuildTree(ch[x][0],l,mid-1,x);
		if(r > mid)
			BuildTree(ch[x][1],mid+1,r,x);
		PushUp(x);
	}

	void NewNode(int & r,int father,int k)
	{
		r = ++cnt;
		pre[r] = father;
		ch[r][0] = ch[r][1] = 0;
		size[r] = e[k] - s[k] + 1;
		num[r] = e[k] - s[k] + 1;
		key[r] = k;
		node[k] = r;
	}

	void PushUp(int r)
	{
		size[r] = size[ch[r][0]] + size[ch[r][1]] + num[r];
	}

	void Rotate(int x,int kind)
	{
		int y = pre[x];
		ch[y][!kind] = ch[x][kind];
		pre[ch[x][kind]] = y;
		if(pre[y])
			ch[pre[y]][ch[pre[y]][1]==y] = x;
		pre[x] = pre[y];
		ch[x][kind] = y;
		pre[y] = x;
		PushUp(y);
	}

	void Splay(int r,int goal)
	{
		while(pre[r] != goal)
		{
			int y = pre[r],z = pre[y];
			if(pre[pre[r]] == goal)
			{
				Rotate(r,ch[pre[r]][0] == r);
			}
			else
			{
				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 Bin(int x)
	{
		int low = 0,high = ccnt - 1,mid;
		while(low <= high)
		{
			mid = (low + high) >> 1;
			if(s[mid] <= x && e[mid] >= x)
				return mid;
			if(e[mid] < x)
				low = mid + 1;
			else high = mid - 1;
		}
	}

	void RotateTo(int k,int goal)
	{
		int r = root;
		while(1)
		{
			if(k == size[ch[r][0]] + 1)
				break;
			if(k <= size[ch[r][0]])
				r = ch[r][0];
			else
			{
				k -= size[ch[r][0]] + 1;
				r = ch[r][1];
			}
		}
		Splay(r,goal);
	}

	void del_root()
	{
		int t = root;
		if(ch[root][1])
		{
			root = ch[root][1];
			RotateTo(1,0);
			ch[root][0] = ch[t][0];
			if(ch[t][0])	pre[ch[t][0]] = root;
		}
		else root = ch[root][0];
		pre[root] = 0;
		PushUp(root);
	}

	void Insert(int & r,int k,int father)
	{
		if(r == 0)
		{
			NewNode(r,father,k);
			return;
		}
		Insert(ch[r][0],k,r);
		PushUp(r);
	}

	void Top(int x)
	{
		int k = Bin(x);
		int y = node[k];
		Splay(y,0);
		del_root();
		Insert(root,k,0);
		Splay(cnt,0);
	}

	int Get_Rank(int x)
	{
		int k = Bin(x);
		int y = node[k];
		Splay(y,0);
		return size[ch[root][0]] + 1;
	}
	
	int Get_Kth(int r,int k)
	{
		int t = size[ch[r][0]];
		if(k <= t)
			return Get_Kth(ch[r][0],k);
		else if(k <= t + num[r])
			return s[key[r]] + (k-t) - 1;
		else return Get_Kth(ch[r][1],k-t-num[r]);
	}

	void solve(int n,int q)
	{
		init(n,q);
		for(int i = 0;i < q;i++)
		{
			if(str[i][0] == 'T')
				Top(ope[i]);
			else if(str[i][0] == 'Q')
				printf("%d\n",Get_Rank(ope[i]));
			else printf("%d\n",Get_Kth(root,ope[i]));
		}
	}
}spt;

int main()
{
	//freopen("in.txt","r",stdin);
	int t,cas = 0;
	scanf("%d",&t);
	while(t--)
	{
		int n,q;
		scanf("%d%d",&n,&q);
		printf("Case %d:\n",++cas);
		spt.solve(n,q);
	}
	return 0;
}


SCUT_Pein
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 3436 Queue-jumpers (无旋treap)
shadiao.的博客
11-09 193
题目传送门（HDU3436） 解题思路 题目的意思是位于一个[1,n]的序列有三种操作，操作一把一个数放到队首，操作二询问某个数现在的位置，操作三询问现在排名为k的数是谁 Part I 口胡 （第一部分可以跳过） 一开始的愚蠢思路是这样的： 用一棵平衡树T1维护进行过top操作的数的序列，另一棵平衡树T2维护top操作过的数的值排序 ①每次top，如果这个数在T1中，找出他的排名，然...
C++ HDU 2000
09-15
#include using namespace std; int main(){ char a[2]; while(cin>>a){ int temp; for(int i=0; i; i++) for(int j=0;j;j++) if(a[i]>a[i+1]) { temp=a[i]; a[i]=a[i+1]; a[i+1]=temp;...}
HDU 3436 Queue-jumpers (Splay tree)
java开发指南博客 【转载】
07-30 103
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 三种操作RANK,TOP,QUERY。尼玛一看，N的范围10^8，必定要离散化。 仔细分析3种操作： RANK就是找出第K位是多少 TOP是将某个人移至队首，对中间区间没有影响 QUERY是某个人的位置 可以发现将QUERY和TOP操作的点...
hdu 3436
weixin_30697239的博客
09-09 95
一开始，直接无脑的对n数组维护。打完之后一看n的范围，默默的删了。 一看范围，就知道要先读进来询问，把涉及到的x做一个统计，这样n的数组 1,2,...,n (1,x0-1),x0,(x0+1,x1),x1,...,n 这样子就缩好了（一个节点是一个区间）。记录每个节点的起始数。 统计的信息，区间和（即数的个数）。 这样三个操作都能写啦。 1 #incl...
hdu 3436 Queue-jumpers
java开发指南博客 【转载】
07-14 109
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3436 题目思路：splay,也可以用线段树或树状数组，主要难点在离散化，这个离散化是把点和点这间的区间都离散化，离散化后的点要保存原来区间的长度和起始点等信息，这样就可用splay模拟了，top操作可以先删点再插入，也可以将要删的点伸展到根结点，然后将它的左子树接到它后继的左边，这样它便成为整棵树最...
hdu3436 Queue-jumpers(Splay)
weixin_30335353的博客
05-17 64
Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3411Accepted Submission(s): 923 Problem Description Ponyo and Garfield a...
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
HDU 3436 题解
ez_yww的博客
07-06 344
有一个队列，开始时第i个数是i。 有三种操作。 Top x：把x放到队头。 Query x：查询x是第几个数。 Rank x：查询第x个数。
【Splay】【离散化】hdu3436 Queue-jumpers
每天心塞一点点
02-25 769
写的最恶心的一个离散化orz……splay的操作其实很简单 用treap也可以写。。 因为N太大必须离散化 = =把 T 和 Q 操作的数字给提出来 然后其他的保存区间  我写的比较orz我是直接把每个操作的节点的地址给保存了 = = T操作：把操作节点提根 然后右子树最小的儿子提到根节点的右儿子 把根节点的左儿子接到右儿子上（删除根节点）然后再把操作节点插入到前面那个哨兵的后面 再
HDU 3436 Queue-jumpers(Splay)
I good vegetable a!
08-28 860
Queue-jumpers Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3545    Accepted Submission(s): 962 Problem Description Ponyo and Garfie
HDU 3436 Queue-jumpers
House
07-19 1057
题意： n个人站成一排 一开始是从1到n有序的 现在有三个操作 Top操作是将一个人排到队首 Query操作是询问某个人现在排第几 Rank操作是询问排某个位置的人是谁 思路： 将队伍扭来扭去… 很像splay的旋转吧（哪像了！！） 这是个不错的splay题… 首先 n很大 但是操作不多 想到离散化 离散化还有个技巧 我们发现只有top和query操作对单人进行 rank和人没什么关系 所以要把top和query操作的人单独拿出来 那么其他的人就可以用区间的形式来表示了 我们只需要开
hdu 3436 Queue-jumpers 树状数组
G.D.Retop的专栏
07-28 881
Queue-jumpers Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1663    Accepted Submission(s): 393 Problem Description Ponyo and Gar
hdu3436 splay
江上白衣凌云
09-09 396
题意：模拟一个队列，能够查询位置k的数是多少 和 数k在哪个位置 操作是把其中一个数提到队头 解法：用splay模拟 把所有的提到头部的操作离线 然后划分区间 每个区间对应树的一个节点 然后提到头部的操作就是将对应线段提根 然后把它的左树送给与它中序的后继节点做左子树 查询位置k的节点很方便就是通过节点所记录的子树节点个数依次走下去就可以 然后查询数k所在的位置的话 要先找到对应的段 然后
hdu3436Queue-jumpers(splay+离散化)
ophunter的专栏
08-23 985
题目请戳这里 题目大意：有一个队，n个人，编号1-n，有3种操作： top x：将编号x的人放到队列首； query x：查询编号x的人现在排在第几位； rank x：查询现在第x位的人编号； 题目分析：splay。人数编号是10^8级别的，但是操作不超过10^5个，只需将top操作中的编号离散化就可以了，因为剩下的人都是连续的，所以将剩下的连续的人缩成一个点，只记录起始位置的人和连续长
hdu 3436 splay模拟题
努力奋斗才能梦想成真
09-30 1512
http://acm.hdu.edu.cn/showproblem.php?pid=3436 离线操作，将两个数之间那段数的个数也当做一个节点放在伸展树中，找的时候根据节点的个数往左或往右找就好了 /* 关键是离散化的技巧 其他没什么 */ #include #include #include #include using namespace std; const int inf = ~
HDU HDU - 3416 （单源最短路 + 最大流）
aozil_yang的博客
09-19 523
大体题意： 给你一个有向图，告诉你起点S和终点T，要求找出不同的路径来，满足路径是最短路，并且每个路只能用一次！ 思路： 方法很巧妙： 可以转换到最大流 先正着求一边单源最短路，在倒着求一边，把在最短路上的边加入到网络中，权值为1，直接求最大流即可！（想一想就知道！） 判断是否在最短路也很简单： 直接看这个边的一个点到S的最短距离和另一个点到T的最短距离之和 加上权值 如果是最短路的
hdu2600java
最新发布
07-18
HDOJ（ HDU Online Judge）是一个由哈尔滨工业大学主办的在线编程竞赛平台，提供大量的算法题目供学生和编程爱好者练习和学习。编号为2600的题目可能是竞赛中的一道题目，具体的题目信息没有直接给出，通常这种类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值