关于主席树的入门，讲解和题单

主席树真是神仙操作啊……搞了好久才弄懂一点点QAQ

 

参考文章：https://www.cnblogs.com/zyf0163/p/4749042.html

　　　　　https://blog.csdn.net/creatorx/article/details/75446472

　　　　　https://blog.csdn.net/jerans/article/details/75807666

　　　　　http://www.cnblogs.com/zcysky/p/6832876.html

 

ps：本文章中的题目我都写过题解了，可以自己去找

 1.前言

据说主席树这个名字的由来呢，是因为创始人的名字缩写hjt与某位相同，然后他因为不会划分树于是自创了这一个数据结构。好强啊orz

 

主席树能实现什么操作呢？最经典的就是查询区间第k小了，其他的还有诸如树上路径第k小啦，带修改第k小啦之类的。以静态区间第k小为例

 2.定义

先贴一下某神犇对主席树的理解：所谓主席树呢，就是对原来的数列[1..n]的每一个前缀[1..i]（1≤i≤n）建立一棵线段树，线段树的每一个节点存某个前缀[1..i]中属于区间[L..R]的数一共有多少个（比如根节点是[1..n]，一共i个数，sum[root] = i；根节点的左儿子是[1..(L+R)/2]，若不大于(L+R)/2的数有x个，那么sum[root.left] = x）。若要查找[i..j]中第k大数时，设某结点x，那么x.sum[j] - x.sum[i - 1]就是[i..j]中在结点x内的数字总数。而对每一个前缀都建一棵树，会MLE，观察到每个[1..i]和[1..i-1]只有一条路是不一样的，那么其他的结点只要用回前一棵树的结点即可，时空复杂度为O(nlogn)。

 

然而没有什么用，因为感觉根本没看懂

 

然后来说说我自己的理解吧。如何求出一个区间内第k小呢？直接sort当然可以，但是复杂度爆表。于是我们可以换一个思路，能否将$[l,r]$之间出现过的数都建成线段树呢？设节点为$p$，区间为$[l,r]$，左儿子是$[l,mid]$，右儿子是$[mid+1,r]$

要查找第k大的话，先看左儿子里有多少个数（表示小于等于$mid$的数的个数），如果大于$k$，进左子树找，否则令$k-=左儿子数的个数$，进右子树找

先来考虑一个序列：3,2,1,4

建完树之后是这样的

然后要查第2大，一下子就能发现是2了

（上面画的可能不是很严谨，大家将就下）

但我们不可能对每一个区间都建一棵树，那样的话空间复杂度绝对爆炸

然后可以转化一下思路：前缀和

区间$[l,r]$中小于等于$mid$的数的个数，可以转换为$[1,r]$中小于等于$mid$的数的个数减去$[1,l-1]$中小于等于$mid$的数的个数

于是我们只要对每一个前缀建一棵树即可

然后空间复杂度还是爆炸

然而我们又发现，区间$[1,l-1]$的树和区间$[1,l]$的树最多只会有$log n$个节点不同（因为每次新插入一个节点最多只会更新$log n$个节点），有许多空间是可以重复利用的

只要能将这些空间重复利用起来，就可以解决空间的问题了

还是上面那个序列：3，2,1,4

一开始先建一棵空树，然后一个个把每一个节点加进去

如果要看图的话可以点这里

 

这个时候有人就要问了，万一序列的数字特别大呢？

当然是离散化

将这些所有值离散一下就行了，可以保证所有数在$1~n$之间

然而感觉讲太多也没啥用……上代码好了，有详细的注释

以区间第k小为例 洛谷p3834

