Design Event Manager solution and explanation

class EventManager:

    def __init__(self, events: list[list[int]]):
        self.sl = SortedList()
        self.d = {}
        for eventId, priority in events:
            self.sl.add((-priority, eventId))
            self.d[eventId] = priority

    def updatePriority(self, eventId: int, newPriority: int) -> None:
        old_priority = self.d[eventId]
        self.sl.remove((-old_priority, eventId))
        self.sl.add((-newPriority, eventId))
        self.d[eventId] = newPriority

    def pollHighest(self) -> int:
        if not self.sl:
            return -1
        eventId = self.sl.pop(0)[1]
        self.d.pop(eventId)
        return eventId


# Your EventManager object will be instantiated and called as such:
# obj = EventManager(events)
# obj.updatePriority(eventId,newPriority)
# param_2 = obj.pollHighest()

class EventManager {
    private TreeSet<int[]> sl;
    private Map<Integer, Integer> d;

    public EventManager(int[][] events) {
        sl = new TreeSet<>((a, b) -> {
            if (a[0] != b[0]) return a[0] - b[0];
            return a[1] - b[1];
        });
        d = new HashMap<>();
        for (int[] e : events) {
            int eventId = e[0], priority = e[1];
            sl.add(new int[] {-priority, eventId});
            d.put(eventId, priority);
        }
    }

    public void updatePriority(int eventId, int newPriority) {
        int old = d.get(eventId);
        sl.remove(new int[] {-old, eventId});
        sl.add(new int[] {-newPriority, eventId});
        d.put(eventId, newPriority);
    }

    public int pollHighest() {
        if (sl.isEmpty()) {
            return -1;
        }
        int[] top = sl.pollFirst();
        int eventId = top[1];
        d.remove(eventId);
        return eventId;
    }
}

/**
 * Your EventManager object will be instantiated and called as such:
 * EventManager obj = new EventManager(events);
 * obj.updatePriority(eventId,newPriority);
 * int param_2 = obj.pollHighest();
 */

class EventManager {
public:
    set<pair<int, int>> sl;
    unordered_map<int, int> d;

    EventManager(vector<vector<int>>& events) {
        for (auto& e : events) {
            int eventId = e[0], priority = e[1];
            sl.insert({-priority, eventId});
            d[eventId] = priority;
        }
    }

    void updatePriority(int eventId, int newPriority) {
        int old = d[eventId];
        sl.erase({-old, eventId});
        sl.insert({-newPriority, eventId});
        d[eventId] = newPriority;
    }

    int pollHighest() {
        if (sl.empty()) {
            return -1;
        }
        auto it = sl.begin();
        int eventId = it->second;
        sl.erase(it);
        d.erase(eventId);
        return eventId;
    }
};

/**
 * Your EventManager object will be instantiated and called as such:
 * EventManager* obj = new EventManager(events);
 * obj->updatePriority(eventId,newPriority);
 * int param_2 = obj->pollHighest();
 */

import (
	rbt "github.com/emirpasic/gods/v2/trees/redblacktree"
	"cmp"
)

type pair struct{ p, id int }

type EventManager struct {
	sl *rbt.Tree[pair, struct{}]
	d  map[int]int
}

func Constructor(events [][]int) EventManager {
	sl := rbt.NewWith[pair, struct{}](func(a, b pair) int {
		return cmp.Or(a.p-b.p, a.id-b.id)
	})
	d := make(map[int]int)

	for _, e := range events {
		eventId, priority := e[0], e[1]
		sl.Put(pair{-priority, eventId}, struct{}{})
		d[eventId] = priority
	}

	return EventManager{sl: sl, d: d}
}

func (this *EventManager) UpdatePriority(eventId int, newPriority int) {
	old := this.d[eventId]
	this.sl.Remove(pair{-old, eventId})
	this.sl.Put(pair{-newPriority, eventId}, struct{}{})
	this.d[eventId] = newPriority
}

func (this *EventManager) PollHighest() int {
	if this.sl.Size() == 0 {
		return -1
	}
	it := this.sl.Iterator()
	it.First()

	top := it.Key()
	eventId := top.id

	this.sl.Remove(top)
	delete(this.d, eventId)

	return eventId
}

/**
 * Your EventManager object will be instantiated and called as such:
 * obj := Constructor(events);
 * obj.UpdatePriority(eventId,newPriority);
 * param_2 := obj.PollHighest();
 */