結果

問題 No.649 ここでちょっとQK！
ユーザー akakimidoriakakimidori
提出日時 2018-12-22 18:42:05
言語 C
(gcc 12.3.0)
結果
AC  
実行時間 184 ms / 3,000 ms
コード長 6,616 bytes
コンパイル時間 1,621 ms
コンパイル使用メモリ 32,008 KB
実行使用メモリ 11,292 KB
最終ジャッジ日時 2023-10-26 02:08:51
合計ジャッジ時間 8,181 ms
ジャッジサーバーID
（参考情報） 		judge11 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
4,348 KB
testcase_01 AC 1 ms
4,348 KB
testcase_02 AC 1 ms
4,348 KB
testcase_03 AC 24 ms
4,348 KB
testcase_04 AC 133 ms
11,292 KB
testcase_05 AC 132 ms
11,292 KB
testcase_06 AC 126 ms
11,292 KB
testcase_07 AC 1 ms
4,348 KB
testcase_08 AC 1 ms
4,348 KB
testcase_09 AC 1 ms
4,348 KB
testcase_10 AC 1 ms
4,348 KB
testcase_11 AC 1 ms
4,348 KB
testcase_12 AC 72 ms
5,676 KB
testcase_13 AC 70 ms
5,676 KB
testcase_14 AC 69 ms
5,648 KB
testcase_15 AC 70 ms
5,716 KB
testcase_16 AC 73 ms
6,084 KB
testcase_17 AC 83 ms
6,340 KB
testcase_18 AC 95 ms
6,724 KB
testcase_19 AC 102 ms
7,060 KB
testcase_20 AC 108 ms
7,460 KB
testcase_21 AC 115 ms
7,812 KB
testcase_22 AC 123 ms
8,228 KB
testcase_23 AC 142 ms
8,568 KB
testcase_24 AC 143 ms
8,964 KB
testcase_25 AC 161 ms
9,340 KB
testcase_26 AC 184 ms
9,692 KB
testcase_27 AC 2 ms
4,348 KB
testcase_28 AC 2 ms
4,348 KB
testcase_29 AC 2 ms
4,348 KB
testcase_30 AC 63 ms
5,668 KB
testcase_31 AC 62 ms
5,948 KB
testcase_32 AC 1 ms
4,348 KB
testcase_33 AC 1 ms
4,348 KB
testcase_34 AC 1 ms
4,348 KB
testcase_35 AC 1 ms
4,348 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct WBTNode {
  int lsize;
  int rsize;
  struct WBTNode *parent;
  struct WBTNode *left;
  struct WBTNode *right;
  unsigned long long int val[];
} WBTNode;

WBTNode* newNode (const void *val, const size_t size) {
  WBTNode *r = (WBTNode *) malloc (sizeof (WBTNode) + size);
  r -> lsize = 0;
  r -> rsize = 0;
  r -> parent = NULL;
  r -> left = NULL;
  r -> right = NULL;
  memcpy (r -> val, val, size);
  return r;
}

int getTreeSize (const WBTNode *t) {
  return t == NULL ? 0 : t -> lsize + t -> rsize + 1;
}

int getBias (const WBTNode *t, const int b) {
  if (t == NULL) return 0;
  int l = t -> lsize;
  int r = t -> rsize;
  if (b * l >= r && l <= b * r) {
    return 0;
  }
  return b * l < r ? -2 : 2;
}

void update (WBTNode *t) {
  t -> lsize = getTreeSize (t -> left);
  t -> rsize = getTreeSize (t -> right);
}

int isLeftChild (const WBTNode *t) {
  return t != NULL && t -> parent != NULL && t -> parent -> left == t;
}

void concatL (WBTNode *parent, WBTNode *child) {
  if (child != NULL) {
    child -> parent = parent;
  }
  if (parent != NULL) {
    parent -> left = child;
  }
}

void concatR (WBTNode *parent, WBTNode *child) {
  if (child != NULL) {
    child -> parent = parent;
  }
  if (parent != NULL) {
    parent -> right = child;
  }
}

void replaceChild (WBTNode *parent, const WBTNode *prevChild, WBTNode *nextChild) {
  if (isLeftChild (prevChild)) {
    concatL (parent, nextChild);
  } else {
    concatR (parent, nextChild);
  }
}

WBTNode* rightRotate (WBTNode *v) {
  WBTNode *u = v -> left;
  concatL (v, u -> right);
  replaceChild (v -> parent, v, u);
  concatR (u, v);
  update (v);
  update (u);
  return u;
}

WBTNode* leftRotate (WBTNode *u) {
  WBTNode *v = u -> right;
  concatR (u, v -> left);
  replaceChild (u -> parent, u, v);
  concatL (v, u);
  update (u);
  update (v);
  return v;
}

WBTNode* balance (WBTNode *t) {
  const int b = getBias (t, 3);
  if (-1 <= b && b <= 1) {
    return t;
  }
  if (b < -1) {
    if (getBias (t -> right, 2) >= 1) {
      rightRotate (t -> right);
    }
    return leftRotate (t);
  } else {
    if(getBias (t -> left, 2) <= -1){
      leftRotate (t -> left);
    }
    return rightRotate (t);
  }
}

