CSES Solutions - Room Allocation

// C# program to implement 
// room allocation problem.

using System;
using System.Collections.Generic;

class Pair {
    public int first, second;
    public Pair(int first, int second) {
        this.first = first;
        this.second = second;
    }
}

class intComparer : IComparer<Pair> {
    public int Compare(Pair a, Pair b) {
        if (a.first > b.first)
            return 1;
        else if (a.first < b.first)
            return -1;
        return 0;
    }
}

class GfG {
    
    // function to find the minimum number of rooms and the
    // rooms allocated to each customer
    static void minimumRooms(int[][] timings) {
        
        int n = timings.Length;
        
        // array to store the {arrival, departure, index} of
        // all customers
        int[][] vec = new int[n][];
        for (int i = 0; i < n; i++) {
            vec[i] = new int[] { timings[i][0], timings[i][1], i };
        }

        // Sort the array according to the arrival time of
        // customers
        Array.Sort(vec, (a, b) => a[0].CompareTo(b[0]));

        // Min heap to store {departure, room number} to fetch
        // the room which gets vacant the earliest
        PriorityQueue<Pair> occupiedRooms = new PriorityQueue<Pair>(new intComparer());

        // Variable to store the total number of rooms needed
        int roomCnt = 0;

        // array to store the room allotted to each customer
        int[] ans = new int[n];

        for (int i = 0; i < n; i++) {
            int arrivalTime = vec[i][0];
            int departureTime = vec[i][1];
            int idx = vec[i][2];

            // Check if there are no rooms available or all the
            // rooms are occupied
            if (occupiedRooms.Count == 0 || occupiedRooms.Peek().first >= arrivalTime) {
                    
                // If there are no rooms or all the rooms are
                // occupied, then increment the total number of
                // rooms needed and allocate the room to the
                // current customer
                roomCnt += 1;
                occupiedRooms.Enqueue(new Pair(departureTime, roomCnt));
                ans[idx] = roomCnt;
            } else {
                
                // If there is a vacant room, then assign that
                // vacant room to the current customer
                int vacantRoom = occupiedRooms.Dequeue().second;
                occupiedRooms.Enqueue(new Pair(departureTime, vacantRoom));
                ans[idx] = vacantRoom;
            }
        }

        // Print the total rooms needed along with the room
        // allocated to each customer
        Console.WriteLine(roomCnt);
        Console.WriteLine(string.Join(" ", ans));
    }

    static void Main() {
        int[][] timings = { new int[] { 1, 2 }, 
        new int[] { 2, 4 }, new int[] { 4, 4 } };
        minimumRooms(timings);
    }
}

class PriorityQueue<T> {
    private List<T> heap;
    private IComparer<T> comparer;

    public PriorityQueue(IComparer<T> comparer = null) {
        this.heap = new List<T>();
        this.comparer = comparer ?? Comparer<T>.Default;
    }

    public int Count => heap.Count;

    // Enqueue operation
    public void Enqueue(T item) {
        heap.Add(item);
        int i = heap.Count - 1;
        while (i > 0) {
            int parent = (i - 1) / 2;
            if (comparer.Compare(heap[parent], heap[i]) <= 0)
                break;
            Swap(parent, i);
            i = parent;
        }
    }
    
    public T Peek() {
        return heap[0];
    }

    // Dequeue operation
    public T Dequeue() {
        if (heap.Count == 0)
            throw new InvalidOperationException("Priority queue is empty.");
        T result = heap[0];
        int last = heap.Count - 1;
        heap[0] = heap[last];
        heap.RemoveAt(last);
        last--;
        int i = 0;
        while (true) {
            int left = 2 * i + 1;
            if (left > last)
                break;
            int right = left + 1;
            int minChild = left;
            if (right <= last && comparer.Compare(heap[right], heap[left]) < 0)
                minChild = right;
            if (comparer.Compare(heap[i], heap[minChild]) <= 0)
                break;
            Swap(i, minChild);
            i = minChild;
        }
        return result;
    }

    // Swap two elements in the heap
    private void Swap(int i, int j) {
        T temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}