Minimum halls required for class scheduling - GeeksforGeeks

25 May, 2021
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++
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; #define MAX 100001 // Function to return the minimum// number of halls requiredint 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 codeint main(){    int lectures[][2] = { { 0, 5 },                          { 1, 2 },                          { 1, 10 } };    int n = sizeof(lectures) / sizeof(lectures[0]);     cout << minHalls(lectures, n);     return 0;}
// Java implementation of the approachimport java.util.*; class GFG{static int MAX = 100001; // Function to return the minimum// number of halls requiredstatic 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 codepublic 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 implementation of the approachMAX = 100001 # Function to return the minimum# number of halls requireddef 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 codeif __name__ == "__main__" :     lectures = [[ 0, 5 ],                [ 1, 2 ],                [ 1, 10 ]];                     n = len(lectures);     print(minHalls(lectures, n)); # This code is contributed by AnkitRai01
// C# implementation of the approachusing System;     class GFG{static int MAX = 100001; // Function to return the minimum// number of halls requiredstatic 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 codepublic 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
<script> // JavaScript implementation of the approach const MAX = 100001; // Function to return the minimum// number of halls requiredfunction 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>
3
 
ankthon
princiraj1992
29AjayKumar
surbhityagi15
prefix-sum
Arrays
Dynamic Programming
Greedy
prefix-sum
Arrays
Dynamic Programming
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Next Greater Element
Window Sliding Technique
Count pairs with given sum
Program to find sum of elements in a given array
Reversal algorithm for array rotation
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Longest Increasing Subsequence | DP-3