1class EventManager {
2    // TreeSet acts as an ordered structure to fetch the highest-priority event quickly.
3    // Each element is stored as {negativePriority, eventId} so that:
4    //   - higher priority (stored as smaller negative value) comes first
5    //   - ties are broken by smaller eventId
6    private TreeSet<int[]> sortedEvents;
7
8    // Maps an eventId to its current priority, enabling O(1) lookups during updates.
9    private Map<Integer, Integer> eventPriority;
10
11    /**
12     * Initializes the EventManager with a list of events.
13     *
14     * @param events array where each entry is {eventId, priority}
15     */
16    public EventManager(int[][] events) {
17        sortedEvents = new TreeSet<>((a, b) -> {
18            // Primary sort by stored priority (negated, so higher priority first).
19            if (a[0] != b[0]) {
20                return a[0] - b[0];
21            }
22            // Secondary sort by eventId to break ties deterministically.
23            return a[1] - b[1];
24        });
25
26        eventPriority = new HashMap<>();
27
28        for (int[] event : events) {
29            int eventId = event[0];
30            int priority = event[1];
31            // Store negated priority so the TreeSet orders highest priority first.
32            sortedEvents.add(new int[] {-priority, eventId});
33            eventPriority.put(eventId, priority);
34        }
35    }
36
37    /**
38     * Updates the priority of an existing event.
39     *
40     * @param eventId     the id of the event to update
41     * @param newPriority the new priority value to assign
42     */
43    public void updatePriority(int eventId, int newPriority) {
44        // Retrieve the current priority to locate the existing entry.
45        int oldPriority = eventPriority.get(eventId);
46
47        // Remove the outdated entry from the ordered set.
48        sortedEvents.remove(new int[] {-oldPriority, eventId});
49
50        // Insert the updated entry with the new (negated) priority.
51        sortedEvents.add(new int[] {-newPriority, eventId});
52
53        // Refresh the priority record in the map.
54        eventPriority.put(eventId, newPriority);
55    }
56
57    /**
58     * Removes and returns the id of the highest-priority event.
59     *
60     * @return the eventId of the highest-priority event, or -1 if none remain
61     */
62    public int pollHighest() {
63        if (sortedEvents.isEmpty()) {
64            return -1;
65        }
66
67        // pollFirst() retrieves and removes the smallest element,
68        // which corresponds to the highest priority due to negation.
69        int[] top = sortedEvents.pollFirst();
70        int eventId = top[1];
71
72        // Keep the map in sync by removing the polled event.
73        eventPriority.remove(eventId);
74
75        return eventId;
76    }
77}
78
79/**
80 * Your EventManager object will be instantiated and called as such:
81 * EventManager obj = new EventManager(events);
82 * obj.updatePriority(eventId, newPriority);
83 * int param_2 = obj.pollHighest();
84 */
85

1class EventManager {
2public:
3    // Ordered set storing events as {-priority, eventId}.
4    // Negating the priority lets the std::set keep the highest-priority
5    // event at begin(), since the set sorts in ascending order.
6    set<pair<int, int>> eventSet;
7
8    // Maps an eventId to its current priority, enabling O(1) lookup
9    // when we need to update or erase a specific event.
10    unordered_map<int, int> priorityOf;
11
12    // Initialize the manager with the given list of events.
13    // Each event is represented as {eventId, priority}.
14    EventManager(vector<vector<int>>& events) {
15        for (auto& event : events) {
16            int eventId = event[0];
17            int priority = event[1];
18            // Insert with negated priority for max-at-front ordering.
19            eventSet.insert({-priority, eventId});
20            // Record the event's priority for future updates.
21            priorityOf[eventId] = priority;
22        }
23    }
24
25    // Change the priority of an existing event.
26    void updatePriority(int eventId, int newPriority) {
27        int oldPriority = priorityOf[eventId];
28        // Remove the entry that holds the stale priority.
29        eventSet.erase({-oldPriority, eventId});
30        // Re-insert the event with the updated priority.
31        eventSet.insert({-newPriority, eventId});
32        // Keep the lookup map in sync.
33        priorityOf[eventId] = newPriority;
34    }
35
36    // Remove and return the eventId with the highest priority.
37    // Returns -1 if no events remain.
38    int pollHighest() {
39        if (eventSet.empty()) {
40            return -1;
41        }
42        // The highest-priority event sits at the front of the set.
43        auto it = eventSet.begin();
44        int eventId = it->second;
45        // Erase it from both containers to fully remove the event.
46        eventSet.erase(it);
47        priorityOf.erase(eventId);
48        return eventId;
49    }
50};
51
52/**
53 * Your EventManager object will be instantiated and called as such:
54 * EventManager* obj = new EventManager(events);
55 * obj->updatePriority(eventId,newPriority);
56 * int param_2 = obj->pollHighest();
57 */
58

