Introduction

In this blog post, we will explore how to solve the LeetCode problem "2102" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

A scenic location is represented by its name and attractiveness score, where name is a unique string among all locations and score is an integer. Locations can be ranked from the best to the worst. The higher the score, the better the location. If the scores of two locations are equal, then the location with the lexicographically smaller name is better. You are building a system that tracks the ranking of locations with the system initially starting with no locations. It supports: Adding scenic locations, one at a time. Querying the ith best location of all locations already added, where i is the number of times the system has been queried (including the current query). For example, when the system is queried for the 4th time, it returns the 4th best location of all locations already added. Note that the test data are generated so that at any time, the number of queries does not exceed the number of locations added to the system. Implement the SORTracker class: SORTracker() Initializes the tracker system. void add(string name, int score) Adds a scenic location with name and score to the system. string get() Queries and returns the ith best location, where i is the number of times this method has been invoked (including this invocation). Example 1: Input ["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "add", "get", "get"] [[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], ["alpine", 2], [], []] Output [null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"] Explanation SORTracker tracker = new SORTracker(); // Initialize the tracker system. tracker.add("bradford", 2); // Add location with name="bradford" and score=2 to the system. tracker.add("branford", 3); // Add location with name="branford" and score=3 to the system. tracker.get(); // The sorted locations, from best to worst, are: branford, bradford. // Note that branford precedes bradford due to its higher score (3 > 2). // This is the 1st time get() is called, so return the best location: "branford". tracker.add("alps", 2); // Add location with name="alps" and score=2 to the system. tracker.get(); // Sorted locations: branford, alps, bradford. // Note that alps precedes bradford even though they have the same score (2). // This is because "alps" is lexicographically smaller than "bradford". // Return the 2nd best location "alps", as it is the 2nd time get() is called. tracker.add("orland", 2); // Add location with name="orland" and score=2 to the system. tracker.get(); // Sorted locations: branford, alps, bradford, orland. // Return "bradford", as it is the 3rd time get() is called. tracker.add("orlando", 3); // Add location with name="orlando" and score=3 to the system. tracker.get(); // Sorted locations: branford, orlando, alps, bradford, orland. // Return "bradford". tracker.add("alpine", 2); // Add location with name="alpine" and score=2 to the system. tracker.get(); // Sorted locations: branford, orlando, alpine, alps, bradford, orland. // Return "bradford". tracker.get(); // Sorted locations: branford, orlando, alpine, alps, bradford, orland. // Return "orland". Constraints: name consists of lowercase English letters, and is unique among all locations. 1 <= name.length <= 10 1 <= score <= 105 At any time, the number of calls to get does not exceed the number of calls to add. At most 4 * 104 calls in total will be made to add and get.

Explanation

Here's a breakdown of the solution:

• Core Idea: Maintain two sets: smaller and larger. smaller stores the i best locations seen so far, where i is the number of times get() has been called. larger stores the rest of the locations. The smaller set is implemented using a max-heap, and the larger set is implemented using a min-heap.
• Balancing: After each add() operation, we need to ensure that the size of smaller is one greater than the number of times get() has been called previously. To achieve this, we can transfer the smallest element from larger to smaller if needed.

• get() Implementation: The get() function simply returns the largest element (root) in the smaller max-heap. Then, we re-balance the heaps if required.

• Runtime & Space Complexity:

  • Time Complexity: add(): O(log N), get(): O(log N), where N is the number of locations added.
  • Space Complexity: O(N)

Code

    import heapq

class Location:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __lt__(self, other):
        if self.score != other.score:
            return self.score > other.score
        return self.name < other.name

    def __eq__(self, other):
        return self.name == other.name and self.score == other.score

class SORTracker:
    def __init__(self):
        self.smaller = []  # Max-heap (stores negated values for max-heap behavior)
        self.larger = []  # Min-heap
        self.get_count = 0

    def add(self, name, score):
        location = Location(name, score)

        if self.smaller and location < Location(self.smaller[0].name, -self.smaller[0].score):  # Compare with the largest element in smaller (negated)
            heapq.heappush(self.larger, Location(self.smaller[0].name, -heapq.heappop(self.smaller).score))
            heapq.heappush(self.smaller, Location(-location.name, location.score))  # Negate the name for max-heap comparison
        else:
            heapq.heappush(self.larger, location)

        while len(self.smaller) < self.get_count:
            if self.larger:
                top = heapq.heappop(self.larger)
                heapq.heappush(self.smaller, Location(-top.name, top.score))
            else:
                break #should never happen in valid test data

    def get(self):
        if self.larger and len(self.smaller) < self.get_count: #handles possible edge case on rebalancing due to earlier 'else' case inside add()
             top = heapq.heappop(self.larger)
             heapq.heappush(self.smaller, Location(-top.name, top.score))

        self.get_count += 1

        if self.smaller:
            return self.smaller[0].name
        else:
            return "" #should never happen due to problem constraints


# Example Usage (From the prompt):
if __name__ == '__main__':
    tracker = SORTracker()
    tracker.add("bradford", 2)
    tracker.add("branford", 3)
    print(tracker.get())  # Output: branford
    tracker.add("alps", 2)
    print(tracker.get())  # Output: alps
    tracker.add("orland", 2)
    print(tracker.get())  # Output: bradford
    tracker.add("orlando", 3)
    print(tracker.get())  # Output: bradford
    tracker.add("alpine", 2)
    print(tracker.get())  # Output: bradford
    print(tracker.get())  # Output: orland