各种树模板(splay,线段树,可持久化线段树...)

Splay

AC tyvj1728 普通平衡树

#include <cstdio>
#include <iostream>
#include <fstream>

#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>

typedef long long int ll;
typedef double db;

using namespace std;

struct SplayTree
{
    struct node
    {
        int v;
        int tot;
        node*s[2];
        node*f;
        
        void update()
        {
            tot=s[0]->tot + s[1]->tot +1;
        }
    };
    node*pool;
    node*nt;
    node*nil;
    node*newnode(node*f,int v)
    {
        nt->v=v;
        nt->tot=1;
        nt->s[0]=nt->s[1]=nil;
        nt->f=f;
        return nt++;
    }
    
    node*root;
    
    SplayTree(int size)
    {
        pool=new node[size+1];
        nt=pool;
        nil=newnode(NULL,-1);
        nil->tot=0;
        nil->f=nil->s[0]=nil->s[1]=nil;
        root=nil;
    }
    
    //===============================================
    
    void update(node*x)
    {
        x->tot= x->s[0]->tot + x->s[1]->tot +1;
    }
    
    void rot(node*x)
    {
        if(x==nil) return ;
        
        node*y=x->f;
        int k=(x==y->s[0]);
        
        y->s[k^1]=x->s[k];
        if(x->s[k]!=nil) x->s[k]->f=y;
        
        x->f=y->f;
        if(y==y->f->s[0]) y->f->s[0]=x;
        else if(y==y->f->s[1]) y->f->s[1]=x;
        
        y->f=x;
        x->s[k]=y;
        
        y->update();
    }
    
    void splay(node*x) { splay(x,nil); }
    void splay(node*x,node*t)
    {
        if(x==nil) return ;
        while(x->f!=t)
        {
            node*y=x->f;
            if(y->f!=t) 
            if((x==y->s[0])^(y==y->f->s[0]))
                rot(x); else rot(y);
            rot(x);
        }
        x->update();
        
        if(t==nil) root=x;
    }
    
    //=============================================
    
    void Insert(int v)
    {
        if(root==nil)
        {
            root=newnode(nil,v);
            return ;
        }
        
        node*x=root;
        node*y=x;
        while(x!=nil)
        {
            y=x;
            if(v<x->v) x=x->s[0];
            else x=x->s[1];
        }
        
        int k=!(v<y->v);
        y->s[k]=newnode(y,v);
        splay(y->s[k]);
    }
    
    
    node*Find(int v)
    {
        node*x=root;
        node*y=x;
        node*r=nil;
        while(x!=nil)
        {
            y=x;
            if(x->v==v) r=x;
            if(v<=x->v) x=x->s[0];
            else x=x->s[1];
        }
        splay(y);
        return r;
    }
    
    node* FindRank(int k)
    {
        node*x=root;
        node*y=x;
        while(x!=nil)
        {
            y=x;
            if(k==x->s[0]->tot+1) break;
            
            if(k<x->s[0]->tot+1)
                x=x->s[0];
            else
            {
                k-=x->s[0]->tot+1;
                x=x->s[1];
            }
        }
        splay(y);
        return x;
    }
    
    int GetRank(node*x)
    {
        splay(x);
        return x->s[0]->tot+1;
    }
    
    int GetRevRank(node*x)
    {
        splay(x);
        return x->s[1]->tot+1;
    }
    
    node*Delete(node*x)
    {
        int k=GetRank(x);
        node*L=FindRank(k-1);
        node*R=FindRank(k+1);
        
        splay(L);
        splay(R,L);
        
        if(L==nil && R==nil) root=nil;
        else if(R==nil) L->s[1]=nil;
        else R->s[0]=nil;
        
        if(R!=nil) update(R);
        if(L!=nil) update(L);
        
        return x;
    }
    
    node*prefix(int v)
    {
        node*x=root;
        node*y=x;
        node*r=nil;
        while(x!=nil)
        {
            y=x;
            if(x->v<v) r=x;
            if(v<=x->v) x=x->s[0];
            else x=x->s[1];
        }
        splay(y);
        return r;
    }
    
    node*suffix(int v)
    {
        node*x=root;
        node*y=x;
        node*r=nil;
        while(x!=nil)
        {
            y=x;
            if(x->v>v) r=x;
            if(v<x->v) x=x->s[0];
            else x=x->s[1];
        }
        splay(y);
        return r;
    }
    
    
    
    
    //===========================================
    void output() { output(root); printf("%s\n",root==nil ? "empty tree!" : ""); }
    void output(node*x)
    {
        if(x==nil)return ;
        output(x->s[0]);
        printf("%d ",x->v);
        output(x->s[1]);
    }
    
    void test() { test(root); printf("%s\n",root==nil ? "empty tree!" : ""); }
    void test(node*x)
    {
        if(x==nil)return ;
        test(x->s[0]);
        printf("%p [ v:%d f:%p L:%p R:%p tot:%d ] \n",x,x->v,x->f,x->s[0],x->s[1],x->tot);
        test(x->s[1]);
    }
    
};


int n;

int main()
{
    scanf("%d",&n);
    SplayTree st(n);
    
    for(int i=0;i<n;i++)
    {
        int c;
        scanf("%d",&c);
        switch(c)
        {
            case 1: //Insert
                scanf("%d",&c);
                st.Insert(c);
            break;
            case 2: //Delete
                scanf("%d",&c);
                st.Delete(st.Find(c));
            break;
            case 3: //Rank
                scanf("%d",&c);
                printf("%d\n",st.GetRank(st.Find(c)));
            break;
            case 4: //FindRank
                scanf("%d",&c);
                printf("%d\n",st.FindRank(c)->v);
            break;
            case 5: //prefix
                scanf("%d",&c);
                printf("%d\n",st.prefix(c)->v);
            break;
            case 6: //suffix
                 scanf("%d",&c);
                 printf("%d\n",st.suffix(c)->v);
            break;
            case 7: //test
                st.test();
            break;
            default: break; 
        } 
    }

    return 0;
}

 

2015年2月19日更新:

我现在才发现我写的双旋一直都是错的!!!!!

记住如果是折线就两次rot(x),直线才是先y后x! if((x==y->s[0])^(y==y->f->s[0])) rot(x); else rot(y);

要点1.别忘了有事没事splay一下保证复杂度.....

要点2.各种if的顺序别搞混了!有些if是不能合并的.

要点3.记住splay前的特判.如果要单独使用rotate就给rotate也加特判.

要点4.不要有事没事就更改某些子树的位置!比如在delete的时候,提x作根,然后找到右子树最左边的节点后,合并左右两颗子树,这是会超时的!

 

AC BZOJ 2733

 

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>

#include <bitset>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

struct node*nil;
struct node
{
    int v;
    int tot;
    node*s[2],*f;
    int code;
    void update(){ tot = s[0]->tot + s[1]->tot +1; }
    
};
node*nt;
int ncnt=10000;
node*newnode(node*f,int v,int c)
{
    if(ncnt==10000) { ncnt=0; nt=new node[10000]; }
    nt->f=f;
    nt->s[0]=nt->s[1]=nil;
    nt->tot=1;
    nt->v=v;
    nt->code=c;
    ncnt++;
    return nt++;
}

struct SplayTree
{
    node*root;
    
    SplayTree(){ root=nil; }
    
    void rot(node*x)
    {
        node*y=x->f;
        if(y==nil) return ;
        int k=(x==y->s[0]);
        
        y->s[!k]=x->s[k];
        if(x->s[k]!=nil) x->s[k]->f=y;
        
        x->f=y->f;
        if(y==y->f->s[0]) y->f->s[0]=x;
        else if(y==y->f->s[1]) y->f->s[1]=x;
        
        y->f=x;
        x->s[k]=y;
        
        y->update();
    }
    
    void splay(node*x,node*t=nil)
    {
        while(x->f!=t)
        {
            node*y=x->f;
            if(y->f!=t)
            if((x==y->s[0])^(y==y->f->s[0]))
            rot(x); else rot(y);
            rot(x);
        }
        x->update();
        if(t==nil) root=x;
    }
    
    void Insert(int v,int c)
    { root=newnode(nil,v,c); }
    
    void Insert(node*t)
    {
        if(root==nil) 
        { root=t; t->s[0]=t->s[1]=t->f=nil; t->tot=1; return ; }
        
        node*x=root;
        node*y=nil;
        while(x!=nil)
        y=x,x=x->s[t->v>=x->v];
        
        int k=(t->v>=y->v);
        
        t->s[0]=t->s[1]=nil; t->tot=1;
        y->s[k]=t; t->f=y;
        
        splay(t);
    }
    
