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 JAVA (judge verdict: Time Limit Exceeded)

import java.util.Scanner;


public class Main{

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int[] S = new int[2000000];
		for(int i= 0 ; i<S.length ; i++) {
			S[i] = -1;
		}
		while(true) {
			String[] input = s.nextLine().split(" ");
			if("insert".equals(input[0])) {
				insert(S, Integer.parseInt(input[1]));
			}else if("extract".equals(input[0])) {
				System.out.println(extract(S));
			}else if("end".equals(input[0])) {
				System.exit(0);
			}
		}
	}

	public static void insert(int[] S, int value) {
		for(int i=0 ; i<S.length ; i++) {
			if(S[i]==-1) {
				S[i] = value;
				break;
			}
		}
		buildMaxHeap(S);
	}

	public static int extract(int[] S) {
		int returnValue = S[0];
		for(int i=0 ; i<S.length ; i++) {
			if(S[i]==-1) {
				S[0] = S[i-1];
				S[i-1] = -1;
				break;
			}
		}
		buildMaxHeap(S);
		return returnValue;
	}


	public static void maxHeapify(int[] maxHeap, int index) {
		int leftChild = index*2;
		int rightChild = (index*2)+1;
		int max = maxHeap[index-1];
		if(maxHeap.length>=leftChild && maxHeap[leftChild-1]>maxHeap[index-1]) {
			max = maxHeap[leftChild-1];
		}
		if(maxHeap.length>=rightChild && maxHeap[rightChild-1]>max) {
			max = maxHeap[rightChild-1];
		}
		if(max!=maxHeap[index-1]) {
			if(max==maxHeap[leftChild-1]) {
				int tmp = maxHeap[leftChild-1];
				maxHeap[leftChild-1] = maxHeap[index-1];
				maxHeap[index-1] = tmp;
				maxHeapify(maxHeap, leftChild);
			}else if(max==maxHeap[rightChild-1]) {
				int tmp = maxHeap[rightChild-1];
				maxHeap[rightChild-1] = maxHeap[index-1];
				maxHeap[index-1] = tmp;
				maxHeapify(maxHeap, rightChild);
			}
		}
	}

	public static void buildMaxHeap(int[] maxHeap) {
		for(int i=(maxHeap.length/2) ; i>0 ; i--) {
			maxHeapify(maxHeap, i);
		}
	}
}