bzoj 3196 Tyvj 1730 二逼平衡树

最新推荐文章于 2018-12-31 09:52:00 发布

原创最新推荐文章于 2018-12-31 09:52:00 发布 · 435 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#bzoj #树套树

数据结构同时被 3 个专栏收录

30 篇文章

订阅专栏

bzoj

26 篇文章

订阅专栏

树套树

3 篇文章

订阅专栏

本文介绍了一种数据结构实现方法——线段树套平衡树，并提供了完整的代码示例。这种方法适用于解决区间操作和查询问题，特别是当涉及到数值范围查询和更新时。

懒得扒题了，还是直接上链接吧。
传送门：http://www.lydsy.com/JudgeOnline/problem.php?id=3196

Key To Problem

线段树套平衡树，第一位区间，第二位是数。

Code

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define N 50010
#define inf 1000000000
#define ls tr[k].l
#define rs tr[k].r
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
using namespace std;
struct node
{
    int l,r,v,w,size,rnd;
};
node tr[N<<6];
int n,m,size,ans;
int a[N<<2];
int root[N<<2];

void updata(int &k)
{
    tr[k].size=tr[ls].size+tr[rs].size+tr[k].w;
}

void lturn(int &k)
{
    int t=rs;
    tr[k].r=tr[t].l,tr[t].l=k;
    tr[t].size=tr[k].size;
    updata(k);
    k=t;
}

void rturn(int &k)
{
    int t=ls;
    tr[k].l=tr[t].r,tr[t].r=k;
    tr[t].size=tr[k].size;
    updata(k);
    k=t;
}

void insert(int &k,int x)
{
    if(!k)
    {
        k=++size;
        tr[k].v=x,tr[k].w=tr[k].size=1,tr[k].rnd=rand();
        return ;
    }
    tr[k].size++;
    if(x==tr[k].v)tr[k].w++;
    else if(x>tr[k].v)
    {
        insert(rs,x);
        if(tr[rs].rnd<tr[k].rnd)lturn(k);
    }else if(x<tr[k].v)
    {
        insert(ls,x);
        if(tr[ls].rnd<tr[k].rnd)rturn(k);
    } 
}

void build(int l,int r,int rt,int c,int x)
{
    insert(root[rt],c);
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(mid>=x)build(lson,c,x);
    else build(rson,c,x);
}

void ask_rank(int &k,int x)
{
    if(!k)return ;
    if(tr[k].v==x)
    {
        ans+=tr[ls].size;
        return ;
    }else if(x>tr[k].v)
        ans+=tr[ls].size+tr[k].w,ask_rank(rs,x);
    else
        ask_rank(ls,x);
}

void query_rank(int l,int r,int rt,int L,int R,int c)
{
    if(l==L&&r==R)
    {
        ask_rank(root[rt],c);
        return ;
    }
    int mid=(l+r)>>1;
    if(mid>=R)query_rank(lson,L,R,c);
    else if(mid<L)query_rank(rson,L,R,c);
    else{
        query_rank(lson,L,mid,c);
        query_rank(rson,mid+1,R,c);
    }
}

int query_index(int L,int R,int c)
{
    int l=0,r=inf,tmp;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        ans=1,query_rank(1,n,1,L,R,mid);
        if(ans<=c)
        {
            tmp=mid;
            l=mid+1;
        }else
            r=mid-1;
    }
    return tmp;
}

void del(int &k,int x)
{
    if(x==tr[k].v)
    {
        if(tr[k].w>1)tr[k].w--,tr[k].size--;
        else if(ls*rs==0)k=ls+rs;
        else if(tr[ls].rnd<tr[rs].rnd)
            rturn(k),del(k,x);
        else lturn(k),del(k,x);
    }else if(x>tr[k].v)
        del(rs,x),tr[k].size--;
    else del(ls,x),tr[k].size--;
}

void change(int l,int r,int rt,int x,int c)
{
    del(root[rt],a[x]);
    insert(root[rt],c);
    if(l==r)return ;
    int mid=(l+r)>>1;
    if(mid>=x)change(lson,x,c);
    else change(rson,x,c);
}

void ask_before(int k,int x)
{
    if(!k)return ;
    if(x>tr[k].v)
        ans=max(ans,tr[k].v),ask_before(rs,x);
    else ask_before(ls,x);
}

void query_before(int l,int r,int rt,int L,int R,int c)
{
    if(l==L&&r==R)
    {
        ask_before(root[rt],c);
        return ;
    }
    int mid=(l+r)>>1;
    if(mid>=R)query_before(lson,L,R,c);
    else if(mid<L)query_before(rson,L,R,c);
    else{
        query_before(lson,L,mid,c);
        query_before(rson,mid+1,R,c);
    }
}

void ask_after(int k,int x)
{
    if(!k)return ;
    if(x<tr[k].v)
    {
        ans=min(ans,tr[k].v);
        ask_after(ls,x);
    }else ask_after(rs,x);
}

void query_after(int l,int r,int rt,int L,int R,int c)
{
    if(l==L&&r==R)
    {
        ask_after(root[rt],c);
        return ;
    }
    int mid=(l+r)>>1;
    if(mid>=R)query_after(lson,L,R,c);
    else if(mid<L)query_after(rson,L,R,c);
    else{
        query_after(lson,L,mid,c);
        query_after(rson,mid+1,R,c);
    }
}

int main()
{
//  freopen("lll.in","r",stdin);
//  freopen("ppp.out","w",stdout);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        build(1,n,1,a[i],i);
    }
    while(m--)
    {
        int opt,x,y,z;
        scanf("%d",&opt);
        switch(opt)
        {
            case 1: scanf("%d%d%d",&x,&y,&z);
                    ans=1,query_rank(1,n,1,x,y,z);
                    printf("%d\n",ans);
                    break;
            case 2: scanf("%d%d%d",&x,&y,&z);
                    printf("%d\n",query_index(x,y,z));
                    break;
            case 3: scanf("%d%d",&x,&z);
                    change(1,n,1,x,z),a[x]=z;
                    break;
            case 4: scanf("%d%d%d",&x,&y,&z);
                    ans=0,query_before(1,n,1,x,y,z);
                    printf("%d\n",ans);
                    break;
            case 5: scanf("%d%d%d",&x,&y,&z);
                    ans=inf,query_after(1,n,1,x,y,z);
                    printf("%d\n",ans);
                    break;
        }
    }
    return 0;
}