数据结构嵌套——学习笔记

引言
随着我们需要解决的问题越来越复杂，很多时候单一的数据结构已经无法解决问题了，所以我们需要把数据结构嵌套起来。

---

什么是数据结构嵌套
顾名思义，数据结构嵌套就是结合使用两个及以上（一般是两个，否则多的一般用其他的方法来代替）的数据结构。
这样看来其实数据结构嵌套非常简单，没有任何思维难度，只不过代码量有一些大，需要一定的封装，我们通过具体题目介绍不同的数据结构嵌套。

---

线段树套线段树
例题：Mobile phones
题目大意：写一个数据结构，实现平面单点加，矩形查询。
这个题非常简单，因为只要求单点修改，横纵各一棵线段树维护一个矩形就搞定了。
代码：

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;

int addnum,n;

struct Segtree_inside
{
    int seg[4100];

    void init()
    {
        memset(seg,0,sizeof(seg));
    }

    void add(int note,int l,int r,int want)
    {
        if(l==r)
        {
            if(seg[note]+addnum<0) addnum=-seg[note];
            seg[note]+=addnum;
            return;
        }
        int mid=(l+r)>>1;
        if(want<=mid) add(note*2,l,mid,want);
        else add(note*2+1,mid+1,r,want);
        seg[note]=seg[note*2]+seg[note*2+1];
    }

    int query(int note,int l,int r,int wantl,int wantr)
    {
        if(l>wantr||r<wantl) return 0;
        if(l>=wantl&&r<=wantr) return seg[note];
        int mid=(l+r)>>1;
        return query(note*2,l,mid,wantl,wantr)+query(note*2+1,mid+1,r,wantl,wantr);
    }

};

struct Segtree_outside
{
    Segtree_inside seg[4100];

    void init()
    {
        for(int i=0;i<=4099;i++)
            seg[i].init();
    }

    void add(int note,int l,int r,int wantx,int wanty)
    {
        if(l==r) { seg[note].add(1,1,n,wanty);return; }
        int mid=(l+r)>>1;
        if(wantx<=mid) add(note*2,l,mid,wantx,wanty);
        else add(note*2+1,mid+1,r,wantx,wanty);
        seg[note].add(1,1,n,wanty);
    }

    int query(int note,int l,int r,int wsx,int wex,int wsy,int wey)
    {
        if(l>wex||r<wsx) return 0;
        if(l>=wsx&&r<=wex) return seg[note].query(1,1,n,wsy,wey);
        int mid=(l+r)>>1;
        return query(note*2,l,mid,wsx,wex,wsy,wey)+query(note*2+1,mid+1,r,wsx,wex,wsy,wey);
    }

}T;

int main()
{
    while(1)
    {
        int type;
        scanf("%d",&type);
        if(type==3) break;
        else if(type==0) { scanf("%d",&n);T.init(); }
        else if(type==1)
        {
            int x,y;
            scanf("%d%d%d",&x,&y,&addnum);
            x++;y++;
            T.add(1,1,n,x,y);
        }
        else
        {
            int x1i,x2i,y1i,y2i;
            scanf("%d%d%d%d",&x1i,&y1i,&x2i,&y2i);
            x1i++;x2i++;y1i++;y2i++;
            printf("%d\n",T.query(1,1,n,x1i,x2i,y1i,y2i));
        }
    }
    return 0;
}

---

线段树套平衡树
例题：Dynamic Rankings
题目大意：动态查询区间第k小
我们通过线段树找到当前要查询的区间，再在当前这个区间的平衡树上查询第k小就行了，注意修改时所有包含那个点的平衡树都要修改。
代码：

#include <bits/stdc++.h>
using namespace std;

const int maxn=1e6;
const int inf=2147483640;
int root[maxn];
int a[maxn];
int ans,cnt=0,T1,n,m;
char s[10];

