Calculate server loads using Round Robin Scheduling

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

// C# Program for the above approach


// Implementing sort in 2d list. 
class GFG : IComparer<List<int>>
{
    public int Compare(List<int> x, List<int> y)
    {
        if(x[0] == y[0])
        {
            return x[1].CompareTo(y[1]);
        }
          
        // CompareTo() method
        return x[0].CompareTo(y[0]);
          
    }
}


class HelloWorld {
    
    // Implementing lower bound function 
    public static int lower_bound(HashSet<int> st, int x){
    
        int[] a = new int[st.Count];
        int i = 0;
        foreach(var val in st){
            a[i] = val;
            i = i + 1;
        }
        
        int l = 0;
        int h = a.Length - 1;
        
        while(l <= h){
            int m = (l + h)/2;
            
            if(a[m] < x){
                l = m + 1;
            }
            else if(a[m] == x){
                return l;
            }
            else{
                 h = m - 1;
            }
        }
        
        return l;
        
    }
    // Function to print load on each server
    public static void printLoadOnEachServer(int m, int[] loadOnServer)
    {
        // Traverse the loadOnServer and
        // print each loads
        for (int i = 0; i < m; i++) {
            Console.Write(i+1);
            Console.Write(" st Server -> ");
            Console.WriteLine(loadOnServer[i] != i ? i+1: 0);
        }
    }
    
    // Function for finding the load
    // on each server
    public static void loadBalancing(int n, int m, int[] arrivalTime, int[] processTime)
    {
        // Stores the load on each Server
        int[] loadOnServer = new int[m];

        for (int i = 0; i < m; i++) {

            // Initialize load on each
            // server as zero
            loadOnServer[i] = 0;
        }

        // Minimum priority queue for
        // storing busy servers according
        // to their release time
        List<List<int>> busyServers = new List<List<int>>();
        // priority_queue<pair<int, int>,
        //                vector<pair<int, int> >,
        //                greater<pair<int, int> > >
        //     busyServers;

        // Set to store available Servers
        HashSet<int> availableServers = new HashSet<int>();

        for (int i = 0; i < m; i++) {

            // Initially, all servers are free
            availableServers.Add(i);
        }

        // Iterating through the requests.
        for (int i = 0; i < n; i++) {

            // End time of current request
            // is the sum of arrival time
            // and process time
            int endTime = arrivalTime[i] + processTime[i];

            // Releasing all the servers which
            // have become free by this time
            while (busyServers.Count > 0 && busyServers[0][0] <= arrivalTime[i]) {

                // Pop the server
                List<int> releasedServer = busyServers[0];
                busyServers.RemoveAt(0);

                // Insert available server
                availableServers.Add(releasedServer[1]);
            }

            // If there is no free server,
            // the request is dropped
            if (availableServers.Count == 0) {
                continue;
            }

            int demandedServer = i % m;

            // Searching for demanded server
            int itr = lower_bound(availableServers, demandedServer);

            if (itr == availableServers.Count) {

                // If demanded Server is not free
                // and no server is free after it,
                // then choose first free server
                itr = availableServers.Single();
            }

            int assignedServer = itr;

            // Increasing load on assigned Server
            loadOnServer[assignedServer]++;

            // Removing assigned server from list
            // of assigned servers
            availableServers.Remove(assignedServer);

            // Add assigned server in the list of
            // busy servers with its release time
            List<int> temp = new List<int>();
            busyServers.Add(temp);
            busyServers[busyServers.Count - 1].Add(endTime);
            busyServers[busyServers.Count - 1].Add(assignedServer);
            GFG gg = new GFG();
            busyServers.Sort(gg);
        }

        // Function to print load on each server
        printLoadOnEachServer(m, loadOnServer);
    }
    
    static void Main() {
        // Given arrivalTime and processTime
        int[] arrivalTime = { 1, 2, 4, 6 };
        int[] processTime = { 7, 1, 4, 4 };

        int N = arrivalTime.Length;

        int M = 2;

        // Function Call
        loadBalancing(N, M, arrivalTime, processTime);
    }
}

// The code is contributed by Arushi Jindal.