//minamoto
#include<bits/stdc++.h>
#define N 200005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[N<<5],L[N<<5],R[N<<5];
int a[N],b[N],t[N];
int n,q,m,cnt=0;
int build(int l,int r){
    int rt=++cnt;
    //建树 
    sum[rt]=0;
    if(l<r){
        int mid=(l+r)>>1;
        L[rt]=build(l,mid);
        R[rt]=build(mid+1,r);
    }
    return rt;
}
int update(int last,int l,int r,int x){
    int rt=++cnt;
    L[rt]=L[last],R[rt]=R[last],sum[rt]=sum[last]+1;
    //先继承上一次的信息 
    //L是左节点，R是右节点，sum是节点内数的个数 
    if(l<r){
        int mid=(l+r)>>1;
        if(x<=mid) L[rt]=update(L[last],l,mid,x);
        else R[rt]=update(R[last],mid+1,r,x);
        //如果有需要更新的信息，更新
        //可以发现每一次更新的节点最多只有log n个 
    }
    return rt;
}
int query(int u,int v,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[v]]-sum[L[u]];
    //查询操作 
    int mid=(l+r)>>1;
    if(x>=k) return query(L[u],L[v],l,mid,k);
    else return query(R[u],R[v],mid+1,r,k-x);
    //如果左节点个数大于等于k，进左子树找第k小
    //否则进右子树 
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i)
    b[i]=a[i]=read();
    sort(b+1,b+1+n);
    m=unique(b+1,b+1+n)-b-1;
    t[0]=build(1,m);
    //先建一棵空树 
    for(int i=1;i<=n;++i){
        int k=lower_bound(b+1,b+1+m,a[i])-b;
        //离散 
        t[i]=update(t[i-1],1,m,k);
        //然后每次在上一次的基础上建树 
    }
    while(q--){
        int x,y,z;
        x=read(),y=read(),z=read();
        int k=query(t[x-1],t[y],1,m,z);
        printf("%d\n",b[k]);
    }
    return 0;
}

 

如果熟练了之后，可以发现其实第一步的建树过程是可以省略的，直接每一步加节点就行了

//minamoto
#include<bits/stdc++.h>
#define N 200005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[N<<5],L[N<<5],R[N<<5];
int a[N],b[N],t[N];
int n,q,m,cnt=0;
void update(int last,int &now,int l,int r,int x){
    //注意这里开的是引用 
    if(!now) now=++cnt;
    sum[now]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[v]]-sum[L[u]];
    int mid=(l+r)>>1;
    if(x>=k) return query(L[u],L[v],l,mid,k);
    else return query(R[u],R[v],mid+1,r,k-x);
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i)
    b[i]=a[i]=read();
    sort(b+1,b+1+n);
    m=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;++i){
        int k=lower_bound(b+1,b+1+m,a[i])-b;
        update(t[i-1],t[i],1,m,k);
        //省略建树过程，直接加入节点 
    }
    while(q--){
        int x,y,z;
        x=read(),y=read(),z=read();
        int k=query(t[x-1],t[y],1,m,z);
        printf("%d\n",b[k]);
    }
    return 0;
}

 还有一道板子题洛谷SP3946 poj2104 K-th Number

 

//minamoto
#include<bits/stdc++.h>
#define N 100005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[N<<5],L[N<<5],R[N<<5];
int a[N],b[N],rt[N];
int n,q,m,cnt=0;
void update(int last,int &now,int l,int r,int x){
    sum[now=++cnt]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[v]]-sum[L[u]];
    int mid=(l+r)>>1;
    if(x>=k) return query(L[u],L[v],l,mid,k);
    else return query(R[u],R[v],mid+1,r,k-x);
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i)
    b[i]=a[i]=read();
    sort(b+1,b+1+n);
    m=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;++i){
        int k=lower_bound(b+1,b+1+m,a[i])-b;
        update(rt[i-1],rt[i],1,m,k);
    }
    while(q--){
        int x,y,z;
        x=read(),y=read(),z=read();
        int k=query(rt[x-1],rt[y],1,m,z);
        printf("%d\n",b[k]);
    }
    return 0;
}

 

还有一道题，也是主席树的一般应用 洛谷P3567 [POI2014]KUR-Couriers

出现次数可以转化为左右节点的大小，如果符合条件就递归

题解

//minamoto
#include<bits/stdc++.h>
#define N 500005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[N*20],L[N*20],R[N*20],t[N];
int n,q,cnt=0;
void update(int last,int &now,int l,int r,int x){
    if(!now) now=++cnt;
    sum[now]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k){
    if(l==r) return l;
    int x=sum[L[v]]-sum[L[u]],y=sum[R[v]]-sum[R[u]];
    int mid=(l+r)>>1;
    if(x*2>k) return query(L[u],L[v],l,mid,k);
    if(y*2>k) return query(R[u],R[v],mid+1,r,k);
    return 0;
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i){
        int x=read();
        update(t[i-1],t[i],1,n,x);
    }
    while(q--){
        int x,y;
        x=read(),y=read();
        int k=query(t[x-1],t[y],1,n,y-x+1);
        printf("%d\n",k);
    }
    return 0;
}

