Maximum Employees To Be Invited To A Meeting - Leetcode Solution

Problem Statement:

You are given a list of employees with their corresponding work hours. You need to schedule a meeting and invite the maximum number of employees possible. However, the total work hours of the employees invited to the meeting cannot exceed a certain threshold.

Write a function max_employee_invitees(schedule: List[Tuple[str, int]], work_hours: int) -> int that will take in a list of tuples called schedule where each tuple contains an employee’s name and work hours, and an integer work_hours, the maximum number of work hours that can be accommodated in the meeting and return the maximum number of employees that can be invited while keeping the total work hours under the threshold.

Example Input:

schedule = [('Employee A', 6), ('Employee B', 4), ('Employee C', 3), ('Employee D', 6), ('Employee E', 6)]
work_hours = 15

Example Output:

3

Explanation:

Employee A, D, and E can be invited to the meeting as their total work hours sum up to 6+6+3=15 which is equal to the maximum threshold, so the function returns 3.

Solution:

First, we need to sort the given employee schedule based on their work hours in descending order. To solve this problem, we can use two pointers, one starting from the beginning and the other one starting from the end of the list.

The idea here is to select the employee with the most number of work hours and see if adding it to the list makes the total work hours go over the maximum required hours. If it does, we drop the employee that has the least number of work hours and check again. We continue this process of adding and dropping employees until we find the maximum number of employees we can invite while keeping the total work hours under the threshold.

Here is the Python code which will implement the above approach:

from typing import List, Tuple

def max_employee_invitees(schedule: List[Tuple[str, int]], work_hours: int) -> int:
    
    # Sort the employee list based on their work hours in descending order
    schedule = sorted(schedule, key=lambda x: x[1], reverse=True)
    
    # Initialize pointers
    left, right = 0, len(schedule) - 1
    max_employees = 0
    
    # Loop through the employee list using two pointers
    while left <= right:
        total_work_hours = schedule[left][1] + schedule[right][1]
            
        # If only one employee in the list, just check if their work_hours fits in the meeting time
        if left == right:
            if total_work_hours <= work_hours:
                max_employees += 1
            break
        
        # If total work hours of both left and right pointer exceeds the threshold,
        # then we must decrement the work hours from the employee with the highest work hours
        if total_work_hours > work_hours:
            right -= 1
        else: # Else, we can add the left and right employee to the meeting
            max_employees += 2
            left += 1
            right -= 1
                
    return max_employees

We have implemented the above-mentioned algorithm using two pointers. The left pointer points at the employee with the most number of work hours, and the right pointer points at the employee with the least number of work hours.

First, we sorted the employee list based on their work hours in descending order. Then we initialized the left pointer to point at the beginning of the list and the right pointer to point at the end of the list. We also initialized a variable max_employees to keep track of the maximum number of employees that can attend the meeting.

Next, we looped through the employee list using the two pointers. We checked if the total work hours of the employees pointed by the left and right pointers are within the maximum threshold or not. If it is, then we added both employees to the meeting and increment both pointers and add 2 to the max_employees variable. If not, then we must decrement the right pointer to remove the employee with the least work hours and check again.

We terminate the loop when the left and right pointers cross or point at the same employee (which means there is only one employee left in the list). If there is only one employee left in the list, we just check if their work hours fit in the meeting time or not and update the max_employees variable accordingly.

Finally, we return the max_employees.

Complexity Analysis:

Time Complexity: sorting the array takes O(nlogn) time and then traversing the array using two pointers would take O(n) time. Hence the time complexity of the function is O(nlogn).

Space Complexity: We used only O(1) extra space, so the space complexity of the function, is O(1).

1