HDU1890

最新推荐文章于 2021-11-03 17:18:44 发布
最新推荐文章于 2021-11-03 17:18:44 发布
阅读量892 收藏
点赞数
分类专栏： 数据结构_伸展树 文章标签： HDU1890
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/scut_pein/article/details/18961015
版权 
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define Keytree (ch[ ch[root][1] ][0])
const int maxn = 100010;
struct node {
    int num,id;
}in[maxn];
int id[maxn];
int cmp(node a,node b){
    if(a.num!=b.num) return a.num<b.num;
    return a.id<b.id;
}
struct SplayTree{
    int tot,root;
    int pre[maxn];
    int size[maxn];
    int ch[maxn][2];
    inline void Rotate(int x, int c) {    // 旋转， c=0 左旋， c=1 右旋
        int y = pre[x];
        pushdown(y);
        pushdown(x);
        ch[y][!c] = ch[x][c];
        if ( ch[x][c] )    pre[ ch[x][c] ] = y;
        pre[x] = pre[y];
        if ( pre[y] )    ch[ pre[y] ][ ch[pre[y]][1] == y ] = x;
        ch[x][c] = y;
        pre[y] = x;
        pushup(y);
    }
    inline void Splay(int x, int f) {    // 把结点x转到结点f的下面
        pushdown(x);
        while ( pre[x] != f ) {
            int y = pre[x], z = pre[y];
            pushdown(z);    pushdown(y);    pushdown(x);    // 旋转前必须先去除反转标记
            if ( pre[ pre[x] ] == f ) {
                Rotate(x, ch[pre[x]][0] == x);
            }
            else {
                if ( ch[z][0] == y ) {
                    if ( ch[y][0] == x ) 
                        Rotate(y, 1), Rotate(x, 1);
                    else 
                        Rotate(x, 0), Rotate(x, 1);
                }
                else {
                    if ( ch[y][0] == x ) 
                        Rotate(x, 1), Rotate(x, 0);
                    else 
                        Rotate(y, 0), Rotate(x, 0);
                }
            }
        }
        pushup(x);
        if ( f == 0 )    root = x;
    }
    inline void Select(int k, int f) {    // 把第k个点旋转到f的下面
        int x = root;
        while ( 1 ) {
            pushdown(x);
            if ( k == size[ ch[x][0] ] + 1 ) 
                break;
            if ( k <= size[ ch[x][0] ] )
                x = ch[x][0];
            else {
                k -= (size[ ch[x][0] ] + 1);
                x = ch[x][1];
            }
        } 
        Splay(x, f);
    }
    inline void del_root(){//删除根节点
        int t=root;
        if(ch[root][1]) {
            root=ch[root][1];
            Select(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);
    }
    inline void pushup(int x){
        size[x]=size[ ch[x][0] ] + size[ ch[x][1] ] +1;
    }
    inline void pushdown(int x){
        if(flip[x]){
            flip[x]=0;
            flip[ch[x][0]]^=1;
            flip[ch[x][1]]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void Newnode(int &x,int f){
        x=++tot;
        pre[x]=f;
        ch[x][0]=ch[x][1]=0;
        flip[x]=0;
        size[x]=1;
    }
    void build(int &x,int l,int r,int f){
        if(l>r) return ;
        int mid=(l+r)>>1;
        Newnode(x,f);
        map[id[mid]]=x;
        build(ch[x][0],l,mid-1,x);
        build(ch[x][1],mid+1,r,x);
        pushup(x);
    }
    void init(int n){
        int i;
        pre[0]=ch[0][0]=ch[0][1]=0;
        size[0]=flip[0]=tot=0;
        for(i=1;i<=n;i++) {
            scanf("%d",&in[i].num);
            in[i].id=i;
        }
        sort(in+1,in+n+1,cmp);
        for(i=1;i<=n;i++) id[in[i].id]=i;
        map[id[1]] = 1;
        map[id[n]] = 2;
        Newnode(root,0);
        Newnode(ch[root][1],root);
        build(Keytree,2,n-1,ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }
    void solve(int n){
        for(int i=1;i<=n;i++){
            Splay(map[i],0);
            printf("%d",i+size[ch[root][0]]);
            if(i<n) printf(" ");
            flip[ch[root][0]]^=1;
            del_root();
        }
        puts("");
    }
    int map[maxn];
    int flip[maxn];
}spt;
int main(){
    int n;
    while(scanf("%d",&n),n)    {
        if(n==1) {scanf("%*d");printf("1\n");continue;}
        spt.init(n);
        spt.solve(n);
    }
    return 0;
}


风格更新后：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define inf 0x3f3f3f3f
#define maxn 100010
#define LL long long int
#define Key_value ch[ch[root][1]][0]

struct node
{
	int num,id;
}in[maxn];

int id[maxn];
bool cmp(node a,node b)
{
	if(a.num != b.num)	return a.num < b.num;
	return a.id < b.id;
}

struct SplayTree
{
	int pre[maxn],ch[maxn][2],size[maxn],flip[maxn],map[maxn],root,cnt;
	
	void init(int n)
	{
		root = cnt = 0;
		pre[0] = ch[0][0] = ch[0][1] = 0;
		size[0] = flip[0] = 0;
		for(int i = 1;i <= n;i++)
		{
			scanf("%d",&in[i].num);
			in[i].id = i;
		}
		sort(in+1,in+n+1,cmp);
		for(int i = 1;i <= n;i++)	id[in[i].id] = i;
		map[id[1]] = 1;
		map[id[n]] = 2;
		NewNode(root,0);
		NewNode(ch[root][1],root);
		BuildTree(Key_value,2,n-1,ch[root][1]);
		PushUp(ch[root][1]);
		PushUp(root);
	}

	void BuildTree(int & x,int l,int r,int father)
	{
		if(l > r)	return;
		int mid = (l+r) >> 1;
		NewNode(x,father);
		map[id[mid]] = x;
		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)
	{
		r = ++cnt;
		pre[r] = father;
		ch[r][0] = ch[r][1] = 0;
		size[r] = 1;
		flip[r] = 0;
	}

	void PushDown(int r)
	{
		if(flip[r])
		{
			flip[r] = 0;
			flip[ch[r][0]] ^= 1;
			flip[ch[r][1]] ^= 1;
			swap(ch[r][0],ch[r][1]);
		}
	}
	
	void PushUp(int r)
	{
		size[r] = size[ch[r][0]] + size[ch[r][1]] + 1;
	}

	void Rotate(int x,int kind)
	{
		int y = pre[x];
		PushDown(y);
		PushDown(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)
	{
		PushDown(r);
		while(pre[r] != goal)
		{
			int y = pre[r],z = pre[y];
			PushDown(z);	PushDown(y);	PushDown(r);
			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;
	}

	void RotateTo(int k,int goal)
	{
		int r = root;
		while(1)
		{
			PushDown(r);
			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 solve(int n)
	{
		init(n);
		for(int i = 1;i <= n;i++)
		{
			Splay(map[i],0);
			printf("%d",i+size[ch[root][0]]);
			if(i < n)	printf(" ");
			flip[ch[root][0]] ^= 1;
			del_root();
		}
		puts("");
	}
}spt;

int main()
{
	int n;
	while(scanf("%d",&n)!=EOF && n)
	{
		if(n == 1)
		{
			scanf("%*d");
			printf("1\n");
			continue;
		}
		spt.solve(n);
	}
	return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 100080
#define Key_value ch[ch[root][1]][0]
int Rank[maxn],Map[maxn];

struct Item
{
	int key,id;
	bool operator < (const Item & a) const
	{
		if(key != a.key)return key < a.key;
		return id < a.id;
	}
}item[maxn];

struct SpalyTree
{
	int pre[maxn],ch[maxn][2],size[maxn],flip[maxn];
	int root,cnt;

	void init(int n)
	{
		cnt = root = 0;
		ch[0][0] = ch[0][1] = size[0] = pre[0] = flip[0] = 0;
		NewNode(root,1,0);
		NewNode(ch[root][1],n,root);
		Buildtree(Key_value,2,n-1,ch[root][1]);
		PushUp(ch[root][1]);
		PushUp(root);
	}

	void NewNode(int & r,int k,int father)
	{
		r = ++cnt;
		ch[r][0] = ch[r][1] = flip[r] = 0;
		pre[r] = father;
		size[r] = 1;
		Map[Rank[k]] = r;
	}

	void PushDown(int x)
	{
		if(flip[x])
		{
			flip[x] = 0;
			flip[ch[x][0]] ^= 1;
			flip[ch[x][1]] ^= 1;
			swap(ch[x][0],ch[x][1]);
		}
	}

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

	void Buildtree(int & r,int L,int R,int father)
	{
		if(L > R)return;
		int mid = (L+R)>>1;
		NewNode(r,mid,father);
		Buildtree(ch[r][0],L,mid-1,r);
		Buildtree(ch[r][1],mid+1,R,r);
		PushUp(r);
	}

	void Rotate(int x,int kind)
	{
		int y = pre[x];
		PushDown(y);
		PushDown(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)
	{
		PushDown(r);//为什么去了这个会超时.假设pre[r] == goal。而且r有懒惰标记
		//如果这里没有PushDown。这里懒惰标记就直接给del_root函数搞没了。。
		while(pre[r] != goal)
		{
			int y = pre[r],z = pre[y];
			PushDown(z);	PushDown(y);	PushDown(r);//这里不加会超时，想想
			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 Get_Kth(int r,int k)
	{
		PushDown(r);
		int t = size[ch[r][0]] + 1;
		if(t == k)
			return r;
		if(t > k)
			return Get_Kth(ch[r][0],k);
		else return Get_Kth(ch[r][1],k-t);
	}

	void del_root()
	{
		int t = root;
		if(ch[root][1])
		{
			root = ch[root][1];
			int x = Get_Kth(root,1);
			Splay(x,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 solve(int n)
	{
		init(n);
		for(int i = 1;i <= n;i++)
		{
			Splay(Map[i],0);
			printf("%d",i+size[ch[root][0]]);
			flip[ch[root][0]] ^= 1;
			del_root();
			if(i == n)	printf("\n");
			else printf(" ");
		}
	}
}spt;

int main()
{
	//freopen("in.txt","r",stdin);
	int n;
	while(scanf("%d",&n)!=EOF && n)
	{
		if(n == 1)
		{
			scanf("%*d");
			printf("1\n");
			continue;
		}
		for(int i = 1;i <= n;i++)
		{
			scanf("%d",&item[i].key);
			item[i].id = i;
		}
		sort(item+1,item+1+n);
		for(int i = 1;i <= n;i++)
		{
			Rank[item[i].id] = i;
		}//Rank数组表示第几个进来的排第几。
		spt.solve(n);
	}
	return 0;
}

HDU 1890 Robotic Sort（无旋treap）
shadiao.的博客
11-09 292
题目传送门（HDU1890） 解题思路 题目大意是[1,n]整个区间询问最小的数的位置x，然后[1,x]整段区间翻转，之后最小的数被放到1位置，之后对于[2,n]区间重复同样的操作，每次都让你输出当前区间内最小的数的位置。 单纯的寻找区间最小值，线段树之类的直接实现以下就可以了。 单纯的区间翻转，随便搞个支持区间操作的平衡树打个标记就可以了。 现在两个操作合并在一起的话，该怎...
HDU1890 Robotic Sort（伸展树换根+删除操作）
Michael_GLF的博客
10-03 631
【题目描述】 Somewhere deep in the Czech Technical University buildings, there are laboratories for examining mechanical and electrical properties of various materials. In one of yesterday’s presentations,...
HDU 1890(Splay树)
weixin_30325071的博客
08-18 114
这个礼拜准备把Splay树补完，这道题被认为是一道Splay的水题，（然而像我这种入门级学习后还是搞了好久，毕竟算是第一次接触吧）。 感觉Splay树必须要明确的一点：该树的中序遍历就是现在的序列 这里面有一个区间翻转的操作，涉及到区间问题，Splay树的核心就是RotateTo(l-1,0),Rotate(r+1,root)，就是把该区间的前一个数转到根节点，后一个数转到根节点的右节...
HDU 1890 Robotic Sort(Splay tree)
java开发指南博客 【转载】
07-27 121
转载请注明出处，谢谢http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents by---cxlove 对区间有反转，同样用懒惰标记，SPT比较方便。 依次考虑第K大的，将其旋转至根，左子树的数量便是需要反转的，之后把根删除即可 难道是我的伸展函数有问题，一直TLE，注释部分的求大神解释。 换了一个Splay函数就过了。。。郁闷啊，debug到死...
HDU 1890
whosemario的专栏
04-08 1653
<br />Splay Tree,重点在子树的旋转，线段树很难实现：<br />#include<iostream> #define DEBUG_ENABLE 1 using namespace std; #define MAXN 100005 #define KeyNode (ch[ch[root][1]][0]) int num[MAXN][2]; struct Pair{int v,i;}; struct SplayTree{ int sz[MAXN];
HDU 1890 splay区间翻转
_rabbit的专栏
11-01 1120
Robotic Sort Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2505    Accepted Submission(s): 1109 Problem Description Somewhere deep in
kuangbin acm模板超级好用
09-05
2.18.1 HDU4656 卷积取模 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 2.19 其它公式 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 2.19.1 Polya . . . ....
5.2 二叉树
weixin_55835175的博客
11-03 306
5.2 二叉树 比起紫书上二叉树的基础知识，黑书拓展了一些特殊的树形结构。 5.2.1 二叉树的存储 二叉树的基本概念就不再多做介绍，对一些用语不太明白的详见紫书6.3 树和二叉树。 关于二叉树的存储结构，一般用指针来实现： struct node{int value; node *l,*r;} l和r分别指向当前结点的左孩子和右孩子，当新建一个node时用new来申请内存，使用完毕时，用delete进行删除。 二叉树的遍历 主要就是两种遍历方式，宽度优先遍历和深度优先遍历。 宽度优先遍历 紫书中的遍
ACM OJ 平台以及平台题目分类
69小石头的博客
05-04 4133
OJ是Online Judge系统的简称，用来在线检测程序源代码的正确性。著名的OJ有RQNOJ、URAL等。国内著名的题库有北京大学题库、浙江大学题库等。国外的题库包括乌拉尔大学、瓦拉杜利德大学题库等。 简介： 　　Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检
hdu 1890
weixin_30914981的博客
09-07 131
区间翻转 一脸Splay。 第一次做区间翻转。一开始懒惰标记表示当前这可子树都需要翻转。这样就有个问题：旋转的状态的不一定是正确的（rotate传的参数不一定正确）。 然后参考ac代码。联系线段树的lazy标记，每次跟新某个区间的时候，该线段区间肯定要先跟新，再在改区间节点打上标记，表示后面的子区间节点需要跟新。所以，翻转标记表示他两个儿子子树需要翻转，但是两个儿子的状态已经...
hdu 1890 Robotic Sort(Splay应用)
志当存高远
10-18 1730
Robotic Sort Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 1102    Accepted Submission(s): 451 Problem Description Somewhere deep
[HDU1890]RoboticSort
Q882199的博客
10-05 154
Problem 每次找到最小值，然后把它和它前面的数翻转，然后找第二小数······ 然后输出这些数的下标。 Solution 用splay维护，每次找到最小值，然后翻转前面区间。 Notice 细节操作巨烦无比。 Code #include<cmath> #include<cstdio> #include<cstring> #include<i...
【splay】hdu 1890
QuanQqqqq的博客
09-04 421
又抓了一道经典例题的splay。 这个主要是区间翻转，其中有一点树型dp的感觉。 传送门：Robotic Sort 题目大意： 每次拿第i位数和第i大的数之间的数进行翻转，这样每次翻转完毕之后第i位数一定是有序的。 每次输出第i大的数的位置，打印完毕后再进行翻转。 思路： 拿一棵splay数。按顺序插入数。 对于每个位置。维护他的序列号和值。
HDU 1890 Robotic Sort
House
07-17 1905
题意： 将一列数字排序 排序规则是 每次找到最小值的位置loc 将1~loc所有数字颠倒 然后删掉第一位 直到排好序 排序要求是稳定的 思路： 这题要做的是 寻找区间最小值位置 翻转区间 的操作 因此可以想到用splay 只需要每个节点记录一个small 就可以实现找到最小值位置 翻转区间操作就是将splay的超级头转到最上面使之成为根 再把loc转到根下面 这时根的右儿子的左儿子就是需要翻转的区间 用一个rev延迟更新 然后将loc转到最上面是指成为根 删掉根 如此循环
HDU - 1890 Robotic Sort 伸展树
还我笑颜
08-30 303
题目链接：https://cn.vjudge.net/problem/HDU-1890 题意：每次将第i个位置到第i大的数所在位置 之间的数进行翻转，输出的是第i大的数所在的位置 题解：按照1-n建树，原序列排序，每次把节点 a[i].id 放到顶部，位置即为左子树数目+i，然后删除顶部节点 #include <iostream> #include <cstdio>...
Robotic Sort hdu1890 （伸展树翻转+删根）
每一次AC都是一种感动
02-22 665
Robotic Sort Time Limit:2000MS    Memory Limit:32768KB    64bit IO Format:%I64d & %I64u Description Somewhere deep in the Czech Technical University buildings, there are laboratories
HDU1890 Robotic Sort(Splay)
ACMer_quack&cheer
03-10 372
有一个长度为n(1≤n≤105)n(1 \leq n \leq 10^5)的排列，排列中的每个元素pi(1≤pi≤n)pi(1 \leq pi \leq n)。每次操作翻转第i个元素和第i大元素之间所有的数，并且输出第i大元素的位置。 刚开始看见又是区间翻转又是求第k大就晕了- -，网上搜了搜题解+自己理会发现：用原数组的下标来建树，每次把排序后的第i个元素对应的原数组的下标旋转到根，i+sz[c
HDU 1890 题解
ez_yww的博客
07-06 447
数组中有n个数，每次输出第i大的数所在位置，再翻转第i个数到第i大的数，如果有多个数大小相同，则在原数组中下标小的数优先。
HDU1890-SplayTree
Sdywolf的博客
04-16 478
题目描述 给你一个序列，第i次操作是把第i个数到第i小的数这段区间翻转，即第i次操作把第i小的数一次翻转到第i个位置，最终序列会变成升序的（注意：如果有相同的数，那么在初始序列中靠前的在最终序列也靠前，即相同的数相对位置不变），每次操作前输出第i小的数所在的位置。 题解： 如果每次直接找整个数列第i小的数，需要树套树，其实，只要每次把第i个数翻转到第i个位置后，下一次操作需要翻转的数就是剩下的
ACM HDU题目分类概要
"该资源是关于ACM竞赛中HDU（杭州电子科技大学在线评测系统）题目的分类，包含了从1001到1087的题目简介，涵盖了各种算法和编程技巧，如搜索、动态规划、贪心、数学、字符串处理等。" 在ACM HDU题目分类中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值