然后区间静态第k大就解决了~\(≧▽≦)/~啦啦啦

 

树上路径

有些题目会给你一棵树，问你树上两点间路径上的第k大

怎么解决呢？

可以发现，这个东西是可以进行差分的

比如说，$u$到$v$路径上的权值和，可以变成$sum[u]+sum[v]-sum[lca]-sum[lca_fa]$

然后套到主席树上，就是小于某个数的个数，同样也可以差分出来表示

但问题是主席树怎么建呢？

我们发现，因为要求lca，我们可以在树剖dfs的时候顺便加点

具体来说，就是用$fa[i]$的信息更新$i$点的信息

以bzoj2588 洛谷p2633. count on a tree为例

题解

//minamoto
#include<bits/stdc++.h>
#define N 100005
#define M 2000005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[M],L[M],R[M];
int a[N],b[N],rt[N];
int fa[N],sz[N],d[N],ver[N<<1],Next[N<<1],head[N],son[N],top[N];
int n,q,m,cnt=0,tot=0,ans=0;
void update(int last,int &now,int l,int r,int x){
    sum[now=++cnt]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
inline void add(int u,int v){
    ver[++tot]=v,Next[tot]=head[u],head[u]=tot;
    ver[++tot]=u,Next[tot]=head[v],head[v]=tot;
}
void dfs(int u){
    sz[u]=1,d[u]=d[fa[u]]+1;
    update(rt[fa[u]],rt[u],1,m,a[u]);
    for(int i=head[u];i;i=Next[i]){
        int v=ver[i];
        if(v==fa[u]) continue;
        fa[v]=u,dfs(v);
        sz[u]+=sz[v];
        if(!son[u]||sz[v]>sz[son[u]]) son[u]=v;
    }
}
void dfs(int u,int tp){
    top[u]=tp;
    if(!son[u]) return;
    dfs(son[u],tp);
    for(int i=head[u];i;i=Next[i]){
        int v=ver[i];
        if(v==son[u]||v==fa[u]) continue;
        dfs(v,v);
    }
}
int LCA(int x,int y){
    while(top[x]!=top[y])
    d[top[x]]>=d[top[y]]?x=fa[top[x]]:y=fa[top[y]];
    return d[x]>=d[y]?y:x;
}
int query(int ql,int qr,int lca,int lca_fa,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[ql]]+sum[L[qr]]-sum[L[lca]]-sum[L[lca_fa]];
    int mid=(l+r)>>1;
    if(x>=k) return query(L[ql],L[qr],L[lca],L[lca_fa],l,mid,k);
    else return query(R[ql],R[qr],R[lca],R[lca_fa],mid+1,r,k-x);
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i)
    b[i]=a[i]=read();
    sort(b+1,b+1+n);
    m=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=n;++i)
    a[i]=lower_bound(b+1,b+1+m,a[i])-b;
    for(int i=1;i<n;++i){
        int u=read(),v=read();
        add(u,v);
    }
    dfs(1),dfs(1,1);
    while(q--){
        int x,y,z,lca;
        x=read(),y=read(),z=read();
        x^=ans,lca=LCA(x,y);
        ans=b[query(rt[x],rt[y],rt[lca],rt[fa[lca]],1,m,z)];
        printf("%d\n",ans);
    }
    return 0;
}

 还有一题[bzoj3123][洛谷P3302] [SDOI2013]森林

路经查询就是主席树维护，而连接两棵树就是用启发式合并

题解

