luogu 3380

树状数组套权值线段树

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>

#define E exit(0)

using namespace std;

#define LL long long

#define gc getchar()
inline int read() {int x = ; char c = gc; while(c < '' || c > '') c = gc;
while(c >= '' && c <= '') x = x *  + c - '', c = gc; return x;}
inline LL read_LL() {LL x = ; char c = gc; while(c < '' || c > '') c = gc;
while(c >= '' && c <= '') x = x *  + c - '', c = gc; return x;}
#undef gc

const int N = 5e4 + ;
const int Out = ;

struct Node {int opt, l, r, k;} Ask[N];
int n, m;
int Num[N << ], totNum, A[N], Length;

int Root[N];
int W[N * ], Lson[N * ], Rson[N * ];

int Add_root[N], Cut_root[N];
int Hjt_;

namespace Seg {

    void Insert(int &rt, int l, int r, int x) {
        if(!rt) rt = ++ Hjt_;
        W[rt] ++;
        if(l == r) return ;
        int mid = (l + r) >> ;
        if(x <= mid) Insert(Lson[rt], l, mid, x);
        else Insert(Rson[rt], mid + , r, x);
    }

    int Getrank(int l, int r, int k, int opt) {
        if(l == r) {
            if(opt == ) return ;
            int s = ;
            for(int i = ; i <= Add_root[]; i ++) s += W[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) s -= W[Cut_root[i]];
            return s;
        }
        int mid = (l + r) >> ;
        if(k <= mid) {
            for(int i = ; i <= Add_root[]; i ++) Add_root[i] = Lson[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) Cut_root[i] = Lson[Cut_root[i]];
            return Getrank(l, mid, k, opt);
        } else {
            int sum = ;
            for(int i = ; i <= Add_root[]; i ++) {
                sum += W[Lson[Add_root[i]]]; Add_root[i] = Rson[Add_root[i]];
            }
            for(int i = ; i <= Cut_root[]; i ++) {
                sum -= W[Lson[Cut_root[i]]]; Cut_root[i] = Rson[Cut_root[i]];
            }
            int ret = sum + Getrank(mid + , r, k, opt);
            return ret;
        }
    }

    int Getnum(int l, int r, int k) {
        if(l == r) return l;
        int mid = (l + r) >> ;
        int sum = ;
        for(int i = ; i <= Add_root[]; i ++) sum += W[Lson[Add_root[i]]];
        for(int i = ; i <= Cut_root[]; i ++) sum -= W[Lson[Cut_root[i]]];
        if(sum >= k) {
            for(int i = ; i <= Add_root[]; i ++) Add_root[i] = Lson[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) Cut_root[i] = Lson[Cut_root[i]];
            Getnum(l, mid, k);
        } else {
            for(int i = ; i <= Add_root[]; i ++) Add_root[i] = Rson[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) Cut_root[i] = Rson[Cut_root[i]];
            Getnum(mid + , r, k - sum);
        }
    }

    void Poi_G(int l, int r, int x, int val) {
        for(int i = ; i <= Cut_root[]; i ++) W[Cut_root[i]] += val;
        if(l == r) return ;
        int mid = (l + r) >> ;
        if(x <= mid) {
            for(int i = ; i <= Cut_root[]; i ++) {
                if(Lson[Cut_root[i]] == ) Lson[Cut_root[i]] = ++ Hjt_;
                Cut_root[i] = Lson[Cut_root[i]];
            }
            Poi_G(l, mid, x, val);
        } else {
            for(int i = ; i <= Cut_root[]; i ++) {
                if(Rson[Cut_root[i]] == ) Rson[Cut_root[i]] = ++ Hjt_;
                Cut_root[i] = Rson[Cut_root[i]];
            }
            Poi_G(mid + , r, x, val);
        }
    }

    int Asknum(int l, int r, int k) {
        if(l == r) {
            int sum = ;
            for(int i = ; i <= Add_root[]; i ++) sum += W[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) sum -= W[Cut_root[i]];
            k -= sum;
            if(k > ) return -;
            return l;
        }
        int sum = ;
        for(int i = ; i <= Add_root[]; i ++) sum += W[Lson[Add_root[i]]];
        for(int i = ; i <= Cut_root[]; i ++) sum -= W[Lson[Cut_root[i]]];
        int mid = (l + r) >> ;
        if(k <= sum) {
            for(int i = ; i <= Add_root[]; i ++) Add_root[i] = Lson[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) Cut_root[i] = Lson[Cut_root[i]];
            Asknum(l, mid, k);
        } else {
            for(int i = ; i <= Add_root[]; i ++) Add_root[i] = Rson[Add_root[i]];
            for(int i = ; i <= Cut_root[]; i ++) Cut_root[i] = Rson[Cut_root[i]];
            Asknum(mid + , r, k - sum);
        }
    }
}