    node*FindRank(int k)
    {
        if(k>root->tot || k<=0) return nil;
        node*x=root;
        node*y=nil;
        while(x!=nil)
        {
            y=x;
            if(k==x->s[0]->tot+1) break;
            if(k>x->s[0]->tot+1)
            {
                k-=x->s[0]->tot+1;
                x=x->s[1];
            }
            else
                x=x->s[0];
        }
        splay(y);
        return y;
    }
};

node*ary[105000]; int ac,ah;
void Merge(SplayTree*&A,SplayTree*&B)
{
    if(A->root==B->root) return ;
    if(A->root->tot>B->root->tot) swap(A,B);
    //descrete nodes of A and insert to B.
    ah=ac=0;
    ary[ac++]=A->root;
    while(ah!=ac)
    {
        node*x=ary[ah];
        if(x->s[0]!=nil) ary[ac++]=x->s[0];
        if(x->s[1]!=nil) ary[ac++]=x->s[1];
        B->Insert(x);
        ah++;
    }
    A=B;
}

SplayTree**T;

int n,m,q;

int main()
{
    nil=new node;
    nil->f=nil->s[0]=nil->s[1]=nil;
    nil->tot=0;
    nil->code=nil->v=-2;
    
    n=getint();
    m=getint();
    
    T=new SplayTree*[n];
    for(int i=0;i<n;i++)
    {
        T[i]=new SplayTree;
        T[i]->Insert(getint(),i);
    }
    
    for(int i=0;i<m;i++)
    {
        int a=getint()-1;
        int b=getint()-1;
        if(T[a]!=T[b]) Merge(T[a],T[b]);
    }
    
    q=getint();
    for(int i=0;i<q;i++)
    {
        char c=getchar();
        while(c!='B' && c!='Q') c=getchar();
        int a=getint()-1;
        int b=getint()-1;
        if(c=='B')
        {
            if(T[a]!=T[b]) Merge(T[a],T[b]);
        }
        else if(c=='Q')
        {
            if(a<0 || a>=n) printf("%d\n",-1);
            else
            printf("%d\n",T[a]->FindRank(b+1)->code+1);
        }
    }
    
    return 0;
}

 

 

启发式合并两棵SplayTree.

代码好长....

速度好慢.....

o(╯□╰)o......

 

 

---

Treap

虽然说蛮好玩的.....

速度快得不行....

但是感觉代码复杂度跟splay一样啊.....

AC BZOJ3224 普通平衡树

排序Treap.

 

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-80;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//===================================================================
//===================================================================
//===================================================================
//===================================================================

int INF=(1<<30)-1;

int getrand()
{ return rand()+32768*rand(); }

int t[105000];
int tot[105000];
int hp[105000];
int s[105000][2];
int f[105000];
int ntot=1;

int n;

void update(int x)
{ if(x) tot[x] = tot[s[x][0]] + tot[s[x][1]] +1; }

int root=0;
void rot(int x)
{
    int y=f[x];
    int k=(x==s[y][0]);
    s[y][!k]=s[x][k];
    if(s[x][k]) f[s[x][k]]=y;
    f[x]=f[y];
    if(y==s[f[y]][0]) s[f[y]][0]=x;
    else if(y==s[f[y]][1]) s[f[y]][1]=x;
    f[y]=x;
    s[x][k]=y;
    update(y);
    update(x);
    if(!f[x]) root=x;
}

int lift(int x)
{ while(f[x] && hp[x]<hp[f[x]]) rot(x);}

void Insert(int v)
{
    if(!root)
    { t[ntot]=v; tot[ntot]=1; root=ntot++; return ; }
    
    int x=root;
    int k=-1;
    while(true)
    {
        tot[x]++;
        if(v>t[x])
        {
            if(!s[x][1]) { k=1; break; }
            x=s[x][1];
        }
        else 
        {
            if(!s[x][0]) { k=0; break; }
            x=s[x][0];
        }
    }
    
    f[ntot]=x;
    tot[ntot]=1;
    hp[ntot]=getrand();
    t[ntot]=v;
    s[x][k]=ntot++;
    lift(s[x][k]);
}

int FindRank(int k)
{
    int x=root;
    int y=0;
    while(x)
    {
        y=x;
        if(k==tot[s[x][0]]+1) break;
        if(k<=tot[s[x][0]])
        x=s[x][0];
        else
        {
            k-=tot[s[x][0]]+1;
            x=s[x][1];
        }
    }
    return y;
}

int Find(int v)
{
    int x=root;
    while(true)
    {
        if(t[x]==v) return x;
        else x=s[x][v>=t[x]];
    }
    return -1;
}

int Rank(int v)
{
    int x=root;
    int r=0;
    while(x)
    {
        if(v>t[x])
        {
            r+=tot[s[x][0]]+1;
            x=s[x][1];
        }
        else
            x=s[x][0];
    }
    return r;
}

void Delete(int x)
{
    while(s[x][0] || s[x][1])
    {
        if(s[x][0]) rot(s[x][0]);
        else rot(s[x][1]);
    }
    
    if(!f[x]) root=0;
    else
    s[f[x]][x==s[f[x]][1]]=0;
    
    x=f[x];
    while(x) tot[x]--,x=f[x];
}

int Prefix(int v)
{
    int x=root;
    int r=-INF;
    while(x)
    {
        if(t[x]<v) r=t[x]; 
        x=s[x][v>t[x]];
    }
    return r;
}

int Suffix(int v)
{
    int x=root;
    int r=INF;
    while(x)
    {
        if(t[x]>v) r=t[x];
        x=s[x][v>=t[x]];
    }
    return r;
}

int a[105000];

int main()
{
    srand(23333);
    
    n=getint();
    for(int i=0;i<n;i++)
    {
        int c=getint();
        switch(c)
        {
            case 1: Insert(getint()); break;
             case 2: Delete(Find(getint())); break;
            case 3:  printf("%d\n",Rank(getint())+1); break;
            case 4:  printf("%d\n",t[FindRank(getint())]); break;
            case 5:  printf("%d\n",Prefix(getint())); break;
            default: printf("%d\n",Suffix(getint())); break;
        }
    }
    
    return 0;
}

 

 

 

---

线段树

AC BZOJ 3212 A Simple Problem 经典题

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


int n,m;
int a[105000];
ll t[405000];
ll tag[405000];
void Build(int x=1,int l=0,int r=n-1)
{
    if(l==r) { t[x]=a[l]; return ; }
    int mid=(l+r)>>1;
    Build(x<<1,l,mid); Build(x<<1|1,mid+1,r);
    t[x]=t[x<<1]+t[x<<1|1];
}
int cl,cr,cv;
void Change(int x=1,int l=0,int r=n-1)
{
    if(cr<l || r<cl) return ;
    if(cl<=l && r<=cr) { tag[x]+=cv; return ; }
    int mid=(l+r)>>1;
    Change(x<<1,l,mid),Change(x<<1|1,mid+1,r);
    t[x]=t[x<<1]+tag[x<<1]*(mid-l+1)+t[x<<1|1]+tag[x<<1|1]*(r-mid);
}
int ql,qr;
ll Query(int x=1,int l=0,int r=n-1)
{
    if(qr<l || r<ql) return 0;
    if(ql<=l && r<=qr) return t[x]+tag[x]*(r-l+1);
    int mid=(l+r)>>1;
    return Query(x<<1,l,mid)+Query(x<<1|1,mid+1,r)+
            tag[x]*(min(r,qr)-max(l,ql)+1);
}
int main()
{
    n=getint();
    m=getint();
    for(int i=0;i<n;i++)
    a[i]=getint();
    Build();
    for(int i=0;i<m;i++)
    {
        char c=getchar();
        while(c!='Q' && c!='C') c=getchar();
        if(c=='C')
        {
            cl=getint()-1;
            cr=getint()-1;
            cv=getint();
            Change();
        }
        else //if(c=='Q')
        {
            ql=getint()-1;
            qr=getint()-1;
            printf("%lld\n",Query());
        }
    }
    
    return 0;
}

区间加,区间求和.永久性lazytag.常数大概是普通线段树的四分之一.......

 

AC BZOJ 3685 用线段树做平衡树查询

 

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while((c<'0' || c>'9')/* && !feof(stdin)*/) mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9'/* && !feof(stdin)*/) res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

int n;
int L,R;
int t[4005000];

