Maximize Profit from Task Assignment - Practice Coding Problems

Maximize Profit from Task Assignment - Problem

You're managing a freelance agency where workers with specific skill levels need to be matched with tasks that require exact skill matches. Each worker has a skill level, and each task has both a skill requirement and a profit reward.

The Challenge: You have an array workers where workers[i] represents the skill level of the i-th worker, and a 2D array tasks where tasks[i][0] is the skill requirement and tasks[i][1] is the profit for completing that task.

Key Rules:

Each worker can complete at most one task
Workers can only take tasks that exactly match their skill level
A special "super worker" joins who can complete any task regardless of skill requirement

Goal: Return the maximum total profit that can be earned by optimally assigning tasks to workers.

Example: If you have workers with skills [4, 5, 6] and tasks [[4, 10], [5, 15], [6, 20], [7, 25]], the super worker should take the highest profit task (skill 7, profit 25), while regular workers take their matching tasks for a total profit of 10 + 15 + 20 + 25 = 70.

Input & Output

example_1.py — Basic Case

$ Input: workers = [4, 5, 6], tasks = [[4, 10], [5, 15], [6, 20], [7, 25]]

› Output: 70

💡 Note: Super worker takes task [7, 25] (skill 7, profit 25). Regular workers: worker with skill 4 takes [4, 10], worker with skill 5 takes [5, 15], worker with skill 6 takes [6, 20]. Total: 25 + 10 + 15 + 20 = 70.

example_2.py — Multiple Workers Same Skill

$ Input: workers = [3, 3, 4], tasks = [[3, 1], [3, 7], [4, 5], [5, 10]]

› Output: 22

💡 Note: Super worker takes [5, 10] (highest profit). Two workers with skill 3 take both [3, 7] and [3, 1]. Worker with skill 4 takes [4, 5]. Total: 10 + 7 + 1 + 5 = 23. Wait, let me recalculate: Super takes [5, 10], one skill-3 worker takes [3, 7], another skill-3 worker takes [3, 1], skill-4 worker takes [4, 5]. Total: 10 + 7 + 1 + 5 = 23.

example_3.py — No Regular Worker Matches

$ Input: workers = [1, 2], tasks = [[3, 15], [4, 20], [5, 25]]

› Output: 25

💡 Note: No regular workers can take any tasks (skill mismatch). Super worker takes the highest profit task [5, 25]. Total profit = 25.

Constraints

1 ≤ workers.length ≤ 10⁴
1 ≤ tasks.length ≤ 10⁴
1 ≤ workers[i], tasks[i][0] ≤ 10⁵
1 ≤ tasks[i][1] ≤ 10⁵
Each worker can complete at most one task
Super worker can take any task regardless of skill requirement

Visualization

Tap to expand

Understanding the Visualization

Inventory Check

Count how many workers you have for each skill level

Prioritize Profits

Sort all tasks by profit amount (highest first)

Smart Assignment

For each high-profit task, assign to a regular worker if possible, otherwise use your super worker

Maximize Returns

Continue until all workers are assigned or no more profitable tasks remain

Key Takeaway

🎯 Key Insight: The greedy approach works because assigning the highest-profit tasks first, with the super worker's flexibility to take any task, always leads to the optimal total profit.

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a greedy approach with sorting. First, count the frequency of each skill level among workers. Then, sort tasks by profit in descending order. Finally, greedily assign the highest-profit tasks first: if a regular worker with matching skill is available, assign to them; otherwise, assign to the super worker (if not already used). This ensures maximum total profit in O(m log m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O(2^(m+n))	O(m+n)	Generate all possible task assignments and find the maximum profit
Greedy Assignment with Sorting	O(m log m + n)	O(k)	Sort tasks by profit and greedily assign highest-profit tasks first

Brute Force (Try All Assignments) — Algorithm Steps

Generate all possible assignments of tasks to regular workers
For each assignment, try assigning each remaining task to the super worker
Calculate total profit for each complete assignment
Return the maximum profit found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with all workers and super worker available

Branch

For each task, try assigning to each compatible worker

Recurse

Continue with remaining tasks and available workers

Backtrack

Return maximum profit found across all branches

Code -

solution.c — C

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

int backtrack(int taskIdx, bool* workerUsed, bool superUsed, int currentProfit,
              int* workers, int workersSize, int** tasks, int tasksSize) {
    if (taskIdx == tasksSize) {
        return currentProfit;
    }
    
    int maxProfit = currentProfit; // Skip this task
    
    // Try assigning to regular workers
    for (int i = 0; i < workersSize; i++) {
        if (!workerUsed[i] && workers[i] == tasks[taskIdx][0]) {
            workerUsed[i] = true;
            int profit = backtrack(taskIdx + 1, workerUsed, superUsed,
                                 currentProfit + tasks[taskIdx][1],
                                 workers, workersSize, tasks, tasksSize);
            if (profit > maxProfit) maxProfit = profit;
            workerUsed[i] = false;
        }
    }
    
    // Try assigning to super worker
    if (!superUsed) {
        int profit = backtrack(taskIdx + 1, workerUsed, true,
                             currentProfit + tasks[taskIdx][1],
                             workers, workersSize, tasks, tasksSize);
        if (profit > maxProfit) maxProfit = profit;
    }
    
    return maxProfit;
}

int maxProfitAssignment(int* workers, int workersSize, int** tasks, int tasksSize) {
    bool* workerUsed = (bool*)calloc(workersSize, sizeof(bool));
    int result = backtrack(0, workerUsed, false, 0, workers, workersSize, tasks, tasksSize);
    free(workerUsed);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

We try all possible assignments of m tasks to n+1 workers, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(m+n)

Space for recursion stack and storing current assignment

⚡ Linearithmic Space

31.2K Views

Medium-High Frequency

~18 min Avg. Time

856 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Assignments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler