Open In App

Find the interval which contains maximum number of concurrent meetings

Improve
Improve
Like Article
Like
Save
Share
Report

Given a two-dimensional array arr[][] of dimensions N * 2 which contains the starting and ending time for N meetings on a given day. The task is to print a list of time slots during which the most number of concurrent meetings can be held.

Examples: 

Input: arr[][] = {{100, 300}, {145, 215}, {200, 230}, {215, 300}, {215, 400}, {500, 600}, {600, 700}} 
Output: [215, 230] 
Explanation: 
The given 5 meetings overlap at {215, 230}.

Input: arr[][] = {{100, 200}, {50, 300}, {300, 400}} 
Output: [100, 200] 
 

Approach: The idea is to use a Min-Heap to solve this problem. Below are the steps: 

  • Sort the array based on the start time of meetings.
  • Initialize a min-heap.
  • Initialize variables max_len, max_start and max_end to store maximum size of min heap, start time and end time of concurrent meetings respectively.
  • Iterate over the sorted array and keep popping from min_heap until arr[i][0] becomes smaller than the elements of the min_heap, i.e. pop all the meetings having ending time smaller than the starting time of current meeting, and push arr[i][1] in to min_heap.
  • If the size of min_heap exceeds max_len, then update max_len = size(min_heap), max_start = meetings[i][0] and max_end = min_heap_element.
  • Return the value of max_start and max_end at the end.

Below is the implementation of the above approach: 

C++14




// C++14 implementation of the
// above approach
#include <bits/stdc++.h>
using namespace std;
 
bool cmp(vector<int> a,vector<int> b)
{
 
    if(a[0] != b[0])
        return a[0] < b[0];
         
    return a[1] - b[1];
}
 
// Function to find time slot of
// maximum concurrent meeting
void maxConcurrentMeetingSlot(
    vector<vector<int>> meetings)
{
     
    // Sort array by
    // start time of meeting
    sort(meetings.begin(), meetings.end(), cmp);
 
    // Declare Minheap
    priority_queue<int, vector<int>,
                       greater<int>> pq;
     
    // Insert first meeting end time
    pq.push(meetings[0][1]);
 
    // Initialize max_len,
    // max_start and max_end
    int max_len = 0, max_start = 0;
    int max_end = 0;
 
    // Traverse over sorted array
    // to find required slot
    for(auto k : meetings)
    {
         
        // Pop all meetings that end
        // before current meeting
        while (pq.size() > 0 &&
                    k[0] >= pq.top())
            pq.pop();
 
        // Push current meeting end time
        pq.push(k[1]);
 
        // Update max_len, max_start
        // and max_end if size of
        // queue is greater than max_len
        if (pq.size() > max_len)
        {
            max_len = pq.size();
            max_start = k[0];
            max_end = pq.top();
        }
    }
 
    // Print slot of maximum
    // concurrent meeting
    cout << max_start << " " << max_end;
}
 
// Driver Code
int main()
{
     
    // Given array of meetings
    vector<vector<int>> meetings = { { 100, 200 },
                                     { 50, 300 },
                                     { 300, 400 } };
                                      
    // Function call
    maxConcurrentMeetingSlot(meetings);
}
 
// This code is contributed by mohit kumar 29


Java




// Java implementation of the
// above approach
 
import java.util.*;
import java.lang.*;
 
class GFG {
 
    // Function to find time slot of
    // maximum concurrent meeting
    static void maxConcurrentMeetingSlot(
        int[][] meetings)
    {
 
        // Sort array by
        // start time of meeting
        Arrays.sort(meetings,
                    (a, b)
                        -> (a[0] != b[0])
                               ? a[0] - b[0]
                               : a[1] - b[1]);
 
        // Declare Minheap
        PriorityQueue<Integer> pq
            = new PriorityQueue<>();
 
        // Insert first meeting end time
        pq.add(meetings[0][1]);
 
        // Initialize max_len,
        // max_start and max_end
        int max_len = 0, max_start = 0;
        int max_end = 0;
 
        // Traverse over sorted array
        // to find required slot
        for (int[] k : meetings) {
 
            // Pop all meetings that end
            // before current meeting
            while (!pq.isEmpty()
                   && k[0] >= pq.peek())
                pq.poll();
 
            // Push current meeting end time
            pq.add(k[1]);
 
            // Update max_len, max_start
            // and max_end if size of
            // queue is greater than max_len
            if (pq.size() > max_len) {
                max_len = pq.size();
                max_start = k[0];
                max_end = pq.peek();
            }
        }
 
        // Print slot of maximum
        // concurrent meeting
        System.out.println(
            max_start + " " + max_end);
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given array of meetings
        int meetings[][]
            = { { 100, 200 },
                { 50, 300 },
                { 300, 400 } };
 
        // Function Call
        maxConcurrentMeetingSlot(meetings);
    }
}


