[HNOI2002]营业额统计

　　　　题目大意：给你一串n数序列，对于每一个刚输入的数a，找到一个前面的数k，使得|a-k|最小。

　　　　注释：$n<=32767，ai<=10^6$。

　　　　　　想法：刚学Treap。这道算Treap的练习题里吧，对于新手来讲还是挺有意义的。首先，我们先来讲一讲Treap是个什么东西。

　　　　　　　　在这之前，我们声明：

struct Node

{

	int lson,rson;//lson和rson分别表示左右儿子的编号

	int size,num;//size表示以当前节点为根节点的子树的节点数，num表示在Treap中有多少是和当前权值重复的

	int val,rnd;//val表示Tree的权值，rnd表示Heap的随机数据

}

void push(int k)//push代表将子树的信息更新至根节点

{

	a[k].size=a[k].num+a[a[k].lson].size+a[a[k].rson].size;

}

　　　　　　　　Treap，是二叉搜索树(Tree)和堆(Heap)的合体，读音也是这两个东西捏在一起的(懵-)。我们来看一下这东西是怎么实现的。

　　　　　　　　Treap是一种二叉搜索树，但也是一种平衡树。我们显然知道，对于二叉搜索树来讲，如果插入的顺序是直接升序或者降序，二叉搜索树就会退化成一条链，查找和修改还有删除的时间复杂度都会从原本的期望logn滚粗会O(n)。这就很蛋疼，而且卡二叉搜索树的题有不少，那么我们可以用一种什么样的办法来使得二叉搜索树趋近于平衡的呢？这是一个问题。然后我们再来看另一个问题。

　　　　　　　　关于Heap来讲，升序或者降序对于堆的伤害显然是... ...没有的。我们尝试用Heap将二叉搜索树进行一定的改造。之前的二叉搜索树的节点维护的只是权值，现在，我们让它在多一个随机的rand。这样的好处是什么？就是可以用这个随机的rand来使得存在一个树，满足这个树对于原本二叉搜索树的权值来讲是满足二叉搜索树的，对于rand来讲是满足heap的(这里是大根堆还是小根堆是无所谓的)。如何来呈现一颗这样的树呢？我们通过旋转Treap的核心操作——旋转。如何进行旋转？首先，我们最主要的目的就在保证二叉搜索树的前提下完成对堆的构建。那么，我们来考虑在如何不改变原有二叉搜索树的前提下旋转堆。首先，二叉搜索树的大小排序是由中序遍历决定的，而堆的大小排序是由深度决定的。我们可以通过这样的操作：

void lturn(int &k)//向左旋转

{

	int t=a[k].rson;

	a[k].rson=a[t].lson;

	a[t].lson=k;

	push(k);push(t);k=t;

}

　　　　　　　　没错，就是这样可以达到我们想要的效果。至于图解...菜逼的我并不会怎么把图粘上来，所以自己在纸上推演即可。然后，附上一些版子，知道了Treap的旋转之后就很好理解了。说一说插入，在插入节点时，先递归处理插入符合二叉搜索树的权值，然后取rand，通过递归旋转达到同时满足Tree和Heap的神奇的树即可。

void update(int &k,int temp)

{

    if(!k)

    {

        k=++tot;

        a[k].num=a[k].size=1;

        a[k].val=temp;

        a[k].rnd=rand();

        return ;

    }

    a[k].size++;

    if(temp==a[k].val) a[k].num++;

    else if(temp<a[k].val)

    {

        update(a[k].lson,temp);

        if(a[a[k].lson].rnd<a[k].rnd) rturn(k);

    }

    else

    {

        update(a[k].rson,temp);

        if(a[a[k].rson].rnd<a[k].rnd) lturn(k);

    }

}

　　　　删除和插入的原理是大致相同的，不在赘述。向说一说找前驱和后继的事情。我是照着lijinnn的版子敲的，所以找前驱和后继是递归的，EdwardFrog说可以不递归，推荐看一下，在此贴递归版子前驱

void ask_before(int k,int temp)

{

    if(!k) return ;

    if(temp>a[k].val)

    {

        befor=max(befor,a[k].val);

        ask_before(a[k].rson,temp);

    }

    else ask_before(a[k].lson,temp);

}

　　　　然后，说一下这道题。由于求的是最小波动，我们考虑什么样的数在Treap上和当前输入的数的波动是最小的？显然，是前驱或者是后继即可。所以，我们只需要找到对应的前驱、后继，然后对于波动的绝对值取min即可。

　　　　最后，附上丑陋的代码... ...

#include <iostream>

#include <cstdio>

#include <algorithm>//rand的时候会用到

using namespace std;

int befor,aftr;

int tot;

int root;

// int v[1000010];

int AbS(int x)//建议手写abs

{

    if(x<0) return -x;

    else return x;

}

struct Node

{

    int size;

    int lson,rson;

    int num,val,rnd;

}a[50010];

void push(int k)//更新节点信息

{

    a[k].size=a[k].num+a[a[k].lson].size+a[a[k].rson].size;

}

void lturn(int &k)//向左旋转

{

    int t=a[k].rson;

    a[k].rson=a[t].lson;

    a[t].lson=k;

    push(k);push(t);k=t;

}

void rturn(int &k)//向右旋转

{

    int t=a[k].lson;

    a[k].lson=a[t].rson;

    a[t].rson=k;

    push(k);push(t);k=t;

}

void update(int &k,int temp)//在以k为根节点的树内插入一个权值为temp的节点

{

    if(!k)//如果已经到达了叶子结点，就新增节点

    {

        k=++tot;

        a[k].num=a[k].size=1;

        a[k].val=temp;

        a[k].rnd=rand();

    }

    a[k].size++;//显然，在以k为根节点的子树中添加节点，k的size必须+1

    if(temp==a[k].val) a[k].num++;

    else if(temp<a[k].val)//左右递归处理即可

    {

        update(a[k].lson,temp);

        if(a[a[k].lson].rnd<a[k].rnd) rturn(k);

    }

    else

    {

        update(a[k].rson,temp);

        if(a[a[k].rson].rnd<a[k].rnd) lturn(k);

    }

}

// int ask_rank(int k,int temp)//只是一个版子

// {

//  if(!k) return 0;

//  if(a[k].val==temp) return a[a[k].lson].size+1;

//  else if(temp>a[k].val)

//      return a[a[k].lson].size+a[k].num+ask_rank(a[k].rson,temp);

//  else return ask_rank(a[k].lson,temp);

// }

void ask_before(int k,int temp)//前驱

{

    if(!k) return;

    if(temp>=a[k].val)

    {

        befor=max(befor,a[k].val);

        ask_before(a[k].rson,temp);

    }

    else ask_before(a[k].lson,temp);

}

void ask_after(int k,int temp)//后继

{

    if(!k) return;

    if(temp<=a[k].val)

    {

        aftr=min(aftr,a[k].val);

        ask_after(a[k].lson,temp);

    }

    else ask_after(a[k].rson,temp);

}

int main()

{

    int n;

    scanf("%d",&n);

    int All=0,ans;

    int x;

    scanf("%d",&x);

    All=x;

    update(root,x);

    // printf("root:%d\n",root);

    for(int i=2;i<=n;i++)

    {

        scanf("%d",&x);

        ans=0x7f7f7f7f;

        befor=0xefefefef;aftr=0x7f7f7f7f;//防止在取前驱的时候使得没有比当前节点大或小时befor和aftr为0

        ask_after(root,x);

        ask_before(root,x);

        ans=min(ans,AbS(befor-x));

        ans=min(ans,AbS(aftr-x));

        // printf("befor:%d aftr:%d ans:%d\n",befor,aftr,ans);

        All+=ans;

        update(root,x);

    }

    printf("%d\n",All);

}

　　　　小结：学到了一个超级强大的数据结构啊!!!。

　　　　　　错误：1.之前的做法是取rank，我们要明白，节点的编号对于Treap来讲，只有在对整个Treap进行修改时才有用，对于使用Treap来讲用处是极其小的。

　　　　　　　　　2.update的!k并不是return，我们要明白update的最核心的一句话其实是第一句。只有在!k的时候才有可能对于整个Treap进行形式上的增加节点的操作(有可能之前有重复)。

巴特西

[HNOI2002]营业额统计_Treap

最新文章

热门文章