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)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ALDS1_9_C
{
    class Program
    {
        static void Main(string[] args)
        {
            PriorityQue priorityQue = new PriorityQue();

            while (true)
            {
                string[] tmpLine = Console.ReadLine()
                                          .Split(' ');

                if (tmpLine[0] == "insert")
                {
                    priorityQue.Insert(int.Parse(tmpLine[1]));
                }
                else if (tmpLine[0] == "extract")
                {
                    Console.WriteLine(priorityQue.Pop());
                }
                else
                {
                    break;
                }
            }
            //Console.ReadLine();
        }
    }

    class PriorityQue
    {
        private int[] heapNodes;
        private int maxIndex;

        public PriorityQue()
        {
            this.heapNodes = new int[2000000];
            this.maxIndex = -1;
        }

        public void Insert(int targetKey)
        {
            //配列サイズ + 1
            this.maxIndex++;
            this.heapNodes[this.maxIndex] = targetKey;
            this.UpHeapfy(this.maxIndex);
        }

        private void UpHeapfy(int targetIndex)
        {
            if (targetIndex == 0)
            {
                return;
            }

            int parentIndex = (int)((targetIndex + 1) / 2) - 1;

            if (this.heapNodes[targetIndex] > this.heapNodes[parentIndex])
            {
                int tmp = this.heapNodes[targetIndex];
                this.heapNodes[targetIndex] = this.heapNodes[parentIndex];
                this.heapNodes[parentIndex] = tmp;
                this.UpHeapfy(parentIndex);
            }
        }

        public int Pop()
        {
            int returnKey = this.heapNodes[0];
            this.heapNodes[0] = this.heapNodes[this.maxIndex];
            this.maxIndex--;
            this.DownHeapfy(0);
            return returnKey;
        }

        private void DownHeapfy(int targetIndex)
        {
            int maxKeyIndex = targetIndex;
            int leftIndex = (targetIndex + 1) * 2 - 1;
            if (leftIndex <= this.maxIndex && this.heapNodes[leftIndex] > this.heapNodes[maxKeyIndex])
            {
                maxKeyIndex = leftIndex;
            }
            int rightIndex = (targetIndex + 1) * 2;
            if (rightIndex <= this.maxIndex && this.heapNodes[rightIndex] > this.heapNodes[maxKeyIndex])
            {
                maxKeyIndex = rightIndex;
            }
            if (maxKeyIndex != targetIndex)
            {
                int tmpKey = this.heapNodes[targetIndex];
                this.heapNodes[targetIndex] = this.heapNodes[maxKeyIndex];
                this.heapNodes[maxKeyIndex] = tmpKey;
                this.DownHeapfy(maxKeyIndex);
            }
        }

    }
}