Maximum Number of Tasks You Can Assign - Practice Coding Problems

Maximum Number of Tasks You Can Assign - Problem

Array Two Pointers Binary Search Greedy Queue Sorting Monotonic Queue Hard

Imagine you're a project manager with n tasks to complete and m workers available. Each task has a specific strength requirement, and each worker has their own strength level. A worker can only handle a task if their strength is greater than or equal to the task's requirement.

Here's the twist: you have pills magical energy boosters that can increase any worker's strength by strength points! Each worker can receive at most one pill, and you need to decide strategically who gets them.

Goal: Determine the maximum number of tasks you can complete by optimally assigning workers to tasks and distributing the magical pills.

Input: Two arrays tasks[] and workers[] representing strength requirements and worker strengths, plus integers pills and strength.

Output: Maximum number of tasks that can be completed.

Input & Output

example_1.py — Basic Case

$ Input: {"tasks": [3,2,1], "workers": [0,3,1], "pills": 1, "strength": 3}

› Output: 3

💡 Note: We can complete all 3 tasks: assign worker with strength 3 to task requiring 3, worker with strength 1 to task requiring 1, and give a pill to worker with strength 0 (becomes 3) to handle task requiring 2.

example_2.py — Limited Pills

$ Input: {"tasks": [5,4], "workers": [0,0,0], "pills": 1, "strength": 5}

› Output: 1

💡 Note: We have 3 workers each with 0 strength, but only 1 pill that adds 5 strength. So only one worker can be enhanced to strength 5, allowing completion of only 1 task.

example_3.py — No Pills Needed

$ Input: {"tasks": [1,1,1], "workers": [10,10,10], "pills": 10, "strength": 10}

› Output: 3

💡 Note: All workers are already strong enough for all tasks, so we can complete all 3 tasks without using any pills.

Visualization

Tap to expand

Understanding the Visualization

Sort by Difficulty

Arrange tasks from easiest to hardest, and workers from weakest to strongest

Binary Search Answer

Use binary search to find the maximum number of tasks we can complete

Greedy Validation

For each candidate answer, try to complete the easiest k tasks using strongest workers first

Strategic Pill Usage

Only use pills when a normal assignment would fail, finding the weakest worker who can handle the task with a pill

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy assignment ensures we find the maximum tasks efficiently. Always tackle easiest tasks first and use pills strategically!

Time & Space Complexity

Time Complexity

⏱️

O(n log n log n)

O(n log n) for sorting, O(log n) for binary search, O(n) for each validation

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted arrays and deque for worker management

⚡ Linearithmic Space

Constraints

n == tasks.length
m == workers.length
1 ≤ n, m ≤ 5 × 10⁴
0 ≤ pills ≤ m
0 ≤ tasks[i], workers[j], strength ≤ 10⁹
Each worker can be assigned to at most one task
Each worker can receive at most one pill

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal approach uses binary search on the answer combined with a greedy validation strategy. We search for the maximum number of tasks we can complete (0 to min(n,m)), and for each candidate, we validate using a greedy approach: sort both arrays, then try to assign the easiest k tasks to workers, always preferring the strongest available worker and using pills strategically only when normal assignment fails. Time complexity: O(n log n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(n log n log n)	O(n)	Binary search on answer with greedy validation using deque
Brute Force (Try All Combinations)	O(2^m × n!)	O(m + n)	Generate all possible ways to assign pills and match workers to tasks

Binary Search + Greedy (Optimal) — Algorithm Steps

Sort both tasks and workers arrays
Binary search on the answer (0 to min(n, m) tasks)
For each candidate k, check if we can complete k tasks
Use greedy validation: try easiest k tasks with strongest workers
Use deque to efficiently manage worker assignments
Apply pills strategically when normal assignment fails

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Arrays

Sort tasks and workers by strength

Binary Search

Search for maximum achievable tasks

Greedy Validation

For each candidate, try easiest tasks first

Strategic Pills

Use pills only when necessary

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

bool canComplete(int* tasks, int* workers, int workersSize, int pills, int strength, int k) {
    if (k == 0) return true;
    
    int* availableWorkers = (int*)malloc(workersSize * sizeof(int));
    for (int i = 0; i < workersSize; i++) {
        availableWorkers[i] = workers[i];
    }
    int availableCount = workersSize;
    int pillsUsed = 0;
    
    for (int i = 0; i < k; i++) {
        int taskStrength = tasks[i];
        bool assigned = false;
        
        // Try to assign without pill first (strongest worker)
        if (availableCount > 0 && availableWorkers[availableCount-1] >= taskStrength) {
            availableCount--;
            assigned = true;
        }
        // Try with pill if possible
        else if (pillsUsed < pills) {
            for (int j = 0; j < availableCount; j++) {
                if (availableWorkers[j] + strength >= taskStrength) {
                    // Remove worker j
                    for (int l = j; l < availableCount - 1; l++) {
                        availableWorkers[l] = availableWorkers[l + 1];
                    }
                    availableCount--;
                    pillsUsed++;
                    assigned = true;
                    break;
                }
            }
        }
        
        if (!assigned) {
            free(availableWorkers);
            return false;
        }
    }
    
    free(availableWorkers);
    return true;
}

int maxTaskAssign(int* tasks, int tasksSize, int* workers, int workersSize, int pills, int strength) {
    qsort(tasks, tasksSize, sizeof(int), compare);
    qsort(workers, workersSize, sizeof(int), compare);
    
    int left = 0, right = (tasksSize < workersSize) ? tasksSize : workersSize;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canComplete(tasks, workers, workersSize, pills, strength, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    printf("Binary search + greedy approach\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n log n)

O(n log n) for sorting, O(log n) for binary search, O(n) for each validation

⚡ Linearithmic

Space Complexity

O(n)

Space for sorted arrays and deque for worker management

⚡ Linearithmic Space

Constraints

n == tasks.length
m == workers.length
1 ≤ n, m ≤ 5 × 10⁴
0 ≤ pills ≤ m
0 ≤ tasks[i], workers[j], strength ≤ 10⁹
Each worker can be assigned to at most one task
Each worker can receive at most one pill

28.5K Views

Medium Frequency

~35 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler