Meeting Rooms III | Leetcode 2402

class Solution {
    #define ll long long
    #define pli pair<ll,int>
public:
    int mostBooked(int n, vector<vector<int>>& meetings) {
        sort(meetings.begin(),meetings.end());
        priority_queue<pli,vector<pli>,greater<pli>> free_rooms, occupied_rooms;
        vector<int> freq(n,0);

        //Initially all rooms are free
        for(int i=0;i<n;++i)
            free_rooms.push({0,i});//{time,room_no} pair

        //Simulate Job Scheduling
        for(int i=0;i<meetings.size();++i){
            //Add rooms getting free now
            while(!occupied_rooms.empty() and occupied_rooms.top().first<=meetings[i][0]){
                pli curr = occupied_rooms.top();
                occupied_rooms.pop();
                curr.first = 0;
                free_rooms.push(curr);
            }
            //Assign a room to current meeting
            if(!free_rooms.empty()){
                pli curr = free_rooms.top();
                free_rooms.pop();
                freq[curr.second]++;
                curr.first = meetings[i][1];
                occupied_rooms.push(curr);
            }else{
                pli curr = occupied_rooms.top();
                occupied_rooms.pop();
                freq[curr.second]++;
                curr.first += 1LL*(meetings[i][1] - meetings[i][0]);
                occupied_rooms.push(curr);
            }
        }
        int max_meeting_room;
        int max_meetings = 0;
        for(int i=0;i<n;++i){
            if(freq[i]>max_meetings){
                max_meeting_room = i;
                max_meetings = freq[i];
            }
        }
        return max_meeting_room;
    }
};
/*
//JAVA
import java.util.*;

class Solution {
    public int mostBooked(int n, int[][] meetings) {
        Arrays.sort(meetings, (a, b) -> a[0] - b[0]);
        PriorityQueue<long[]> freeRooms = new PriorityQueue<>((a, b) -> {
            if (a[0] != b[0]) return Long.compare(a[0], b[0]);
            return Long.compare(a[1], b[1]);
        });
        PriorityQueue<long[]> occupiedRooms = new PriorityQueue<>((a, b) -> {
            if (a[0] != b[0]) return Long.compare(a[0], b[0]);
            return Long.compare(a[1], b[1]);
        });
        int[] freq = new int[n];

        // Initially all rooms are free
        for (int i = 0; i < n; i++) {
            freeRooms.offer(new long[]{0, i});
        }

        // Simulate Job Scheduling
        for (int[] meeting : meetings) {
            long start = meeting[0];
            long end = meeting[1];

            // Add rooms getting free now
            while (!occupiedRooms.isEmpty() && occupiedRooms.peek()[0] <= start) {
                long[] curr = occupiedRooms.poll();
                curr[0] = 0;
                freeRooms.offer(curr);
            }

            // Assign a room to current meeting
            if (!freeRooms.isEmpty()) {
                long[] curr = freeRooms.poll();
                freq[(int)curr[1]]++;
                curr[0] = end;
                occupiedRooms.offer(curr);
            } else {
                long[] curr = occupiedRooms.poll();
                freq[(int)curr[1]]++;
                curr[0] += (end - start);
                occupiedRooms.offer(curr);
            }
        }

        int maxMeetings = 0;
        int maxMeetingRoom = 0;
        for (int i = 0; i < n; i++) {
            if (freq[i] > maxMeetings) {
                maxMeetings = freq[i];
                maxMeetingRoom = i;
            }
        }
        return maxMeetingRoom;
    }
}

#Python
import heapq

class Solution:
    def mostBooked(self, n: int, meetings: List[List[int]]) -> int:
        meetings.sort()
        free_rooms = []
        occupied_rooms = []
        freq = [0] * n

        # Initially all rooms are free
        for i in range(n):
            heapq.heappush(free_rooms, (0, i))

        # Simulate Job Scheduling
        for start, end in meetings:
            # Add rooms getting free now
            while occupied_rooms and occupied_rooms[0][0] <= start:
                time, room = heapq.heappop(occupied_rooms)
                heapq.heappush(free_rooms, (0, room))

            # Assign a room to current meeting
            if free_rooms:
                time, room = heapq.heappop(free_rooms)
                freq[room] += 1
                heapq.heappush(occupied_rooms, (end, room))
            else:
                time, room = heapq.heappop(occupied_rooms)
                freq[room] += 1
                heapq.heappush(occupied_rooms, (time + (end - start), room))

        max_meetings = max(freq)
        return freq.index(max_meetings)
*/