Print Maximum Meetings in One Room

Last Updated : 12 Jul, 2025

Given n meetings in the form of start[] and end[], where start[i] is the start time of ith meeting and end[i] is the end time of ith meeting. The task is to print the meeting number of all the meetings which can be held in a single room such that total number of meetings held is maximized. The meeting room can have only one meeting at a particular time.

Note: The start time of one chosen meeting can't be equal to the end time of any other chosen meeting.

Examples:

Input: start[] = {1, 3, 0, 5, 8, 5}, end[] = {2, 4, 6, 7, 9, 9}
Output: 1 2 4 5
Explanation: We can attend the 1st meeting from (1 to 2), then the 2nd meeting from (3 to 4), then the 4th meeting from (5 to 7), and the 5th meeting from (8 to 9).
Input: start[] = {10, 12, 20}, end[] = {20, 25, 30}
Output: 1
Explanation: We can attend at most one meeting in a single meeting room.

Approach:

The idea is to use greedy approach to always choose the meeting whose
start time is greater than the end time of the previously selected meeting and
end time is the smallest among all the remaining meetings. This is because, smaller the end time, sooner the meeting will end and the meeting room will become available for the next meeting.
So, we can sort the meetings according to their end time so that we always choose the meeting which has minimum end time.

Below is the implementation of the above approach.

C++

// C++ program to print maximum meetings in one room using
// Greedy Algorithm

#include <bits/stdc++.h>
using namespace std;

struct meeting {
	int startTime, endTime, pos;
};

// custom comparator to compare meetings according to end time
bool compare(meeting m1, meeting m2) {
	return m1.endTime < m2.endTime;
}

// Function for finding maximum meeting in one room
vector<int> maxMeetings(vector<int> &start, vector<int> &end) {
    vector<int> res;
    int n = start.size();
  
    // Store details of all meetings in a vector
    vector<meeting> meets(n);
    for(int i = 0; i < n; i++) {
    	meets[i].startTime = start[i];
        meets[i].endTime = end[i];
      	meets[i].pos = i + 1;
    }
    
    // Sort the meetings according to the ending time
    sort(meets.begin(), meets.end(), compare);
    
    // Initialize current time as -1
    int currTime = -1;
    for(int i = 0; i < n; i++) {
      
        // Check if the meeting room is free at the start
        // time of ith meeting
        if(meets[i].startTime > currTime) {
        	currTime = meets[i].endTime;
            res.push_back(meets[i].pos);
        }
    }
    sort(res.begin(), res.end());
  	return res;
}

int main() {
    vector<int> start = { 1, 3, 0, 5, 8, 5 };
    vector<int> end = { 2, 4, 6, 7, 9, 9 };

    vector<int> res = maxMeetings(start, end);
  	for(int i = 0; i < res.size(); i++)
        cout << res[i] << " ";
    return 0;
}

Java

// Java program to print maximum meetings in one room using
// Greedy Algorithm

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

class Meeting {
    int startTime, endTime, pos;

    Meeting(int startTime, int endTime, int pos) {
        this.startTime = startTime;
        this.endTime = endTime;
        this.pos = pos;
    }
}

// Custom comparator to compare meetings according to end time
class MeetingComparator implements Comparator<Meeting> {
    @Override
    public int compare(Meeting m1, Meeting m2) {
        return Integer.compare(m1.endTime, m2.endTime);
    }
}

// Function for finding maximum meeting in one room
class GfG {

    static List<Integer> maxMeetings(int[] start, int[] end) {
        List<Integer> res = new ArrayList<>();
        int n = start.length;

        // Store details of all meetings in a list
        List<Meeting> meets = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            meets.add(new Meeting(start[i], end[i], i + 1));
        }

        // Sort the meetings according to the ending time
        meets.sort(new MeetingComparator());

        // Initialize current time as -1
        int currTime = -1;
        for (Meeting meeting : meets) {
            
            // Check if the meeting room is free 
            // at the start time of the meeting
            if (meeting.startTime > currTime) {
                currTime = meeting.endTime;
                res.add(meeting.pos);
            }
        }

        // Sort result array
        res.sort(Integer::compareTo);
        return res;
    }

    public static void main(String[] args) {
        int[] start = {1, 3, 0, 5, 8, 5};
        int[] end = {2, 4, 6, 7, 9, 9};

        List<Integer> res = maxMeetings(start, end);
        for (int meeting : res) {
            System.out.print(meeting + " ");
        }
    }
}

Python

# Python program to print maximum meetings in one room using
# Greedy Algorithm

class Meeting:
    def __init__(self, startTime, endTime, pos):
        self.startTime = startTime
        self.endTime = endTime
        self.pos = pos

# custom comparator to compare meetings according to end time
def compare(m1, m2):
    return m1.endTime < m2.endTime

# Function for finding maximum meeting in one room
def maxMeetings(start, end):
    res = []
    n = len(start)
  
    # Store details of all meetings in a vector
    meets = [Meeting(start[i], end[i], i + 1) for i in range(n)]
    
    # Sort the meetings according to the ending time
    meets.sort(key=lambda m: m.endTime)
    
    # Initialize current time as -1
    currTime = -1
    for i in range(n):
      
        # Check if the meeting room is free at the start
        # time of ith meeting
        if meets[i].startTime > currTime:
            currTime = meets[i].endTime
            res.append(meets[i].pos)
    
    res.sort()
    return res

if __name__ == "__main__":
    start = [1, 3, 0, 5, 8, 5]
    end = [2, 4, 6, 7, 9, 9]

    res = maxMeetings(start, end)
    for r in res:
        print(r, end=" ")

// C# program to print maximum meetings in one room using
// Greedy Algorithm

using System;
using System.Collections.Generic;
using System.Linq;

class GfG {
    struct Meeting {
        public int StartTime;
        public int EndTime;
        public int Pos;
    }

    // Custom comparator to compare meetings according to end time
    static bool Compare(Meeting m1, Meeting m2) {
        return m1.EndTime < m2.EndTime;
    }

    // Function for finding maximum meeting in one room
    static List<int> MaxMeetings(List<int> start, List<int> end) {
        List<int> res = new List<int>();
        int n = start.Count;

        // Store details of all meetings in a list
        List<Meeting> meets = new List<Meeting>(n);
        for (int i = 0; i < n; i++) {
            meets.Add(new Meeting { 
                  StartTime = start[i], EndTime = end[i], Pos = i + 1 });
        }

        // Sort the meetings according to the ending time
        meets = meets.OrderBy(m => m.EndTime).ToList();

        // Initialize current time as -1
        int currTime = -1;
        for (int i = 0; i < n; i++) {
            
            // Check if the meeting room is free at the start time of ith meeting
            if (meets[i].StartTime > currTime) {
                currTime = meets[i].EndTime;
                res.Add(meets[i].Pos);
            }
        }
        res.Sort();
        return res;
    }

    static void Main() {
        List<int> start = new List<int> { 1, 3, 0, 5, 8, 5 };
        List<int> end = new List<int> { 2, 4, 6, 7, 9, 9 };

        List<int> res = MaxMeetings(start, end);
        foreach (int meeting in res) {
            Console.Write(meeting + " ");
        }
    }
}

JavaScript

// JavaScript program to print maximum meetings in one room using
// Greedy Algorithm

class Meeting {
    constructor(startTime, endTime, pos) {
        this.startTime = startTime;
        this.endTime = endTime;
        this.pos = pos;
    }
}

// Custom comparator to compare meetings according to end time
function compare(m1, m2) {
    return m1.endTime - m2.endTime;
}

// Function for finding maximum meetings in one room
function maxMeetings(start, end) {
    let res = [];
    let n = start.length;

    // Store details of all meetings in an array
    let meets = [];
    for (let i = 0; i < n; i++) {
        meets.push(new Meeting(start[i], end[i], i + 1));
    }

    // Sort the meetings according to the ending time
    meets.sort(compare);

    // Initialize current time as -1
    let currTime = -1;
    for (let i = 0; i < n; i++) {
        // Check if the meeting room is free at the start time of ith meeting
        if (meets[i].startTime > currTime) {
            currTime = meets[i].endTime;
            res.push(meets[i].pos);
        }
    }
    
    // Sort the result array
    res.sort((a, b) => a - b);
    return res;
}

let start = [1, 3, 0, 5, 8, 5];
let end = [2, 4, 6, 7, 9, 9];

let res = maxMeetings(start, end);
console.log(res.join(" "));

Output

1 2 4 5

Time Complexity: O(n * logn) as we are sorting the meetings according to end time.
Auxiliary Space: O(n) for creating a vector of meetings to sort the meetings.

Maximum Meetings in One Room | DSA Problem

Analysis of Algorithms

ShalikramPatel

Improve

Article Tags :

Print Maximum Meetings in One Room

Similar Reads

Basics & Prerequisites

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?