主席树 笔记

目录

• 废话
• 可持久化是啥
• 经典题型
  • 静态的问题
    • 一个伏笔
    • 静态问题(板子)的代码
  • 动态的问题
  • 前置芝士： 树状数组
  • 故 技 重 施
  • 总体思路
    • 初始化
    • 修改操作
    • 查询操作
    • 代码

废话

首先介绍一下主席树与其名字的来历。主席树是“可持久化线段树”（Persistant Segment Tree）的中文民间俗称。不知道是因为有人把 Persistant 看成了 Presidant，还是因为它的发明者是 HJT（和某一任国家主席简称相同），被叫做“主席树”。

但是，可持久化是啥呢？

可持久化是啥

可持久化是亿点小优化，当你要开 $n$ 个线段树，但是线段树之间只差一次修改的时候，把空间复杂度降到 $O(n\log n)$。

如何优化呢？考虑我们现在要对一个单点进行修改，那么我们能影响到的位置（就是这个点以及它的祖先），一共才 $\log n$ ，个而其它位置都一样，所以我们可以 只新建 $\log n$ 个位置，整一个副本出来，其余位置直接继承原树即可。

蒯一张图举个例子，$n=5$，修改了第四个点：

（原作者）

（原博客）

这样就能节省下超级多的空间！

但是，有利总有弊。这样的结构破坏的原来线段树的编号的完美特性，不能再用 index<<1 和 index<<1|1 来访问左右儿子了。我们要在线段树中多维护两个元素，左儿子和右儿子的编号。

经典题型

静态/动态区间第 $k$ 位：给定一个序列，每次给出 $l,r,k$，求 $[l,r]$ 中的数排序后，第 $k$ 个位置的数是谁。（当然，我们不会实际去排序，所以询问操作对原序列没有影响）

如果是动态的，那你还要支持单点修改的操作，会给定 $x,y$，要支持把第 $x$ 个位置上的数改成 $y$。

（假设我们离散化过了所有 $a_i$，和所有询问修改后变成的 $y$）

静态的问题

板子见 洛谷 3834

对于一个查询 $(l,r,k)$ ，（假设我们能）把 $a[l\cdots r]$ 拿出来建一颗权值线段树 $T$，查询就很容易了：把区间分成左半部分和右半部分，设左半部分中数字的个数为 $lsum$。如果 $k\le lsum$，那么就在左半部分中查找，否则就在右半部分中查找第 $k-lsum$ 个。

但是我们怎么把 $a[l\cdots r]$ 拿出来建一颗权值线段树呢？这个时空复杂度都是 $O(nlogn)$ 每次，再乘一个询问次数，肯定炸。

但是我们发现，线段树满足一种微妙的“可减性”：我们考虑建 $n$ 颗线段树 $T$，$T_i$ 表示 $a[1\cdots i]$ 组成的权值线段树。然后 $a[l\cdots r]$ 组成的权值线段树的对应位置就是 $T_r$ 的对应位置减去 $T_{l-1}$的对应位置。但是把 $T$ 建出来，光空间就够炸的了，是 $O(n^2)$ 的

考虑用上面“可持久化”的办法来优化求 $T$ 的过程：$T_i$ 和 $T_{i-1}$之间，差的只是在（离散化后的） $a_i$ 位置上加一。那么我们就让 $T_i$ 在 $T_{i-1}$ 的基础上，复制其中的 $\log$ 条链即可。这样就可以空间复杂度 $O(n\log n)$ ，时间复杂度 $O(n\log^2 n)$ 的过去了。

一个伏笔

请把它理解成“前缀和套线段树”。

那么恭喜您，现在您已经会了一个嵌套型的数据结构了

静态问题(板子)的代码

点击展开/折叠

#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet
{   
    #define N 200005
    #define F(i,l,r) for(int i=l;i<=r;++i)
    #define D(i,r,l) for(int i=r;i>=l;--i)
    #define Fs(i,l,r,c) for(int i=l;i<=r;c)
    #define Ds(i,r,l,c) for(int i=r;i>=l;c)
    #define MEM(x,a) memset(x,a,sizeof(x))
    #define FK(x) MEM(x,0)
    #define Tra(i,u) for(int i=G.Start(u),v=G.To(i);~i;i=G.Next(i),v=G.To(i))
    #define p_b push_back
    #define sz(a) ((int)a.size())
    #define iter(a,p) (a.begin()+p)
    int I()
    {
        int x=0;char c=getchar();int f=1;
        while(c<'0' or c>'9') f=(c=='-')?-1:1,c=getchar();
        while(c>='0' and c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
        return (x=(f==1)?x:-x);
    }
    void Rd(int cnt,...)
    {
        va_list args; va_start(args,cnt);
        F(i,1,cnt) {int* x=va_arg(args,int*);(*x)=I();}
        va_end(args);
    }
    class Persistant_Tree
    {
    public:
        struct node{int lid,rid; int l,r; int s;} t[N<<5];
        // 注意空间往死里开
        // lid,rid 存储左右儿子编号
        int rt[N],tot=0;
        // rt[i] 存第 i 颗线段树的根的编号
        #define ls(x) t[x].lid
        #define rs(x) t[x].rid
        #define L  t[rt].l
        #define R  t[rt].r
        #define S  t[rt].s
        #define up(x) t[x].s=t[t[x].lid].s+t[t[x].rid].s
        void Init() {tot=0;}
        int Build(int l,int r) // 建树，这一步和普通的线段树差别不大
        {
            int rt=++tot;
            L=l,R=r,S=0;
            if (l<r)
            {
                int mid=(l+r)>>1;
                ls(rt)=Build(l,mid); 
                rs(rt)=Build(mid+1,r); 
            }
            return rt;
        }
        int Insert(int pos,int rt) 
        // 在 rt 这个根的基础上，修改了 pos 位置
        // 把一路上修改的线段树上的链存一个副本，并返回这个链的顶端
        {
            int rr=++tot;
            t[rr].l=L; t[rr].r=R; t[rr].s=S+1;
            ls(rr)=ls(rt); rs(rr)=rs(rt); // 默认直接继承

            if (L<R)
            {
                int mid=(L+R)>>1;
                if (pos<=mid) ls(rr)=Insert(pos,ls(rt)); // 如果要修改左儿子，那么就左儿子开一个副本
                else          rs(rr)=Insert(pos,rs(rt)); // 右儿子同理
            }
            return rr;
        }
        int QueryKth(int r1,int r2,int l,int r,int k) // 在 T[r2]-T[r1] 这颗权值线段树中，查询排名为 k 的位置
        {
            if (l==r) return l;

            int mid=(l+r)>>1;
            int lsum=t[ls(r2)].s-t[ls(r1)].s; // 左边有多少数
            if (k<=lsum) return QueryKth(ls(r1),ls(r2),l,mid,k); // k<=lsum，在左边找
            else         return QueryKth(rs(r1),rs(r2),mid+1,r,k-lsum); // 否则在右边找
        }
    }T;

    int n,q,a[N];
    void Input()
    {
        Rd(2,&n,&q);
        F(i,1,n) a[i]=I();
    }

    int d[N];
    void Soviet()
    {
        F(i,1,n) d[i]=a[i];
        sort(d+1,d+n+1);
        F(i,1,n) a[i]=lower_bound(d+1,d+n+1,a[i])-d;

        T.Init();
        T.rt[0]=T.Build(1,n);
        F(i,1,n)
        {
            T.rt[i]=T.Insert(a[i],T.rt[i-1]);
            // 第 i 颗线段树的根，就是在第 i-1 颗线段树的基础上，在 a[i] 的位置上加了一
        }
        F(i,1,q)
        {
            int l=I(),r=I(),k=I();
            int pos=T.QueryKth(T.rt[l-1],T.rt[r],1,n,k);
            // 查询第 r 颗树减去第 l-1 颗树的第 k 位，就相当于 a[l...r] 中的第 k 位
            printf("%d\n",d[pos]);
        }
    }

    #define Flan void
    Flan IsMyWife()
    {
        Input();
        Soviet();
    }
}
int main()
{
    Flandre_Scarlet::IsMyWife();
    getchar();getchar();
    return 0;
}

动态的问题

板子见 洛谷 2617

做好准备，这比静态的问题要困难的多。我当时调试了 $10$ 个小时才过去。

（后期：纯粹是我傻，抱歉）

前置芝士： 树状数组

不会这个，学个锤子主席树。

为了方便说明，下面设 $nex(i)=i+\operatorname{lowbit}(i)$，$pre(i)=i-\operatorname{lowbit}(i)$

故 技 重 施

动态的问题就是我们要支持对其中一个位置进行修改了。修改 了第 $i$ 个位置后，$[i,n]$ 范围内的所有线段树都要被修改一次，时间复杂度就爆炸了。

等等，这个问题我们是不是见过一次？

把时间倒回大约一两年前，我们遇到过这样一个问题：“单点修改，求区间和”。当时，懵懂的我们也在想：求区间和就要维护前缀和；当时改了一个点，$[i,n]$ 范围内的所有前缀和都要被修改一次，时间复杂度就爆炸了。

（对比一下这两句话）

我们当时是用的树状数组解决的问题：树状数组 $T$，第 $i$ 个位置 $T_i$ 维护 $pre(i)+1$ 到 $i$ 的和。要查询 $i$ 的前缀和，只要求 $T_i,T_{pre(i)},T_{pre(pre(i))}\cdots$ 的和即可。

那么我们可以用树状数组的思路维护主席树啊！

总体思路

那么我们怎么写呢？我们写一个“树状数组套主席树”：维护 $n$ 个线段树 $T$，其中 $T_i$ 维护 $[pre(i)+1,i]$ 之间的所有 $a_{x}$ 组成的权值线段树即可。

实际上这个引号可以去掉，这个就是树状数组套主席树

初始化

对于初始化操作，我们建树。先开 $n$ 颗线段树，但是初始的时候 $n$ 颗线段树 全部 和初始的线段树共用 （也就是对于每个 $i$，$root[i]=root[0]$）

然后对于第 $i$ 个位置，它只能影响到 $i,nex(i),nex(nex(i))\cdots$ 位置上的线段树。对于这些位置上的每一个线段树 $T_i$，我们在它 自己 的基础上，插入 $a[i]$ 位置（并加一）。

修改操作

对于修改第 $x$ 个位置从原来的 $a[x]$ 变成 $y$ （修改完令 $a[x]=y$），我们要找到所有包含它的线段树，$T$，在第 $a[x]$ 个位置 $-1$，在 $y$ 的位置 $+1$，这样就完成了修改操作。

查询操作

静态的问题中，查询 $[l,r]$ 的第 $k$ 大，用 $T_r$ 来减掉 $T_{l-1}$，然后判断答案在左边还是在右边。传参数只要传入 $T_{l-1}$ 和 $T_r$ 的根节点编号即可。

然而我们现在是树状数组套线段树，两者相减，可不是两颗线段树相减了，而是

第 $r,pre(r),pre(pre(r))\cdots$ 颗线段树的和，减去

第 $l-1,pre(l-1),pre(pre(l-1)) \cdots$ 颗线段树的和。

然后我们显然没法一次性传这么多参数进去（而且还是不定长度，更麻烦了）。我们的办法是，在查询之前，先把所有的 $l-1,pre(l-1),pre(pre(l-1)) \cdots$ 保存在一个数组 $R_1$ 里，再把所有的 $r,pre(r),pre(pre(r)) \cdots$ 保存在一个数组 $R_2$ 里（并记下这两个数组的长度）（从 $1$ 开始编号的同学可以考虑用第 $0$ 个位置作为长度，我就是这么写的）

每次查询前缀 $r$ 颗树减去前缀 $l-1$ 颗树的时候，就遍历 $R_1,R_2$，把第 $R_{2i}$ 颗树的对应位置都加起来，把第 $R_{1i}$ 颗树的对应位置都减掉，得到 $lsum$。然后用静态里面的做法即可。

代码

点击展开/折叠

#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet
{
	#define N 100005
	#define F(i,l,r) for(int i=l;i<=r;++i)
	#define D(i,r,l) for(int i=r;i>=l;--i)
	#define Fs(i,l,r,c) for(int i=l;i<=r;c)
	#define Ds(i,r,l,c) for(int i=r;i>=l;c)
	#define MEM(x,a) memset(x,a,sizeof(x))
	#define FK(x) MEM(x,0)
	#define Tra(i,u) for(int i=G.Start(u),v=G.To(i);~i;i=G.Next(i),v=G.To(i))
	#define p_b push_back
	#define sz(a) ((int)a.size())
	#define iter(a,p) (a.begin()+p)
	int I()
	{
	    int x=0;char c=getchar();int f=1;
	    while(c<'0' or c>'9') f=(c=='-')?-1:1,c=getchar();
	    while(c>='0' and c<='9') x=(x<<1)+(x<<3)+(c^48),c=getchar();
	    return (x=(f==1)?x:-x);
	}
	void Rd(int cnt,...)
	{
	    va_list args; va_start(args,cnt);
	    F(i,1,cnt) {int* x=va_arg(args,int*);(*x)=I();}
	    va_end(args);
	}

	class Persistant_tree // 被卡常了的主席树...
	{
	public:
		struct node{int lid,rid,s;} t[N*400];
		// 去掉了存储左右区间的成员变量，左右区间在函数调用过程中记录
		// 从而把空间优化成原来的 3/5，然后数组开大点
		int rt[N],tot;
		#define ls(x) t[x].lid
		#define rs(x) t[x].rid
		#define S     t[rt].s
		void Init() {tot=0;}
		int Build(int l,int r)
		{
			int rt=++tot; S=0;
			if (l<r)
			{
				int mid=(l+r)>>1;
				ls(rt)=Build(l,mid);
				rs(rt)=Build(mid+1,r);
			}
			return rt;
		} // 这个一样的
		int Insert(int l,int r,int pos,int type,int rt)
		// 修改操作可能会有 -1，于是加上一个 type，type=1或-1表示加还是减
		{
			int rr=++tot;
			ls(rr)=ls(rt); rs(rr)=rs(rt); t[rr].s=S+type;
			if (l<r)
			{
				int mid=(l+r)>>1;
				if (pos<=mid) ls(rr)=Insert(l,mid,pos,type,ls(rt));
				else 		  rs(rr)=Insert(mid+1,r,pos,type,rs(rt));
				// 这些一样的
			}
			return rr;
		}
		int R2[30],R1[30];
		// R2,R1 含义见上面
		// 数组第 0 个位置保存数组长度
		int QueryKth(int l,int r,int k)
		{
			if (l==r) return l;
	
			int lsum=0;
			F(i,1,R2[0]) lsum+=t[ls(R2[i])].s;
			F(i,1,R1[0]) lsum-=t[ls(R1[i])].s;
			// 这个就是要遍历累加来求出 lsum 的值了
			int mid=(l+r)>>1;
			if (k<=lsum) 
			{
				F(i,1,R2[0]) R2[i]=ls(R2[i]);
				F(i,1,R1[0]) R1[i]=ls(R1[i]);
				// 跳左右儿子也要一块跳...这个复杂度活生生的多一个 log 啊
				return QueryKth(l,mid,k);
			}
			else
			{
				F(i,1,R2[0]) R2[i]=rs(R2[i]);
				F(i,1,R1[0]) R1[i]=rs(R1[i]);
				return QueryKth(mid+1,r,k-lsum);
			}
		}
	}T;
	
	int n,m,a[N];
	struct node{char type; int a,b,c;} q[N];
	// 如果是 C 操作，那么我们只用 a,b，表示将 a 位置变成了 b
	// 如果是 Q 操作，那么我们 a,b,c 都用，表示 [a,b] 区间排名第 c 位的数
	void Input()
	{
		Rd(2,&n,&m);
		F(i,1,n) a[i]=I();
		F(i,1,m)
		{
			char o[3]; scanf("%s",o);
			if (o[0]=='Q') 
			{
				q[i]=(node){o[0],I(),I(),I()};
			}
			else
			{
				q[i]=(node){o[0],I(),I()};
			}
		}
	}
	
	int d[N<<2],dcnt=0;
	#define Find(x) (lower_bound(d+1,d+dcnt+1,x)-d)
	void Insert(int pos,int type)
	{
		int x=Find(a[pos]);
		for(int i=pos;i<=n;i+=(i&(-i))) 
		{
			int lastr=T.rt[i]; // 保存原来的根
			T.rt[i]=T.Insert(1,dcnt,x,type,lastr); // 以便在原来的基础上插入
		}
	}
	int Query(int l,int r,int k)
	{
		F(i,0,22) T.R1[i]=T.R2[i]=0;
		for(int i=r;i>0;i-=(i&(-i))) T.R2[++T.R2[0]]=T.rt[i];
		for(int i=l;i>0;i-=(i&(-i))) T.R1[++T.R1[0]]=T.rt[i];
		// 先预先求好 R1,R2
		return T.QueryKth(1,dcnt,k);
	}
	void Soviet()
	{
		F(i,1,n) d[++dcnt]=a[i];
		F(i,1,m) if (q[i].type=='C') d[++dcnt]=q[i].b;
		sort(d+1,d+dcnt+1);
	
		T.Init();
		T.rt[0]=T.Build(1,dcnt); F(i,1,n) T.rt[i]=1;
		F(i,1,n) Insert(i,1);
		F(i,1,m)
		{
			if (q[i].type=='Q')
			{
				int pos=Query(q[i].a-1,q[i].b,q[i].c);
				printf("%d\n",d[pos]);
			}
			if (q[i].type=='C')
			{
				int x=q[i].a,y=q[i].b;
				Insert(x,-1); a[x]=y;
				Insert(x,1);
			}
		}
	}
	
	#define Flan void
	Flan IsMyWife()
	{
		Input();
		Soviet();
	}
}
int main()
{
	Flandre_Scarlet::IsMyWife();
	getchar();getchar();
	return 0;
}