You have n tasks and m workers. Each task has a strength requirement stored in a 0-indexed integer array tasks, with the ith task requiring tasks[i] strength to complete. The strength of each worker is stored in a 0-indexed integer array workers, with the jth worker having workers[j] strength. Each worker can only be assigned to a single task and must have a strength greater than or equal to the task's strength requirement (i.e., workers[j] >= tasks[i]).
Additionally, you have pills magical pills that will increase a worker's strength by strength. You can decide which workers receive the magical pills, however, you may only give each worker at most one magical pill.
Given the 0-indexed integer arrays tasks and workers and the integers pills and strength, return the maximum number of tasks that can be completed.
Example 1:
Input: tasks = [3,2,1], workers = [0,3,3], pills = 1, strength = 1 Output: 3 Explanation: We can assign the magical pill and tasks as follows: - Give the magical pill to worker 0. - Assign worker 0 to task 2 (0 + 1 >= 1) - Assign worker 1 to task 1 (3 >= 2) - Assign worker 2 to task 0 (3 >= 3)
Example 2:
Input: tasks = [5,4], workers = [0,0,0], pills = 1, strength = 5 Output: 1 Explanation: We can assign the magical pill and tasks as follows: - Give the magical pill to worker 0. - Assign worker 0 to task 0 (0 + 5 >= 5)
Example 3:
Input: tasks = [10,15,30], workers = [0,10,10,10,10], pills = 3, strength = 10 Output: 2 Explanation: We can assign the magical pills and tasks as follows: - Give the magical pill to worker 0 and worker 1. - Assign worker 0 to task 0 (0 + 10 >= 10) - Assign worker 1 to task 1 (10 + 10 >= 15) The last pill is not given because it will not make any worker strong enough for the last task.
Constraints:
n == tasks.lengthm == workers.length1 <= n, m <= 5 * 1040 <= pills <= m0 <= tasks[i], workers[j], strength <= 109The first approach involves using a hashmap to store and quickly access data. This is useful when you need to perform quick insertion, deletion, or access operations. You can leverage the hashmap to map keys to their respective values, which provides average O(1) time complexity for these operations.
This C program uses a simple array to implement a hashmap, with each entry as a struct to hold key-value pairs. The hash function is a basic modulus operation to ensure even distribution of keys across the array. Insertion and search operations check the mapped index for the key and perform operations appropriately.
C++
Java
Python
C#
JavaScript
The time complexity for insert and search operations in this hashmap is O(1) on average, assuming good hash distribution. The space complexity is O(n), where n is the number of entries in the hashmap.
The second approach involves using a Balanced Binary Search Tree (BST), such as an AVL tree or Red-Black tree, which organizes keys in sorted order, supporting in-order traversal and ordered operations. This is beneficial when operations requiring order (like finding the smallest/largest element) are needed alongside standard operations.
Implementing a balanced BST in C, such as an AVL tree, involves creating struct nodes with height parameters and implementing rotations for balancing after insertions. Complete implementation details require full rotation and height update mechanisms.
C++
Java
Python
C#
JavaScript
Time complexity for insert, delete, and search in a balanced BST is O(log n), where n is the number of nodes, due to the tree's height maintaining balance. Space complexity is O(n) for n nodes.
| Approach | Complexity |
|---|---|
| Approach 1: Use a HashMap | The time complexity for insert and search operations in this hashmap is O(1) on average, assuming good hash distribution. The space complexity is O(n), where n is the number of entries in the hashmap. |
| Approach 2: Balanced BST for Ordered Key Access | Time complexity for insert, delete, and search in a balanced BST is O(log n), where n is the number of nodes, due to the tree's height maintaining balance. Space complexity is O(n) for n nodes. |
How many LeetCode problems should you solve? #leetcode #techinterview #developer #softwareengineer • CrioDo • 304,653 views views
Watch 9 more video solutions →Practice Maximum Number of Tasks You Can Assign with our built-in code editor and test cases.
Practice on FleetCodePractice this problem
Open in Editor