//minamoto
#include<bits/stdc++.h>
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
const int N=80005,M=N*200;
int ver[N<<2],Next[N<<2],head[N];
int a[N],fa[N],sz[N],b[N];
int n,m,tot,q,size,ans;
void add(int u,int v){
    ver[++tot]=v,Next[tot]=head[u],head[u]=tot;
    ver[++tot]=u,Next[tot]=head[v],head[v]=tot;
}
int L[M],R[M],sum[M],rt[N],cnt;
void update(int last,int &now,int l,int r,int x){
    sum[now=++cnt]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int lca,int lca_fa,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[v]]+sum[L[u]]-sum[L[lca]]-sum[L[lca_fa]];
    int mid=(l+r)>>1;
    if(x>=k) return query(L[u],L[v],L[lca],L[lca_fa],l,mid,k);
    else return query(R[u],R[v],R[lca],R[lca_fa],mid+1,r,k-x);
}
inline int hash(int x){
    return lower_bound(b+1,b+1+size,x)-b;
}
int ff(int x){
    return fa[x]==x?x:fa[x]=ff(fa[x]);
}
int st[N][17],d[N],vis[N];
void dfs(int u,int father,int root){
    st[u][0]=father;
    for(int i=1;i<=16;++i)
    st[u][i]=st[st[u][i-1]][i-1];
    ++sz[root];
    d[u]=d[father]+1;
    fa[u]=root;
    vis[u]=1;
    update(rt[father],rt[u],1,size,hash(a[u]));
    for(int i=head[u];i;i=Next[i]){
        int v=ver[i];
        if(v==father) continue;
        dfs(v,u,root);
    }
}
int LCA(int x,int y){
    if(x==y) return x;
    if(d[x]<d[y]) swap(x,y);
    for(int i=16;i>=0;--i){
        if(d[st[x][i]]>=d[y]) x=st[x][i];
    }
    if(x==y) return x;
    for(int i=16;i>=0;--i){
        if(st[x][i]!=st[y][i])
        x=st[x][i],y=st[y][i];
    }
    return st[x][0];
}
int main(){
    //freopen("testdata.in","r",stdin);
    int t=read();
    n=read(),m=read(),q=read();
    for(int i=1;i<=n;++i)
    a[i]=b[i]=read(),fa[i]=i;
    sort(b+1,b+1+n);
    size=unique(b+1,b+1+n)-b-1;
    for(int i=1;i<=m;++i){
        int u=read(),v=read();
        add(u,v);
    }
    for(int i=1;i<=n;++i)
    if(!vis[i]) dfs(i,0,i);
    while(q--){
        char ch;int x,y;
        while(!isupper(ch=getchar()));
        x=read()^ans,y=read()^ans;
        if(ch=='Q'){
            int k=read()^ans;
            int lca=LCA(x,y);
            ans=b[query(rt[x],rt[y],rt[lca],rt[st[lca][0]],1,size,k)];
            printf("%d\n",ans);
        }
        else{
            add(x,y);
            int u=ff(x),v=ff(y);
            if(sz[u]<sz[v]) swap(x,y),swap(u,v);
            dfs(y,x,u);
        }
    }
    return 0;
}

洛谷P3066 [USACO12DEC]逃跑的BarnRunning Away From…

要对每一个子树进行操作，怎么做呢？

我们可以直接dfs这棵树，并记录下进入一个点的编号$l[i]$和从这个点出去时的编号$r[i]$

那么这个点的子树的区间一定是$[l[i],r[i]]$

然后直接在树上查询就行了

题解

//minamoto
#include<bits/stdc++.h>
#define N 200005
#define M 4000005
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
inline ll read(){
    #define num ch-'0'
    char ch;bool flag=0;ll res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int sum[M],L[M],R[M],rt[N];
int ver[N<<1],Next[N<<1],head[N];ll edge[N<<1];
int ls[N],rs[N];ll a[N],b[N];
int n,m,cnt,tot;ll p;
void update(int last,int &now,int l,int r,int x){
    sum[now=++cnt]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k){
    if(r<k) return sum[v]-sum[u];
    if(l>=k) return 0;
    int mid=(l+r)>>1;
    if(k<=mid) return query(L[u],L[v],l,mid,k);
    else return query(R[u],R[v],mid+1,r,k)+sum[L[v]]-sum[L[u]];
}
inline void add(int u,int v,ll e){
    ver[++tot]=v,Next[tot]=head[u],head[u]=tot,edge[tot]=e;
}
void dfs(int u,int fa,ll d){
    b[ls[u]=++m]=d,a[m]=d;
    for(int i=head[u];i;i=Next[i])
    if(ver[i]!=fa) dfs(ver[i],u,d+edge[i]);
    rs[u]=m;
}
int main(){
    n=read(),p=read();
    for(int u=2;u<=n;++u){
        int v=read();ll e=read();
        add(v,u,e);
    }
    dfs(1,0,0);
    sort(b+1,b+1+m);
    m=unique(b+1,b+1+m)-b-1;
    for(int i=1;i<=n;++i){
        int k=lower_bound(b+1,b+1+m,a[i])-b;
        update(rt[i-1],rt[i],1,m,k);
    }
    b[m+1]=inf;
    for(int i=1;i<=n;++i){
        int k=upper_bound(b+1,b+2+m,a[ls[i]]+p)-b;
        k=query(rt[ls[i]-1],rt[rs[i]],1,m,k);
        printf("%d\n",k);
    }
    return 0;
}

 

bzoj 1803: Spoj1487 Query on a tree III(主席树)。基础的树上查询

题解

//minamoto
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
char obuf[1<<24],*o=obuf;
inline void print(int x){
    if(x>9) print(x/10);
    *o++=x%10+48;
}
const int N=100005,M=N*30;
int sum[M],L[M],R[M],rt[N];
int ver[N<<1],Next[N<<1],head[N];
int ls[N],rs[N],a[N],b[N],id[N],pos[N];
int n,m,cnt,tot,q;
void update(int last,int &now,int l,int r,int x){
    sum[now=++cnt]=sum[last]+1;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) R[now]=R[last],update(L[last],L[now],l,mid,x);
    else L[now]=L[last],update(R[last],R[now],mid+1,r,x);
}
int query(int u,int v,int l,int r,int k){
    if(l>=r) return l;
    int x=sum[L[v]]-sum[L[u]];
    int mid=(l+r)>>1;
    if(x>=k) return query(L[u],L[v],l,mid,k);
    else return query(R[u],R[v],mid+1,r,k-x);
}
inline void add(int u,int v){
    ver[++tot]=v,Next[tot]=head[u],head[u]=tot;
    ver[++tot]=u,Next[tot]=head[v],head[v]=tot;
}
void dfs(int u,int fa){
    a[ls[u]=++m]=b[u],id[m]=u;
    for(int i=head[u];i;i=Next[i])
    if(ver[i]!=fa) dfs(ver[i],u);
    rs[u]=m;
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i) b[i]=read();
    for(int i=1;i<n;++i){
        int u,v;
        u=read(),v=read();
        add(u,v);
    }
    dfs(1,0);
    sort(b+1,b+1+m);
    for(int i=1;i<=n;++i){
        int k=lower_bound(b+1,b+1+m,a[i])-b;
        update(rt[i-1],rt[i],1,m,k);
        pos[k]=id[i];
    }
    q=read();
    while(q--){
        int u=read(),k=read();
        int ans=pos[query(rt[ls[u]-1],rt[rs[u]],1,m,k)];
        print(ans),*o++='\n';
    }
    fwrite(obuf,o-obuf,1,stdout);
    return 0;
}

 

带修改主席树

我们可以发现，主席树每一棵线段树维护的都是一个前缀和

如果有修改操作，每一次都要对后面的所有的前缀和都进行修改，那样的话时间复杂度就太爆炸了

我们可以考虑一下树状数组

树状数组维护的也是前缀和，但它的每一次修改是$O(log n)$的

他的节点存的并不是前缀和，但我们仍可以用树状数组来求出前缀和

于是我们可以用树状数组的思想来维护，主席树

用树状数组存一下每个节点的位置，每一次修改都按树状数组的方法去修改，也就是说并不需要修改那么多节点

查询的时候，也按树状数组的方法查询就好了

建议对这段话仔细理解，我当初也是懵逼了好久，最后看了zcysky大佬的那篇blog才蓦然醒悟的

拿bzoj1901洛谷P2617 Dynamic Rankings为例

是一个带修改主席树的板子

思路就按我上面所说的

题解

