結果

問題 No.618 labo-index
ユーザー rickythetarickytheta
提出日時 2017-12-18 00:17:40
言語 C++11
(gcc 11.4.0)
結果
AC  
実行時間 194 ms / 6,000 ms
コード長 4,303 bytes
コンパイル時間 1,795 ms
コンパイル使用メモリ 171,592 KB
実行使用メモリ 8,916 KB
最終ジャッジ日時 2023-08-22 05:05:14
合計ジャッジ時間 5,486 ms
ジャッジサーバーID
(参考情報)
judge13 / judge11
このコードへのチャレンジ(β)

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
4,376 KB
testcase_01 AC 1 ms
4,376 KB
testcase_02 AC 2 ms
4,376 KB
testcase_03 AC 1 ms
4,376 KB
testcase_04 AC 2 ms
4,380 KB
testcase_05 AC 2 ms
4,376 KB
testcase_06 AC 1 ms
4,376 KB
testcase_07 AC 1 ms
4,376 KB
testcase_08 AC 2 ms
4,380 KB
testcase_09 AC 2 ms
4,376 KB
testcase_10 AC 2 ms
4,376 KB
testcase_11 AC 2 ms
4,376 KB
testcase_12 AC 1 ms
4,376 KB
testcase_13 AC 2 ms
4,376 KB
testcase_14 AC 2 ms
4,376 KB
testcase_15 AC 2 ms
4,380 KB
testcase_16 AC 2 ms
4,376 KB
testcase_17 AC 2 ms
4,376 KB
testcase_18 AC 3 ms
4,376 KB
testcase_19 AC 77 ms
5,244 KB
testcase_20 AC 88 ms
5,184 KB
testcase_21 AC 71 ms
5,188 KB
testcase_22 AC 77 ms
5,244 KB
testcase_23 AC 76 ms
5,232 KB
testcase_24 AC 75 ms
5,240 KB
testcase_25 AC 80 ms
5,228 KB
testcase_26 AC 80 ms
5,232 KB
testcase_27 AC 77 ms
5,260 KB
testcase_28 AC 71 ms
5,232 KB
testcase_29 AC 84 ms
5,360 KB
testcase_30 AC 77 ms
5,228 KB
testcase_31 AC 77 ms
5,228 KB
testcase_32 AC 80 ms
5,224 KB
testcase_33 AC 77 ms
5,224 KB
testcase_34 AC 166 ms
8,684 KB
testcase_35 AC 194 ms
8,916 KB
testcase_36 AC 58 ms
5,820 KB
testcase_37 AC 127 ms
6,100 KB
testcase_38 AC 1 ms
4,376 KB
権限があれば一括ダウンロードができます

ソースコード

diff #

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)

#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()

#define CHMIN(a,b) a=min((a),(b))
#define CHMAX(a,b) a=max((a),(b))

// mod
const ll MOD = 1000000007ll;
#define FIX(a) ((a)%MOD+MOD)%MOD

// floating
typedef double Real;
const Real EPS = 1e-11;
#define EQ0(x) (abs(x)<EPS)
#define EQ(a,b) (abs(a-b)<EPS)
typedef complex<Real> P;

struct Treap{
private:
  static const ll rd_msk = (1ll<<32)-1;
  static ll rd(){
    static ll rd_x = 123456789;
    static ll rd_y = 362436069;
    static ll rd_z = 521288629;
    static ll rd_w = 88675123;
    ll t = (rd_x^(rd_x<<11))&rd_msk;
    rd_x = rd_y;
    rd_y = rd_z;
    rd_z = rd_w;
    return rd_w = (rd_w^(rd_w>>19)) ^ (t^(t>>8));
  }
  struct node{
    ll val,pri,cnt;;
    node *lch, *rch;
    node(ll val):val(val),cnt(1){
      pri = rd();
      lch = rch = NULL;
    }
  };
public:
  node *root;
  Treap():root(NULL){}
private:
  ll count(node *t){return t==NULL?0:t->cnt;}
  node* update(node *t){t->cnt=count(t->lch)+count(t->rch)+1;return t;}
  node* merge(node *l, node *r){
    if(!l || !r)return !l?r:l;
    if(l->pri > r->pri){
      l->rch = merge(l->rch,r);
      return update(l);
    }else{
      r->lch = merge(l,r->lch);
      return update(r);
    }
  }
  pair<node*,node*> split(node *t, ll k){
    if(!t) return make_pair<node*,node*>(NULL,NULL);
    if(k <= count(t->lch)){
      pair<node*,node*> s = split(t->lch,k);
      t->lch = s.second;
      return make_pair(s.first,update(t));
    }else{
      pair<node*,node*> s = split(t->rch,k-count(t->lch)-1);
      t->rch = s.first;
      return make_pair(update(t),s.second);
    }
  }
  ll __find(node *p,ll v){
    if(!p)return 0;
    if(p->val==v)return count(p->lch);
    return (p->val > v)?__find(p->lch,v):(count(p->lch)+1+__find(p->rch,v));
  }
  ll __less(node *p,ll v){
    if(!p)return 0;
    return (p->val >= v)?__less(p->lch,v):(count(p->lch)+1+__less(p->rch,v));
  }
  ll __less_eq(node *p,ll v){
    if(!p)return 0;
    return (p->val > v)?__less_eq(p->lch,v):(count(p->lch)+1+__less_eq(p->rch,v));
  }
  ll __get_at(node *p,ll k,ll acc){
    if(!p)return -1;
    ll lc=count(p->lch);
    if(acc+lc==k)return p->val;
    if(acc+lc>k)return __get_at(p->lch,k,acc);
    if(acc+lc<k)return __get_at(p->rch,k,acc+lc+1);
  }
public:
  void merge(Treap that){
    root = merge(root, that.root);
  }
  Treap split(ll k){
    Treap that;
    pair<node*,node*> p = split(root,k);
    root = p.first;
    that.root = p.second;
    return that;
  }
  void insert_at(ll v,ll k){
    pair<node*,node*> p = split(root,k);
    node* nn = new node(v);
    root = merge(p.first, nn);
    root = merge(root, p.second);
  }
  void erase_at(ll k){
    pair<node*,node*> p,q;
    q = split(root,k+1);
    p = split(q.first,k);
    root = merge(p.first, q.second);
  }
  void insert_by(ll v){
    insert_at(v,__less(root,v));
  }
  void erase_by(ll v){
    erase_at(__find(root,v));
  }
  ll count_less(ll v){
    return __less(root,v);
  }
  ll count_less_equal(ll v){
    return __less_eq(root,v);
  }
  ll get_at(ll k){
    return __get_at(root,k,0);
  }
  ll size(){
    return count(root);
  }
};

int main(){
  Treap tr;
  int q;
  scanf("%d",&q);
  ll add = 0ll;
  vl insrted;
  REP(tms,q){
    int t,x;
    scanf("%d%d",&t,&x);
    if(t==1){
      // insert
      tr.insert_by(x-add);
      insrted.push_back(x-add);
      // insrted[tms] = x-add;
    }else if(t==2){
      // delete
      ll v = insrted[x-1];
      tr.erase_by(v);
    }else if(t==3){
      // + x
      add += x;
    }
    // query
    ll low = 0ll;
    ll high = 100001ll;
    while(low + 1 < high){
      ll x = (low + high) / 2;
      ll cnt = tr.size() - tr.count_less(x-add);
      if(cnt >= x){
        low = x;
      }else{
        high = x;
      }
    }
    printf("%lld\n", low);
  }
  return 0;
}
0