WBTNode* saveTree (WBTNode *t) {
  WBTNode *now = t;
  WBTNode *before = NULL;
  while (now != NULL) {
    update (now);
    before = balance (now);
    now = before -> parent;
  }
  return before;
}

typedef struct MultiSet_WBT {
  WBTNode *root;
  size_t valSize;
  int (*cmp) (const void *, const void *);
} multiset;

multiset* newMultiSet (const size_t size, int (*cmp) (const void *, const void *)) {
  multiset *mset = (multiset *)malloc(sizeof (multiset));
  mset -> root = NULL;
  mset -> valSize = size;
  mset -> cmp = cmp;
  return mset;
}

int getSize (const multiset *set) {
  return getTreeSize (set -> root);
}

WBTNode* getMaxRef (const multiset *set) {
  if (set -> root == NULL) {
    return NULL;
  }
  WBTNode *now = set -> root;
  while (now -> right != NULL) {
    now = now -> right;
  }
  return now;
}

WBTNode* getMinRef (const multiset *set) {
  if (set -> root == NULL) {
    return NULL;
  }
  WBTNode *now = set -> root;
  while (now -> left != NULL) {
    now = now -> left;
  }
  return now;
}

WBTNode* getAtRef (const multiset *set, int k) {
  if (k < 1 || getSize (set) < k) {
    return NULL;
  }
  WBTNode *now = set -> root;
  while (1) {
    int lsize = now -> lsize;
    if (k == lsize + 1){
      return now;
    }
    if (k <= lsize) {
      now = now -> left;
    } else {
      k -= lsize + 1;
      now = now -> right;
    }
  }
}

WBTNode* nextRef(WBTNode *t){
  if (t -> right != NULL) {
    WBTNode *s = t -> right;
    while (s -> left != NULL) {
      s = s-> left;
    }
    return s;
  }
  WBTNode *now = t -> parent;
  WBTNode *before = t;
  while (now != NULL && now -> left != before) {
    before = now;
    now = now -> parent;
  }
  return now;
}

WBTNode* prevRef(WBTNode *t){
  if (t -> left != NULL) {
    WBTNode *s = t -> left;
    while (s -> right != NULL) {
      s = s-> right;
    }
    return s;
  }
  WBTNode *now = t -> parent;
  WBTNode *before = t;
  while (now != NULL && now -> right != before) {
    before = now;
    now = now -> parent;
  }
  return now;
}

WBTNode* insert (multiset *set, const void *val) {
  WBTNode * const in = newNode (val, set -> valSize);
  if (set -> root == NULL) {
    set -> root = in;
    return in;
  }
  int (*cmp) (const void *, const void *) = set -> cmp;
  WBTNode *before = NULL;
  WBTNode *now = set -> root;
  int cmpRes = 0;
  while (now != NULL) {
    before = now;
    cmpRes = cmp (in -> val, now -> val);
    now = cmpRes <= 0 ? now -> left : now -> right;
  }
  if (cmpRes <= 0) {
    concatL (before, in);
  } else {
    concatR (before, in);
  }
  set -> root = saveTree (before);
  return in;
}

void eraseByRef (multiset * const set, WBTNode * const t) {
  if (t == NULL) {
    return;
  }
  if(t -> left == NULL && t -> right == NULL) {
    replaceChild (t -> parent, t, NULL);
    set -> root = saveTree (t -> parent);
    free (t);
  } else if (t -> left == NULL) {
    replaceChild (t -> parent, t, t -> right);
    set -> root = saveTree (t -> right);
    free (t);
  } else if (t -> right == NULL) {
    replaceChild (t -> parent, t, t -> left);
    set -> root = saveTree (t -> left);
    free (t);
  } else {
    WBTNode *max = t -> left;
    while (max -> right != NULL) {
      max = max -> right;
    }
    WBTNode *p = NULL;
    if (max != t -> left) {
      concatR (max -> parent, max -> left);
      t -> left -> parent = NULL;
      p = saveTree (max -> parent);
    } else {
      p = t -> left -> left;
    }
    concatL (max, p);
    concatR (max, t -> right);
    replaceChild (t -> parent, t, max);
    set -> root = saveTree (max);
    free (t);
  }
}

void eraseAt (multiset *set, const int k) {
  if (k < 1 || getSize (set) < k) {
    return;
  }
  eraseByRef (set, getAtRef (set, k));
}

typedef WBTNode Ref;

typedef long long int int64;

int cmp(const void *a,const void *b){
  int64 p=*(int64 *)a;
  int64 q=*(int64 *)b;
  return p==q?0:p-q<0?-1:1;
}

void run(void){
  int q,k;
  scanf("%d%d",&q,&k);
  multiset *set=newMultiSet(sizeof(int64),cmp);
  while(q--){
    int c;
    scanf("%d",&c);
    if(c==1){
      int64 v;
      scanf("%lld",&v);
      insert(set,&v);
    } else if(getSize(set)<k){
      printf("-1\n");
    } else {
      Ref *p=getAtRef(set,k);
      int64 v=*(int64 *)p->val;
      eraseByRef(set, p);
      printf("%lld\n",v);
    }
  }
}

int main(void){
  run();
  return 0;
}
0