什么样的数据结构可以可持久化
只有在操作过程中拓扑序不变的数据结构才可以做可持久化(参考y总教学视频的开头)
可持久化线段树(主席树)
AcWing 255. 第K小数
一篇写的很好的博客
我的看法:
- 首先数据很大,需要离散化,n个数离散化后也就是nth(nth指的是第n大)
- 对本题来说线段树每个节点中的l和r维护的是lth和rth,也就是排过序后nums中第l大和第r大的数字。
- 离散化数组nums排序去重后。遍历原数组,每插入一个a[i],就是一个版本号。因为最后查询的时候是查询原数组的[l,r]之间kth的数。也就是查询第l个版本和第r个版本这两个树。我们通过
int cnt = tr[tr[q].l].cnt - tr[tr[p].l].cnt;
得知在l-1
版本之后一直到r
版本有多少个数插入了线段树的左子树中,根据cnt和k的大小关系我们判断接下来是去左子树继续搜索还是去右子树。如果搜索到了叶子节点l == r
直接返回r或l
即可,因为线段树每个节点中的l和r维护的是lth和rth
在通过lth或rth
直接去排序去重过的nums数组中找对应的值即可
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10, M = 1e4 + 10;
int n, m;
struct Node{
int l, r, cnt;//l和r维护的是区间的数值,表示的是nums中第l大和第r大之间的一个区间,是一个kth而不是真正的值
}tr[N * 4 + N * 17];
int a[N];
vector<int> nums;
int root[N], idx;
int find(int x)
{
return lower_bound(nums.begin(), nums.end(), x) - nums.begin();//二分库函数,找到数值为x的数在nums的位置
}
int build(int l, int r)//虽然有很多版本的树,但是他们的骨架是一样的
{
int p = idx ++;
if (l == r)
{
return p;//idx就是节点编号
}
int mid = l + r >> 1;
tr[p].l = build(l, mid); tr[p].r = build(mid + 1, r);
return p;
}
int insert(int p, int l, int r, int k)
{
int q = idx ++;//建立一个新的根节点
tr[q] = tr[p];//先把旧版本的树的所有信息复制过来
if (l == r)
{
tr[q].cnt++;
return q;
}
int mid = l + r >> 1;
if (k <= mid) tr[q].l = insert(tr[p].l, l, mid, k);//递归,说明左节点要更新,不能用之前旧的树的版本信息了
else tr[q].r = insert(tr[p].r, mid + 1, r, k);
tr[q].cnt = tr[tr[q].l].cnt + tr[tr[q].r].cnt; // 相当于pushup了
return q;
}
int query(int q, int p,int l, int r, int k)//bug..不知道为啥调换q和p的顺序不行(传参的时候也是反着的,顺序都对的上)
{
if (l == r)
{
return r;//l, r维护的信息就是nums中的kth。
}
//cnt求的是在p之后一直到q,有多少个数插入了p的左子树中
//根据cnt和k的大小关系我们判断接下来是去左子树继续搜索还是去右子树
int cnt = tr[tr[q].l].cnt - tr[tr[p].l].cnt;
int mid = l + r >> 1;
if (k <= cnt) return query(tr[q].l, tr[p].l, l, mid, k);
else return query(tr[q].r, tr[p].r, mid + 1, r, k - cnt);//因为维护的是每个区间有多少个数,所以递归到右边的时候要减去左边计的数
}
int main()
{
cin >> n >> m;
for (int i = 1; i <= n; ++ i)
{
cin >> a[i]; nums.push_back(a[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
//其实可以不用build(主要是方便理解),在我们insert的过程中就会慢慢build
root[0] = build(0, nums.size() - 1);//线段树维护kth即可,不用维护真的数值,找到kth再去nums[k]就可以得到值了
for (int i = 1; i <= n; ++ i)
{
root[i] = insert(root[i - 1], 0, nums.size() - 1, find(a[i]));
}
for (int i = 0; i < m; ++ i)
{
int l, r, k;
cin >> l >> r >> k;
//查询[l,r]区间中的第k大数,利用前缀和的思想,从[l ~ r]中的数据剔除掉[1 ~ l-1]的数据,
int x = query(root[r], root[l - 1], 0, nums.size() - 1, k);
cout << nums[x] << endl;
}
return 0;
}
可持久化trie
AcWing 256. 最大异或和
- 我发现基本上可持久化都需要用到前缀和的思想,其实变相来想就是把前面的数据充分利用起来,寻找其规律发现可以用前缀的思想。
- 老样子,root数组记录的是不同版本的树的入口
#include <iostream>
using namespace std;
const int M = 3e5 * 2 * 25 + 10, N = 3e5 * 2 + 10;//序列的长度可能不止N,因为还有M次操作,所以*2
int tr[M][2];
int root[N], idx;
int max_id[M];
int s[N];
int n, m;
void insert(int i, int k, int p, int q)
{
if (k < 0)
{
max_id[q] = i;
return ;
}
int v = s[i] >> k & 1;
if (p)//可能是p = 0,我们初始化的时候idx = 0没有值
{
tr[q][v ^ 1] = tr[p][v ^ 1];//先把上一个版本的信息记录下来
}
tr[q][v] = ++ idx;
insert(i, k - 1, tr[p][v], tr[q][v]);//递归的精髓:本轮的p和q就是上一轮的tr[p][v]和tr[q][v]
max_id[q] = max(max_id[tr[q][1]], max_id[tr[q][0]]);
}
int query(int l, int r, int C)
{
int p = root[r];
for (int i = 23; i >= 0; -- i)
{
int v = C >> i & 1;
if (max_id[tr[p][v ^ 1]] >= l) p = tr[p][v ^ 1];//可以自己画一棵树,第一个节点的值就是tr[root[r]][v];
else p = tr[p][v];//迭代往下走
}
return C ^ s[max_id[p]];
}
int main()
{
cin >> n >> m;
//初始化
max_id[0] = -1;
// s[0] = 0; 全局变量默认就是0
root[0] = ++ idx;//idx = 0当作空
insert(0, 23, 0, root[0]);
for (int i = 1; i <= n; ++ i)
{
int x;
cin >> x;
s[i] = s[i - 1] ^ x;//发现可持久化数据结构都有前缀和的思想
root[i] = ++ idx;
insert(i, 23, root[i - 1], root[i]);
}
char op[2];
int l, r, x;
while (m --)
{
cin >> op;
if (op[0] == 'A')
{
cin >> x;
++ n;
s[n] = s[n - 1] ^ x;
root[n] = ++ idx;
insert(n, 23, root[n - 1], root[n]);
}
else
{
cin >> l >> r >> x;
cout << query(l - 1, r - 1, s[n] ^ x) << endl;//树的版本号是0~N-1
}
}
return 0;
}