Find Maximum Meetings in One Room

/*C++ code to find the maximum meetings in one room using greedy approach*/
#include <bits/stdc++.h>
using namespace std;

struct meet
{
    int meetingID;
    int startTime;
    int endTime;
};

bool compare(struct meet a, struct meet b)
{
    if (a.endTime == b.endTime)
    {
        return a.meetingID < b.meetingID;
    }
    else
    {
        return a.endTime < b.endTime;
    }
}

vector<int> maximumMeetings(vector<int> &start, vector<int> &end)
{
    int n = start.size();

    // Creating meeting array of size N
    struct meet meeting[n];

    for (int i = 0; i < n; i++)
    {
        meeting[i].meetingID = i + 1;
        meeting[i].startTime = start[i];
        meeting[i].endTime = end[i];
    }

    // Sorting the meeting array in increasing order of end time using customized comparator.
    sort(meeting, meeting + n, compare);

    vector<int> result;

    // Taking the first meeting of sorted array as our first meeting.
    result.push_back(meeting[0].meetingID);
    int currentTime = meeting[0].endTime;

    for (int i = 1; i < n; i++)
    {

        // If startTime of current meeting is greater than our currentTime.
        // Then we will perform this meeting and update currentTime with endTime of the meeting.
        if (meeting[i].startTime > currentTime)
        {
            result.push_back(meeting[i].meetingID);
            currentTime = meeting[i].endTime;
        }
    }

    return result;
}

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

    vector<int> result = maximumMeetings(start, end);
    cout << "The meetings that can be scheduled in one room such that number of meetings is maximum are:\n";
    for (int a : result)
    {
        cout << a << " ";
    }
}

You can also try this code with Online C++ Compiler

Run Code

// Java program to find maximum number of meetings in one room
import java.util.*;
 
/*The comparator function compares the meeting's finish time and sorts the results.*/
class mycomparator implements Comparator<meeting>
{
    @Override
    public int compare(meeting obj1, meeting obj2)
    {
        if (obj1.endOfMeeting < obj2.endOfMeeting)
        {
            
            // If the second item is larger than the first, return -1.
            return -1;
        }
        else if (obj1.endOfMeeting > obj2.endOfMeeting)
        
            // If the second item is smaller than the first, return 1.
            return 1;
            
        return 0;
    }
}
 
/*Custom class for storing meeting start and end times, as well as meeting location.*/
class meeting
{
    int startOfMeeting;
    int endOfMeeting;
    int posOfMeeting;
    
    meeting(int startOfMeeting, int endOfMeeting, int posOfMeeting)
    {
        this.startOfMeeting = startOfMeeting;
        this.endOfMeeting = endOfMeeting;
        this.posOfMeeting = posOfMeeting;
    }
}
 
class Main{
    
// Finding the most meetings in a single room is a function.
public static void maximumMeeting(ArrayList<meeting> alVar, int s)
{
    
    // Setting up an arraylist to store the response
    ArrayList<Integer> myAl = new ArrayList<>();
    
    int time_limit = 0;
    
    mycomparator mcomp = new mycomparator();
    
    // Meetings are arranged in order of their completion time.
    Collections.sort(alVar, mcomp);
    
    // To begin, choose the first meeting.
    myAl.add(alVar.get(0).posOfMeeting);
    
    // To see if a new meeting may be held, use the time_limit parameter.
    time_limit = alVar.get(0).endOfMeeting;
    
    // Check whether all meetings can be selected or not.
    for(int i = 1; i < alVar.size(); i++)
    {
        if (alVar.get(i).startOfMeeting > time_limit)
        {
            
            // Add a meeting to the arraylist that you've chosen.
            myAl.add(alVar.get(i).posOfMeeting);
            
            // Time limit updates
            time_limit = alVar.get(i).endOfMeeting;
        }
    }
    
    // Print the final list of meetings.
    for(int i = 0; i < myAl.size(); i++)
        System.out.print(myAl.get(i) + 1 + " ");
}
 

public static void main (String[] args)
{
    
    // Starting_time
    int start[] = { 1, 3, 0, 5, 8, 5 };
    
    // End_time
    int end[] = { 2, 4, 6, 7, 9, 9 }; 
    
    // Creating a meet type arraylist
    ArrayList<meeting> meetAl = new ArrayList<>();
    for(int i = 0; i < start.length; i++)
    
        // Creating a meeting object and adding it to the list
        meetAl.add(new meeting(start[i], end[i], i));
        
    // Function_Call
    System.out.println("The meetings that can be scheduled in one room such that number of meetings is maximum are:");
    maximumMeeting(meetAl, meetAl.size());
}
}

You can also try this code with Online Java Compiler

Run Code

# Python program to find maximum number of meetings in one room
 
# For storing the start time, create a custom class.
# Time and location of the meeting's conclusion.
class meeting:
    
    def __init__(self, start, end, pos):
        
        self.start = start
        self.end = end
        self.pos = pos
 
# Function for finding maximum meeting in one room
def maxMeeting(l, n):
 
    # Setting up an arraylist to store the response
    ans = []
    
    # Meetings are arranged in order of their completion time.
    l.sort(key = lambda x: x.end)
 
    # To begin, choose the first meeting.
    ans.append(l[0].pos)
 
    # To see if a new meeting may be held, use the time_limit parameter.
    time_limit = l[0].end
    
    # Check whether all meetings can be selected or not.
    for i in range(1, n):
        if l[i].start > time_limit:
            ans.append(l[i].pos)
            time_limit = l[i].end
            
    # Print the final list of meetings.
    for i in ans:
        print(i + 1, end = " ")
        
    print()

if __name__ == '__main__':
    
    # Starting_time
    start = [ 1, 3, 0, 5, 8, 5 ]
 
    # End_time
    end = [ 2, 4, 6, 7, 9, 9 ]
 
    # NumberOfMeetings
    n = len(start)
 
    l = []
 
    for i in range(n):
        
        # Creating a meeting object and adding it to the list
        l.append(meeting(start[i], end[i], i))
    print("The meetings that can be scheduled in one room such that number of meetings is maximum are:")     
    # FunctionCall
    maxMeeting(l, n)

You can also try this code with Online Python Compiler

Run Code