Minimum halls required for class scheduling
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: 3
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: 2
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++
#include <bits/stdc++.h>
using namespace std;
#define MAX 100001
int minHalls( int lectures[][2], int n)
{
int prefix_sum[MAX] = { 0 };
for ( int i = 0; i < n; i++) {
prefix_sum[lectures[i][0]]++;
prefix_sum[lectures[i][1] + 1]--;
}
int ans = prefix_sum[0];
for ( int i = 1; i < MAX; i++) {
prefix_sum[i] += prefix_sum[i - 1];
ans = max(ans, prefix_sum[i]);
}
return ans;
}
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
import java.util.*;
class GFG
{
static int MAX = 100001 ;
static int minHalls( int lectures[][], int n)
{
int []prefix_sum = new int [MAX];
for ( int i = 0 ; i < n; i++)
{
prefix_sum[lectures[i][ 0 ]]++;
prefix_sum[lectures[i][ 1 ] + 1 ]--;
}
int ans = prefix_sum[ 0 ];
for ( int i = 1 ; i < MAX; i++)
{
prefix_sum[i] += prefix_sum[i - 1 ];
ans = Math.max(ans, prefix_sum[i]);
}
return ans;
}
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
MAX = 100001
def minHalls(lectures, n) :
prefix_sum = [ 0 ] * MAX ;
for i in range (n) :
prefix_sum[lectures[i][ 0 ]] + = 1 ;
prefix_sum[lectures[i][ 1 ] + 1 ] - = 1 ;
ans = prefix_sum[ 0 ];
for i in range ( 1 , MAX ) :
prefix_sum[i] + = prefix_sum[i - 1 ];
ans = max (ans, prefix_sum[i]);
return ans;
if __name__ = = "__main__" :
lectures = [[ 0 , 5 ],
[ 1 , 2 ],
[ 1 , 10 ]];
n = len (lectures);
print (minHalls(lectures, n));
|
C#
using System;
class GFG
{
static int MAX = 100001;
static int minHalls( int [,]lectures, int n)
{
int []prefix_sum = new int [MAX];
for ( int i = 0; i < n; i++)
{
prefix_sum[lectures[i,0]]++;
prefix_sum[lectures[i,1] + 1]--;
}
int ans = prefix_sum[0];
for ( int i = 1; i < MAX; i++)
{
prefix_sum[i] += prefix_sum[i - 1];
ans = Math.Max(ans, prefix_sum[i]);
}
return ans;
}
public static void Main(String[] args)
{
int [,]lectures = {{ 0, 5 },
{ 1, 2 },
{ 1, 10 }};
int n = lectures.GetLength(0);
Console.WriteLine(minHalls(lectures, n));
}
}
|
Javascript
<script>
const MAX = 100001;
function minHalls(lectures, n)
{
let prefix_sum = new Uint8Array(MAX);
for (let i = 0; i < n; i++) {
prefix_sum[lectures[i][0]]++;
prefix_sum[lectures[i][1] + 1]--;
}
let ans = prefix_sum[0];
for (let i = 1; i < MAX; i++) {
prefix_sum[i] += prefix_sum[i - 1];
ans = Math.max(ans, prefix_sum[i]);
}
return ans;
}
let lectures = [ [ 0, 5 ],
[ 1, 2 ],
[ 1, 10 ] ];
let n = lectures.length;
document.write(minHalls(lectures, n));
</script>
|
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++
#include <bits/stdc++.h>
using namespace std;
int minHalls( int lectures[][2], int n)
{
vector<pair< int , int > > Time;
for ( int i = 0; i < n; i++) {
Time.push_back({ lectures[i][0], 1 });
Time.push_back({ lectures[i][1] + 1, -1 });
}
sort(Time.begin(), Time.end());
int answer = 0, sum = 0;
for ( int i = 0; i < Time.size(); i++) {
sum += Time[i].second;
answer = max(answer, sum);
}
return answer;
}
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
import java.util.*;
class GFG {
static int minHalls( int lectures[][], int n)
{
ArrayList<pair> Time = new ArrayList<>();
for ( int i = 0 ; i < n; i++) {
Time.add( new pair(lectures[i][ 0 ], 1 ));
Time.add( new pair(lectures[i][ 1 ] + 1 , - 1 ));
}
Collections.sort(Time, (pair A, pair B) -> {
return A.first - B.first;
});
int answer = 0 , sum = 0 ;
for ( int i = 0 ; i < Time.size(); i++) {
sum += Time.get(i).second;
answer = Math.max(answer, sum);
}
return answer;
}
static class pair {
int first, second;
pair( int x, int y)
{
first = x;
second = y;
}
}
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
from typing import List
def minHalls(lectures: List [ List [ int ]], n: int ) - > int :
Time = []
for i in range (n):
Time.append((lectures[i][ 0 ], 1 ))
Time.append((lectures[i][ 1 ] + 1 , - 1 ))
Time.sort(key = lambda x: x[ 0 ])
answer = 0
sum = 0
for i in range ( len (Time)):
sum + = Time[i][ 1 ]
answer = max (answer, sum )
return answer
if __name__ = = '__main__' :
lectures = [[ 0 , 5 ], [ 1 , 2 ], [ 1 , 10 ]]
n = len (lectures)
print (minHalls(lectures, n))
|
C#
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;
}
static int minHalls( int [, ] lectures, int n)
{
List<Pair< int , int > > Time
= new List<Pair< int , int > >();
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));
}
Time.Sort(cmp);
int answer = 0, sum = 0;
for ( int i = 0; i < 2*n; i++) {
sum += Time[i].Second;
answer = Math.Max(answer, sum);
}
return answer;
}
static public void Main(String[] args)
{
int [,] lectures = { { 0, 5 }, { 1, 2 }, { 1, 10 } };
int n = lectures.GetLength(0);
Console.WriteLine(minHalls(lectures, n));
}
}
|
Javascript
function minHalls(lectures, n) {
const Time = [];
for (let i = 0; i < n; i++) {
Time.push([lectures[i][0], 1]);
Time.push([lectures[i][1] + 1, -1]);
}
Time.sort((a, b) => a[0] - b[0]);
let answer = 0,
sum = 0;
for (let i = 0; i < Time.length; i++) {
sum += Time[i][1];
answer = Math.max(answer, sum);
}
return answer;
}
const lectures = [
[0, 5],
[1, 2],
[1, 10]
];
const n = lectures.length;
console.log(minHalls(lectures, n));
|
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.
Last Updated :
01 Feb, 2024
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...