struct Splay_tree
{
    int size[maxn],c[maxn][2],fa[maxn],val[maxn];
    void pushup(int x)
    {
        size[x]=size[c[x][0]]+size[c[x][1]]+1;
    }
    void rotate(int x)
    {
        int y=fa[x],z=fa[y],k=c[y][1]==x,w=c[x][!k];
        c[z][c[z][1]==y]=x,c[x][!k]=y,c[y][k]=w;
        if(w) fa[w]=y;
        fa[y]=x,fa[x]=z;
        pushup(y);pushup(x);
    }
    void splay(int k,int x,int tar)
    {
        while(fa[x]!=tar)
        {
            int y=fa[x],z=fa[y];
            if(z!=tar) rotate((c[y][1]==x)^(c[z][1]==y)?x:y);
            rotate(x);
        }
        if(tar==0) root[k]=x;
    }
    void insert(int k,int num)
    {
        int now=root[k],f=0;
        while(now) { f=now;now=c[now][num>val[now]]; }
        now=++cnt;
        val[now]=num;
        size[now]=1;
        fa[now]=f;
        c[now][0]=c[now][1]=0;
        if(f==0) root[k]=now;
        else { c[f][num>val[f]]=now;splay(k,now,0); }
    }
    void find(int k,int num)
    {
        int now=root[k];
        while(c[now][num>val[now]]&&val[now]!=num) now=c[now][num>val[now]];
        splay(k,now,0);
    }
    int nxt(int k,int num,int f)
    {
        find(k,num);
        int now=c[root[k]][f];
        while(c[now][f^1]) now=c[now][f^1];
//        cout<<val[now]<<endl;
        return now;
    }
    void del(int k,int num)
    {
        int now=root[k];
        int last1=nxt(k,num,0);
        int next1=nxt(k,num,1);
        splay(k,last1,0);
        splay(k,next1,last1);
        c[next1][0]=0;
        pushup(next1);
    }
    int rank(int k,int num)
    {
        find(k,num);
//        cout<<size[c[root[k]][0]]+(val[root[k]]<=num)-1<<endl;
        return size[c[root[k]][0]]+(val[root[k]]<=num)-1;
    }
    void init()
    {
        memset(size,0,sizeof(size));
        memset(c,0,sizeof(c));
        memset(fa,0,sizeof(fa));
        memset(val,0,sizeof(val));
        for(int i=1;i<=50000;i++)
        {
            insert(i,inf);
            insert(i,-inf);
        }
    }
}T;

void seg_change(int k,int l,int r,int want,int oldnum,int newnum)
{
    if(oldnum!=-inf) T.del(k,oldnum);
    T.insert(k,newnum);
    if(l==r) return;
    int mid=(l+r)>>1;
    if(mid>=want) seg_change(k*2,l,mid,want,oldnum,newnum);
    else seg_change(k*2+1,mid+1,r,want,oldnum,newnum);
}

int seg_query(int k,int l,int r,int wantl,int wantr,int num)
{
    if(l>wantr||r<wantl) return 0;
    if(l>=wantl&&r<=wantr) return T.rank(k,num);
    int mid=(l+r)>>1;
    return seg_query(k*2,l,mid,wantl,wantr,num)+seg_query(k*2+1,mid+1,r,wantl,wantr,num);
}

int main()
{
//    scanf("%d",&T1);
//    while(T1--)
//    {
//        memset(root,0,sizeof(root));
        T.init();
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            seg_change(1,1,n,i,-inf,a[i]);
        }
        while(m--)
        {
            scanf("%s",s);
            if(s[0]=='Q')
            {
                int x,y,z;
                scanf("%d%d%d",&x,&y,&z);
                int low=0,high=1000000000;
                while(low<=high)
                {
                    int mid=(low+high)>>1;
                    int nowans=seg_query(1,1,n,x,y,mid);

                    if(nowans>=z) { ans=mid;high=mid-1; }
                    else low=mid+1;
                }
                printf("%d\n",ans);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                seg_change(1,1,n,x,a[x],y);
                a[x]=y;
            }
        }
//    }
    return 0;
}