//minamoto
#include<bits/stdc++.h>
#define N 10005
using namespace std;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
inline int lowbit(int x){return x&(-x);}
int sum[N*600],L[N*600],R[N*600];
int xx[N],yy[N],rt[N],a[N],b[N<<1],ca[N],cb[N],cc[N];
int n,q,m,cnt=0,totx,toty;
void update(int last,int &now,int l,int r,int x,int v){
    sum[now=++cnt]=sum[last]+v;
    L[now]=L[last],R[now]=R[last];
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) update(L[last],L[now],l,mid,x,v);
    else update(R[last],R[now],mid+1,r,x,v);
}
int query(int l,int r,int q){
    if(l==r) return l;
    int x=0,mid=(l+r)>>1;
    for(int i=1;i<=totx;++i) x-=sum[L[xx[i]]];
    for(int i=1;i<=toty;++i) x+=sum[L[yy[i]]];
    if(q<=x){
        for(int i=1;i<=totx;++i) xx[i]=L[xx[i]];
        for(int i=1;i<=toty;++i) yy[i]=L[yy[i]];
        return query(l,mid,q);
    }
    else{
        for(int i=1;i<=totx;++i) xx[i]=R[xx[i]];
        for(int i=1;i<=toty;++i) yy[i]=R[yy[i]];
        return query(mid+1,r,q-x);
    }
}
void add(int x,int y){
    int k=lower_bound(b+1,b+1+m,a[x])-b;
    for(int i=x;i<=n;i+=lowbit(i)) update(rt[i],rt[i],1,m,k,y);
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i)
    b[++m]=a[i]=read();
    for(int i=1;i<=q;++i){
        char ch;
        while(!isupper(ch=getchar()));
        ca[i]=read(),cb[i]=read();
        if(ch=='Q') cc[i]=read();else b[++m]=cb[i];
    }
    sort(b+1,b+1+m);
    m=unique(b+1,b+1+m)-b-1;
    for(int i=1;i<=n;++i) add(i,1);
    for(int i=1;i<=q;++i){
        if(cc[i]){
            totx=toty=0;
            for(int j=ca[i]-1;j;j-=lowbit(j)) xx[++totx]=rt[j];
            for(int j=cb[i];j;j-=lowbit(j)) yy[++toty]=rt[j];
            printf("%d\n",b[query(1,m,cc[i])]);
        }
        else{add(ca[i],-1),a[ca[i]]=cb[i],add(ca[i],1);}
    }
    return 0;
}

还有一道[BZOJ3295] [Cqoi2011]洛谷p3157动态逆序对

题解

