Baekjoon #21939

#include<bits/stdc++.h>

using namespace std;

set<pair<int, int>> problemList;
unordered_map<int, int> problemInfo;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);

    int N; cin >> N;
    for(int i=0;i<N;i++){
        int problem, level; cin >> problem >> level;
        problemList.insert(pair<int, int>(level, problem));
        problemInfo[problem] = level;
    }

    int M; cin >> M;
    for(int i=0;i<M;i++){
        string cmd; cin >> cmd;
        if(cmd == "recommend") {
            int x; cin >> x;
            if(x > 0) {
                cout << problemList.rbegin()->second << '\n';
            }
            else {
                cout << problemList.begin()->second << '\n';
            }
        }
        else if(cmd == "solved") {
            int problem; cin >> problem;
            int level = problemInfo[problem];
            problemList.erase(pair<int, int>(level, problem));
            problemInfo.erase(problem);
        }
        else if(cmd == "add") {
            int problem, level; cin >> problem >> level;
            problemList.insert(pair<int, int>(level, problem));
            problemInfo[problem] = level;
        }
    }

    return 0;
}

import java.util.*;
import java.io.*;

class Problem implements Comparable<Problem> {
    int num, level;
    Problem(int num, int level){
        this.num = num;
        this.level = level;
    }
    // 난이도로 내림차순 정렬을 먼저 한 뒤
    // 같은 난이도에 대해서는 문제번호로 내림차순 정렬
    @Override
    public int compareTo(Problem op) {
        if(level < op.level) return 1;
        else if(level == op.level) {
            if(num < op.num) return 1;
            else if(num == op.num) return 0;
            else return -1;
        }
        else return -1;
    }
}

public class Main {
    static TreeSet<Problem> tset = new TreeSet<Problem>();
    static int[] problem = new int[100010];
    public static void main(String[] args) {
        FastReader rd = new FastReader();
        int N = rd.nextInt();
        
        // problem 배열에서 문제번호와 난이도를 저장하고
        // TreeSet을 이용하여 난이도, 문제번호 순으로 정렬합니다.
        for(int i = 0;i < N;i++) {
            int num = rd.nextInt();
            int lev = rd.nextInt();
            tset.add(new Problem(num, lev));
            problem[num] = lev;
        }

        int M = rd.nextInt();
        for(int i = 0;i < M;i++) {
            String command = rd.next();
            
            // "add" 명령시 TreeSet과 problem 배열에 추가
            if(command.equals("add")) {
                int num = rd.nextInt();
                int lev = rd.nextInt();
                tset.add(new Problem(num, lev));
                problem[num] = lev;
            }
            // "solved" 명령시 입력받은 문제번호와
            // 저장해놓은 문제번호의 난이도를 배열에서 찾은 후
            // TreeSet에서 삭제합니다.
            else if(command.equals("solved")) {
                int num = rd.nextInt();
                tset.remove(new Problem(num, problem[num]));
            }
            // recommend 1 은 가장 어렵고 큰 번호 이므로 첫 번째 값
            // recommend 2 는 가장 쉽고 작은 번호 이므로 마지막 값
            else {
                int n = rd.nextInt();
                if(n == 1) 
                    System.out.println(tset.first().num);
                else 
                    System.out.println(tset.last().num);
            }
        }
    }
    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while(st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import sys
import heapq

def input():
    return sys.stdin.readline().rstrip()

mx_heap, mn_heap = [], []
level = [0] * 100001

def recommend(x):
    while len(mx_heap):
        l, p = mx_heap[0]
        if level[-p] == -l: break
        heapq.heappop(mx_heap)
    while len(mn_heap):
        l, p = mn_heap[0]
        if level[p] == l: break
        heapq.heappop(mn_heap)
    print(-mx_heap[0][1] if x == 1 else mn_heap[0][1])

def add(p, l):
    heapq.heappush(mx_heap, (-l, -p))
    heapq.heappush(mn_heap, (l, p))
    level[p] = l

def solved(p):
    level[p] = 0

N = int(input())
for i in range(N):
    P, L = map(int, input().split())
    add(P, L)

Q = int(input())
for i in range(Q):
    cmd, *args = input().split()
    args = list(map(int, args))
    if cmd == 'solved':
        solved(args[0])
    elif cmd == 'recommend':
        recommend(args[0])
    else:
        add(args[0], args[1])