int cp,cv;
void Change(int x=1,int l=L,int r=R)
{
    if(l==r) { t[x]=cv; return ; }
    int mid=(l+r)>>1;
    if(cp<=mid) Change(x<<1,l,mid);
    else Change(x<<1|1,mid+1,r);
    t[x]=t[x<<1]+t[x<<1|1];
}

int GetMin(int x=1,int l=L,int r=R)
{
    if(!t[x]) return -1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(t[x<<1]) { r=mid; x<<=1; }
        else { l=mid+1; x=x<<1|1; }
    }
    return l;
}

int GetMax(int x=1,int l=L,int r=R)
{
    if(!t[x]) return -1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(t[x<<1|1]) { l=mid+1; x=x<<1|1; }
        else { r=mid; x<<=1; }
    }
    return l;
}

int Exist(int p,int x=1,int l=L,int r=R)
{
    if(!t[x]) return -1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(p<=mid) { x<<=1; r=mid; }
        else { x=x<<1|1; l=mid+1; }
        if(!t[x]) return -1;
    }
    return 1;
}

int Prefix(int v,int x=1,int l=L,int r=R)
{
    int y=0,yl=0,yr=0;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(v<=mid) { x<<=1; r=mid; }
        else 
        {
            if(t[x<<1]) { y=x<<1; yl=l; yr=mid; }
            x=x<<1|1; l=mid+1;
        }
    }
    return y ? GetMax(y,yl,yr) : -1;
}

int Suffix(int v,int x=1,int l=L,int r=R)
{
    int y=0,yl=0,yr=0;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(v<=mid)
        {
            if(t[x<<1|1]) { y=x<<1|1; yl=mid+1; yr=r; }
            x<<=1; r=mid;
        }
        else { x=x<<1|1; l=mid+1; }
    }
    return y ? GetMin(y,yl,yr) : -1;
}

int main()
{
    n=getint();
    L=-1; R=n+1;
    int m=getint();
    for(int i=0;i<m;i++)
    {
        int c=getint();
        switch(c)
        {
            case 1: cp=getint(); cv=1; Change(); break;
            case 2: cp=getint(); cv=0; Change(); break;
            case 3: printf("%d\n",GetMin()); break;
            case 4: printf("%d\n",GetMax()); break;
            case 5: printf("%d\n",Prefix(getint())); break;
            case 6: printf("%d\n",Suffix(getint())); break;
            case 7: printf("%d\n",Exist(getint()));
            default:break;
        }
    }
    
    return 0;
}

注意前驱和后继的写法:

想象一下前缀的搜索过程,我们先搜索到询问数字的代表节点,然后回退,如果左子树非空就进入这棵左子树并一直往右往下走.

先写一个GetMax和GetMin函数,表示找到某一棵子树中最靠右的存在的节点.

然后查询前驱(或后继)时,考虑记下一个"最右(左)可行子树y".就是说

我们遍历从根到所查询的值的节点的路径,如果遍历过程中往右(左)走了,并且当前节点左(右)子树非空,

那么拿当前节点的左(右)子树替换掉y,这样我们就得到了"最靠右(左)的可行子树".

然后在这棵子树中GetMax(GetMin)就行了.

 

 

---

可持久化线段树

AC VIJOS 1081 野生动物园

一道非常裸的区间k大

const int INF=(1<<30)-1;

struct node
{
    int t;
    node*l,*r;
    node(){ t=0; l=r=NULL;  }
    
    void update()
    { t=l->t+r->t; }
}pool[4000000];
int nt;
node*newnode()
{ return &pool[nt++]; }

node*nil;

node*root[100050];

void SegmentTreeInit(int size)
{
    nil=newnode();
    nil->l=nil->r=nil;
    nil->t=0;
    for(int i=0;i<=size;i++)
    root[i]=nil;
}

int cp;
node*Change(node*x,node*y,int l,int r)
{
    if(cp<l || r<cp) return y;
    x=newnode();
    if(l==r) { x->t=1+y->t; return x; }
    int mid=(l+r)>>1;
    x->l=Change(x->l,y->l,l,mid);
    x->r=Change(x->r,y->r,mid+1,r);
    x->update();
    return x;
}
void Change(int i,int j,int pos)
{ cp=pos; root[i]=Change(nil,root[j],0,INF); }

int Query(int ql,int qr,int k)
{
    node*x=root[ql],*y=root[qr];
    int l=0,r=INF;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if( k<= x->l->t - y->l->t )
             r=mid,x=x->l,y=y->l;
        else
        {
            k-=x->l->t-y->l->t;
            l=mid+1,x=x->r,y=y->r;
        }
    }
    return l;
}



int n;



int main()
{
    
    int q;
    scanf("%d",&n);
    scanf("%d",&q);
    
    SegmentTreeInit(n);
    
    
    for(int i=0;i<n;i++)
    {
        int c;
        scanf("%d",&c);
        cp=c;
        root[i+1]=Change(root[i+1],root[i],0,INF);
    }
    
    
    for(int i=0;i<q;i++)
    {
        int a,b,k;
        scanf("%d%d%d",&a,&b,&k);
        printf("%d\n",Query(b,a-1,k));
    }
    
    return 0;
}

要点1.使用nil节点可以省一点代码

要点2.千万注意空间开销.一般为nlogv级别,数组经常开上百万(懒得写离散化系列)

要点3.注意前缀和的写法. tree[R]-tree[L-1]. 这就要求root[0]=nil.

要点4.智商捉急表示普通查找操作总是写错...splay也一样.....思考...思考......写之前一定要想好....

 

AC BZOJ 3932 加强版的主席树,以时间轴为询问区间,插入一个值,删除一个值.

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

const int INF=10000001;

struct node*nil;
struct node
{
    int t;
    ll v;
    node*l,*r;
    
    void update()
    { t = l->t + r->t; v = l->v + r->v; }
    
};
int cnt=10000;
node*nt;
node*newnode()
{
    if(cnt==10000){ cnt=0; nt=new node[10000]; }
    nt->t=nt->v=0;
    nt->l=nt->r=nil;
    cnt++;
    return nt++;
}

int n,m;

node*root[105000];

struct operation
{
    int p; //time block
    int v; //value
    bool type; //0:add 1:dec
    
}op[205000];

bool cmp(const operation&a,const operation&b)
{ return a.p<b.p; }


int cp,cv;
node*Change(node*y,int l,int r)
{
    if(cp<l || r<cp) return y;
    node*x=newnode();
    if(l==r) { x->t=y->t+cv; x->v=y->v+cp*cv; return x; }
    int mid=(l+r)>>1;
    x->l=Change(y->l,l,mid);
    x->r=Change(y->r,mid+1,r);
    x->update();
    return x;
}

node*Change(int p,int v,node*pre)
{ cp=p; cv=v; return Change(pre,0,INF); }


int ql,qr;

ll rest;
ll last;
int Query(int k,node*x) //x-y. query for the kth node.
{
    if(x->t<k) return INF;
    int l=0,r=INF;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(k<=x->l->t)
        {
            x=x->l;
            r=mid;
        }
        else
        {
            k-=x->l->t;
            x=x->r;
            l=mid+1;
        }
    }
    rest=x->t-k;
    last=x->v/x->t;
    return l;
}

ll Query(node*x,int l=0,int r=INF) //x-y. query for sum.
{
    if(qr<l || r<ql) return 0;
    if(ql<=l && r<=qr) return x->v;
    int mid=(l+r)>>1;
    return Query(x->l,l,mid) + Query(x->r,mid+1,r);
}

int main()
{
    nil=newnode();
    nil->l=nil->r=nil;
    
    n=getint();
    m=getint();
    for(int i=0;i<n;i++)
    {
        int a=getint();
        int b=getint();
        int c=getint();
        op[i].p=a; op[i].v=c; op[i].type=0;
        op[i+n].p=b+1; op[i+n].v=c; op[i+n].type=1;
    }
    
    for(int i=0;i<=103000;i++) root[i]=nil;
    
    sort(op,op+2*n,cmp);

    int cur=0;
    for(int i=1;i<=103000;i++)
    {
        root[i]=root[i-1];
        while(op[cur].p==i && cur<2*n)
        {
            root[i]=Change(op[cur].v,op[cur].type==0 ? 1 : -1,root[i]);
            cur++;
        }
    }
    
    ll pre=1;
    
    ql=0;
    for(int i=0;i<m;i++)
    {
        int p=getint();
        int a=getint();
        int b=getint();
        int c=getint();
        ll k=((ll)a*pre+(ll)b)%c+1;
        qr=Query(k,root[p]);
        printf("%lld\n",pre=(Query(root[p])-rest*last));
    }
    
    
    return 0;
}

