上课时间表所需的最低礼堂

给定N个授课时间，包括开始时间和结束时间(包括结束时间)，任务是找到举行所有课程所需的最小教室数量，以使单个大厅在给定时间只能用于一次讲座。请注意，最大结束时间可以是10 ⁵ 。

例子：

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

方法：

• 假设时间T从0开始。任务是找到在特定时间实例正在进行的最大讲座数。这将为安排所有讲座提供最少的礼堂数量。
• 查找在任何时间进行的讲座数量。维护一个prefix_sum []，它将存储在任何时间t进行的讲座数。对于时间在[s，t]之间的任何演讲，请执行prefix_sum [s] ++和prefix_sum [t + 1] –。
• 之后，此前缀数组的累加总和将提供在任何时间实例上正在进行的讲座的数量。
• 数组中任何时刻t的最大值是所需的最小霍尔数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
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

输出：

3