伸展树模板(BZOJ 1500,UVALive 3961 HDU 1890)

最新推荐文章于 2017-10-05 12:44:00 发布
最新推荐文章于 2017-10-05 12:44:00 发布
阅读量347 收藏
点赞数
分类专栏： 个人总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsnbb123456789/article/details/53290804
版权

伸展树和名次树基本上差不多，直接上模板。

HYSBZ 1500维修数列

链表实现

#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <utility>
#include <map>
#include <set>
#include <queue>
#include <vector>
#include <iostream>
#include <stack>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-6
#define CLR( a, v ) memset ( a, v, sizeof ( a ) )
#define LL long long
#define DBUG printf ( "here!!!\n" )
#define rep( i, a, b ) for ( int i = ( a ); i < ( b ); i ++ )
#define PB push_back
#define ULL unsigned long long
#define PI acos ( -1.0 )
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1
#define lowbit( x ) ( ( x )&( -x ) )
#define CASE int Test; scanf ( "%d", &Test ); for ( int cas = 1; cas <= Test; cas ++ )
#define ALL( x ) x.begin ( ), x.end ( )
#define INS( x ) x, x.begin ( )
typedef pair < int, int > Pii;
typedef pair < double, double > Pdd;
typedef set < int > Set;
const int maxn = 500005;
int read_int ( )
{
    int res = 0;
    int ch;
    while ( ( ch = getchar ( ) ) && ! ( ch >= '0' && ch <= '9' ) )
    {
        if ( ch == -1 )
            return -1;
    }
    while ( ch >= '0' && ch <= '9' )
    {
        res = res*10+( ch-'0' );
        ch = getchar ( );
    }
    return res;
}
struct Node
{
    int x, cnt, lv, mv, rv, rev;
    int md, sum;
    struct Node * ch[2];
    void maintain ( )
    {
        cnt = ch[0]->cnt+ch[1]->cnt+1;
        sum = ch[0]->sum+ch[1]->sum+x;
        //维护子串和
        lv = max ( ch[0]->lv, ch[0]->sum+x+max ( 0, ch[1]->lv ) );
        rv = max ( ch[1]->rv, ch[1]->sum+x+max ( 0, ch[0]->rv ) );
        mv = max ( ch[0]->mv, ch[1]->mv );
        mv = max ( mv, max ( 0, ch[0]->rv )+x+max ( 0, ch[1]->lv )  );
    }
    void modify ( int s )
    {
        md = s;
        x = s;
        lv = mv = rv = max ( s, cnt*s );    //s可能为负数
        sum = cnt*s;
    }
    void reverse ( )
    {
        swap ( ch[0], ch[1] );
        swap ( lv, rv );
        rev ^= 1;   //注意只要当前rev更新
    }
    void PushDown ( )
    {
        if ( md != INF )
        {
            rev = 0;
            if ( ch[0]->cnt )
                ch[0]->modify ( md );
            if ( ch[1]->cnt )
                ch[1]->modify ( md );
            md = INF;
        }
        if ( rev )
        {
            rev = 0;
            if ( ch[0]->cnt )
                ch[0]->reverse ( );
            if ( ch[1]->cnt )
                ch[1]->reverse ( );
        }
    }
    int cmp ( int k )
    {
        int d = k-ch[0]->cnt;
        if ( d == 1 )
            return -1;
        return d <= 0 ? 0 : 1;
    }
}*root, *null;
int a[maxn], cc;
Node * Build ( int L, int R )
{
    if ( L >= R )
        return null;
    int M = ( L+R ) >> 1;
    Node * p = new Node ( );
    p->x = p->lv = p->mv = p->rv = p->sum = a[M];
    p->rev = 0;
    p->md = INF;
    p->ch[0] = Build ( L, M );
    p->ch[1] = Build ( M+1, R );
    p->maintain ( );
    return p;
}
void Rotate ( Node * &o, int k )
{
    Node * p = o->ch[k^1];
    o->ch[k^1] = p->ch[k];
    p->ch[k] = o;
    o->maintain ( );
    p->maintain ( );
    o = p;
}
void splay ( Node * &o, int k )
{
    o->PushDown ( );
    int d = o->cmp ( k );
    if ( d == 1 )
        k -= o->ch[0]->cnt+1;
    if ( d != -1 )
    {
        Node * p = o->ch[d];
        p->PushDown ( );
        int d2 = p->cmp ( k );
        int k2 = ( d2 == 0 ? k : k-p->ch[0]->cnt-1 );
        if ( d2 != -1 )
        {
            splay ( p->ch[d2], k2 );
            if ( d == d2 )
                Rotate ( o, d^1 );
            else
                Rotate ( o->ch[d], d );
        }
        Rotate ( o, d^1 );
    }
    o->maintain ( );
}
void split ( Node * o, int k, Node * &left, Node * &right )
{
    splay ( o, k );
    left = o;
    right = o->ch[1];
    left->ch[1] = null;
    left->maintain ( );
}
Node * Merge ( Node * left, Node * right )
{
    splay ( left, left->cnt );
    left->ch[1] = right;
    left->maintain ( );
    return left;
}
void print ( Node * o )
{
    if ( o == null )
        return ;
    o->PushDown ( );
    print ( o->ch[0] );
    printf ( "%d ", o->x );
    print ( o->ch[1] );
}
void remove ( Node * &o )
{
    if ( o == null )
        return ;
    remove ( o->ch[0] );
    remove ( o->ch[1] );
    delete o;
    o = null;
}
void solve ( )
{
    int n, m, pos, tot, x;
    char op[15];
    null = new Node ( );
    null->x = null->cnt = null->rev = null->sum = 0;
    null->lv = null->mv = null->rv = -INF;
    Node *o, *left, *mid, *right;

    //freopen ( "in0.in", "r", stdin );
    //freopen ( "in1.out", "w", stdout );
    scanf ( "%d%d", &n, &m );
    cc = 0;
    for ( int i = 1; i <= n; i ++ )
        scanf ( "%d", &a[i] );
    root = Build ( 1, n+1 );
    while ( m -- )
    {
        scanf ( "%s", op );
        if ( op[0] == 'I' )
        {
            scanf ( "%d%d", &pos, &tot );
            if ( tot == 0 )
                continue ;
            for ( int i = 1; i <= tot; i ++ )
                scanf ( "%d", &a[i] );
            o = Build ( 1, tot+1 );
            if ( pos == 0 )
                root = Merge ( o, root );
            else
            {
                split ( root, pos, left, right );
                root = Merge ( Merge ( left, o ), right );
            }
        }
        else if ( op[0] == 'D' )
        {
            scanf ( "%d%d", &pos, &tot );
            if ( tot == 0 )
                continue ;
            if ( pos == 1 )
            {
                split ( root, tot, left, o );
                remove ( left );
                root = o;
            }
            else
            {
                split ( root, pos-1, left, o );
                split ( o, tot, mid, right );
                remove ( mid );
                root = Merge ( left, right );
            }
        }
        else if ( op[0] == 'M' )
        {
            if ( strcmp ( op, "MAKE-SAME" ) == 0 )
            {
                scanf ( "%d%d%d", &pos, &tot, &x );
                if ( tot == 0 )
                    continue ;
                if ( pos == 1 )
                {
                    split ( root, tot, left, o );
                    left->modify ( x );
                    root = Merge ( left, o );
                }
                else
                {
                    split ( root, pos-1, left, o );
                    split ( o, tot, mid, right );
                    mid->modify ( x );
                    root = Merge ( Merge ( left, mid ), right );
                }
            }
            else
                printf ( "%d\n", root->mv );
        }
        else if ( op[0] == 'R' )
        {
            scanf ( "%d%d", &pos, &tot );
            if ( pos == 1 )
            {
                split ( root, tot, left, o );
                left->reverse ( );
                root = Merge ( left, o );
            }
            else
            {
                split ( root, pos-1, left, o );
                split ( o, tot, mid, right );
                mid->reverse ( );
                root = Merge ( Merge ( left, mid ), right );
            }
        }
        else
        {
            scanf ( "%d%d", &pos, &tot );
            if ( tot == 0 ) //tot为0处理
            {
                printf ( "0\n" );
                continue ;
            }
            if ( pos == 1 )
            {
                split ( root, tot, left, o );
                printf ( "%d\n", left->sum );
                root = Merge ( left, o );
            }
            else
            {
                split ( root, pos-1, left, o );
                split ( o, tot, mid, right );
                printf ( "%d\n", mid->sum );
                root = Merge ( Merge ( left, mid ), right );
            }
        }
        //print ( root );
        //printf ( "\n" );
    }
}
int main ( )
{
    solve ( );
    return 0;
}

UVaLive 3961 HDU 1890

这题主要是将某个点旋转至某个节点的操作，所以需要保存父节点。

数组实现

#include <cstdio>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <utility>
#include <map>
#include <set>
#include <queue>
#include <vector>
#include <iostream>
#include <stack>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-6
#define CLR( a, v ) memset ( a, v, sizeof ( a ) )
#define LL long long
#define DBUG printf ( "here!!!\n" )
#define rep( i, a, b ) for ( int i = ( a ); i < ( b ); i ++ )
#define PB push_back
#define ULL unsigned long long
#define PI acos ( -1.0 )
#define lson l, m, rt << 1
#define rson m+1, r, rt << 1 | 1
#define lowbit( x ) ( ( x )&( -x ) )
#define CASE int Test; scanf ( "%d", &Test ); for ( int cas = 1; cas <= Test; cas ++ )
#define ALL( x ) x.begin ( ), x.end ( )
#define INS( x ) x, x.begin ( )
#define Key_value ch[ ch[root][1] ][0]
typedef pair < int, int > Pii;
typedef pair < double, double > Pdd;
typedef set < int > Set;
const int maxn = 100005;
int read_int ( )
{
    int res = 0;
    int ch;
    while ( ( ch = getchar ( ) ) && ! ( ch >= '0' && ch <= '9' ) )
    {
        if ( ch == -1 )
            return -1;
    }
    while ( ch >= '0' && ch <= '9' )
    {
        res = res*10+( ch-'0' );
        ch = getchar ( );
    }
    return res;
}
int ch[maxn][2], cnt[maxn], rev[maxn], pre[maxn];
int tot, pp[maxn], root, key[maxn], mp[maxn];
void newNode ( int &r, int fa, int k )
{
    r = ++ tot;
    pre[r] = fa;
    ch[r][0] = ch[r][1] = rev[r] = 0;
    key[r] = k;
}
void PushUP ( int x )
{
    cnt[x] = cnt[ ch[x][0] ]+cnt[ ch[x][1] ]+1;
}
void Rever ( int x )
{
    if ( x == 0 )
        return ;
    swap ( ch[x][0], ch[x][1] );
    rev[x] ^= 1;
}
void PushDown ( int x )
{
    if ( rev[x] )
    {
        Rever ( ch[x][0] );
        Rever ( ch[x][1] );
        rev[x] = 0;
    }
}
void Build ( int &x, int L, int R, int fa )
{
    if ( L >= R )
    {
        x = 0;
        return ;
    }
    int M = ( L+R ) >> 1;
    newNode ( x, fa, pp[M] );
    mp[ pp[M] ] = x;
    Build ( ch[x][0], L, M, x );
    Build ( ch[x][1], M+1, R, x );
    PushUP ( x );
}
Pii a[maxn];
int cmp ( Pii x, Pii y )
{
    return x.first < y.first || x.first == y.first && x.second < y.second;
}
void Init ( int n )
{
    root = tot = 0;
    for ( int i = 1; i <= n; i ++ )
    {
        scanf ( "%d", &a[i].first );
        a[i].second = i;
    }
    sort ( a+1, a+1+n, cmp );
    for ( int i = 1; i <= n; i ++ )
        pp[ a[i].second ] = i;
    ch[root][0] = ch[root][1] = cnt[root] = rev[root] = pre[root] = 0;
    newNode ( root, 0, -1 );
    newNode ( ch[root][1], root, -1 );
    Build ( Key_value, 1, n+1, ch[root][1] );
    PushUP ( ch[root][1] );
    PushUP ( root );
}
void Rotate ( int x, int k )
{
    int y = pre[x];
    ch[y][k^1] = ch[x][k];
    if ( ch[x][k] )
        pre[ ch[x][k] ] = y;
    ch[x][k] = y;
    if ( pre[y] )
        ch[ pre[y] ][ ch[ pre[y] ][1] == y ] = x;
    pre[x] = pre[y];
    pre[y] = x;
    PushUP ( y );
    PushUP ( x );
}
void Splay ( int x, int goal )
{
    PushDown ( x );
    while ( pre[x] != goal )
    {
        int y = pre[x];
        PushDown ( y );
        PushDown ( x );
        if ( pre[y] == goal )
            Rotate ( x, ch[y][0] == x );
        else
        {
            int z = pre[y];
            PushDown ( z );
            PushDown ( y );
            PushDown ( x );
            int d = ch[z][1] == y, d2 = ch[y][1] == x;
            if ( d == d2 )
                Rotate ( x, d^1 );
            else
                Rotate ( x, d );
            Rotate ( x, d^1 );
        }
    }
    PushUP ( x );
    if ( goal == 0 )
        root = x;
}
int Get_Kth ( int x, int k )
{
    PushDown ( x ); //注意需要向下更新否则中间运行会有问题
    int d = cnt[ ch[x][0] ]+1;
    if ( d == k )
        return x;
    if ( d > k )
        return Get_Kth ( ch[x][0], k );
    return Get_Kth ( ch[x][1], k-d );
}
void solve ( )
{
    int n;
    //freopen ( "in0.in", "r", stdin );
    while ( ~ scanf ( "%d", &n ), n )
    {
        Init ( n );
        for ( int i = 1; i <= n; i ++ )
        {
            Splay ( mp[i], root );
            printf ( i == 1 ? "%d" : " %d", i+cnt[Key_value] );
            Rever ( Key_value );
            Splay ( Get_Kth( ch[root][1], cnt[Key_value]+2 ), root );
            Splay ( Get_Kth ( Key_value, cnt[Key_value] ), ch[root][1] );
            int x = ch[Key_value][0];
            if ( x )
                pre[x] = ch[root][1];
            Key_value = x;
            PushUP ( ch[root][1] );
            PushUP ( root );
        }
        printf ( "\n" );
    }
}
int main ( )
{
    solve ( );
    return 0;
}