所以说啊....我写的可持久化线段树也没那么容易RE啊.....COT怎么就是A不了呢.....

WA了一发是因为没有想清楚前k个的含义,那些值与第k个元素相等但不计入结果的元素没有考虑进去....

哎......这个算智商么......

 

AC BZOJ3674 可持久化并查集加强版

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


struct node*nil;
struct node
{
    int v;
    node*l,*r;
};
int ncnt=4000;
node*nt;
node*newnode()
{
    if(ncnt==4000) { ncnt=0; nt=new node[4000]; }
    nt->v=0;
    nt->l=nt->r=nil;
    ncnt++;
    return nt++;
}

node*root[405000]; //operations.

int n,m;

int cp,cv;
node*Change(node*y,int l=0,int r=n+1)
{
    if(cp<l || r<cp) return y;
    node*x=newnode();
    if(l==r) { x->v=cv; return x; }
    int mid=(l+r)>>1;
    x->l=Change(y->l,l,mid);
    x->r=Change(y->r,mid+1,r);
    return x;
}

int Get(node*x,int p)
{
    int l=0,r=n+1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(p<=mid)
        x=x->l,r=mid;
        else
        x=x->r,l=mid+1;
    }
    return x->v;
}

node*Build(int l=0,int r=n+1)
{
    node*x=newnode();
    if(l==r) { x->v=l; return x; }
    int mid=(l+r)>>1;
    x->l=Build(l,mid);
    x->r=Build(mid+1,r);
    return x;
}

int findf(node*&t,int x)
{
    int f=Get(t,x);
    if(f==x) return x;
    int ff=findf(t,f);
    cp=x; cv=ff;
    t=Change(t);
    return ff;
}

int main()
{
    nil=newnode();
    nil->v=0;
    nil->l=nil->r=nil;
    
    n=getint();
    m=getint();
    
    root[0]=Build();
    
    int lastans=0;
    
    for(int i=1;i<=m;i++)
    {
        int c=getint();
        
        if(c==1) //Merge
        {
            int a=getint();
            int b=getint();
            
            root[i]=root[i-1];
            int fa=findf(root[i],a);
            int fb=findf(root[i],b);
            if(fa!=fb)
            {
                cp=fa;
                cv=fb;
                root[i]=Change(root[i]);
            }
        }
        else if(c==2) //Back
        {
            int k=getint()^lastans;
            root[i]=root[k];
        }
        else if(c==3) //Query
        {
            int a=getint()^lastans;
            int b=getint()^lastans;
            root[i]=root[i-1];
            int fa=findf(root[i],a);
            int fb=findf(root[i],b);
            printf("%d\n",lastans=(fa==fb));
        }
    }
    
    return 0;
}

好吧,不知怎么的就A了.....

加强版的话,不加路径压缩会TLE哦.....

 

AC BZOJ2588 SPOJ:COT Count On A Tree

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

struct edge
{ int in; edge*nxt; };
int ecnt=2000; edge*et;
edge*eds[105000];
void addedge(int a,int b)
{
    if(ecnt==2000) { ecnt=0; et=new edge[2000]; }
    et->in=b; et->nxt=eds[a]; eds[a]=et++; ecnt++;
}
#define FOREACH_EDGE(e,x) for(edge*e=eds[x];e;e=e->nxt)

int v[105000]; int lim=0;

struct node*nil;
struct node
{ int t; node*l,*r; void update(){t=l->t+r->t;} };
int ncnt=4000; node*nt;
node*newnode()
{
    if(ncnt==4000) { ncnt=0; nt=new node[4000]; }
    ncnt++; return nt++;
}
int cp;
node*Insert(node*y,int l=0,int r=lim-1)
{
    node*x=newnode();
    if(l==r) { x->l=x->r=nil; x->t=y->t+1; return x; }
    int mid=(l+r)>>1;
    x->l= cp<=mid ? Insert(y->l,l,mid) : y->l;
    x->r= cp>mid ? Insert(y->r,mid+1,r) : y->r;
    x->update(); return x;
}

int n,m,q;

int a[105000];
int dep[105000];
int f[105000];
node*root[105000];
int ch[105000]; int chtot=0;
int h[105000];

int Build(int x)
{
    //printf("%d\n",x);
    int sum=0;
    int mxp=0;
    int mx=0;
    FOREACH_EDGE(e,x)
    if(e->in!=f[x]) 
    {
        dep[e->in]=dep[x]+1;
        f[e->in]=x;
        cp=a[e->in]; root[e->in]=Insert(root[x]);
        int v=Build(e->in);
        if(v>mx) mx=v,mxp=e->in;
        sum+=v;
    }
    
    if(mxp) ch[x]=ch[mxp];
    else ch[x]=chtot++;
    h[ch[x]]=x;
    
    return sum+1;
}

int getlca(int a,int b)
{
    while(ch[a]!=ch[b])
    {
        if(dep[h[ch[a]]]<dep[h[ch[b]]]) swap(a,b);
        a=f[h[ch[a]]];
    }
    return dep[a]<dep[b] ? a : b;
}

int Query(int a,int b,int k)
{
    node*c[4];
    c[0]=root[a];
    c[1]=root[b];
    int lca=getlca(a,b);
    c[2]=root[lca];
    c[3]=root[f[lca]];
    int l=0,r=lim-1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        int lv=c[0]->l->t + c[1]->l->t - c[2]->l->t -c[3]->l->t;
        if(k<=lv)
        {
            for(int i=0;i<4;i++) c[i]=c[i]->l;
            r=mid;
        }
        else
        { 
            k-=lv;
            for(int i=0;i<4;i++) c[i]=c[i]->r;
            l=mid+1;
        }
    }
    return l;
}

int main()
{
    nil=new node;
    nil->t=0;
    nil->l=nil->r=nil;
    
    n=getint();
    m=n-1;
    q=getint();
    for(int i=0;i<n;i++) v[i]=a[i]=getint();
    sort(v,v+n);
    lim=int(unique(v,v+n)-v);
    for(int i=0;i<n;i++)
    a[i]=int(lower_bound(v,v+lim,a[i])-v);
    
    for(int i=0;i<m;i++)
    {
        int a=getint()-1;
        int b=getint()-1;
        addedge(a,b); addedge(b,a);
    }
    addedge(n,0); //node n is a sepcial dummy node.
    root[n]=nil; f[n]=n;
    Build(n);
    
    int lst=0;
    for(int i=0;i<q;i++)
    {
        int a=getint();
        int b=getint()-1;
        int k=getint();
        a=a^lst;
        a--;
        printf("%d",lst=v[Query(a,b,k)]);
        if(i!=q-1) printf("\n"); 
    }
    
    return 0;
}

终于A了啊.....

离散化 + HLD-LCA 拿到了rank3 2333333

 

 

 

 

---

树套树

AC VIJOS 1665

树状数组 套 动态开点的权值线段树

题目就是裸的带修改区间K大

写了一个多小时...调了大概....一个半小时?

树状数组怎么写都快忘记了........

由于懒得离散化......所以.....开了一个巨大的数组.......

VJ的内存限制不错....先把数组从400W改到800W...还是RE..怒而改到1.3kW...AC了.....

看了看空间消耗.....160M.....

这告诉我们千万不要忽视离散化的力量!  千万不要忽视常数空间!

但是我还是很懒=w=能不写离散化就不写离散化=w=

好吧......

下面是代码.....

附带一大版的文件头以及调试信息2333

 

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-18;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

