結果

問題 No.649 ここでちょっとQK！
ユーザー akakimidoriakakimidori
提出日時 2018-12-22 18:42:05
言語 C
(gcc 12.3.0)
結果
AC  
実行時間 134 ms / 3,000 ms
コード長 6,616 bytes
コンパイル時間 380 ms
コンパイル使用メモリ 32,512 KB
実行使用メモリ 11,264 KB
最終ジャッジ日時 2024-09-25 10:13:17
合計ジャッジ時間 5,141 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge5
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 1 ms
6,812 KB
testcase_01 AC 1 ms
6,944 KB
testcase_02 AC 1 ms
6,940 KB
testcase_03 AC 23 ms
6,944 KB
testcase_04 AC 129 ms
11,136 KB
testcase_05 AC 130 ms
11,136 KB
testcase_06 AC 125 ms
11,264 KB
testcase_07 AC 1 ms
6,944 KB
testcase_08 AC 1 ms
6,940 KB
testcase_09 AC 1 ms
6,940 KB
testcase_10 AC 1 ms
6,940 KB
testcase_11 AC 1 ms
6,940 KB
testcase_12 AC 61 ms
6,940 KB
testcase_13 AC 62 ms
6,944 KB
testcase_14 AC 61 ms
6,940 KB
testcase_15 AC 65 ms
6,940 KB
testcase_16 AC 59 ms
6,944 KB
testcase_17 AC 67 ms
6,944 KB
testcase_18 AC 72 ms
6,940 KB
testcase_19 AC 81 ms
7,040 KB
testcase_20 AC 88 ms
7,424 KB
testcase_21 AC 96 ms
7,680 KB
testcase_22 AC 103 ms
8,192 KB
testcase_23 AC 116 ms
8,320 KB
testcase_24 AC 126 ms
8,832 KB
testcase_25 AC 132 ms
9,216 KB
testcase_26 AC 134 ms
9,600 KB
testcase_27 AC 1 ms
6,948 KB
testcase_28 AC 1 ms
6,940 KB
testcase_29 AC 1 ms
6,940 KB
testcase_30 AC 54 ms
6,940 KB
testcase_31 AC 53 ms
6,944 KB
testcase_32 AC 1 ms
6,940 KB
testcase_33 AC 1 ms
6,940 KB
testcase_34 AC 1 ms
6,944 KB
testcase_35 AC 1 ms
6,944 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