RookieZQF
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU 1890 Robotic Sort（无旋treap）
shadiao.的博客
11-09 229
题目传送门（HDU1890） 解题思路 题目大意是[1,n]整个区间询问最小的数的位置x，然后[1,x]整段区间翻转，之后最小的数被放到1位置，之后对于[2,n]区间重复同样的操作，每次都让你输出当前区间内最小的数的位置。 单纯的寻找区间最小值，线段树之类的直接实现以下就可以了。 单纯的区间翻转，随便搞个支持区间操作的平衡树打个标记就可以了。 现在两个操作合并在一起的话，该怎...
hdu 1890 Robotic Sort(Splay应用)
志当存高远
10-18 1631
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
HDU 1890(Splay树)
weixin_30325071的博客
08-18 84
这个礼拜准备把Splay树补完，这道题被认为是一道Splay的水题，（然而像我这种入门级学习后还是搞了好久，毕竟算是第一次接触吧）。 感觉Splay树必须要明确的一点：该树的中序遍历就是现在的序列 这里面有一个区间翻转的操作，涉及到区间问题，Splay树的核心就是RotateTo(l-1,0),Rotate(r+1,root)，就是把该区间的前一个数转到根节点，后一个数转到根节点的右节...
HDU1890
SCUT_Pein
02-07 832
#include #include #include 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){
[HDU1890]RoboticSort
Q882199的博客
10-05 110
Problem 每次找到最小值，然后把它和它前面的数翻转，然后找第二小数······ 然后输出这些数的下标。 Solution 用splay维护，每次找到最小值，然后翻转前面区间。 Notice 细节操作巨烦无比。 Code #include<cmath> #include<cstdio> #include<cstring> #include<i...
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
BZOJ上面的题目以及数据
10-13
【BZOJ】全称是“北京邮电大学在线评测系统”，它是一个为编程爱好者和参赛者提供在线编程练习和比赛的平台。该平台涵盖了多种算法和编程问题，旨在提升用户的编程技能和解决复杂问题的能力。BZOJ支持C、C++、Java等...
bzoj problem
08-21
【标题】"bzoj problem" 指的是“八中OJ（Online Judge）问题集”，这是一个在线编程竞赛平台的题目合集。八中OJ可能是某所中学的在线编程训练系统，它提供了大量的编程题目供用户练习和挑战，以提升编程能力和算法...
Splay伸展树结构体模板
01-06
Splay结构体的模板，含有各种旋转、插入、翻转等操作，注释清晰
树套树数据结构从入门到精通
10-16
树套树数据结构从入门到精通,包教包会树套树就是你有一种树形数据结构，它的每个节点也是一颗树形的数据结构。
HDU 1890 splay区间翻转
_rabbit的专栏
11-01 1062
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
HDU 1890 Robotic Sort(Splay tree)
java开发指南博客 【转载】
07-27 95
转载请注明出处，谢谢http://blog.csdn.net/ACM_cxlove?viewmode=contents by---cxlove 对区间有反转，同样用懒惰标记，SPT比较方便。 依次考虑第K大的，将其旋转至根，左子树的数量便是需要反转的，之后把根删除即可 难道是我的伸展函数有问题，一直TLE，注释部分的求大神解释。 换了一个Splay函数就过了。。。郁闷啊，debug到死...
HDU 1890
whosemario的专栏
04-08 1619
<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
weixin_30914981的博客
09-07 98
区间翻转 一脸Splay。 第一次做区间翻转。一开始懒惰标记表示当前这可子树都需要翻转。这样就有个问题：旋转的状态的不一定是正确的（rotate传的参数不一定正确）。 然后参考ac代码。联系线段树的lazy标记，每次跟新某个区间的时候，该线段区间肯定要先跟新，再在改区间节点打上标记，表示后面的子区间节点需要跟新。所以，翻转标记表示他两个儿子子树需要翻转，但是两个儿子的状态已经...
Robotic Sort hdu1890 （伸展树翻转+删根）
每一次AC都是一种感动
02-22 620
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 343
有一个长度为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
【splay】hdu 1890
QuanQqqqq的博客
09-04 377
又抓了一道经典例题的splay。 这个主要是区间翻转，其中有一点树型dp的感觉。 传送门：Robotic Sort 题目大意： 每次拿第i位数和第i大的数之间的数进行翻转，这样每次翻转完毕之后第i位数一定是有序的。 每次输出第i大的数的位置，打印完毕后再进行翻转。 思路： 拿一棵splay数。按顺序插入数。 对于每个位置。维护他的序列号和值。
bzoj 1040 zjoi2008 骑士 树形dp
最新发布
08-08
我们可以使用树形dp来解决这个问题，具体来说，我们可以将这个图看作是一棵树，每个点的父节点是它的前驱或者后继，然后我们从根节点开始，依次向下遍历，对于每个节点，我们可以考虑它的两个儿子，如果它的两个儿子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值