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 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 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);
}
} |
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)
|
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);
}
} |
<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> |
100 200
Time Complexity: O(N * logN)
Auxiliary Space: O(N)