inline int avg(const int a,const int b)
{ return a+((b-a)>>1); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

const int INF=(1<<30)-1;

int n;
struct node*nil;
struct node
{
    int v; //total
    node*l,*r;
    void update()
    { v=l->v+r->v; }
}pool[13000000];
node*nt=pool;
node*newnode()
{
    nt->l=nt->r=nil;
    nt->v=0;
    return nt++;
}

int cp,cv;

//Sub segment trees
struct SegmentTree
{
    node*root;
    
    node*Change(node*x,int l=0,int r=INF)
    {
        if(cp<l || r<cp) return x;
        if(x==nil) x=newnode();
        if(l==r) { x->v+=cv; return x; }
        int mid=avg(l,r);
        x->l=Change(x->l,l,mid);
        x->r=Change(x->r,mid+1,r);
        x->update();
        return x;
    }
    
    void Set(int p,int v)
    {
        if(root<pool) root=nil;
        cp=p;
        cv=v;
        root=Change(root);
    }
};

//original segment tree
//performed as tree array

#define bt(x) (x&-x)

int a[1000000]; //this array must be stay here....
SegmentTree t[1000000];
void Change(int p,int s,int v) //location of point, value of point, delete or add in.
{ for(int i=p;i<=n;i+=bt(i)) t[i].Set(s,v); }

node*c[1000];
int adt,ct;

int Query(int l,int r,int k) //find the element which is rank k.
{
    adt=0;
    
    for(int i=r;i>0;i-=bt(i))
    c[adt++]=t[i].root;
    
    ct=adt;
    for(int i=l-1;i>0;i-=bt(i))
    c[ct++]=t[i].root;
    
    //we perform add when i<adt, and than dec when adt<=i<ct
    
    
    l=0,r=INF;
    while(l!=r)
    {
        //for(int i=0;i<ct;i++)
        //cout<<c[i]<<' '; cout<<endl; cout<<l<<' '<<r<<endl; cout<<endl;
    
        int mid=avg(l,r);
        int clv=0; //current node's left node count.
        
        for(int i=0;i<adt;i++)
        clv+=c[i]->l->v;
        for(int i=adt;i<ct;i++)
        clv-=c[i]->l->v;
        
        if(k<=clv) //the element we want find is on the left block
        {
            for(int i=0;i<ct;i++)
                c[i]=c[i]->l;
            r=mid;
        }
        else
        {
            for(int i=0;i<ct;i++)
                c[i]=c[i]->r;
            k-=clv;
            l=mid+1;
        }
    }
    
    return l;
}

int q;

int main()
{
    nil=newnode();
    nil->l=nil->r=nil;
    nil->v=0;
    
    n=getint();
    q=getint();
    for(int i=0;i<n;i++)
    Change(i+1,a[i+1]=getint(),1);
    
    for(int i=0;i<q;i++)
    {
        char c[5];
        scanf("%s",c);
        if(c[0]=='C')
        {
            int i=getint();
            int v=getint();
            Change(i,a[i],-1);
            Change(i,a[i]=v,1);
        }
        else
        {
            int i=getint();
            int j=getint();
            int k=getint();
            printf("%d\n",Query(i,j,k));
        }
    }
    
    return 0;
}

 

 

需要注意的地方:

1.树状数组什么的一级结构别写错了啊啊啊啊啊啊

2.既然是动态开点(即便离散化了也给我动态!绝对不要写静态的树套在另外的树里面!)....

那么,我们只需要记录每棵树的根节点就好了.其它节点在访问的时候会碰到.

3.嗯....(结构相同的)线段树是可加的.......所以不要再去写二分,直接在加起来的那棵树上隐式二分即可.详见代码.可以降低一个log的复杂度.

4.二分的界,以及二分后的操作(k-=...)一定要考虑清楚.

2015年3月4日更新

<5.不知道为什么, 用@iwtwiioi在某些地方的AC代码交到VJ,TLE了...就AC了我第一次提交没有RE的那两个范围较小的点...... http://www.cnblogs.com/iwtwiioi/p/3929957.html>

嘛,以上TLE的原因是在BZOJ上原题的数据范围是n<=1W,VIJOS上是N<=5W.....噗......不知道当时看走眼了还是什么的囧

 

树状数组套动态开点的权值线段树

AC BZOJ 3196 tyvj 二逼平衡树

传说中都用树状数组套Treap.....然而我是蒟蒻不会套平衡树......所以写了线段树.....1A.....

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================



const int INF=100000001;


struct node*nil;
struct node
{
    int v;
    node*l,*r;
};
int ncnt=5000;
node*nt;
node*newnode()
{
    if(ncnt==5000) { ncnt=0; nt=new node[5000]; }
    nt->l=nt->r=nil;
    ncnt++; return nt++;
}

int ip,iv;
void Insert(node*&x,int l=-1,int r=INF)
{
    if(ip<l || r<ip) return ;
    if(x==nil) x=newnode();
    int mid=(l+r)>>1;
    if(l==r) { x->v+=iv; return ; }
    Insert(x->l,l,mid);
    Insert(x->r,mid+1,r);
    x->v = x->l->v + x->r->v;
}

int n,m;
int a[50050]; // true array

node*t[50050];
void Change(int loc,int p,int v)
{
    ip=p; iv=v;
    for(int i=loc;i<=n;i+=(i&-i))
    Insert(t[i]);
}

node*p[1000];
node*s[1000];
int sp,ss;
inline void QueryBIT(int L,int R)
{
    sp=ss=0;
    for(int i=L-1;i;i-=(i&-i)) s[ss++]=t[i];
    for(int i=R;i;i-=(i&-i)) p[sp++]=t[i];
}
inline void GoLeft()
{
    for(int i=0;i<sp;i++) p[i]=p[i]->l;
    for(int i=0;i<ss;i++) s[i]=s[i]->l;
}
inline void GoRight()
{
    for(int i=0;i<sp;i++) p[i]=p[i]->r;
    for(int i=0;i<ss;i++) s[i]=s[i]->r;
}
inline int CountLeft()
{
    int res=0;
    for(int i=0;i<sp;i++) res+=p[i]->l->v;
    for(int i=0;i<ss;i++) res-=s[i]->l->v;
    return res;
}
inline int CountRight()
{
    int res=0;
    for(int i=0;i<sp;i++) res+=p[i]->r->v;
    for(int i=0;i<ss;i++) res-=s[i]->r->v;
    return res;
}

int GetRank(int v) //Query the count of numbers smaller than v.
{
    int l=-1,r=INF;
    int res=0;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(v<=mid) { GoLeft(); r=mid; }
        else { res+=CountLeft(); GoRight(); l=mid+1; }
    }
    return res;
}

int FindRank(int k) //find the number with rank k.
{
    int l=-1,r=INF;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        int t=CountLeft();
        if(k<=t) { GoLeft(); r=mid; }
        else { k-=t; GoRight(); l=mid+1; }
    }
    return l;
}

int GetPrefix(int L,int R,int v)
{
    QueryBIT(L,R);
    int t=GetRank(v);
    QueryBIT(L,R);
    return FindRank(t);
}

int GetSuffix(int L,int R,int v)
{
    QueryBIT(L,R);
    int t=GetRank(v+1);
    QueryBIT(L,R);
    return FindRank(t+1);
}

int main()
{
    nil=new node;
    nil->l=nil->r=nil;
    nil->v=0;
    
    n=getint();
    m=getint();
    
    for(int i=0;i<=n;i++)
    t[i]=nil;
    
    for(int i=1;i<=n;i++)
    Change(i,a[i]=getint(),1);
    
    for(int i=0;i<m;i++)
    {
        int c=getint();
        int b=getint();
        int d=getint();
        if(c==1) //Get Rank
        {
            int v=getint();
            QueryBIT(b,d);
            printf("%d\n",GetRank(v)+1);
        }
        else if(c==2) //Find by Rank
        {
            int k=getint();
            QueryBIT(b,d);
            printf("%d\n",FindRank(k));            
        }
        else if(c==3) //Change
        {
            Change(b,a[b],-1);
            Change(b,a[b]=d,1);
        }
        else if(c==4) //Prefix
        {
            int v=getint();
            printf("%d\n",GetPrefix(b,d,v));
        }
        else if(c==5) //Suffix
        {
            int v=getint();
            printf("%d\n",GetSuffix(b,d,v));
        }
    }
    
    return 0;
}

运行时间为3.46s. 这个找前驱和后继的操作简直SXBK......

先统计一下比那个数小的数的个数(就是找排名)......然后再找到排名等于那个数的数......后继差不多.....

似乎比较慢? 没有开离散化....内存用得很多.....但是比treap快2333333

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


struct node*nil;
struct node
{
    int v;
    node*l,*r;
};
int ncnt=5000;
node*nt;
node*newnode()
{
    if(ncnt==5000) { ncnt=0; nt=new node[5000]; }
    nt->l=nt->r=nil;
    ncnt++; return nt++;
}

int lim;

int ip,iv;
void Insert(node*&x,int l=0,int r=lim-1)
{
    if(ip<l || r<ip) return ;
    if(x==nil) x=newnode();
    int mid=(l+r)>>1;
    if(l==r) { x->v+=iv; return ; }
    Insert(x->l,l,mid);
    Insert(x->r,mid+1,r);
    x->v = x->l->v + x->r->v;
}

int n,m;
int a[50050]; // true array

