Open In App

Minimum halls required for class scheduling

Last Updated : 01 Feb, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

Given N lecture timings, with their start time and end time (both inclusive), the task is to find the minimum number of halls required to hold all the classes such that a single hall can be used for only one lecture at a given time. Note that the maximum end time can be 105.
Examples: 
 

Input: lectures[][] = {{0, 5}, {1, 2}, {1, 10}} 
Output:
All lectures must be held in different halls because 
at time instance 1 all lectures are ongoing.
Input: lectures[][] = {{0, 5}, {1, 2}, {6, 10}} 
Output:

Approach: 

  • Assuming that time T starts with 0. The task is to find the maximum number of lectures that are ongoing at a particular instance of time. This will give the minimum number of halls required to schedule all the lectures.
  • To find the number of lectures ongoing at any instance of time. Maintain a prefix_sum[] which will store the number of lectures ongoing at any instance of time t. For any lecture with timings between [s, t], do prefix_sum[s]++ and prefix_sum[t + 1]–.
  • Afterward, the cumulative sum of this prefix array will give the count of lectures going on at any instance of time.
  • The maximum value for any time instant t in the array is the minimum number of halls required.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
#define MAX 100001
 
// Function to return the minimum
// number of halls required
int minHalls(int lectures[][2], int n)
{
 
    // Array to store the number of
    // lectures ongoing at time t
    int prefix_sum[MAX] = { 0 };
 
    // For every lecture increment start
    // point s decrement (end point + 1)
    for (int i = 0; i < n; i++) {
        prefix_sum[lectures[i][0]]++;
        prefix_sum[lectures[i][1] + 1]--;
    }
 
    int ans = prefix_sum[0];
 
    // Perform prefix sum and update
    // the ans to maximum
    for (int i = 1; i < MAX; i++) {
        prefix_sum[i] += prefix_sum[i - 1];
        ans = max(ans, prefix_sum[i]);
    }
 
    return ans;
}
 
// Driver code
int main()
{
    int lectures[][2] = { { 0, 5 },
                          { 1, 2 },
                          { 1, 10 } };
    int n = sizeof(lectures) / sizeof(lectures[0]);
 
    cout << minHalls(lectures, n);
 
    return 0;
}


Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
static int MAX = 100001;
 
// Function to return the minimum
// number of halls required
static int minHalls(int lectures[][], int n)
{
 
    // Array to store the number of
    // lectures ongoing at time t
    int []prefix_sum = new int[MAX];
 
    // For every lecture increment start
    // point s decrement (end point + 1)
    for (int i = 0; i < n; i++)
    {
        prefix_sum[lectures[i][0]]++;
        prefix_sum[lectures[i][1] + 1]--;
    }
 
    int ans = prefix_sum[0];
 
    // Perform prefix sum and update
    // the ans to maximum
    for (int i = 1; i < MAX; i++)
    {
        prefix_sum[i] += prefix_sum[i - 1];
        ans = Math.max(ans, prefix_sum[i]);
    }
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
    int lectures[][] = {{ 0, 5 },
                        { 1, 2 },
                        { 1, 10 }};
    int n = lectures.length;
 
    System.out.println(minHalls(lectures, n));
}
}
 
// This code is contributed by PrinciRaj1992


Python3




# Python3 implementation of the approach
MAX = 100001
 
# Function to return the minimum
# number of halls required
def minHalls(lectures, n) :
 
    # Array to store the number of
    # lectures ongoing at time t
    prefix_sum = [0] * MAX;
     
    # For every lecture increment start
    # point s decrement (end point + 1)
    for i in range(n) :
        prefix_sum[lectures[i][0]] += 1;
        prefix_sum[lectures[i][1] + 1] -= 1;
         
    ans = prefix_sum[0];
     
    # Perform prefix sum and update
    # the ans to maximum
    for i in range(1, MAX) :
        prefix_sum[i] += prefix_sum[i - 1];
        ans = max(ans, prefix_sum[i]);
         
    return ans;
 
# Driver code
if __name__ == "__main__" :
 
    lectures = [[ 0, 5 ],
                [ 1, 2 ],
                [ 1, 10 ]];
                 
    n = len(lectures);
 
    print(minHalls(lectures, n));
 
# This code is contributed by AnkitRai01


C#




// C# implementation of the approach
using System;
     
class GFG
{
static int MAX = 100001;
 
// Function to return the minimum
// number of halls required
static int minHalls(int [,]lectures, int n)
{
 
    // Array to store the number of
    // lectures ongoing at time t
    int []prefix_sum = new int[MAX];
 
    // For every lecture increment start
    // point s decrement (end point + 1)
    for (int i = 0; i < n; i++)
    {
        prefix_sum[lectures[i,0]]++;
        prefix_sum[lectures[i,1] + 1]--;
    }
 
    int ans = prefix_sum[0];
 
    // Perform prefix sum and update
    // the ans to maximum
    for (int i = 1; i < MAX; i++)
    {
        prefix_sum[i] += prefix_sum[i - 1];
        ans = Math.Max(ans, prefix_sum[i]);
    }
    return ans;
}
 
// Driver code
public static void Main(String[] args)
{
    int [,]lectures = {{ 0, 5 },
                       { 1, 2 },
                       { 1, 10 }};
    int n = lectures.GetLength(0);
 
    Console.WriteLine(minHalls(lectures, n));
}
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
 
// JavaScript implementation of the approach
 
const MAX = 100001;
 
// Function to return the minimum
// number of halls required
function minHalls(lectures, n)
{
 
    // Array to store the number of
    // lectures ongoing at time t
    let prefix_sum = new Uint8Array(MAX);
 
    // For every lecture increment start
    // point s decrement (end point + 1)
    for (let i = 0; i < n; i++) {
        prefix_sum[lectures[i][0]]++;
        prefix_sum[lectures[i][1] + 1]--;
    }
 
    let ans = prefix_sum[0];
 
    // Perform prefix sum and update
    // the ans to maximum
    for (let i = 1; i < MAX; i++) {
        prefix_sum[i] += prefix_sum[i - 1];
        ans = Math.max(ans, prefix_sum[i]);
    }
 
    return ans;
}
 
// Driver code
    let lectures = [ [ 0, 5 ],
                        [ 1, 2 ],
                        [ 1, 10 ] ];
    let n = lectures.length;
 
    document.write(minHalls(lectures, n));
 
 
 
// This code is contributed by Surbhi Tyagi.
 
</script>


Output

3

Time Complexity: O(MAX)
Auxiliary Space: O(MAX), where MAX is 100001.

Another Approach:

The above approach works when MAX is limited to 105. When the limits of MAX are extended up to 109, we cannot use above approach due to Memory Limit and Time Limit Constraints.

So, we think in a different dimension, towards sorting and cumulative sum. Store the lecture time (start time and end time) in chronological order, +1 denoting the start time of a lecture and -1 denoting the end time of a lecture. Then apply the concept of cumulative sum, this gives the maximum number of lectures being conducted at a time. This gives the bare minimum number of halls that are required.

Algorithm:

  • Initialize a vector of pair, Time, the first value of which indicates the entry or exit time of lecture and the second value denotes whether the lecture starts or ends. 
  • Traverse the lectures vector and store the values in the vector Time.
  • Sort the vector Time.
  • Maintain two variables answer = 0, and sum = 0. answer denotes the final answer to be returned and sum denotes the number of lectures going on at a particular time.
  • Traverse the Time vector, add the second value of the pair into sum and update the answer variable.
  • Return answer.

Below is the implementation of the above approach: 

C++




// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum
// number of halls required
int minHalls(int lectures[][2], int n)
{
 
    // Initialize a vector of pair, Time, first value
    // indicates the time of entry or exit of a lecture
    // second value denotes whether the lecture starts or
    // ends
    vector<pair<int, int> > Time;
 
    // Store the lecture times
    for (int i = 0; i < n; i++) {
        Time.push_back({ lectures[i][0], 1 });
        Time.push_back({ lectures[i][1] + 1, -1 });
    }
 
    // Sort the vector
    sort(Time.begin(), Time.end());
 
    int answer = 0, sum = 0;
 
    // Traverse the Time vector and Update sum and answer
    // variables
    for (int i = 0; i < Time.size(); i++) {
        sum += Time[i].second;
        answer = max(answer, sum);
    }
 
    // Return the answer
    return answer;
}
 
// Driver code
int main()
{
    int lectures[][2] = { { 0, 5 }, { 1, 2 }, { 1, 10 } };
    int n = sizeof(lectures) / sizeof(lectures[0]);
 
    cout << minHalls(lectures, n);
 
    return 0;
}
 
// This code is contributed by Shatrunjay Srivastava


Java




// Java implementation of the above approach
import java.util.*;
 
class GFG {
    // Function to return the minimum
    // number of halls required
    static int minHalls(int lectures[][], int n)
    {
 
        // Initialize a vector of pair, Time, first value
        // indicates the time of entry or exit of a lecture
        // second value denotes whether the lecture starts
        // or ends
        ArrayList<pair> Time = new ArrayList<>();
 
        // Store the lecture times
        for (int i = 0; i < n; i++) {
            Time.add(new pair(lectures[i][0], 1));
            Time.add(new pair(lectures[i][1] + 1, -1));
        }
 
        // Sort the vector
        Collections.sort(Time, (pair A, pair B) -> {
            return A.first - B.first;
        });
 
        int answer = 0, sum = 0;
 
        // Traverse the Time vector and Update sum and
        // answer variables
        for (int i = 0; i < Time.size(); i++) {
            sum += Time.get(i).second;
            answer = Math.max(answer, sum);
        }
 
        // Return the answer
        return answer;
    }
 
