ACM练级日志：可持久化线段树初级-POJ 2104

近期决定把数据结构技能树继续开发下去，学习更深入层次的三项技能：可持久化线段树、动态树、树链剖分。然后那天看了看动态树，碎了，然后就去看可持久化线段树了……

简单地说，这玩意是一个可以保存修改的历史版本的线段树。其本质想法是：对线段树每改一次，就建一棵新的树，保留原来的版本。这听起来挺疯狂的，但是却有很令人意想不到的用处：比如POJ 2104这个题，普通线段树是无力的，但是如果你需要对付的区间永远只有1~n一个的话，就会轻松搞定：对值建树，然后记录一下每个节点里有几个数，来询问“第k大的数是几？”的时候，我就看看我左子树的数够不够k，如果够k，说明这个数在左子树里，你去左子树找吧；不然就肯定在右子树里，因为左子树已经占了sum（假设sum是每个节点有的数的个数）个，所以只需要去右子树找第k-sum个即可。时间复杂度是很好的n·logn。

可持久化线段树厉害之处就是在于它可以利用跟前缀和差不多的思想，把所有区间询问全都变成“从头到尾”的，只要我们这么考虑：一开始有一个空线段树，然后把a[1]加进去，a[2]加进去…… 注意加的时候你不要直接改，而是【弄一棵新线段树】，这样我们就有了n+1棵线段树，当询问l~r的时候，只需要把 线段树[r]所有节点的sum值 减去 线段树[l-1]所有节点的sum值，我们就有了一棵建在[l,r]上的线段树，就可以很快乐地搞了~

问题在于，真正去建n+1棵线段树是不现实的，因为这需要n²级别的内存量…… 但是我们不用真正去建这么多。你会发现，每次改的时候，真正被修改的节点只有logn个（左右儿子最多只改一个），所以我们可以在需要修改一个节点的时候，先把上一棵线段树的这个节点抄过来，然后改这个节点，然后看看左右儿子哪个需要改，需要改的去抄然后改，不需要改的就这么搁着就行。这个在代码里非常清楚。

目前只是这个东西的入门，级别还不够，之后还会有更厉害的玩意吧……

附上自己的代码

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;
 
struct ntype
{
    int l,r,sum;
} node[3000000]//注意开够，本身需要3n个，每改一次又会出现logn个
int p_nodes=0;
 
int n,m;
int a[100010], root[100010];//root注意开够，每改一次就意味着一棵新线段树
int numbers[100010];//离散化用的
int p_numbers=0;
 
void build(int s, int e, int &p)
{
    p=++p_nodes;
    node[p].l=node[p].r=node[p].sum=0;
    if(s>=e)
        return;
         
    int mid=(s+e)/2;
    build(s,mid, node[p].l);
    build(mid+1,e, node[p].r);
}
 
void update(int pre, int &p, int s, int e, int mir)
{
    p=++p_nodes;
    node[p]=node[pre];//把上一棵的信息抄过来
    node[p].sum++;//改我的信息
     
    if(s>=e)
        return;
     
    int mid=(s+e)/2;//看看哪个需要改，抄过来改，正好指针就更新了，不改的那个搁着不动
    if(mir<=mid)
        update(node[pre].l, node[p].l, s, mid, mir);
    else
        update(node[pre].r, node[p].r, mid+1, e, mir);
}
 
int ask(int r1, int r2, int s, int e, int k)
{
    if(s>=e)
        return s;
     
    int mid=(s+e)/2;
    int left_sum=node[ node[r2].l ].sum - node[ node[r1].l ].sum;
    if(left_sum>=k)
    {
        int r=ask(node[r1].l, node[r2].l, s, mid, k);
        return r;
    }
    else
    {
        int r=ask(node[r1].r, node[r2].r, mid+1, e, k-left_sum);
        return r;
    }
}
 
int main()
{
    scanf("%d %d", &n, &m);
    int i;
    for(i=1;i<=n;i++)
    {
        scanf("%d", &a[i]);
        numbers[i]=a[i];
    }
    sort(numbers+1, numbers+n+1);
    p_numbers=unique(numbers+1, numbers+n+1) - numbers - 1;//一一映射的离散化用STL写很简洁
     
    build(1,p_numbers, root[0]);
     
    for(i=1;i<=n;i++)
    {
        int mirror=lower_bound(numbers+1, numbers+n+1, a[i]) - numbers;
        update(root[i-1], root[i], 1, p_numbers, mirror);//抄上一棵的信息
    }
     
    for(i=1;i<=m;i++)
    {
        int s,e,k;
        scanf("%d %d %d", &s,&e,&k);
         
        int ans_mirror = ask(root[s-1], root[e], 1,p_numbers, k);//在没有被实际建出来的“新线段树”上询问
        printf("%d\n", numbers[ans_mirror]);
    }
    system("pause");
    return 0;
}