Python3




import heapq
 
 
def cmp(a, b):
    if a[0] != b[0]:
        return a[0] < b[0]
    return a[1] - b[1]
 
 
def maxConcurrentMeetingSlot(meetings):
    meetings.sort(key=lambda x: (x[0], x[1]))
 
    pq = []  # Minheap
 
    # Insert first meeting end time
    heapq.heappush(pq, meetings[0][1])
 
    # Initialize max_len, max_start, and max_end
    max_len = 0
    max_start = 0
    max_end = 0
 
    # Traverse over sorted array to find the required slot
    for k in meetings:
        # Pop all meetings that end before the current meeting
        while pq and k[0] >= pq[0]:
            heapq.heappop(pq)
 
        # Push the current meeting end time
        heapq.heappush(pq, k[1])
 
        # Update max_len, max_start, and max_end if the size of the queue is greater than max_len
        if len(pq) > max_len:
            max_len = len(pq)
            max_start = k[0]
            max_end = pq[0]
 
    # Print the slot of the maximum concurrent meeting
    print(max_start, max_end)
 
 
# Driver Code
if __name__ == "__main__":
    # Given array of meetings
    meetings = [[100, 200], [50, 300], [300, 400]]
 
    # Function call
    maxConcurrentMeetingSlot(meetings)


C#




using System;
using System.Collections.Generic;
 
class Program
{
    // Custom comparator for sorting meetings
    static int CompareMeetings(List<int> a, List<int> b)
    {
        if (a[0] != b[0])
            return a[0].CompareTo(b[0]);
        return a[1].CompareTo(b[1]);
    }
 
    // Function to find the time slot of maximum concurrent meetings
    static void MaxConcurrentMeetingSlot(List<List<int>> meetings)
    {
        // Sort the array by the start time of meetings
        meetings.Sort(CompareMeetings);
 
        // Declare MinHeap
        SortedSet<int> minHeap = new SortedSet<int>();
 
        // Insert the end time of the first meeting
        minHeap.Add(meetings[0][1]);
 
        // Initialize max_len, max_start, and max_end
        int maxLen = 0, maxStart = 0, maxEnd = 0;
 
        // Traverse over the sorted array to find the required slot
        foreach (var meeting in meetings)
        {
            // Remove all meetings that end before the current meeting
            while (minHeap.Count > 0 && meeting[0] >= minHeap.Min)
                minHeap.Remove(minHeap.Min);
 
            // Add the end time of the current meeting
            minHeap.Add(meeting[1]);
 
            // Update maxLen, maxStart, and maxEnd if the size of the
            // heap is greater than maxLen
            if (minHeap.Count > maxLen)
            {
                maxLen = minHeap.Count;
                maxStart = meeting[0];
                maxEnd = minHeap.Min;
            }
        }
 
        // Print the time slot of maximum concurrent meeting
        Console.WriteLine(maxStart + " " + maxEnd);
    }
// Driver code
    static void Main()
    {
        // Given list of meetings
        List<List<int>> meetings = new List<List<int>>()
        {
            new List<int> { 100, 200 },
            new List<int> { 50, 300 },
            new List<int> { 300, 400 }
        };
 
        // Function call
        MaxConcurrentMeetingSlot(meetings);
    }
}


Javascript




<script>
// JavaScript implementation of the above approach
 
function cmp(a, b) {
    if (a[0] !== b[0]) return a[0] - b[0];
    return a[1] - b[1];
}
 
// Function to find time slot of maximum concurrent meeting
function maxConcurrentMeetingSlot(meetings) {
    meetings.sort(cmp);
 
    // Declare Minheap
    let pq = [];
 
    // Insert first meeting end time
    pq.push(meetings[0][1]);
 
    // Initialize max_len, max_start, and max_end
    let max_len = 0,
        max_start = 0,
        max_end = 0;
 
    // Traverse over sorted array to find required slot
    for (let k of meetings) {
        // Pop all meetings that end before current meeting
        while (pq.length > 0 && k[0] >= pq[0]) pq.shift();
 
        // Push current meeting end time
        pq.push(k[1]);
        pq.sort((a, b) => a - b);
 
        // Update max_len, max_start, and max_end if size of queue is greater than max_len
        if (pq.length > max_len) {
            max_len = pq.length;
            max_start = k[0];
            max_end = pq[0];
        }
    }
 
    // Print slot of maximum concurrent meeting
    document.write(max_start + " " + max_end);
}
 
// Driver Code
let meetings = [[100, 200], [50, 300], [300, 400]];
 
// Function call
maxConcurrentMeetingSlot(meetings);
 
// This code is contributed by Susobhan Akhuli
</script>


Output

100 200






Time Complexity: O(N * logN) 
Auxiliary Space: O(N)



Last Updated : 31 Oct, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads