結果

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

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,816 KB
testcase_01 AC 2 ms
6,816 KB
testcase_02 AC 2 ms
6,820 KB
testcase_03 AC 301 ms
6,820 KB
testcase_04 AC 236 ms
12,800 KB
testcase_05 AC 235 ms
12,800 KB
testcase_06 AC 239 ms
12,800 KB
testcase_07 AC 2 ms
6,816 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 229 ms
7,680 KB
testcase_13 AC 218 ms
7,552 KB
testcase_14 AC 224 ms
7,680 KB
testcase_15 AC 231 ms
7,552 KB
testcase_16 AC 227 ms
7,680 KB
testcase_17 AC 257 ms
8,064 KB
testcase_18 AC 280 ms
8,704 KB
testcase_19 AC 307 ms
8,960 KB
testcase_20 AC 340 ms
9,344 KB
testcase_21 AC 379 ms
9,728 KB
testcase_22 AC 396 ms
10,240 KB
testcase_23 AC 428 ms
10,624 KB
testcase_24 AC 469 ms
11,136 KB
testcase_25 AC 485 ms
11,520 KB
testcase_26 AC 540 ms
11,904 KB
testcase_27 AC 3 ms
6,816 KB
testcase_28 AC 3 ms
6,820 KB
testcase_29 AC 3 ms
6,816 KB
testcase_30 AC 190 ms
7,680 KB
testcase_31 AC 188 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,820 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 xor128(){ 
        static unsigned long x=123456789,y=362436069,z=521288629,w=88675123; 
        unsigned long t; 
        t=(x^(x<<11));x=y;y=z;z=w; return( w=(w^(w>>19))^(t^(t>>8)) ); 
    }
    vector<node*> delete_nodes;
    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);
        delete_nodes.push_back(sr.second);
        if (delete_nodes.size()>1000)delete_nodes.clear();
        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