带更新主席树
也可以理解为 动态主席树/树套树。
先从静态的说起。
我对主席树的理解
静态
主席树相关的数据结构就是为了压缩内存。主席树=线段树+前缀和+内存优化
比如说主席树的经典题：区间第k大。我们可以开一颗线段树来记录这个位置之前比它小的数有几个。然后用前缀和的思想，开n棵线段树求差即可知道区间第k大。
但是这样空间不够，会用
n
2
log
n
n^2\log{n}
n2logn的空间。于是我们观察到每次构建下一棵线段树的时候，相比上一棵只更新了一条链。又因为二叉树是一个链接结构，所以其他的节点可以直接链接过去。
动态
如果我们要修改区间的内容呢？依然以区间第k大为例。
一个最简单的想法
还是先从笨办法开始。我们可以先开n棵线段树，用于记录变化。比如，2->5，就在2上-1，5上+1。（这里不能直接用主席树是因为主席树的节点是共用的，修改会影响到其他节点。）在用上前缀和的思想，两个差即可代表一个区间。
第一个优化：动态开节点，节省内存。
和主席树一样，线段树上如果只更新一个节点，只需要开
log
n
\log{n}
logn个节点即可。这样就能节省一些内存。但是还不够。
第二个优化：升级前缀和
前缀和的效率是更新
O
(
n
)
O(n)
O(n)，查询
O
(
1
)
O(1)
O(1)，查询已经够快了，有没有什么办法可以加快更新速度呢？牺牲一点查询时间也没啥。
这个答案就是树状数组。作为前缀和的升级版，它的效率是更新
O
(
log
n
)
O(\log{n})
O(logn)，查询
O
(
log
n
)
O(\log{n})
O(logn)，这样就能满足要求啦！不仅加快速度，而且每次更新只需要更新
log
n
\log{n}
logn棵树了。
所以，动态主席树=线段树+树状数组+内存优化
例子 ZOJ2112 附（伪）AC代码
板子题。我WA了19发。虽然在OJ上过了，但是和网上的题解对拍还是有点不对，有误请指出。
因为是板子题，加上我写了非常详细的注释，所以只丢个代码。
另外，我是指针型选手，在此告诫各位指针型选手，OJ是64位机，指针也是64位，会被卡内存！（不，我就是要用指针！）（强行用指针可以看我代码，有骚操作）
前排警告：代码爆长，长度高达400行，7k。里面有很多奇奇怪怪的东西，还有调试代码。
#include <algorithm>
#include <iostream>
#include <cstring>
#include <climits>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <vector>
#include <cctype>
#include <ctime>
#include <cmath>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::fill;
using std::lower_bound;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::upper_bound;
using std::vector;
#define nullptr NULL//辣鸡oj没有c++11
//zoj2112 Dynamic Rankings
//可能是数据比较水，我的ac代码和网上答案对拍不一样。。。
//我也不知道到底算不算a了
//但是只要数据不重复，就是对的（目测）
//（GTMD离散化）
//树状数组专用套件，用于求二进制最后一位1
inline int lowbit(int x)
{
return x & (-x);
}
//用于离散化
struct sortnode
{
int id;
int val;
int after;
};
//离线处理，离散化
struct querynode
{
char mode;
int i;
int j;
int k;
};
//可以用lambda表达式（c++11）
bool cmp_id(const sortnode & a, const sortnode & b)
{
return a.id < b.id;
}
bool cmp_val(const sortnode & a, const sortnode & b)
{
return a.val < b.val;
}
const int maxn = 50000 + 10000;
const int maxm = 10000 + 10000;
const int maxsize = maxn + maxm;//每次更新也需要存进来
sortnode arr[maxsize];
querynode qarr[maxm];
int n, m;
struct node;
struct node_ptr//指针被卡内存的解决方法：用int模拟指针
{
int index;
static node* pool;
node_ptr()
{
index = -1;//以-1代表nullptr
}
node* operator->();
node& operator*();//注意这个node&，返回值必须可修改
operator bool()
{
return index != -1;
}
};
struct node
{
int sum;
node_ptr lson;
node_ptr rson;
node()
{
sum = 0;
}
};
node tree[32 * maxsize];//内存池
node_ptr root[maxn];//主席树的根
node_ptr exroot[maxsize];//树状数组套线段树的根
int rootcnt;
int nodecnt;
vector<node_ptr>use1;//用于临时存储在query时用到的一组线段树节点，左端点版本
vector<node_ptr>use2;//同上，这里是区间右端点版本
int conv[maxsize];//把离散化后的数转换成原始数据
int arr_now[maxn];//当前（最新）的数组，应该存储离散化后的值，防止多个相同元素导致更新错误位置，这里是一个巨坑
node* node_ptr::pool = tree;
//简单输出叶子节点
void print(node_ptr p, int l, int r)
{
if (l == r)
printf("%d:%d ", r, p->sum);
else
{
int mid = (l + r) / 2;
if (p->lson)
print(p->lson, l, mid);
if (p->rson)
print(p->rson, mid + 1, r);
}
}
//输出整棵线段树
void printtree(node_ptr p, int l, int r)
{
printf("%d: l:%d r:%d lson:%d rson:%d sum:%d\n", p.index, l, r, p->lson.index, p->rson.index, p->sum);
if (l != r)
{
int mid = (l + r) / 2;
if (p->lson)
printtree(p->lson, l, mid);
else
printf("%d: lson null\n", p.index);
if (p->rson)
printtree(p->rson, mid + 1, r);
else
printf("%d: rson null\n", p.index);
}
}
//输出所有记录更改的线段树
void print_all_extree()
{
for (int i = 1; i <= n; i++)
{
cout << "extree" << i << endl;
if (exroot[i])
printtree(exroot[i], 1, n);
else
printf("null");
cout << endl;
}
}
//计算use数组里树的左儿子的和
int lson_sum(vector<node_ptr> & v)
{
int sum = 0;
for (int i = 0; i < (int)v.size(); i++)
{
if (v[i] && v[i]->lson)
sum += v[i]->lson->sum;
}
return sum;
}
//把临时数组里的节点向左儿子下推一次
//因为是动态建树，所以非最底层的null节点是合法节点，
//在计数的时候应该视为0
void to_lson(vector<node_ptr> & v)
{
//在下推的时候，即使儿子是null也要下推
//如果不推的话，可能向错误的位置（右）推
for (int i = 0; i < (int)v.size(); i++)
{
if (v[i])
v[i] = v[i]->lson;
}
}
//把临时数组里的节点向右儿子下推一次
void to_rson(vector<node_ptr> & v)
{
for (int i = 0; i < (int)v.size(); i++)
{
if (v[i])
v[i] = v[i]->rson;
}
}
node_ptr newnode()
{
node_ptr p;
p = node_ptr();
p.index = nodecnt++;
*p = node();//分配之前清空/初始化，写的时候就不用了
if (nodecnt > 32 * maxsize)
throw;//如果开的内存不够，就会返回RE
return p;
}
//一个小辅助函数，在递归update的时候用，
//作用是让儿子始终能访问。
void nonull(node_ptr & p)
{
if (!p)
p = newnode();
}
//初始化
void reset()
{
for (int i = 0; i <= n; i++)
exroot[i] = node_ptr();
rootcnt = 0;
nodecnt = 0;
root[0] = newnode();
root[0]->lson = root[0];
root[0]->rson = root[0];
root[0]->sum = 0;
rootcnt++;
}
//增加一个主席树的根节点，即向右推一格
void add(node_ptr pre, int l, int r, int pos, int val)
{
root[rootcnt] = newnode();
node_ptr now = root[rootcnt];
rootcnt++;
while (l != r)
{
*now = *pre;
now->sum += val;
int mid = (l + r) / 2;
if (pos <= mid)
{
now->lson = newnode();
pre = pre->lson;
now = now->lson;
r = mid;
}
else
{
now->rson = newnode();
pre = pre->rson;
now = now->rson;
l = mid + 1;
}
}
now->sum += val;
//node_ptr 默认构造为nullptr,所以叶子节点不用设置nullptr
}
void tree_update(node_ptr p, int l, int r, int pos, int val)
{
//这些额外的线段树是没有build函数的。为了节省空间，
//只在更新到这个节点的时候申请新空间。
//所以在update的时候，应该检查它不为空，
//（如果用数组并且没有检查，就不会报错，会导致莫名其妙的错误）
//总之，指针大法好！（开始安利）
p->sum += val;
if (l != r)
{
int mid = (l + r) / 2;
if (pos <= mid)
{
nonull(p->lson);
tree_update(p->lson, l, mid, pos, val);
}
else
{
nonull(p->rson);
tree_update(p->rson, mid + 1, r, pos, val);
}
}
}
//从t时刻开始的记录，把before改成after
//通过+1，-1来实现
void update(int t, int before, int after)
{
for (int i = t; i <= n; i += lowbit(i))
{
nonull(exroot[i]);
tree_update(exroot[i], 1, n, before, -1);
tree_update(exroot[i], 1, n, after, 1);
}
}
//返回值是离散化后的值，查询区间为(pl,pr]
//这里的查询和静态主席树一样，就是单节点变为多节点
//把数组看成一个节点就行了
int query(node_ptr pl, node_ptr pr, int l, int r, int q)
{
if (l == r)
{
return r;
}
int leftsum = pr->lson->sum - pl->lson->sum;
leftsum += lson_sum(use2) - lson_sum(use1);
int mid = (l + r) / 2;
if (q <= leftsum)
{
to_lson(use1);
to_lson(use2);
return query(pl->lson, pr->lson, l, mid, q);
}
else
{
to_rson(use1);
to_rson(use2);
return query(pl->rson, pr->rson, mid + 1, r, q - leftsum);
}
}
//查询之前先把树状数组对应的节点取出
int query(int tl, int tr, int q)
{
use1.clear();
use2.clear();
for (int i = tl - 1; i > 0; i -= lowbit(i))
if (exroot[i])
use1.push_back(exroot[i]);
for (int i = tr; i > 0; i -= lowbit(i))
if (exroot[i])
use2.push_back(exroot[i]);
return query(root[tl - 1], root[tr], 1, n, q);
}
int main(int argc, char** argv)
{
if (argc == 2 && strcmp(argv[1], "-debug") == 0)
{
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int T;
cin >> T;
while (T--)
{
cin >> n >> m;
for (int i = 0; i < n; i++)
{
scanf("%d", &arr[i].val);
arr[i].id = i + 1;
arr_now[i + 1] = arr[i].val;
}
int n1 = n;
for (int i = 0; i < m; i++)
{
char s[100];
scanf("%s", s);
if (s[0] == 'Q')
{
qarr[i].mode = 'Q';
scanf("%d%d%d", &qarr[i].i, &qarr[i].j, &qarr[i].k);
}
else
{
qarr[i].mode = 'C';
scanf("%d%d", &qarr[i].i, &qarr[i].j);
arr[n].val = qarr[i].j;
arr[n].id = n + 1;
n++;
}
}
reset();
//这个离散化写的非常迷
//因为改过至少3次，全部代码重写过1次
//然后不想改了，就这样吧
//有更好的写法请指出（懒得改了）
sort(arr, arr + n, cmp_val);
for (int i = 0; i < n; i++)
arr[i].after = i + 1;
for (int i = 0; i < n; i++)
conv[i + 1] = arr[i].val;
sort(arr, arr + n, cmp_id);
for (int i = 1; i <= n; i++)
arr_now[i] = arr[i - 1].after;
for (int i = 0; i < n1; i++)
add(root[i], 1, n, arr[i].after, 1);
for (int i = 0; i < m; i++)
{
if (qarr[i].mode == 'Q')
{
printf("%d\n", conv[query(qarr[i].i, qarr[i].j, qarr[i].k)]);
}
else
{
int before = arr_now[qarr[i].i];
int after = lower_bound(conv + 1, conv + n + 1, qarr[i].j) - conv;
update(qarr[i].i, before, after);
arr_now[qarr[i].i] = lower_bound(conv + 1, conv + 1 + n, qarr[i].j) - conv;//可能有问题？
}
}
//print_all_extree();
}
return 0;
}
node* node_ptr::operator->()
{
if (index == -1)
return nullptr;//这样的话，引用空指针会报错，方便调试
return &pool[index];
}
node& node_ptr::operator*()
{
if (index == -1)
return *(node*)(nullptr);//这样的话，引用空指针会报错，方便调试
return pool[index];
}
87
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
