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 <iostream>
using namespace std;

struct Heap {
    int *heapTable;
    int length;
    int curr;

    Heap () {
        this->heapTable = new int[20000001];
        this->length = 0;
        this->curr = 1;
    }

    void add (int valor) {
        this->heapTable[this->curr] = valor;
        this->curr++;
        this->length++;
    }

    void bottomUp() {
        if (this->length > 1) {
            int k = this->length;
            int v = this->heapTable[k];
            bool heapConfirm = false;
            while (!heapConfirm && k > 1) {
                int j = k / 2;
                if (v <= this->heapTable[j]) {
                    heapConfirm = true;
                } else {
                   this->heapTable[k] = this->heapTable[j];
                   this->heapTable[j] = v;
                   k = j;
                }
            }
        }
    }
    void upDown() {
            int k = 1;
            int v = this->heapTable[k];
            bool heapConfirm = false;
            while (!heapConfirm) {
                int j = 2 * k;
                if (j < this->curr) {
                    if (this->heapTable[j] < this->heapTable[j+1]) {
                        j = j + 1;
                    }
                } if (v >= this->heapTable[j]) {
                    heapConfirm = true;
                } else {
                    this->heapTable[k] = this->heapTable[j];
                    k = j;
                }
            }
            this->heapTable[k] = v;
        }


    void extract () {
        int aux = this->heapTable[1];
        this-> heapTable[1] = this->heapTable[length];
        this->heapTable[length] = 0;
        this->curr--;
        this->length--;
        cout << aux << endl;
    }

    void printArray() {
        for (int i = 0; i < this->length+1; i++) {
            cout << this->heapTable[i] << " ";
        }
    cout << "\n";
    }
};

int main () {
    Heap *heap = new Heap();
    bool stop = false;
    while (!stop) {
        string action = "";
        int valor = 0;
        cin >> action;
        if (action == "end") {
            stop = true;
        }
        else if (action == "insert") {
            cin >> valor;
            heap->add(valor);
            heap->bottomUp();
           // heap->printArray();
        } else {
            heap->extract();
            heap->upDown();
            //heap->printArray();
        }
    }
}