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 Python3 (judge verdict: Accepted)

import sys
from heapq import heappush, heappop

# わからん
pq = []
lines = sys.stdin.readlines()
for line in lines:
    op = line.strip().split(' ')
    if op[0] == 'insert':
        heappush(pq, -int(op[1]))
    elif op[0] == 'extract':
        print(-heappop(pq))
    else:
        break

# import sys, time
#
# class PriorityQueue:
#     __slots__ = ['nodes', 'num']
#
#     def __init__(self):
#         self.nodes = []
#         self.num = 0
#
#     def max_heapify(self, i):
#         if i >= self.num: return
#         left, right = (i+1)*2-1, (i+1)*2
#
#         largest = i
#         if left < self.num and self.nodes[i] < self.nodes[left]: largest = left
#         if right < self.num and self.nodes[largest] < self.nodes[right]: largest = right
#
#         if largest != i:
#             self.nodes[i], self.nodes[largest] = self.nodes[largest], self.nodes[i]
#             self.max_heapify(largest)
#
#     def extract_max(self):
#         if self.num < 1: return
#         max = self.nodes[0]
#         self.nodes[0] = self.nodes[-1]
#         self.nodes.pop()
#         self.num -= 1
#         self.max_heapify(0)
#         return max
#
#     def insert(self, key):
#         self.nodes.append(key)
#         self.num += 1
#         i = self.num-1
#         par = lambda i: (i-1)//2
#         while i > 0 and self.nodes[par(i)] < self.nodes[i]:
#             self.nodes[i], self.nodes[par(i)] = self.nodes[par(i)], self.nodes[i]
#             i = par(i)
#
#     def print_element(self):
#         for node in self.nodes:
#             print('', node, end='')
#         print('')
#
# pq = PriorityQueue()
#
# start = time.time()
# lines = sys.stdin.readlines()
# for line in lines:
#     op = line.strip().split(' ')
#     if op[0] == 'insert':
#         pq.insert(int(op[1]))
#     elif op[0] == 'extract':
#         # print(pq.extract_max())
#         pq.extract_max()
#     else:
#         break
# print('elapsed:', time.time()-start)