    static class pair {
        int first, second;
        pair(int x, int y)
        {
            first = x;
            second = y;
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int lectures[][]
            = { { 0, 5 }, { 1, 2 }, { 1, 10 } };
        int n = lectures.length;
 
        System.out.println(minHalls(lectures, n));
    }
}


Python3




# Python implementation of the above approach
from typing import List
 
# Function to return the minimum
# number of halls required
def minHalls(lectures: List[List[int]], n: int) -> int:
 
    # Initialize a list of tuples, Time, first value
    # indicates the time of entry or exit of a lecture
    # second value denotes whether the lecture starts
    # or ends
    Time = []
 
    # Store the lecture times
    for i in range(n):
        Time.append((lectures[i][0], 1))
        Time.append((lectures[i][1] + 1, -1))
 
    # Sort the list
    Time.sort(key=lambda x: x[0])
 
    answer = 0
    sum = 0
 
    # Traverse the Time list and Update sum and
    # answer variables
    for i in range(len(Time)):
        sum += Time[i][1]
        answer = max(answer, sum)
 
    # Return the answer
    return answer
 
# Driver Code
if __name__ == '__main__':
    lectures = [[0, 5], [1, 2], [1, 10]]
    n = len(lectures)
 
    print(minHalls(lectures, n))


C#




// C# implementation of the above approach
using System;
using System.Collections.Generic;
 
public class Pair<T, U> {
  public Pair() {}
 
  public Pair(T first, U second)
  {
    this.First = first;
    this.Second = second;
  }
 
  public T First
  {
    get;
    set;
  }
  public U Second
  {
    get;
    set;
  }
};
class GFG {
  public static int cmp(Pair<int, int> a,
                        Pair<int, int> b)
  {
    if(a.First < b.First)
      return -1;
    else
      return 0;
  }
  // Function to return the minimum
  // number of halls required
  static int minHalls(int[, ] lectures, int n)
  {
 
    // Initialize a vector of pair, Time, first value
    // indicates the time of entry or exit of a lecture
    // second value denotes whether the lecture starts
    // or ends
    List<Pair<int, int> > Time
      = new List<Pair<int, int> >();
    // Store the lecture times
    for (int i = 0; i < n; i++) {
      Time.Add(new Pair<int, int>(lectures[i, 0], 1));
      Time.Add(new Pair<int, int>(lectures[i, 1] + 1, -1));
    }
 
    // Sort the vector
    Time.Sort(cmp);
 
    int answer = 0, sum = 0;
 
    // Traverse the Time vector and Update sum and
    // answer variables
    for (int i = 0; i < 2*n; i++) {
      sum += Time[i].Second;
      answer = Math.Max(answer, sum);
    }
 
    // Return the answer
    return answer;
  }
 
  // Driver Code
  static public void Main(String[] args)
  {
    int[,] lectures = { { 0, 5 }, { 1, 2 }, { 1, 10 } };
    int n = lectures.GetLength(0);
 
    Console.WriteLine(minHalls(lectures, n));
  }
}
 
// This code is contributed by Abhijeet Kumar(abhijeet19403)


Javascript




// JS implementation of the above approach
 
// Function to return the minimum
// number of halls required
function minHalls(lectures, n) {
    // Initialize a vector of pair, Time, first value
    // indicates the time of entry or exit of a lecture
    // second value denotes whether the lecture starts or
    // ends
    const Time = [];
 
    // Store the lecture times
    for (let i = 0; i < n; i++) {
        Time.push([lectures[i][0], 1]);
        Time.push([lectures[i][1] + 1, -1]);
    }
 
    // Sort the vector
    Time.sort((a, b) => a[0] - b[0]);
 
    let answer = 0,
        sum = 0;
 
    // Traverse the Time vector and Update sum and answer
    // variables
    for (let i = 0; i < Time.length; i++) {
        sum += Time[i][1];
        answer = Math.max(answer, sum);
    }
 
    // Return the answer
    return answer;
}
 
// Driver code
const lectures = [
    [0, 5],
    [1, 2],
    [1, 10]
];
const n = lectures.length;
 
console.log(minHalls(lectures, n));
 
// This code is contributed by phasing17


Output

3

Time Complexity: O(n*log(n))
Auxiliary Space: O(n)

Note that instead of vector of pair, one can use map or priority queue, the time complexity and space complexity would remain the same. 



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads