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 Haskell (judge verdict: Memory Limit Exceeded)

import           Control.Applicative
import           Control.Monad
import           Data.List           hiding (insert, union)
import           Data.Maybe
import           Text.Printf

data SkewHeap a = Empty
                | Node a (SkewHeap a) (SkewHeap a)

singleton :: Ord a => a -> SkewHeap a
singleton x = Node x Empty Empty

union :: Ord a => SkewHeap a -> SkewHeap a -> SkewHeap a
Empty              `union` t2                 = t2
t1                 `union` Empty              = t1
t1@(Node x1 l1 r1) `union` t2@(Node x2 l2 r2)
   | x1 >= x2                                 = Node x1 (t2 `union` r1) l1
   | otherwise                                = Node x2 (t1 `union` r2) l2

insert :: Ord a => a -> SkewHeap a -> SkewHeap a
insert x heap = singleton x `union` heap

extractMax :: Ord a => SkewHeap a -> Maybe (a, SkewHeap a)
extractMax Empty        = Nothing
extractMax (Node x l r) = Just (x, l `union` r)

go:: SkewHeap Int -> IO ()
go heap = do
  cmd <- getLine
  if cmd=="end" then return ()
  else do
    let params = words cmd
    case head params of
      "insert" -> go (insert (read $ last params) heap)
      "extract" -> do
          let m = extractMax heap
          if isJust m then do
            print $ fst (fromJust m)
            go $ snd (fromJust m)
          else go Empty
      _ -> return ()

main = go Empty