node*t[50050];
void Change(int loc,int p,int v)
{
    ip=p; iv=v;
    for(int i=loc;i<=n;i+=(i&-i))
    Insert(t[i]);
}

node*p[1000];
node*s[1000];
int sp,ss;
inline void QueryBIT(int L,int R)
{
    sp=ss=0;
    for(int i=L-1;i;i-=(i&-i)) s[ss++]=t[i];
    for(int i=R;i;i-=(i&-i)) p[sp++]=t[i];
}
inline void GoLeft()
{
    for(int i=0;i<sp;i++) p[i]=p[i]->l;
    for(int i=0;i<ss;i++) s[i]=s[i]->l;
}
inline void GoRight()
{
    for(int i=0;i<sp;i++) p[i]=p[i]->r;
    for(int i=0;i<ss;i++) s[i]=s[i]->r;
}
inline int CountLeft()
{
    int res=0;
    for(int i=0;i<sp;i++) res+=p[i]->l->v;
    for(int i=0;i<ss;i++) res-=s[i]->l->v;
    return res;
}
inline int CountRight()
{
    int res=0;
    for(int i=0;i<sp;i++) res+=p[i]->r->v;
    for(int i=0;i<ss;i++) res-=s[i]->r->v;
    return res;
}

int GetRank(int v) //Query the count of numbers smaller than v.
{
    int l=0,r=lim-1;
    int res=0;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        if(v<=mid) { GoLeft(); r=mid; }
        else { res+=CountLeft(); GoRight(); l=mid+1; }
    }
    return res;
}

int FindRank(int k) //find the number with rank k.
{
    int l=0,r=lim-1;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        int t=CountLeft();
        if(k<=t) { GoLeft(); r=mid; }
        else { k-=t; GoRight(); l=mid+1; }
    }
    return l;
}

int GetPrefix(int L,int R,int v)
{
    QueryBIT(L,R);
    int t=GetRank(v);
    QueryBIT(L,R);
    return FindRank(t);
}

int GetSuffix(int L,int R,int v)
{
    QueryBIT(L,R);
    int t=GetRank(v+1);
    QueryBIT(L,R);
    return FindRank(t+1);
}

int op[50050][4];
int v[105000];
int c;

int main()
{
    nil=new node;
    nil->l=nil->r=nil;
    nil->v=0;
    
    n=getint();
    m=getint();
    
    for(int i=0;i<=n;i++)
    t[i]=nil;
    
    for(int i=1;i<=n;i++)
    v[c++]=a[i]=getint();
    
    for(int i=0;i<m;i++)
    {
        op[i][0]=getint();
        op[i][1]=getint();
        op[i][2]=getint();
        if(op[i][0]!=3) op[i][3]=getint();
        
        if(op[i][0]==3) v[c++]=op[i][2];
        else
        if(op[i][0]!=2) v[c++]=op[i][3];
    }
    
    sort(v,v+c);
    lim=int(unique(v,v+c)-v);
    for(int i=1;i<=n;i++)
    a[i]=int(lower_bound(v,v+lim,a[i])-v);
    for(int i=0;i<m;i++)
    if(op[i][0]==3) op[i][2]=int(lower_bound(v,v+lim,op[i][2])-v);
    else
    if(op[i][0]!=2) op[i][3]=int(lower_bound(v,v+lim,op[i][3])-v);
    
    for(int i=1;i<=n;i++)
    Change(i,a[i],1);
    
    for(int i=0;i<m;i++)
    {
        //printf("i:%d ",i);
        if(op[i][0]==1) //Get Rank
        {
            QueryBIT(op[i][1],op[i][2]);
            printf("%d\n",GetRank(op[i][3])+1);
        }
        else if(op[i][0]==2) //Find by Rank
        {
            QueryBIT(op[i][1],op[i][2]);
            printf("%d\n",v[FindRank(op[i][3])]);            
        }
        else if(op[i][0]==3) //Change
        {
            Change(op[i][1],a[op[i][1]],-1);
            Change(op[i][1],a[op[i][1]]=op[i][2],1);
        }
        else if(op[i][0]==4) //Prefix
            printf("%d\n",v[GetPrefix(op[i][1],op[i][2],op[i][3])]);
        else if(op[i][0]==5) //Suffix
            printf("%d\n",v[GetSuffix(op[i][1],op[i][2],op[i][3])]);
    }
    
    return 0;
}

加离散化之后2.37s....内存少了50M.....

 

AC BZOJ 3110

权值线段树套常规线段树

 

#include <cstdio>
#include <fstream>
#include <iostream>

#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>

#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>

typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;

using namespace std;

inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while((c<'0' || c>'9')/* && !feof(stdin)*/) mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9'/* && !feof(stdin)*/) res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


struct operation{bool t; int l,r; int v; }op[50050];
int dsv[50050]; int vt;

//segment tree
struct node{ node*l,*r; int t; int tag; };
node*nt; int ncnt=20000;
node*newnode()
{
    if(ncnt==20000){ nt=new node[20000]; ncnt=0; }
    nt->l=nt->r=NULL; nt->t=nt->tag=0; ncnt++;
    return nt++;
}

int n,m;

int cl,cr;
void Change(node*&x,int l=0,int r=n-1)
{
    if(x==NULL) x=newnode();
    if(cl<=l && r<=cr) { x->tag++; return ; }
    int mid=(l+r)>>1;
    if(mid>=cl) Change(x->l,l,mid);
    if(mid<cr) Change(x->r,mid+1,r);
    x->t = ( x->l ? x->l->t + x->l->tag*(mid-l+1) : 0 ) + 
           ( x->r ? x->r->t + x->r->tag*(r-mid)   : 0 ) ;
}
int ql,qr;
int Query(node*x,int l=0,int r=n-1)
{
    if(qr<l || r<ql || x==NULL) return 0;
    if(ql<=l && r<=qr) { return x->t + x->tag*(r-l+1); }
    int mid=(l+r)>>1;
    return Query(x->l,l,mid)+Query(x->r,mid+1,r)+x->tag*(min(qr,r)-max(ql,l)+1) ;
}

node*t[205000]; //outer segment tree

void Insert(int L,int R,int p,int x=1,int l=0,int r=vt-1)
{
    cl=L; cr=R; 
    while(l!=r)
    {
        int mid=(l+r)>>1;
        Change(t[x]);
        if(p<=mid) { x<<=1; r=mid; }
        else { x=x<<1|1; l=mid+1; }
    }
    Change(t[x]);
}

int Query(int L,int R,int k,int x=1,int l=0,int r=vt-1)
{
    ql=L; qr=R;
    while(l!=r)
    {
        int mid=(l+r)>>1;
        int v=Query(t[x<<1|1]);
        if(k>v) { k-=v; x<<=1; r=mid; }
        else { x=x<<1|1; l=mid+1; }
    }
    return l;
}

int main()
{
    n=getint();
    m=getint();
    
    for(int i=0;i<m;i++)
    {
        op[i].t=getint()-1;
        op[i].l=getint()-1;
        op[i].r=getint()-1;
        op[i].v=getint();
        if(!op[i].t) dsv[vt++]=op[i].v;
    }
    sort(dsv,dsv+vt);
    vt=int(unique(dsv,dsv+vt)-dsv);
    for(int i=0;i<m;i++) if(!op[i].t)
    { op[i].v=int(lower_bound(dsv,dsv+vt,op[i].v)-dsv); }
    
    for(int i=0;i<m;i++)
    {
        if(op[i].t) printf("%d\n",dsv[Query(op[i].l,op[i].r,op[i].v)]);
        else Insert(op[i].l,op[i].r,op[i].v);
    }
    
    return 0;
}

居然能这么玩..好神......

我们不是要对每个询问在权值线段树上跑嘛...那么位置限制[l,r]怎么办呢? 树套树! 每一个权值线段树的节点都开一棵线段树,用于统计该节点代表的所有权值在某个区间[l,r]内出现过几次.....好神好神.....

 

 

 

 

---

动态树

不带其余任何标记的,带换根的LCT.

AC BZOJ2049 一道非常裸的LCT.

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-18;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================





struct node* nil;

struct node
{
    bool rev;
    node*s[2],*f;

    bool root() 
    { return this!=f->s[0] && this!=f->s[1]; }
    
    void pushtag()
    {
        if(rev)
        {
            s[0]->rev^=1;
            s[1]->rev^=1;
            swap(s[0],s[1]);
            rev=false;
        }
    }
    
};


struct LinkCutTree
{
    node*nt;
    LinkCutTree(int size)
    {
        nt=new node[size];
        for(int i=0;i<size;i++)
        {
            nt[i].s[0]=nt[i].s[1]=nt[i].f=nil;
            nt[i].rev=false;
        }
    }
    