1// Ordered list storing events as [-priority, eventId].
2// Negating the priority lets us keep the highest-priority event at the
3// front (index 0), since the list is sorted in ascending order.
4let eventList: [number, number][] = [];
5
6// Maps an eventId to its current priority, enabling quick lookup
7// when we need to update or erase a specific event.
8let priorityOf: Map<number, number> = new Map();
9
10// Compare two [negPriority, eventId] pairs the same way std::set does:
11// first by the negated priority, then by the eventId.
12function comparePair(a: [number, number], b: [number, number]): number {
13    if (a[0] !== b[0]) {
14        return a[0] - b[0];
15    }
16    return a[1] - b[1];
17}
18
19// Binary search for the index where `target` should reside.
20// Returns the first index whose element is >= target (lower bound).
21function lowerBound(target: [number, number]): number {
22    let low = 0;
23    let high = eventList.length;
24    while (low < high) {
25        const mid = (low + high) >> 1;
26        if (comparePair(eventList[mid], target) < 0) {
27            low = mid + 1;
28        } else {
29            high = mid;
30        }
31    }
32    return low;
33}
34
35// Insert a pair into the sorted list at its correct position.
36function insertPair(pair: [number, number]): void {
37    const index = lowerBound(pair);
38    eventList.splice(index, 0, pair);
39}
40
41// Erase a pair from the sorted list if it exists.
42function erasePair(pair: [number, number]): void {
43    const index = lowerBound(pair);
44    // Confirm the element at `index` is exactly the target before removing.
45    if (index < eventList.length && comparePair(eventList[index], pair) === 0) {
46        eventList.splice(index, 1);
47    }
48}
49
50// Initialize the manager with the given list of events.
51// Each event is represented as [eventId, priority].
52function EventManager(events: number[][]): void {
53    // Reset global state in case of repeated instantiation.
54    eventList = [];
55    priorityOf = new Map();
56    for (const event of events) {
57        const eventId = event[0];
58        const priority = event[1];
59        // Insert with negated priority for max-at-front ordering.
60        insertPair([-priority, eventId]);
61        // Record the event's priority for future updates.
62        priorityOf.set(eventId, priority);
63    }
64}
65
66// Change the priority of an existing event.
67function updatePriority(eventId: number, newPriority: number): void {
68    const oldPriority = priorityOf.get(eventId)!;
69    // Remove the entry that holds the stale priority.
70    erasePair([-oldPriority, eventId]);
71    // Re-insert the event with the updated priority.
72    insertPair([-newPriority, eventId]);
73    // Keep the lookup map in sync.
74    priorityOf.set(eventId, newPriority);
75}
76
77// Remove and return the eventId with the highest priority.
78// Returns -1 if no events remain.
79function pollHighest(): number {
80    if (eventList.length === 0) {
81        return -1;
82    }
83    // The highest-priority event sits at the front of the list.
84    const front = eventList[0];
85    const eventId = front[1];
86    // Erase it from both containers to fully remove the event.
87    eventList.splice(0, 1);
88    priorityOf.delete(eventId);
89    return eventId;
90}
91