namespace Bit {

    inline int Lowbit(int x) {return (x & (-x));}

    void Add(int rt, int x, int val) {
        for(int i = rt; i <= n; i += Lowbit(i)) {
            Seg:: Insert(Root[i], , Length, x);
        }
    }

    int Getrank(int l, int r, int k) {
        Add_root[] = Cut_root[] = ;
        for(int i = r; i >= ; i -= Lowbit(i)) Add_root[++ Add_root[]] = Root[i];
        for(int i = l - ; i >= ; i -= Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        k = lower_bound(Num + , Num + Length + , k) - Num;
        return Seg:: Getrank(, Length, k, );
     }

    int Getnum(int l, int r, int k) {
        Add_root[] = Cut_root[] = ;
        for(int i = r; i >= ; i -= Lowbit(i)) {
            Add_root[++ Add_root[]] = Root[i];
        }
        for(int i = l - ; i >= ; i -= Lowbit(i)) {
            Cut_root[++ Cut_root[]] = Root[i];
        }
        return Seg:: Getnum(, Length, k);
    }

    void Poi_G(int x, int k) {
        Cut_root[] = ;
        for(int i = x; i <= n; i += Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        int a = lower_bound(Num + , Num + Length + , A[x]) - Num;
        A[x] = k;
        Seg:: Poi_G(, Length, a, -);
        Cut_root[] = ;
        for(int i = x; i <= n; i += Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        a = lower_bound(Num + , Num + Length + , k) - Num;
        Seg:: Poi_G(, Length, a, );
    }

    int Asknum(int l, int r, int k, int opt) {
        k = lower_bound(Num + , Num + Length + , k) - Num;
        int kk = k;
        Add_root[] = Cut_root[] = ;
        for(int i = r; i >= ; i -= Lowbit(i)) Add_root[++ Add_root[]] = Root[i];
        for(int i = l - ; i >= ; i -= Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        k = Seg:: Getrank(, Length, k, );
        Add_root[] = Cut_root[] = ;
        for(int i = r; i >= ; i -= Lowbit(i)) Add_root[++ Add_root[]] = Root[i];
        for(int i = l - ; i >= ; i -= Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        int k2 = Seg:: Getrank(, Length, kk, );
        Add_root[] = Cut_root[] = ;
        for(int i = r; i >= ; i -= Lowbit(i)) Add_root[++ Add_root[]] = Root[i];
        for(int i = l - ; i >= ; i -= Lowbit(i)) Cut_root[++ Cut_root[]] = Root[i];
        if(opt == ) {
            if(k == ) return -;
            return Seg:: Asknum(, Length, k - );
        }
        else return Seg:: Asknum(, Length, k2 + );
    }
}

int main() {
    n = read(), m = read();
    for(int i = ; i <= n; i ++) Num[i] = read(), A[i] = Num[i];
    totNum = n;
    for(int i = ; i <= m; i ++) {
        Ask[i].opt = read();
        if(Ask[i].opt != ) {Ask[i].l = read(), Ask[i].r = read(), Ask[i].k = read();}
        else Ask[i].l = read(), Ask[i].k = read(), Num[++ totNum] = Ask[i].k;
        if(Ask[i].opt ==  || Ask[i].opt == ) {
            Num[++ totNum] = Ask[i].k;
        }
    }
    sort(Num + , Num + totNum + );
    Length = unique(Num + , Num + totNum + ) - Num - ;
    for(int i = ; i <= n; i ++) {
        int a = lower_bound(Num + , Num + Length + , A[i]) - Num;
        Bit:: Add(i, a, );
    }

    #define opt Ask[i].opt
    #define l Ask[i].l
    #define r Ask[i].r
    #define k Ask[i].k

    for(int i = ; i <= m; i ++) {
        if(opt == ) {
            cout << Bit:: Getrank(l, r, k) << "\n";
        } else if(opt == ) {
            int ans = Bit:: Getnum(l, r, k);
            cout << Num[ans] << "\n";
        } else if(opt == ) {
            Bit:: Poi_G(l, k);
        } else if(opt == ) {
            int ans = Bit:: Asknum(l, r, k, );
            if(ans == -) cout << "-2147483647" << "\n";
            else cout << Num[ans] << "\n";
        } else {
            int ans = Bit:: Asknum(l, r, k, );
            if(ans == -) cout << "" << "\n";
            else cout << Num[ans] << "\n";
        }
    }
    return ;
}