可持久化：

指的是我们每对树做一次修改，就将其保存为一个历史版本，在以后的询问/修改中，我可以选择任意一个历史版本来询问/修改

实现：

最简单的实现思路：

最简单的思路当然是每次修改的时候都将历史版本的树copy一遍，然后对其进行修改并保存，但是这样的话，如果要留存的历史版本很多而且树也很大，很容易就会MLE

正确的实现思路：

对于一棵树来说，我们每次单点修改的时候，无非就是修改了它的左子树或者是右子树，那么对于新的版本来说，当他修改的是左子树的节点的时候，显然我们可以继续沿用历史版本的右子树，也就是只要复制并修改一棵左子树就可以了；当他修改的是右子树的节点的时候，显然我们可以继续沿用历史版本的左子树，也就是只要复制并修改一棵右子树就可以了。这就是可持久化的核心思想

实现方式：

我们每访问一个历史版本的结点的位置的时候，都先新开一个对应的结点，并让这个节点继承历史版本的左子树和右子树，然后根据我们需要修改的位置去递归他的左子树或者右子树。假设我们递归的是左子树，这样一来，当我们一访问需要更新的左子树的时候，我们又会开了一个新的结点，就达到了开新树的目的，同时，没有递归的右子树就是继承了原来历史版本的旧子树。

可持久化线段树： 

题目链接：P3919 【模板】可持久化线段树 1（可持久化数组） - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

实现代码：

#include <iostream>
#include <cstdio>
using namespace std;
const int N = 1E6 + 10;
int n, m;
#define mid (l+r>>1)
int ls[N * 55], rs[N * 55], val[N * 55];
int root[N],idx;
int a[N];//点修点查不需要pushup
void build(int &u,int l,int r){//动态开点if(!u){u = ++idx;}if(l==r){val[u] = a[l];return;}build(ls[u], l, mid);build(rs[u], mid + 1, r);
}void change(int v,int &u,int l,int r,int p,int k){//开新结点u = ++idx;//递归到了叶子结点直接修改if(l==r){val[u] = k;return;}//非叶子结点继承左右子树ls[u] = ls[v];rs[u] = rs[v];//递归要修改的子树if(p<=mid){change(ls[v], ls[u], l, mid, p, k);}else{change(rs[v], rs[u], mid + 1,r, p, k);}
}//和正常的点查一样
int query(int u,int l,int r,int p){if(l==r){return val[u];}if(p<=mid){return query(ls[u], l, mid, p);}else{return query(rs[u], mid + 1,r, p);}
}int main(){scanf("%d%d", &n, &m);for (int i = 1; i <= n;i++){scanf("%d", a + i);}build(root[0], 1, n);for (int i = 1,v,op,p,value; i <= m;i++){scanf("%d%d", &v, &op);if(op==1){scanf("%d%d", &p, &value);change(root[v], root[i], 1, n, p, value);}else{scanf("%d", &p);//这里也要生成一个新的版本//一开始漏了这句话，只有24ptsroot[i] = root[v];printf("%d\n", query(root[v], 1, n, p));}}return 0;
}

可持久化平衡树：

题目链接：P3835 【模板】可持久化平衡树 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

操作和可持久化线段树类似，我这里采用的是FHQ-Treap实现的平衡树，在split的过程中会修改树的值，因此在split的时候需要开新点，由于merge的时候连接的都是split开的新点，所以merge就不用再开新点了

实现代码如下：

#include <iostream>
#include <climits>
#include <time.h>
using namespace std;
const int N = 5E5 + 10;
struct node
{int l, r;int key;int val;int size;
} tr[N * 50];
int idx, root[N];
int newnode(int v)
{tr[++idx].val = v;tr[idx].key = rand();tr[idx].size = 1;return idx;
}
void pushup(int p)
{tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + 1;
}
// split更新裂痕的时候开新树
void split(int p, int v, int &x, int &y)
{if (!p){x = y = 0;return;}if (tr[p].val <= v){x = ++idx;tr[x] = tr[p];split(tr[x].r, v, tr[x].r, y);pushup(x);}else{y = ++idx;tr[y] = tr[p];split(tr[y].l, v, x, tr[y].l);pushup(y);}
}
//split的时候，更新的裂痕结点开了新结点
//在merge的时候，只有裂痕结点会发生连接，则不需要再开新结点
int merge(int x, int y)
{if (!x || !y){return x + y;}if (tr[x].key < tr[y].key){tr[x].r = merge(tr[x].r, y);pushup(x);return x;}else{tr[y].l = merge(x, tr[y].l);pushup(y);return y;}
}
void insert(int &rt, int v)
{int x, y;split(rt, v, x, y);rt = merge(merge(x, newnode(v)), y);
}
void del(int &rt, int v)
{int x, y, z;split(rt, v, x, y);split(x, v - 1, x, z);z = merge(tr[z].l, tr[z].r);rt = merge(merge(x, z), y);
}
int getk(int &rt, int v)
{int x, y;split(rt, v - 1, x, y);int ans = tr[x].size + 1;rt = merge(x, y);return ans;
}
int getval(int p, int k)
{if (k == tr[tr[p].l].size + 1){return tr[p].val;}else if (k <= tr[tr[p].l].size){return getval(tr[p].l, k);}else{return getval(tr[p].r, k - tr[tr[p].l].size - 1);}
}
int getpre(int &rt, int v)
{int x, y;split(rt, v - 1, x, y);int z = x;if (!z){return INT_MIN + 1;}while (tr[z].r){z = tr[z].r;}rt = merge(x, y);return tr[z].val;
}
int getnxt(int &rt, int v)
{int x, y;split(rt, v, x, y);int z = y;if (!z){return INT_MAX;}while (tr[z].l){z = tr[z].l;}rt = merge(x, y);return tr[z].val;
}
// 还能优化：
// 操作数为3,4,5,6时，不需要copy一份新树
int main()
{int n;cin >> n;srand((unsigned int)time(NULL));for (int i = 1, v, opt, x; i <= n; i++){cin >> v >> opt >> x;root[i] = root[v];if (opt == 1){insert(root[i], x);}else if (opt == 2){del(root[i], x);}else if (opt == 3){cout << getk(root[i], x) << endl;}else if (opt == 4){cout << getval(root[i], x) << endl;}else if (opt == 5){cout << getpre(root[i], x) << endl;}else if (opt == 6){cout << getnxt(root[i], x) << endl;}}return 0;
}