Design Ride Sharing System solution and explanation

class RideSharingSystem:

    def __init__(self):
        self.t = 0
        self.riders = SortedList()
        self.drivers = SortedList()
        self.d = defaultdict(int)

    def addRider(self, riderId: int) -> None:
        self.d[riderId] = self.t
        self.riders.add((self.t, riderId))
        self.t += 1

    def addDriver(self, driverId: int) -> None:
        self.drivers.add((self.t, driverId))
        self.t += 1

    def matchDriverWithRider(self) -> List[int]:
        if len(self.riders) < 1 or len(self.drivers) < 1:
            return [-1, -1]
        return [self.drivers.pop(0)[1], self.riders.pop(0)[1]]

    def cancelRider(self, riderId: int) -> None:
        self.riders.discard((self.d[riderId], riderId))


# Your RideSharingSystem object will be instantiated and called as such:
# obj = RideSharingSystem()
# obj.addRider(riderId)
# obj.addDriver(driverId)
# param_3 = obj.matchDriverWithRider()
# obj.cancelRider(riderId)

class RideSharingSystem {
    private int t;
    private TreeSet<int[]> riders;
    private TreeSet<int[]> drivers;
    private Map<Integer, Integer> d;

    public RideSharingSystem() {
        this.t = 0;
        this.riders = new TreeSet<>(
            (a, b) -> a[0] != b[0] ? Integer.compare(a[0], b[0]) : Integer.compare(a[1], b[1]));
        this.drivers = new TreeSet<>(
            (a, b) -> a[0] != b[0] ? Integer.compare(a[0], b[0]) : Integer.compare(a[1], b[1]));
        this.d = new HashMap<>();
    }

    public void addRider(int riderId) {
        d.put(riderId, t);
        riders.add(new int[] {t, riderId});
        t++;
    }

    public void addDriver(int driverId) {
        drivers.add(new int[] {t, driverId});
        t++;
    }

    public int[] matchDriverWithRider() {
        if (riders.isEmpty() || drivers.isEmpty()) {
            return new int[] {-1, -1};
        }
        int driverId = drivers.pollFirst()[1];
        int riderId = riders.pollFirst()[1];
        return new int[] {driverId, riderId};
    }

    public void cancelRider(int riderId) {
        Integer time = d.get(riderId);
        if (time != null) {
            riders.remove(new int[] {time, riderId});
        }
    }
}

/**
 * Your RideSharingSystem object will be instantiated and called as such:
 * RideSharingSystem obj = new RideSharingSystem();
 * obj.addRider(riderId);
 * obj.addDriver(driverId);
 * int[] param_3 = obj.matchDriverWithRider();
 * obj.cancelRider(riderId);
 */

class RideSharingSystem {
private:
    int t;
    set<pair<int, int>> riders;
    set<pair<int, int>> drivers;
    unordered_map<int, int> d;

public:
    RideSharingSystem() {
        t = 0;
    }

    void addRider(int riderId) {
        d[riderId] = t;
        riders.insert({t, riderId});
        t++;
    }

    void addDriver(int driverId) {
        drivers.insert({t, driverId});
        t++;
    }

    vector<int> matchDriverWithRider() {
        if (riders.empty() || drivers.empty()) {
            return {-1, -1};
        }
        int driverId = drivers.begin()->second;
        int riderId = riders.begin()->second;
        drivers.erase(drivers.begin());
        riders.erase(riders.begin());
        return {driverId, riderId};
    }

    void cancelRider(int riderId) {
        auto it = d.find(riderId);
        if (it != d.end()) {
            riders.erase({it->second, riderId});
        }
    }
};

/**
 * Your RideSharingSystem object will be instantiated and called as such:
 * RideSharingSystem* obj = new RideSharingSystem();
 * obj->addRider(riderId);
 * obj->addDriver(driverId);
 * vector<int> param_3 = obj->matchDriverWithRider();
 * obj->cancelRider(riderId);
 */

type RideSharingSystem struct {
	t       int
	riders  *redblacktree.Tree[int, int]
	drivers *redblacktree.Tree[int, int]
	d       map[int]int
}

func Constructor() RideSharingSystem {
	return RideSharingSystem{
		t:       0,
		riders:  redblacktree.New[int, int](),
		drivers: redblacktree.New[int, int](),
		d:       make(map[int]int),
	}
}

func (this *RideSharingSystem) AddRider(riderId int) {
	this.d[riderId] = this.t
	this.riders.Put(this.t, riderId)
	this.t++
}

func (this *RideSharingSystem) AddDriver(driverId int) {
	this.drivers.Put(this.t, driverId)
	this.t++
}

func (this *RideSharingSystem) MatchDriverWithRider() []int {
	if this.riders.Empty() || this.drivers.Empty() {
		return []int{-1, -1}
	}

	driverTime, driverId := this.drivers.Left().Key, this.drivers.Left().Value
	riderTime, riderId := this.riders.Left().Key, this.riders.Left().Value

	this.drivers.Remove(driverTime)
	this.riders.Remove(riderTime)

	return []int{driverId, riderId}
}

func (this *RideSharingSystem) CancelRider(riderId int) {
	time, exists := this.d[riderId]
	if !exists {
		return
	}
	this.riders.Remove(time)
}

/**
 * Your RideSharingSystem object will be instantiated and called as such:
 * obj := Constructor();
 * obj.AddRider(riderId);
 * obj.AddDriver(driverId);
 * param_3 := obj.MatchDriverWithRider();
 * obj.CancelRider(riderId);
 */