結果

問題 No.649 ここでちょっとQK！
ユーザー るこーそーるこーそー
提出日時 2024-11-15 01:11:47
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
AC  
実行時間 502 ms / 3,000 ms
コード長 3,385 bytes
コンパイル時間 3,797 ms
コンパイル使用メモリ 259,904 KB
実行使用メモリ 12,800 KB
最終ジャッジ日時 2024-11-15 01:12:35
合計ジャッジ時間 12,061 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge2
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,820 KB
testcase_01 AC 2 ms
6,816 KB
testcase_02 AC 1 ms
6,820 KB
testcase_03 AC 321 ms
6,820 KB
testcase_04 AC 230 ms
12,800 KB
testcase_05 AC 230 ms
12,800 KB
testcase_06 AC 265 ms
12,672 KB
testcase_07 AC 2 ms
6,820 KB
testcase_08 AC 2 ms
6,820 KB
testcase_09 AC 2 ms
6,820 KB
testcase_10 AC 2 ms
6,816 KB
testcase_11 AC 2 ms
6,816 KB
testcase_12 AC 219 ms
7,552 KB
testcase_13 AC 210 ms
7,680 KB
testcase_14 AC 208 ms
7,680 KB
testcase_15 AC 219 ms
7,680 KB
testcase_16 AC 238 ms
7,680 KB
testcase_17 AC 244 ms
8,064 KB
testcase_18 AC 265 ms
8,448 KB
testcase_19 AC 290 ms
8,960 KB
testcase_20 AC 345 ms
9,344 KB
testcase_21 AC 343 ms
9,856 KB
testcase_22 AC 369 ms
10,240 KB
testcase_23 AC 398 ms
10,496 KB
testcase_24 AC 446 ms
11,008 KB
testcase_25 AC 453 ms
11,520 KB
testcase_26 AC 502 ms
11,904 KB
testcase_27 AC 3 ms
6,820 KB
testcase_28 AC 3 ms
6,820 KB
testcase_29 AC 3 ms
6,816 KB
testcase_30 AC 176 ms
7,680 KB
testcase_31 AC 174 ms
7,808 KB
testcase_32 AC 2 ms
6,816 KB
testcase_33 AC 2 ms
6,816 KB
testcase_34 AC 2 ms
6,816 KB
testcase_35 AC 2 ms
6,820 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;

template<typename S>
class RBST{
public:
    struct  node{
        S v, sum;
        node *l, *r;
        int cnt;
        node(S v): v(v), sum(v), cnt(1){
            l = r =nullptr;
        }
    };
    unsigned long long x=123456789, y=362436069, z=521288629, w=88675123;
    unsigned long long xor128(){
        unsigned long long t=(x^(x<<11));
        x=y;y=z;z=w;
        return w=(w^(w>>19))^(t^(t>>8));
    }
    S op(S x, S y){return x^y;};
    node *root=nullptr;
    int size(node *t){return !t ? 0 : t->cnt;}
    S sum(node *t){return !t ? 0 : t->sum;}
    node *update(node *t){
        node *l=t->l, *r=t->r;
        t->cnt=1+size(l)+size(r);
        t->sum=op(op(sum(l),t->v),sum(r));
        return t;
    }
    node *merge(node *l, node *r){
        if (!l || !r)return !l ? r : l;
        if (xor128()%(size(l)+size(r))<size(l)){
            l->r=merge(l->r,r);
            return update(l);
        }else{
            r->l=merge(l,r->l);
            return update(r);
        }
    }
    pair<node*, node*> split(node *t, int k){
        if (!t)return {nullptr, nullptr};
        if (k<=size(t->l)){
            pair<node*, node*> s=split(t->l, k);
            t->l=s.second;
            return make_pair(s.first, update(t));
        }else{
            pair<node*, node*> s=split(t->r, k-size(t->l)-1);
            t->r=s.first;
            return make_pair(update(t), s.second);
        }
    }
    S lower_bound(node *t, S k){
        if (!t)return 0;
        if (t->v<k)return size(t->l)+1+lower_bound(t->r, k);
        else return lower_bound(t->l, k);
    }
    S upper_bound(node *t, S k){
        if (!t)return 0;
        if (t->v<=k)return size(t->l)+1+upper_bound(t->r, k);
        else return upper_bound(t->l, k);
    }
    S get(node *t, int k){
        int s=size(t->l);
        if (s>k)return get(t->l, k);
        else if (s<k)return get(t->r, k-size(t->l)-1);
        else return t->v;
    }
    node *insert(node *t, S v){
        int k=lower_bound(t, v);
        auto s=split(t, k);
        node *n=new node(v);
        return merge(merge(s.first, n), s.second);
    }
    pair<node*, node*> erase(node *t, int k){
        auto sl=split(t, k+1);
        auto sr=split(sl.first, k);
        return make_pair(merge(sr.first, sl.second), sr.second);
    }
    tuple<node*, node*, node*> prod(node *t, int l, int r){
        auto sr=split(t, r);
        auto sl=split(sr.first, l);
        return make_tuple(sl.first, sl.second, sr.second);
    }
public:
    int size(){return size(root);}
    void insert(S v){root=insert(root, v);}
    void erase(int k){root=erase(root, k).first;}
    S get(int k){return get(root, k);}
    S lower_bound(S k){return lower_bound(root, k);}
    S upper_bound(S k){return upper_bound(root, k);}
    S prod(int l, int r){
        auto [left,mid,right]=prod(root, l, r);
        S res=sum(mid);
        root=merge(merge(left,mid),right);
        return res;
    }
};

int main() {
    RBST<long long> st;
    int q,k;
    cin >> q >> k;

    while (q--){
        long long t,x;
        cin >> t;
        if (t==1){
            cin >> x;
            st.insert(x);
        }else {
            if (k<=st.size()){
                cout << st.get(k-1) << endl;
                st.erase(k-1);
            }else{
                cout << -1 << endl;
            }
        }
    }
}
0