//minamoto
#include<bits/stdc++.h>
#define N 100005
#define M 5000005
#define ll long long
using namespace std;
inline ll read(){
    #define num ch-'0'
    char ch;bool flag=0;ll res;
    while(!isdigit(ch=getchar()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getchar());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
int L[M],R[M],sum[M],rt[N];
int val[N],pos[N],xx[N],yy[N],c[N],a1[N],a2[N];
int n,cnt,q;ll ans=0;
inline int lowbit(int x){return x&(-x);}
int ask(int x){
    int s=0;
    for(int i=x;i;i-=lowbit(i)) s+=c[i];
    return s;
}
void update(int &now,int l,int r,int k){
    if(!now) now=++cnt;
    ++sum[now];
    if(l==r) return;
    int mid=(l+r)>>1;
    if(k<=mid) update(L[now],l,mid,k);
    else update(R[now],mid+1,r,k);
}
int querysub(int x,int y,int v){
    int cntx=0,cnty=0,ans=0;--x;
    for(int i=x;i;i-=lowbit(i)) xx[++cntx]=rt[i];
    for(int i=y;i;i-=lowbit(i)) yy[++cnty]=rt[i];
    int l=1,r=n;
    while(l<r){
        int mid=(l+r)>>1;
        if(v<=mid){
            for(int i=1;i<=cntx;++i) ans-=sum[R[xx[i]]];
            for(int i=1;i<=cnty;++i) ans+=sum[R[yy[i]]];
            for(int i=1;i<=cntx;++i) xx[i]=L[xx[i]];
            for(int i=1;i<=cnty;++i) yy[i]=L[yy[i]];
            r=mid;
        }
        else{
            for(int i=1;i<=cntx;++i) xx[i]=R[xx[i]];
            for(int i=1;i<=cnty;++i) yy[i]=R[yy[i]];
            l=mid+1;
        }
    }
    return ans;
}
int querypre(int x,int y,int v){
    int cntx=0,cnty=0,ans=0;--x;
    for(int i=x;i;i-=lowbit(i)) xx[++cntx]=rt[i];
    for(int i=y;i;i-=lowbit(i)) yy[++cnty]=rt[i];
    int l=1,r=n;
    while(l<r){
        int mid=(l+r)>>1;
        if(v>mid){
            for(int i=1;i<=cntx;++i) ans-=sum[L[xx[i]]];
            for(int i=1;i<=cnty;++i) ans+=sum[L[yy[i]]];
            for(int i=1;i<=cntx;++i) xx[i]=R[xx[i]];
            for(int i=1;i<=cnty;++i) yy[i]=R[yy[i]];
            l=mid+1;
        }
        else{
            for(int i=1;i<=cntx;++i) xx[i]=L[xx[i]];
            for(int i=1;i<=cnty;++i) yy[i]=L[yy[i]];
            r=mid;
        }
    }
    return ans;
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),q=read();
    for(int i=1;i<=n;++i){
        val[i]=read(),pos[val[i]]=i;
        a1[i]=ask(n)-ask(val[i]);
        ans+=a1[i];
        for(int j=val[i];j<=n;j+=lowbit(j)) ++c[j];
    }
    memset(c,0,sizeof(c));
    for(int i=n;i;--i){
        a2[i]=ask(val[i]-1);
        for(int j=val[i];j<=n;j+=lowbit(j)) ++c[j];
    }
    while(q--){
        printf("%lld\n",ans);
        int x=read();x=pos[x];
        ans-=(a1[x]+a2[x]-querysub(1,x-1,val[x])-querypre(x+1,n,val[x]));
        for(int j=x;j<=n;j+=lowbit(j)) update(rt[j],1,n,val[x]);
    }
    return 0;
}

 进阶

个人认为主席树的一些好题

【bzoj2653】【middle】

可以加深对主席树的应用，不再只会求第k大之类的套路

题解

//minamoto
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
char obuf[1<<24],*o=obuf;
inline void print(int x){
    if(x>9) print(x/10);
    *o++=x%10+48;
}
const int N=20005,M=N*30;
int n,Pre,q,cnt;
int rt[N],p[5];
struct node{
    int l,r,lmx,rmx,sum;
}t[M],op;
struct data{
    int x,id;
    inline bool operator <(const data &b)const
    {return x<b.x;}
}a[N];
inline void pushup(int x){
    t[x].sum=t[t[x].l].sum+t[t[x].r].sum;
    t[x].lmx=max(t[t[x].l].lmx,t[t[x].l].sum+t[t[x].r].lmx);
    t[x].rmx=max(t[t[x].r].rmx,t[t[x].r].sum+t[t[x].l].rmx);
}
void build(int &now,int l,int r){
    now=++cnt;
    if(l==r){t[now].lmx=t[now].rmx=t[now].sum=1;return;}
    int mid=(l+r)>>1;
    build(t[now].l,l,mid);
    build(t[now].r,mid+1,r);
    pushup(now);
}
void update(int last,int &now,int l,int r,int k){
    now=++cnt;
    if(l==r){t[now].lmx=t[now].rmx=t[now].sum=-1;return;}
    int mid=(l+r)>>1;
    if(k<=mid) t[now].r=t[last].r,update(t[last].l,t[now].l,l,mid,k);
    else t[now].l=t[last].l,update(t[last].r,t[now].r,mid+1,r,k);
    pushup(now);
}
node merge(node x,node y){
    node z;
    z.sum=x.sum+y.sum;
    z.lmx=max(x.lmx,x.sum+y.lmx);
    z.rmx=max(y.rmx,y.sum+x.rmx);
    return z;
}
node find(int x,int l,int r,int y,int z){
    if(y>z) return op;
    if(l==y&&r==z) return t[x];
    int mid=(l+r)>>1;
    if(z<=mid) return find(t[x].l,l,mid,y,z);
    else if(y>mid) return find(t[x].r,mid+1,r,y,z);
    else return merge(find(t[x].l,l,mid,y,mid),find(t[x].r,mid+1,r,mid+1,z));
}
int query(int x){
    return find(rt[x],1,n,p[1],p[2]).rmx+find(rt[x],1,n,p[2]+1,p[3]-1).sum+find(rt[x],1,n,p[3],p[4]).lmx;
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read();
    for(int i=1;i<=n;++i) a[i].x=read(),a[i].id=i;
    sort(a+1,a+1+n);
    build(rt[1],1,n);
    for(int i=2;i<=n;++i) update(rt[i-1],rt[i],1,n,a[i-1].id);
    q=read();
    while(q--){
        int x=read(),y=read(),z=read(),k=read();
        p[1]=(x+Pre)%n+1,p[2]=(y+Pre)%n+1,p[3]=(z+Pre)%n+1,p[4]=(k+Pre)%n+1;
        sort(p+1,p+5);
        int l=1,r=n,ans=1;
        while(l<=r){
            int mid=(l+r)>>1;
            int f=query(mid);
            if(f>=0) ans=mid,l=mid+1;
            else r=mid-1;
        }
        Pre=a[ans].x;
        print(a[ans].x),*o++='\n';
    }
    fwrite(obuf,o-obuf,1,stdout);
    return 0;
}

 

hdu 4348 To the moon

主席树的区间修改，应该算是真正的可持久化？

题解

//minamoto
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=100005,M=N*30;
int n,m,cnt,rt[N];
int L[M],R[M];ll sum[M],add[M];
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
inline ll read(){
    #define num ch-'0'
    char ch;bool flag=0;ll res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
void build(int &now,int l,int r){
    add[now=++cnt]=0;
    if(l==r) return (void)(sum[now]=read());
    int mid=(l+r)>>1;
    build(L[now],l,mid);
    build(R[now],mid+1,r);
    sum[now]=sum[L[now]]+sum[R[now]];
}
void update(int last,int &now,int l,int r,int ql,int qr,int x){
    now=++cnt;
    L[now]=L[last],R[now]=R[last],add[now]=add[last],sum[now]=sum[last];
    sum[now]+=1ll*x*(qr-ql+1);
    if(ql==l&&qr==r) return (void)(add[now]+=x);
    int mid=(l+r)>>1;
    if(qr<=mid) update(L[last],L[now],l,mid,ql,qr,x);
    else if(ql>mid) update(R[last],R[now],mid+1,r,ql,qr,x);
    else return (void)(update(L[last],L[now],l,mid,ql,mid,x),update(R[last],R[now],mid+1,r,mid+1,qr,x));
}
ll query(int now,int l,int r,int ql,int qr){
    if(l==ql&&r==qr) return sum[now];
    int mid=(l+r)>>1;
    ll res=1ll*add[now]*(qr-ql+1);
    if(qr<=mid) res+=query(L[now],l,mid,ql,qr);
    else if(ql>mid) res+=query(R[now],mid+1,r,ql,qr);
    else res+=query(L[now],l,mid,ql,mid)+query(R[now],mid+1,r,mid+1,qr);
    return res;
}
int main(){
    //freopen("testdata.in","r",stdin);
    n=read(),m=read();
    cnt=-1;
    build(rt[0],1,n);
    int now=0;
    while(m--){
        char ch;int l,r,x;
        while(!isupper(ch=getc()));
        switch(ch){
            case 'C':{
                l=read(),r=read(),x=read();
                ++now;
                update(rt[now-1],rt[now],1,n,l,r,x);
                break;
            }
            case 'Q':{
                l=read(),r=read();
                printf("%lld\n",query(rt[now],1,n,l,r));
                break;
            }
            case 'H':{
                l=read(),r=read(),x=read();
                printf("%lld\n",query(rt[x],1,n,l,r));
                break;
            }
            case 'B':{
                now=read();
                cnt=rt[now+1]-1;
                break;
            }
        }
    }
    return 0;
}

鉴于本人十分弱鸡，可能讲的不是非常清楚，欢迎大家在下面补充