题目链接：https://www.luogu.org/problem/P2617
题目大意：

第一行有两个正整数n(1≤n≤100000)，m(1≤m≤100000)。分别表示序列的长度和指令的个数。

第二行有n个数，表示a[1],a[2]……a[n]，这些数都小于10^9。接下来的m行描述每条指令，每行的格式是下面两种格式中的一种。 Q
i j k 或者 C i t

Q i j k （i,j,k是数字，1≤i≤j≤n, 1≤k≤j-i+1）表示询问指令，询问a[i]，a[i+1]……a[j]中第k小的数。

C i t (1≤i≤n，0≤t≤10^9)表示把a[i]改变成为t。

输出格式
对于每一次询问，你都需要输出他的答案，每一个输出占单独的一行。

输入
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

输出
3
6

对于所有数据，m,n≤100000

转：https://www.jianshu.com/p/050da7a9abfd
转：https://www.cnblogs.com/ljq-despair/p/8639394.html
我们知道,如果修改了arr[i],那么对于静态主席树来说,它影响的是tree[i],tree[i+1]…tree[n];有一个办法是对这些树全部进行更新,但是这样的复杂度会很高;同时,我们注意到,有一个很适合单点更改和求序列和的数据结构,那就是树状数组,;所以我们可以这样做:对于原序列,我们建立静态主席树,对于要修改的节点,我们用树状数组来维护,每个树状数组的节点都是线段树。
　　比如原序列:1 5 6 2 3 9 8,现在我要把第四位2改为7,理论上说,我们修改一个数字,首先要消除原数字对序列的影响,再添加新的数,然后再产生新的影响;现在2对序列的影响是:第四位以及到最后一位的对应的所有前缀树,每个前缀树中包含2的区间对应的节点与原来比都加上了1,要消除这些影响,我们要对4-n颗前缀树的所有包含2的区间的节点都要减去1,然后再把第四位改为7,再对第4-n颗前缀树的所有包含7的区间的节点都要加上1,到此,更新就结束了。
　　只不过,我们修改的时候是利用树状数组,所以修改的树不再是4-n颗树,而是x1=4,x2=4+lowbit(x1),x3=x2+lowbit(x2)…n颗树,对修改的次数为原来的log2n,同时空间复杂度也减少了
　　其实动态主席树的空间消耗还是很大的，比如上次修改了序列的第i位或者修改某位沿着lowbit上升时经过了第i位，那么修改的时候是会对i重新建树的,用新的树代替了原来的树,大概原理就是这样。修改的次数越多,新建的树越多,消耗空间越多。
　　当然了,用数组开的静态区间消耗的空间是固定的,但是它的剩余空间会随着修改的增加越来越少。

思路：原数组用主席树维护， 修改用树套树维护（树状数组套主席树维护）

#include <bits/stdc++.h>
#define LL long long
using namespace std;
#define mid (l+r)/2
const int maxn=2e5+10;

int root[maxn]={0}, L[maxn*100]={0}, R[maxn*100]={0}, sum[maxn*100]={0};
int n, m, cut=0, Len=0;

int s[maxn], use[maxn];

int BT(int l, int r)
{
    int rt=++cut;
    sum[rt]=0;
    if(l<r)
    {
        L[rt]=BT(l, mid);
        R[rt]=BT(mid+1, r);
    }

    return rt;
}

int gx(int i, int l, int r, int x, int v)
{
    int rt=++cut;
    L[rt]=L[i], R[rt]=R[i], sum[rt]=sum[i]+v;//更新
    if(l<r)
    {
        if(x<=mid)
        {
            L[rt]=gx(L[i], l, mid, x, v);
        }
        else
        {
            R[rt]=gx(R[i], mid+1, r, x, v);
        }
    }
    return rt;
}

int lowbit(int x)
{
	return x&(-x);
}
void add(int x,int pos,int val)
{
	while(x <= n)
	{
		s[x] = gx(s[x],1, Len, pos,val);
		x += lowbit(x);
	}
}
int getSum(int x)
{
	int ret = 0;
	while(x > 0)
	{
		ret += sum[L[use[x]]];
		x -= lowbit(x);
	}
	return ret;
}

int a[maxn], b[maxn];
void Lsh()
{
    sort(b+1, b+Len+1);
    Len=unique(b+1, b+Len+1)-b-1;
    for(int i=1; i<=n; i++)
    {
        a[i]=lower_bound(b+1, b+1+Len, a[i])-b;
    }
}

int getId(int x)
{
    return lower_bound(b+1, b+1+Len, x)-b;
}

struct node{
    int op, L, R, k;
}q[maxn];

int query(int left,int right,int k)
{
    int left_root = root[left-1];
    int right_root = root[right];
    int l = 1, r = Len;
    for(int i = left-1;i;i -= lowbit(i)) use[i] = s[i];
    for(int i = right;i ;i -= lowbit(i)) use[i] = s[i];
    while(l < r)
    {
        int tmp = getSum(right) - getSum(left-1) + sum[L[right_root]] - sum[L[left_root]];
        if(tmp >= k)
        {
            r = mid;
            for(int i = left-1; i ;i -= lowbit(i))
                use[i] = L[use[i]];
            for(int i = right; i; i -= lowbit(i))
                use[i] = L[use[i]];
            left_root = L[left_root];
            right_root = L[right_root];
        }
        else
        {
            l = mid+1;
            k -= tmp;
            for(int i = left-1; i;i -= lowbit(i))
                use[i] = R[use[i]];
            for(int i = right;i ;i -= lowbit(i))
                use[i] = R[use[i]];
            left_root = R[left_root];
            right_root = R[right_root];
        }
    }
    return l;
}

int main()
{
    int t=1;
    while(t--)
    {
        scanf("%d%d", &n, &m);
        cut=0, Len=0;
        for(int i=1; i<=n; i++)
        {
            scanf("%d", &a[i]);
            b[++Len]=a[i];
        }

        char op[5];
        for(int i=1; i<=m; i++)
        {
            scanf("%s", op);
            if(op[0]=='Q')
            {
                q[i].op=0;
                scanf("%d%d%d", &q[i].L, &q[i].R, &q[i].k);
            }
            else
            {
                q[i].op=1;
                scanf("%d%d", &q[i].L, &q[i].R);
                b[++Len]=q[i].R;
            }
        }
        Lsh();

        root[0] = BT(1, Len);
        for(int i=1; i<=n; i++)
        {
            root[i]=gx(root[i-1], 1, Len, a[i], 1);
        }
        for(int i = 0;i <= n;i++)
        {
            s[i] = root[0];//为每个树状数组根节点初始化
        }
        for(int i=1; i<=m; i++)
        {
            if(q[i].op==0)
            {
                printf("%d\n",b[query(q[i].L,q[i].R,q[i].k)]);
            }
            else
            {
                add(q[i].L, a[q[i].L], -1);//先消除影响
                add(q[i].L, getId(q[i].R), 1);//再新建影响
                a[q[i].L] = getId(q[i].R);
            }
        }
    }

    return 0;
}