    void cleartag(node*x)
    { if(!x->root()) cleartag(x->f); x->pushtag(); }
    
    node*operator[](int k)
    { return nt+k; }
    
    void rot(node*x)
    {
        if(x->root()) return ;
        node*y=x->f;
        bool k=(x==y->s[0]);
        
        y->s[!k]=x->s[k];
        if(x->s[k]!=nil) x->s[k]->f=y;
        
        x->f=y->f;
        if(y==y->f->s[0]) y->f->s[0]=x;
        else if(y==y->f->s[1]) y->f->s[1]=x;
        
        y->f=x;
        x->s[k]=y;
    }
    
    void splay(node*x)
    {
        cleartag(x);
        while(!x->root())
        {
            node*y=x->f;
            if(!y->root())
            {
                if((x==y->s[0])^(y==y->f->s[0]))
                rot(y); else rot(x);
            }
            rot(x);
        }
    }
    
    node*access(node*x)
    {
        node*y=nil;
        node*t=x;
        while(t!=nil)
        {
            splay(t);
            t->s[0]=y;
            y=t;
            t=t->f;
        }
        splay(x);
        return x;
    }
    
    node*FindRoot(node*x)
    {
        access(x);
        while(x->s[1]!=nil) x=x->s[1];
        return x;
    }
    
    node*SetRoot(node*x)
    {
        access(x)->rev^=1;
        return x;
    }
    
    void Link(node*x,node*y)
    {
        SetRoot(x)->f=y;
    }
    
    void Cut(node*x,node*y)
    {
        SetRoot(x);
        access(y);
        y->s[1]->f=nil;
        y->s[1]=nil;
    }
    
    void output(int i)
    { cout<<i<<' '<<&nt[i]<<' '<<nt[i].s[0]<<' '<<nt[i].s[1]<<' '<<nt[i].f<<endl; }
};

int n,m;

int main()
{
    nil=new node;
    nil->s[0]=nil->s[1]=nil->f=nil;
    
    n=getint();
    m=getint();
    
    LinkCutTree t(n);
    
    for(int i=0;i<m;i++)
    {
        char c[20];
        scanf("%s",c);
        if(c[0]=='C') //Link
        {
            t.Link(t[getint()-1],t[getint()-1]);
        }
        else if(c[0]=='D') //Cut
        {
            t.Cut(t[getint()-1],t[getint()-1]);
        }
        else if(c[0]=='Q') //Query
        {
            if(t.FindRoot(t[getint()-1])==t.FindRoot(t[getint()-1])) printf("Yes\n");
            else printf("No\n");
        }
    }
    
    return 0;
}

 
很奇怪,Link,Cut,FindRoot和SetRoot这些函数换一种写法就各种TLE/RE,还有cleartag()也是一样,不知道为什么.....

 

还是LCT.

AC VIJOS1190 LCT-MST

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-18;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


const int INF=(1<<30)-1;


struct node* nil;

struct node
{
    node*mxp;
    int code;
    int v;
    bool rev;
    node*s[2],*f;

    bool root() 
    { return this!=f->s[0] && this!=f->s[1]; }
    
    void pushtag()
    {
        if(rev)
        {
            s[0]->rev^=1;
            s[1]->rev^=1;
            swap(s[0],s[1]);
            rev=false;
        }
    }
    
    void update()
    {
        mxp=this;
        int lv=s[0]->mxp->v;
        int rv=s[1]->mxp->v;
        if(lv>mxp->v) mxp=s[0]->mxp;
        if(rv>mxp->v) mxp=s[1]->mxp;
    }
};


struct LinkCutTree
{
    node*nt;
    LinkCutTree(int size)
    {
        nt=new node[size];
        for(int i=0;i<size;i++)
        {
            nt[i].s[0]=nt[i].s[1]=nt[i].f=nil;
            nt[i].rev=false;
            nt[i].mxp=&nt[i];
            nt[i].v=-INF;
            nt[i].code=i;
        }
    }
    
    void cleartag(node*x)
    { if(!x->root()) cleartag(x->f); x->pushtag(); }
    
    node*operator[](int k)
    { return nt+k; }
    
    void rot(node*x)
    {
        if(x->root()) return ;
        node*y=x->f;
        bool k=(x==y->s[0]);
        
        y->s[!k]=x->s[k];
        if(x->s[k]!=nil) x->s[k]->f=y;
        
        x->f=y->f;
        if(y==y->f->s[0]) y->f->s[0]=x;
        else if(y==y->f->s[1]) y->f->s[1]=x;
        
        y->f=x;
        x->s[k]=y;
        
        y->update();
    }
    
    void splay(node*x)
    {
        cleartag(x);
        while(!x->root())
        {
            node*y=x->f;
            if(!y->root())
            {
                if((x==y->s[0])^(y==y->f->s[0]))
                rot(y); else rot(x);
            }
            rot(x);
        }
        x->update();
    }
    
    node*access(node*x)
    {
        node*y=nil;
        while(x!=nil)
        {
            splay(x);
            x->s[0]=y;
            y=x;
            x=x->f;
        }
        return x;
    }
    
    node*expend(node*x)
    {
        access(x);
        splay(x);
        return x;
    }
    
    node*FindRoot(node*x)
    {
        expend(x);
        while(x->s[1]!=nil) x=x->s[1];
        splay(x);
        return x;
    }
    
    node*SetRoot(node*x)
    {
        expend(x)->rev^=1;
        return x;
    }
    
    void Link(node*x,node*y)
    {
        SetRoot(x)->f=y;
    }
    
    void Cut(node*x,node*y)
    {
        SetRoot(x);
        expend(y);
        y->s[1]->f=nil;
        y->s[1]=nil;
    }
    
    node* GetMax(node*x,node*y)
    {
        SetRoot(x);
        return expend(y)->mxp;
    }
    
    
    void output(int i)
    { printf("%p[ id:%d v:%d L:%p R:%p f:%p rev:%d max:%d ]\n",&nt[i],nt[i].code,nt[i].v,nt[i].s[0],nt[i].s[1],nt[i].f,nt[i].rev,nt[i].mxp->v); }
};

int n,m;
int EL[10050];
int ER[10050];

int main()
{
    nil=new node;
    nil->mxp=nil->s[0]=nil->s[1]=nil->f=nil;
    nil->v=-INF;
    nil->code=-1;
    
    n=getint();
    m=getint();
    
    LinkCutTree T(n+m+1);
    
    int mx=-INF;
    
    for(int i=0;i<m;i++)
    {
        int p=n+i;
        
        int a,b,c;
        EL[i]=(a=getint()-1);
        ER[i]=(b=getint()-1);
        c=getint();
        
        T[p]->v=c;
        
        bool able=true;
        
        if(T.FindRoot(T[a])==T.FindRoot(T[b]))
        {
            node* mxp=T.GetMax(T[a],T[b]);
            able=false;
            
            if(mxp->v>c)
            {
                int d=mxp->code-n;
                
                T.Cut(T[EL[d]],mxp);
                T.Cut(T[ER[d]],mxp);
                
                able=true;
            }
        }
        
        if(able)
        {
            T.Link(T[a],T[p]);
            T.Link(T[b],T[p]);
        }
    }
    
    for(int i=n;i<n+m;i++)
    if(T.FindRoot(T[0])==T.FindRoot(T[i]))
    mx=max(mx,T[i]->v);
    
    printf("%d %d\n",n-1,mx);
    
    return 0;
}

调半天发现update写错了......TAT

 要点:

1.所有的操作函数都不要写错啊!虽然很短......

2.access操作返回的是上一次access时的路径与本次access节点在有根树的LCA.

   所以用expend函数来作为返回x的access操作.

3.找到根后别忘记splay根上去,毕竟访问了根节点就要保证其复杂度.

4.Cut操作一定要换根,expend(y)之后,把y与y的右儿子断掉.尤其是x,y不一定相邻的时候.

5.update()与pushtag()别写错!

6.在splay前把要splay的节点的父节点的tag清空.因为splay操作是以结构作为基础的.

7.不要在写LCT的时候纠结struct node到底该写哪怎么写的问题!想到怎么写就怎么写,并且LCT函数全部用node*形式.

 

NOI2014 Day1 T2 魔法森林 用LCT维护MST.上一题就是为这个做准备的.

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-18;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


const int INF=(1<<30)-1;


struct node* nil;

