Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Priority Queue

A priority queue is a data structure which maintains a set $S$ of elements, each of with an associated value (key), and supports the following operations:

$insert(S, k)$: insert an element $k$ into the set $S$

$extractMax(S)$: remove and return the element of $S$ with the largest key

Write a program which performs the $insert(S, k)$ and $extractMax(S)$ operations to a priority queue $S$.
The priority queue manages a set of integers, which are also keys for the priority.

Input

Multiple operations to the priority queue $S$ are given. Each operation is given by "insert $k$", "extract" or "end" in a line. Here, $k$ represents an integer element to be inserted to the priority queue.

The input ends with "end" operation.

Output

For each "extract" operation, print the element extracted from the priority queue $S$ in a line.

Constraints

The number of operations $\leq 2,000,000$

$0 \leq k \leq 2,000,000,000$

Sample Input 1

insert 8
insert 2
extract
insert 10
extract
insert 11
extract
extract
end

Sample Output 1

8
10
11
2

Solution in C (judge verdict: Accepted)

#include<stdio.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<math.h>
#include<limits.h>
#include<float.h>
#define ERROR -1
#define MIN -2000000300
#define MAX 20000200
typedef long ll;
typedef struct
{
  ll x,y,z;
} Coordinates;

Coordinates Tree[MAX];//binary heap 
int Index;            //the size of a heap

int getParent(int i){ return i/2; }

int getLeft(int i)  { return 2*i; }

int getRight(int i) { return 2*i+1; }

void setValue(Coordinates *coor, ll x, ll y, ll z)
{
  coor->x = x;
  coor->y = y;
  coor->z = z;
}

void swap(Coordinates *a,Coordinates *b)
{
  Coordinates h = *a;
  *a = *b;
  *b = h;
}

// a > b
bool Compare(const Coordinates a,const Coordinates b)
{
  //?????????????????????????即????
  return a.x > b.x;
}


void maxHeapify(int i)
{
  int Left = getLeft(i);
  int Right = getRight(i);
  int largest;
 
  if(Left <= Index && Compare(Tree[Left],Tree[i]) ) largest = Left;
  else                                              largest = i;

  if(Right <= Index && Compare(Tree[Right],Tree[largest]) ) largest = Right;

  if(largest != i)
    {
      swap(&Tree[i],&Tree[largest]);
      maxHeapify(largest);
    }
}

int heapIncreaseKey(int i,Coordinates key)
{
  if(Compare(Tree[i],key))return ERROR;
  Tree[i] = key;
 
  while(i > 1 && Compare(Tree[i],Tree[getParent(i)]))
    {
      swap(&Tree[i],&Tree[getParent(i)]);
      i = getParent(i);
    }
}

Coordinates heapExtractMax()
{
  assert(Index >= 1);//heap underflow
  Coordinates Max = Tree[1];
  Tree[1] = Tree[Index];
  Index--;
  maxHeapify(1);
  return Max;
}

void add_node(Coordinates value)
{
  Coordinates dummy;
  setValue(&dummy,MIN,MIN,MIN);
  Tree[++Index] = dummy;
  heapIncreaseKey(Index,value);
}


int main()
{
  char op[1000];
  //double x,y,z;
  ll x;

  while(1){
    scanf("%s",op);
    if(strcmp(op,"insert") == 0){
      scanf("%ld",&x);
      Coordinates input;
      setValue(&input,x,MIN,MIN);
      add_node(input);
    }
    else if(strcmp(op,"extract") == 0){
      Coordinates output = heapExtractMax();
      printf("%ld\n",output.x);
      //printf("%ld\n",heapExtractMax());
    }
    else if(strcmp(op,"end") == 0)break;
  }
 
  return 0;
}