果然在zju上交是要超内存的。。。据说,可以把树拆开,这样就不会爆掉了。先对原数组建一颗主席树,然后修改的时候再新建一颗主席树,这样的话据说可过。。。太伤感了。
带修改的主席树更加冷艳了,思想还是和原来差不多,不带修改的时候保存的是前缀和,这时只查询的话时间只需要logn,显然是可以接受的。但是对于带修改的话,如果还是之前那种建树的话,我们会发现,修改的话时间复杂度就是nlogn了,查询还是logn,因为我们需要修改所有包含这个节点的后缀(或前缀),怎么才能均衡一下,降低修改时间复杂度呢?
对于一个数组,我们要是求这个数组的前缀和的话,如果事先先求出前缀和的话,那么如果修改的话,时间复杂度就是n,查询是1,然后对于这个问题,我们显然可以用树状数组去优化,这样就可以做到查询修改都是logn了。其实带修改的主席树和裸的数组这个情况是一样的,我们也可以通过树状数组去优化"前缀和"问题,这样就很愉快了。查询修改都是nlognlogn了。
还是比着cxlove大神的写的,很清楚,但是只能过掉bzoj的。。。如果想若zoj的话,还是得建两棵树。有兴趣的话大家可以试一下。。。
cxlove大神这道题的blog,http://blog.csdn.net/acm_cxlove/article/details/8565309
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
#include<stack>
#include<set>
#include<map>
#define INF 0x3f3f3f3f3f3f3f3fll
#define CLR(a, b) memset(a, b, sizeof(a))
#define lowbit(x) (x&(-x))
using namespace std;
#ifdef __int64
typedef __int64 LL;
#else
typedef long long LL;
#endif
const int maxn = 61005;
const int maxm = 2560005;
int n, q, m, tot;
int a[maxn], h[maxn];
int T[maxm], lson[maxm], rson[maxm], c[maxm];
struct Qt
{
int kind;
int l, r, k;
Qt(){}
Qt(int kind, int l, int r, int k)
:kind(kind), l(l), r(r), k(k){}
}Q[maxn];
void init_hash(int n)
{
sort(h + 1, h + 1 + n);
m = unique(h + 1, h + n + 1) - h - 1;
}
int hash(int x)
{
return lower_bound(h + 1, h + m + 1, x) - h;
}
int build(int l, int r)
{
int root = tot ++;
c[root] = 0;
if(l != r)
{
int mid = (l + r) >> 1;
lson[root] = build(l, mid);
rson[root] = build(mid + 1, r);
}
return root;
}
int update(int root, int pos, int val)
{
int newroot = tot ++, tmp = newroot;
c[newroot] = c[root] + val;
int l = 1, r = m;
while(l < r)
{
int mid = (l + r) >> 1;
if(pos <= mid)
{
lson[newroot] = tot ++; rson[newroot] = rson[root];
newroot = lson[newroot]; root = lson[root];
r = mid;
}
else
{
rson[newroot] = tot ++; lson[newroot] = lson[root];
newroot = rson[newroot]; root = rson[root];
l = mid + 1;
}
c[newroot] = c[root] + val;
}
return tmp;
}
int use[maxn];
void add(int x, int pos, int val)
{
for(int i = x; i <= n; i += lowbit(i))
T[i] = update(T[i], pos, val);
}
int sum(int x)
{
int ret = 0;
for(int i = x; i; i -= lowbit(i))
ret += c[lson[use[i]]];
return ret;
}
int query(int left_root, int right_root, int k)
{
int l = 1, r = m;
for(int i = left_root - 1; i; i -= lowbit(i)) use[i] = T[i];
for(int i = right_root; i; i -= lowbit(i)) use[i] = T[i];
while(l < r)
{
int mid = (l + r) >> 1;
int tmp = sum(right_root) - sum(left_root - 1);
if(tmp >= k)
{
r = mid;
for(int i = left_root - 1; i; i -= lowbit(i))
use[i] = lson[use[i]];
for(int i = right_root; i; i -= lowbit(i))
use[i] = lson[use[i]];
}
else
{
l = mid + 1;
k -= tmp;
for(int i = left_root - 1; i; i -= lowbit(i))
use[i] = rson[use[i]];
for(int i = right_root; i; i -= lowbit(i))
use[i] = rson[use[i]];
}
}
return l;
}
void init_tree()
{
T[0] = build(1, m);
for(int i = 1; i <= n; i ++)
T[i] = T[0];
for(int i = 1; i <= n; i ++)
add(i, hash(a[i]), 1);
}
int main()
{
// int cas;
// scanf("%d", &cas);
// while(cas --)
while(scanf("%d%d", &n, &q) != EOF)
{
tot = 0; m = 1;
// scanf("%d%d", &n, &q);
for(int i = 1; i <= n; i ++)
{
scanf("%d", &a[i]);
h[m ++] = a[i];
}
for(int i = 0; i < q; i ++)
{
char op[3]; int l, r, k;
scanf("%s", op);
if(op[0] == 'Q')
{
scanf("%d%d%d", &l, &r, &k);
Q[i] = Qt(0, l, r, k);
}
else
{
scanf("%d%d", &l, &k);
Q[i] = Qt(1, l, 0, k);
h[m ++] = k;
}
}
init_hash(m);
init_tree();
for(int i = 0; i < q; i ++)
{
if(Q[i].kind == 0)
{
printf("%d\n", h[query(Q[i].l, Q[i].r, Q[i].k)]);
}
else
{
add(Q[i].l, hash(a[Q[i].l]), -1);
add(Q[i].l, hash(Q[i].k), 1);
a[Q[i].l] = Q[i].k;
}
}
}
}