struct node
{
    node*mxp;
    int code;
    int v;
    bool rev;
    node*s[2],*f;

    bool root() 
    { return this!=f->s[0] && this!=f->s[1]; }
    
    void pushtag()
    {
        if(rev)
        {
            s[0]->rev^=1;
            s[1]->rev^=1;
            swap(s[0],s[1]);
            rev=false;
        }
    }
    
    void update()
    {
        mxp=this;
        int lv=s[0]->mxp->v;
        int rv=s[1]->mxp->v;
        if(lv>mxp->v) mxp=s[0]->mxp;
        if(rv>mxp->v) mxp=s[1]->mxp;
    }
};


struct LinkCutTree
{
    node*nt;
    LinkCutTree(int size)
    {
        nt=new node[size];
        for(int i=0;i<size;i++)
        {
            nt[i].s[0]=nt[i].s[1]=nt[i].f=nil;
            nt[i].rev=false;
            nt[i].mxp=&nt[i];
            nt[i].v=-INF;
            nt[i].code=i;
        }
    }
    
    void cleartag(node*x)
    { if(!x->root()) cleartag(x->f); x->pushtag(); }
    
    node*operator[](int k)
    { return nt+k; }
    
    void rot(node*x)
    {
        if(x->root()) return ;
        node*y=x->f;
        bool k=(x==y->s[0]);
        
        y->s[!k]=x->s[k];
        if(x->s[k]!=nil) x->s[k]->f=y;
        
        x->f=y->f;
        if(y==y->f->s[0]) y->f->s[0]=x;
        else if(y==y->f->s[1]) y->f->s[1]=x;
        
        y->f=x;
        x->s[k]=y;
        
        y->update();
    }
    
    void splay(node*x)
    {
        cleartag(x);
        while(!x->root())
        {
            node*y=x->f;
            if(!y->root())
            {
                if((x==y->s[0])^(y==y->f->s[0]))
                rot(y); else rot(x);
            }
            rot(x);
        }
        x->update();
    }
    
    node*access(node*x)
    {
        node*y=nil;
        while(x!=nil)
        {
            splay(x);
            x->s[0]=y;
            y=x;
            x=x->f;
        }
        return x;
    }
    
    node*expend(node*x)
    {
        access(x);
        splay(x);
        return x;
    }
    
    node*FindRoot(node*x)
    {
        expend(x);
        while(x->s[1]!=nil) x=x->s[1];
        splay(x);
        return x;
    }
    
    node*SetRoot(node*x)
    {
        expend(x)->rev^=1;
        return x;
    }
    
    void Link(node*x,node*y)
    {
        SetRoot(x)->f=y;
    }
    
    void Cut(node*x,node*y)
    {
        SetRoot(x);
        expend(y);
        y->s[1]->f=nil;
        y->s[1]=nil;
    }
    
    node* GetMax(node*x,node*y)
    {
        SetRoot(x);
        return expend(y)->mxp;
    }
    
    
    void output(int i)
    { printf("%p[ id:%d v:%d L:%p R:%p f:%p rev:%d max:%d ]\n",&nt[i],nt[i].code,nt[i].v,nt[i].s[0],nt[i].s[1],nt[i].f,nt[i].rev,nt[i].mxp->v); }
};

int n,m;
int EL[100050];
int ER[100050];
int Ea[100050];
int Eb[100050];
int p[100050];
bool cmp(int a,int b)
{ return Ea[a]<Ea[b]; }

int res=INF;

int main()
{
    nil=new node;
    nil->mxp=nil->s[0]=nil->s[1]=nil->f=nil;
    nil->v=-INF;
    nil->code=-1;
    
    n=getint();
    m=getint();
    
    LinkCutTree T(n+m+2);
    
    int st=0,ed=n-1;
    
    for(int i=0;i<m;i++)
    {
        EL[i]=getint()-1;
        ER[i]=getint()-1;
        Ea[i]=getint();
        Eb[i]=getint();
    }
    
    for(int i=0;i<m;i++) p[i]=i;
    stable_sort(p,p+m,cmp);
    
    int curbase=0;
    
    for(int i=0;i<m;i++)
    {
        int e=p[i]; //the id of current edge.
        int cur=n+i; //the id of current edge node.
        node*L=T[EL[e]];
        node*R=T[ER[e]];
        curbase=Ea[e]; //current value count.
        T[cur]->v=Eb[e]; //assign value of current edge node.
        
        if(L==R) continue;
        
        if(T.FindRoot(L)==T.FindRoot(R))
        {
            node*X=T.GetMax(L,R);
            int v=X->v;
            
            if(v>Eb[e]) //replace point mxp
            {
                T.Cut(T[EL[X->code-n]],X);
                T.Cut(T[ER[X->code-n]],X);
                
                T.Link(L,T[cur]);
                T.Link(R,T[cur]);
            }
        }
        else
        {
            T.Link(L,T[cur]);
            T.Link(R,T[cur]);
        }
        
        if(T.FindRoot(T[n-1])==T.FindRoot(T[0]))
        {
            T.SetRoot(T[n-1]);
            T.expend(T[0]);
            res=min(res,curbase+T[0]->mxp->v);
        }
    }
    
    if(res==INF) printf("-1\n");
    else printf("%d\n",res);
    
    return 0;
}

 

 

---

替罪羊树

AC BZOJ 1588

平衡树/权值线段树裸题.

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while((c<'0' || c>'9')&&!feof(stdin)) mi=(c=='-'),c=getchar();
    while(('0'<=c && c<='9')&&!feof(stdin)) res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

int f[205000];
int s[205000][2];
int t[205000];
int tot[205000];
int ncnt=0;

int root=0;

int q[205000]; int qt;
void fetch(int x)
{ if(!x) return ; fetch(s[x][0]); q[qt++]=x; fetch(s[x][1]); }
int construct(int l=0,int r=qt-1)
{
    if(l>r) return 0; //nil
    int mid=(l+r)>>1; int x=q[mid]; tot[x]=1;
    s[x][0]=construct(l,mid-1); f[s[x][0]]=x; tot[x]+=tot[s[x][0]];
    s[x][1]=construct(mid+1,r); f[s[x][1]]=x; tot[x]+=tot[s[x][1]];
    return x;
}
int rebuild(int x)
{ qt=0; fetch(x); return construct(); }

void balance(int x)
{
    int y=0;
    while(x)
    {
        if(tot[x]>=5)
        {
            db v=db(tot[s[x][0]])/db(tot[x]-1);
            if(v<=0.20 || v>=0.80) y=x;
        }
        x=f[x];
    }
    if(y)
    {
        int z=f[y];
        if(z)
        {
            int d=(y==s[z][1]);
            s[z][d]=rebuild(y);
            f[s[z][d]]=z;
        }
        else root=rebuild(y),f[root]=0;
    }
}

void Insert(int v)
{
    int p=++ncnt; t[p]=v; tot[p]=1;
    if(!root) { root=p; return ; }
    int x=root,y=0;
    while(x) tot[x]+=1,y=x,x=s[x][v>=t[x]];
    s[y][v>=t[y]]=p; f[p]=y;
    balance(p);
}

int Rank(int v)
{
    int x=root,res=0;
    while(x)
    if(v<=t[x]) x=s[x][0];
    else res+=tot[s[x][0]]+1,x=s[x][1];
    return res;
}

int FindRank(int k)
{
    int x=root,y=0;
    while(x)
    {
        y=x;
        int c=tot[s[x][0]]+1;
        if(k==c) break;
        if(k<c) x=s[x][0];
        else k-=c,x=s[x][1];
    }
    return y;
}

int Prefix(int v) { return t[FindRank(Rank(v))]; }
int Suffix(int v) { return t[FindRank(Rank(v)+1)]; }


void op(int x=root)
{ if(!x)return; op(s[x][0]); printf("%d[v:%d l:%d r:%d f:%d tot:%d]\n",x,t[x],s[x][0],s[x][1],f[x],tot[x]); op(s[x][1]); }

int n;

inline int abs(int p){ return p&0x80000000 ? -p : p ; }

int main()
{
    n=getint();
    
    int res=getint(); Insert(res);
    for(int i=1;i<n;i++)
    {
        int c=getint();
        res+=min(abs(c-Prefix(c)),abs(c-Suffix(c)));
        Insert(c);
    }
    printf("%d\n",res);
    
    return 0;
}

参数调成6:0.8/1,加上读入优化,跑了308ms.

不带删除....rank查询前驱后继..........

常数依然降不下来,晚上写一个线段树版本对比一下效率.

 

 

 ...