bzoj3217 ALOEXT

替罪羊套$01Trie$

一看就是傻逼树套树，后来一直$MLE$，发现有内存没删干净。删了之后$TLE$，$Trie$重载$new$和$delete$了就快的飞起了。

#include<cstdio>
#include<iostream>
#include<vector>
#define N 200050
#define alp 0.75
#define inf 0x7fffffff
#define MAX(a,b) ((a>b)?(a):(b))
#define MIN(a,b) ((a<b)?(a):(b))
using namespace std;

char xch,xB[1<<15],*xS=xB,*xTT=xB;
#define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
inline int read()
{
    int x=0,f=1;char ch=getc();
    while(ch<'0'|ch>'9'){if(ch=='-')f=-1;ch=getc();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
    return x*f;
}

int n,m,tot;
namespace Trie{
    struct Node{
        Node *ch[2];
        int size;
        Node();
        inline void* operator new(size_t);
        inline void operator delete(void* p);
    }*null=new Node(),*root[N],*L[N],*C,*mempool;
    inline Node:: Node(){
        ch[0]=ch[1]=null;
        size=0;
    }
    std::vector<Node*>bin;
    inline void* Node::operator new(size_t){
        Node *p;
        if(!bin.empty()) {
            p = bin.back();
            bin.pop_back();
        }
        else {
            if(C == mempool) C = new Node[1 << 15], mempool = C + (1 << 15);
            p = C ++;
        }
        return p;
    }
    inline void Node::operator delete (void* p){
        bin.push_back((Node*)p);
    }
    inline void init(){
        null->ch[0]=null->ch[1]=null;null->size=0;
        for(int i=1;i<=n+m;i++)root[i]=new Node();
    }
    inline void dfs(Node *&rt){
        if(rt==null)return ;
        dfs(rt->ch[0]);
        dfs(rt->ch[1]);
        delete (rt);
    }
    inline void insert(Node *rt,int x){
        rt->size++;
        for(int i=19;~i;i--){
            bool t=(x>>i)&1;
            if(rt->ch[t]==null)
                rt->ch[t]=new Node();
            rt=rt->ch[t];
            rt->size++;
        }
    }
    inline void del(Node *rt,int x){
        rt->size--;
        for(int i=19;~i;i--){
            bool t=(x>>i)&1;
            rt->ch[t]->size--;
            if(rt->ch[t]->size==0){/*dfs(rt->ch[t]);*/rt->ch[t]=null;break;}
            rt=rt->ch[t];
        }
    }
}
struct Node{
    Node *ch[2];
    int key,size,cover,ex,id,mx,sec;
    inline void pushup(){
        if(ex){
            mx=MAX(MAX(ch[0]->mx,ch[1]->mx),key);
            if(mx==key)sec=MAX(ch[0]->mx,ch[1]->mx);
            else if(mx==ch[0]->mx)sec=MAX(key,MAX(ch[0]->sec,ch[1]->mx));
            else sec=MAX(key,MAX(ch[0]->mx,ch[1]->sec));
        }
        else{
            mx=MAX(ch[0]->mx,ch[1]->mx);
            if(mx==ch[0]->mx)sec=MAX(ch[0]->sec,ch[1]->mx);
            else sec=MAX(ch[0]->mx,ch[1]->sec);
        }
        size=ch[0]->size+ch[1]->size+ex;
        cover=ch[0]->cover+ch[1]->cover+1;
    }
    inline bool bad(){
        return ch[0]->cover>=cover*alp+5||ch[1]->cover>=cover*alp+5;
    }
    Node(int x,int y);
}*null=new Node(0,0),*root,*sta[N];
int len,l_len;
inline Node :: Node(int x,int y){
    key=mx=x;sec=-inf;id=y;
    ch[0]=ch[1]=null;
    size=cover=ex=1;
}
inline void init(){
    null->ch[0]=null->ch[1]=null;
    null->size=null->cover=null->ex=0;
    null->mx=null->sec=-inf;
    root=null;
}
inline Node **insert(Node *&now,int x,int y,int pos){
    if(now==null){
        now=new Node(y,pos);
        Trie::insert(Trie::root[now->id],y);
        return &null;
    }
    Trie::insert(Trie::root[now->id],y);
    Node **ret;
    if(now->ch[0]->size>=x)ret=insert(now->ch[0],x,y,pos);
    else ret=insert(now->ch[1],x-now->ch[0]->size-now->ex,y,pos);
    now->pushup();
    if(now->bad())ret=&now;
    return ret;
}

inline void travel(Node *now){
    if(now==null)return;
    Trie::dfs(Trie::root[now->id]);
    travel(now->ch[0]);
    if(now->ex){sta[++len]=now;travel(now->ch[1]);}
    else{travel(now->ch[1]);delete(now);}
}
inline Node *divide(int l,int r){
    if(l>r)return null;
    int mid=(l+r)>>1;
    sta[mid]->ch[0]=divide(l,mid-1);
    sta[mid]->ch[1]=divide(mid+1,r);
    sta[mid]->pushup();
    Trie::root[sta[mid]->id]=new Trie::Node();
    for(int i=l;i<=r;i++)
        Trie::insert(Trie::root[sta[mid]->id],sta[i]->key);
    return sta[mid];
}
inline void rebuild(Node *&now){
    len=0;travel(now);
    now=divide(1,len);
}
inline void insert(int x,int y,int pos){
    Node **p=insert(root,x,y,pos);
    if(*p!=null)rebuild(*p);
}
inline int find(Node *now,int x){
    if(now->ex&&x==now->ch[0]->size+1)return now->key;
    if(now->ch[0]->size>=x)return find(now->ch[0],x);
    else return find(now->ch[1],x-now->ch[0]->size-now->ex);
}
inline void del(Node *now,int x,int y){
    Trie::del(Trie::root[now->id],y);
    if(now->ex&&x==now->ch[0]->size+1){now->ex=0;now->pushup();return;}
    if(now->ch[0]->size>=x)del(now->ch[0],x,y);
    else del(now->ch[1],x-now->ch[0]->size-now->ex,y);
    now->pushup();
}
inline void del(int x){
    del(root,x,find(root,x));
    if(root->size<=root->cover*alp+5)rebuild(root);
}
inline void change(Node *now,int x,int y,int z){
    Trie::del(Trie::root[now->id],y);
    Trie::insert(Trie::root[now->id],z);
    if(now->ex&&x==now->ch[0]->size+1){
        now->key=z;
        now->pushup();
        return;
    }
    if(now->ch[0]->size>=x)change(now->ch[0],x,y,z);
    else change(now->ch[1],x-now->ch[0]->size-now->ex,y,z);
    now->pushup();
}
inline void change(int x,int y){
    change(root,x,find(root,x),y);
}
int MX,SEC;
inline void query_init(Node *now,int l,int r){
    if(now==null)return;
    if(r-l+1==now->size){
        if(now->mx>MX){SEC=MAX(MX,now->sec);MX=now->mx;}
        else SEC=MAX(SEC,now->mx);
        Trie::L[++l_len]=Trie::root[now->id];
        return;
    }
    if(now->ex&&now->ch[0]->size+1>=l&&now->ch[0]->size+1<=r){
        Trie::insert(Trie::L[1],now->key);
        if(now->key>MX)SEC=MX,MX=now->key;
        else SEC=MAX(SEC,now->key);
    }
    if(now->ch[0]->size>=l)query_init(now->ch[0],l,MIN(now->ch[0]->size,r));
    if(now->ch[0]->size+now->ex<r)query_init(now->ch[1],MAX(1,l-now->ch[0]->size-now->ex),r-now->ch[0]->size-now->ex);
}
inline int query_work(int x){
    int ans=0;
    for(int i=19;~i;i--){
        int t=(x>>i)&1,num=0;
        for(int j=1;j<=l_len;j++)
            num+=Trie::L[j]->ch[t^1]->size;
        ans+=(num?1:0)<<i;
        for(int j=1;j<=l_len;j++)
            Trie::L[j]=Trie::L[j]->ch[t^(num?1:0)];
    }
    return ans;
}
inline int query(int l,int r){
    l_len=0;
    Trie::L[++l_len]=new Trie::Node();
    MX=SEC=-inf;
    query_init(root,l,r);
    Trie::L[0]=Trie::L[1];
    int ans=query_work(SEC);
    Trie:: dfs(Trie::L[0]);
    return ans;
}
int main(){
    n=read();m=read();tot=n;
    init();Trie::init();
    for(int i=1,x;i<=n;i++){
        x=read();
        sta[i]=new Node(x,i);
    }
    root=divide(1,n);
    int ans=0,x,y,l,r;char ch;
    while(m--){
        ch=getc();
        while(ch!='I'&&ch!='D'&&ch!='C'&&ch!='F')ch=getc();
        if(ch=='I'){
            x=(read()+ans)%n;y=(read()+ans)%1048576;
            insert(x,y,++tot);n++;
        }
        if(ch=='D'){
            x=(read()+ans)%n;
            del(x+1);n--;
        }
        if(ch=='C'){
            x=(read()+ans)%n;y=(read()+ans)%1048576;
            change(x+1,y);
        }
        if(ch=='F'){
            l=(read()+ans)%n;r=(read()+ans)%n;
            ans=query(l+1,r+1);
            printf("%d
",ans);
        }
    }
    return 0;
}