题目地址：

https://www.luogu.com.cn/problem/P3919

题目背景：
标题即题意

有了可持久化数组，便可以实现很多衍生的可持久化功能（例如：可持久化并查集）

题目描述：
如题，你需要维护这样的一个长度为$N$的数组，支持如下几种操作：
1.在某个历史版本上修改某一个位置上的值
2.访问某个历史版本上的某一位置的值
此外，每进行一次操作（对于操作$2$，即为生成一个完全一样的版本，不作任何改动），就会生成一个新的版本。版本编号即为当前操作的编号（从$1$开始编号，版本$0$表示初始状态数组）

输入格式：
输入的第一行包含两个正整数$N,M$， 分别表示数组的长度和操作的个数。
第二行包含$N$个整数，依次为初始状态下数组各位的值（依次为 $a_i$，$1\le i\le N$）。
接下来$M$行每行包含$3$或$4$个整数，代表两种操作之一（$i$为基于的历史版本号）：
1.对于操作$1$，格式为$v_{i}1{loc}_i{value}_i$，即为在版本$v_i$的基础上，将 $a_{{loc}_i}$修改为 ${value}_i$；
2.对于操作$2$，格式为$v_{i}2{loc}_i$，即访问版本$v_i$中的 $a_{{loc}_i}$的值，生成一样版本的对象应为$v_i$

输出格式：
输出包含若干行，依次为每个操作$2$的结果。

数据范围：
对于$30\%$的数据：$1\le N,M\le {10}^3$
对于$50\%$的数据：$1\le N,M\le {10}^4$
对于$70\%$的数据：$1\le N,M\le {10}^5$
对于$100\%$的数据：$1\le N,M\le {10}^6,1\le {loc}_i\le N,0\le v_i<i,-{10}^9\le a_i,{value}_i\le {10}^9$
询问生成的版本是指你访问的那个版本的复制

可以用主席树，即可持久化线段树，来维护这个数组，参考https://blog.csdn.net/qq_46105170/article/details/119052276。这里只需要做单点修改和单点查询即可。代码如下：

#include <algorithm>
#include <iostream>
using namespace std;

const int N = 1e6 + 10;
int n, m;
int a[N];
struct Node {
    
  int l, r, v;
} tr[(N << 2) + N * 20];
int root[N], idx;

int build(int l, int r) {
    
  int p = ++idx;
  if (l == r) tr[p].v = a[l];
  else {
    
    int mid = l + r >> 1;
    tr[p].l = build(l, mid), tr[p].r = build(mid + 1, r);
  }
  return p;
}

// 更新数组的第k个位置为v，并产生新的版本，返回新版本的树根
int update(int p, int l, int r, int k, int v) {
    
  int q = ++idx;
  tr[q] = tr[p];

  if (l == r) tr[q].v = v;
  else {
    
    int mid = l + r >> 1;
    if (k <= mid) tr[q].l = update(tr[q].l, l, mid, k, v);
    else tr[q].r = update(tr[q].r, mid + 1, r, k, v);
  }

  return q;
}

// 查询树根p对应的那个版本中第k个位置的数是多少
int query(int p, int l, int r, int k) {
    
  if (l == r) return tr[p].v;
  int mid = l + r >> 1;
  if (k <= mid) return query(tr[p].l, l, mid, k);
  else return query(tr[p].r, mid + 1, r, k);
}

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

  root[0] = build(1, n);
  for (int i = 1; i <= m; i++) {
    
    int vi, op, loc, val;
    scanf("%d%d%d", &vi, &op, &loc);
    if (op == 1) {
    
      scanf("%d", &val);
      root[i] = update(root[vi], 1, n, loc, val);
    } else {
    
      printf("%d\n", query(root[vi], 1, n, loc));
      // 查询完之后，新版本树根等于被查询版本的树根
      root[i] = root[vi];
    }
  }
}

预处理时间复杂度$O(N)$，每次询问时间$O(\log n)$，空间$O(N+M\log N)$。