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.

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

Visualization

Tap to expand

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

✓ Binary Search + Greedy (Optimal)

⏱️ Time: O(n log n log n) Space: O(n)

This optimal approach uses binary search on the number of tasks we can complete. For each candidate answer, we validate if it's achievable using a greedy strategy: sort tasks and workers, then try to assign the easiest remaining tasks to the strongest available workers, using pills strategically only when necessary.

Brute Force (Try All Combinations)

⏱️ Time: O(2^m × n!) Space: O(m + n)

This approach tries every possible combination of giving pills to workers, then for each combination, attempts to find the maximum matching between enhanced workers and tasks. It uses recursive backtracking to explore all possibilities.

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>
#include <string.h>

static int tasks[50001], workers[50001];

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;
    
    // Process tasks from hardest to easiest (k-1 down to 0)
    for (int i = k - 1; i >= 0; i--) {
        int taskStrength = tasks[i];
        bool assigned = false;
        
        // Try to assign with strongest worker without pill first
        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() {
    char line[200000];
    
    // Read tasks
    fgets(line, sizeof(line), stdin);
    int tasksSize = 0;
    char* token = strtok(line, ",\n");
    while (token != NULL) {
        tasks[tasksSize++] = atoi(token);
        token = strtok(NULL, ",\n");
    }
    
    // Read workers
    fgets(line, sizeof(line), stdin);
    int workersSize = 0;
    token = strtok(line, ",\n");
    while (token != NULL) {
        workers[workersSize++] = atoi(token);
        token = strtok(NULL, ",\n");
    }
    
    // Read pills and strength
    int pills, strength;
    scanf("%d", &pills);
    scanf("%d", &strength);
    
    printf("%d\n", maxTaskAssign(tasks, tasksSize, workers, workersSize, pills, strength));
    
    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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for sorted arrays and deque for worker management

⚡ Linearithmic Space

28.6K 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

Maximum Number of Tasks You Can Assign - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler