主席树（可持久化线段树）入门详解

一.问题引入.

当我们遇到要求快速查询区间的问题时，通常用线段树、平衡树等数据结构维护这类问题.但是使用这些数据结构的前提是要求区间信息可以快速合并（例如$O(1)$或$O(\log n)$合并），还有很多问题是不可以这样做的，例如区间第k小的问题.

区间第k小问题可以使用很多数据结构来解决，例如划分树、归并树、分块、树套树等数据结构来解决，然而这些数据结构一次查询的时间复杂度大多劣于$O(\log n)$.

就当这些数据结构都对这类问题显得十分无力的时候，可持久化这种数据结构上的技巧横空出世，而主席树（可持久化线段树）就是其中的一种经典应用.


二.权值线段树.

在认识主席树之前，我们先来看一种特殊的线段树——权值线段树，这种线段树的维护的是序列的数值范围内每一个值的出现情况.

我们不考虑时空复杂度，尝试利用权值线段树来维护区间第$k$小问题.

首先建立$n$棵结构相同线段树，每棵线段树维护区间$[1,n]$中出现的权值信息.那么当我们要查询区间$[l,r]$的第$k$小数时，就可以同时从维护$[1,l-1]$和$[1,r]$的线段树的根节点出发往下走.设$tr[m][i]$表示维护$[1,m]$的线段树的第$i$个节点，那么若$tr[r][i]$的左儿子所包含的权值数量减去$tr[l-1][i]$左儿子所包含的权值数量小于$k$则往右儿子走（注意让$k$减掉权值数量），否则往左儿子走.

这个时候我们会发现查询一次的时间复杂度为$O(\log n)$，但是空间复杂度和建树的时间复杂度均为$O(n^2)$（离散化后），于是我们的算法就要考虑如何优化这一复杂度.


三.可持久化的引入.

我们设原来的权值序列为$2,1,3,4$，那么原来的$4$棵线段树大概是这样的：

其中橙色的节点表示与上一棵线段树之间的差异.

我们考虑相邻的两棵线段树之间的关系，发现两棵线段树之间的差异只有树上的一条长度为$O(\log n)$的链！

这是否可以启发我们可以每次只存储发生改变的节点，其它节点直接调用上一棵的？

考虑这样子存储原来的$n$棵线段树：

图有点丑不要介意QAQ.

我们发现这正好对应了我们上面的只存修改节点的思想，看起来这个想法非常可行，显然时空复杂度均为$O(n\log n)$.

事实上，这是一种被称作“可持久化”的技巧，这种技巧被广泛应用于数据结构的维护上，我们上面维护的线段树就是可持久化线段树，也被称为主席树.

类比可持久化线段树，我们还可以维护可持久化Trie、可持久化并查集、可持久化平衡树等数据结构，除了可持久化树状数据结构外，也有可持久化栈、可持久化块状链表等数据结构.


四.可持久化线段树的实现.

说了那么多，我们该如何实现一棵可持久化线段树呢？

首先我们可以仿照动态开点线段树，初始第一棵树直接利用$0$节点的自我迭代来实现，也就是说我们不需要建树.

之后考虑如何往后增加一棵树$k$.其实很简单，只需要顺着第$k-1$棵树往下，新建一条链即可，代码如下：

void Add_tree(int x,int l,int r,int hk,int &k){
  tr[k=++cn]=tr[hk];
  if (l==r) {++tr[k].sum;return;}
  int mid=l+r>>1;
  if (x<=mid) Add_tree(x,l,mid,tr[hk].s[0],tr[k].s[0]);
  else Add_tree(x,mid+1,r,tr[hk].s[1],tr[k].s[1]);
  Pushup(k);
}
//主程序中
Add_tree(a[i],1,n,rot[i-1],rot[i]);

查询$[l,r]$就从第$l-1$和第$r$往下走就好了，代码如下：

int Query(int k,int l,int r,int L,int R){
  if (l==r) return l;
  int sum=tr[tr[R].s[0]].sum-tr[tr[L].s[0]].sum,mid=l+r>>1;
  if (sum>=k) return Query(k,l,mid,tr[L].s[0],tr[R].s[0]);
  else return Query(k-sum,mid+1,r,tr[L].s[1],tr[R].s[1]);
}

五.例题与代码.

题目：luogu3834.

注意，这题由于数的范围太大权值线段树开不下，需要离散化.

代码如下：

#include<bits/stdc++.h>
  using namespace std;
 
#define Abigail inline void
typedef long long LL;

const int N=200000,C=30; 

int n,m,a[N+9],ord[N+9];

int Lower(int *a,int n,int x){
  int l=1,r=n,mid=l+r>>1;
  for (;l<r;mid=l+r>>1)
    x>a[mid]?l=mid+1:r=mid;
  return l;
}

struct tree{
  int s[2],sum;
}tr[N*C+9];
int cn,rot[N+9];

void Pushup(int k){tr[k].sum=tr[tr[k].s[0]].sum+tr[tr[k].s[1]].sum;}

void Add_tree(int x,int l,int r,int hk,int &k){
  tr[k=++cn]=tr[hk];
  if (l==r) {++tr[k].sum;return;}
  int mid=l+r>>1;
  if (x<=mid) Add_tree(x,l,mid,tr[hk].s[0],tr[k].s[0]);
  else Add_tree(x,mid+1,r,tr[hk].s[1],tr[k].s[1]);
  Pushup(k);
}

int Query(int k,int l,int r,int L,int R){
  if (l==r) return l;
  int sum=tr[tr[R].s[0]].sum-tr[tr[L].s[0]].sum,mid=l+r>>1;
  if (sum>=k) return Query(k,l,mid,tr[L].s[0],tr[R].s[0]);
  else return Query(k-sum,mid+1,r,tr[L].s[1],tr[R].s[1]);
}

Abigail into(){
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;++i){ 
    scanf("%d",&a[i]);
    ord[i]=a[i];
  }
}

Abigail work(){
  sort(ord+1,ord+1+n);
  for (int i=1;i<=n;++i)
    a[i]=Lower(ord,n,a[i]);
  for (int i=1;i<=n;++i)
    Add_tree(a[i],1,n,rot[i-1],rot[i]);
}

Abigail getans(){
  int l,r,k;
  while (m--){
  	scanf("%d%d%d",&l,&r,&k);
  	printf("%d\n",ord[Query(k,1,n,rot[l-1],rot[r])]);
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}