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: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Text;

class Program
{

    public void Proc()
    {
        List<long> arr = new List<long>();

        for (long i = 0; i < 2000000; i++)
        {
            string[] inpt = Console.ReadLine().Split(' ');
            long target = 0;
            if (inpt.Length >= 2)
            {
                target = long.Parse(inpt[1]);
            }

            if (inpt[0].Equals("insert"))
            {
                arr.Insert(0, target);
                this.MaxHieapfy(arr, 0);
            }
            else if (inpt[0].Equals("extract"))
            {
                Console.WriteLine(arr[0]);
                arr.RemoveAt(0);
                arr.Insert(0, arr[arr.Count - 1]);
                arr.RemoveAt(arr.Count - 1);
                MaxHieapfy(arr, 0);
            }
            else
            {
                break;
            }
             
        }
    }

    public void MaxHieapfy(List<long> arr, int rootIdx)
    {
        // ????????????INDEX
        int leftChildIndex = this.GetLeftChildIndex(rootIdx);
        int rightChildIndex = leftChildIndex + 1;
        int largest = -1;
        if (leftChildIndex < arr.Count && arr[rootIdx] < arr[leftChildIndex])
        {
            largest = leftChildIndex;
        }
        else
        {
            largest = rootIdx;
        }
        if (rightChildIndex < arr.Count && arr[largest] < arr[rightChildIndex])
        {
            largest = rightChildIndex;
        }
        if (largest != rootIdx)
        {
            long tmp = arr[rootIdx];
            arr[rootIdx] = arr[largest];
            arr[largest] = tmp;
            this.MaxHieapfy(arr, largest);
        }
    }


    private Dictionary<int, int> LeftChildDic = new Dictionary<int, int>();
    private int GetLeftChildIndex(int parentIndex)
    {
        if (LeftChildDic.ContainsKey(parentIndex))
        {
            return LeftChildDic[parentIndex];
        }
        int prev = 0;
        int idx = 0;
        for (int i = 0; i <= parentIndex; i++)
        {
            int plus = (int)Math.Pow(2, i);
            if (parentIndex >= prev && parentIndex < prev + plus)
            {
                int innerIdx = parentIndex - prev;
                idx = (innerIdx * 2) + (prev + plus);
                this.LeftChildDic.Add(parentIndex, idx);
                break;
            }
            else
            {
                prev += plus;
            }
        }
        return idx;
    }

    static void Main(string[] args)
    {
        Program prg = new Program();
        prg.Proc();
    }
}