Maximize Profit from Task Assignment

Maximize Profit from Task Assignment - Problem

You are given an integer array workers, where workers[i] represents the skill level of the i-th worker. You are also given a 2D integer array tasks, where:

tasks[i][0] represents the skill requirement needed to complete the task
tasks[i][1] represents the profit earned from completing the task

Each worker can complete at most one task, and they can only take a task if their skill level is equal to the task's skill requirement. An additional worker joins today who can take up any task, regardless of the skill requirement.

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

Input & Output

Example 1 — Basic Assignment

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

› Output: 16

💡 Note: Worker with skill 1 takes task [1,7] for profit 7, worker with skill 2 takes task [2,4] for profit 4, worker with skill 3 takes task [3,5] for profit 5. Total profit = 7 + 4 + 5 = 16

Example 2 — Super Worker Needed

$ Input: workers = [1,1], tasks = [[1,5],[2,6],[1,3]]

› Output: 14

💡 Note: Two workers with skill 1 can take tasks [1,5] and [1,3] for profit 5+3=8. Super worker takes remaining task [2,6] for profit 6. Total = 8 + 6 = 14

Example 3 — More Tasks Than Workers

$ Input: workers = [2], tasks = [[1,8],[2,7],[3,6]]

› Output: 15

💡 Note: Regular worker with skill 2 takes task [2,7] for profit 7. Super worker takes highest remaining task [1,8] for profit 8. Total = 7 + 8 = 15

Constraints

1 ≤ workers.length ≤ 10⁵
1 ≤ tasks.length ≤ 10⁵
1 ≤ workers[i], tasks[i][0] ≤ 10⁵
1 ≤ tasks[i][1] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use a greedy approach: sort tasks by profit descending and assign high-profit tasks to available workers first. The super worker gets the highest-profit task that regular workers can't handle. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Assignments

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

Try every possible way to assign tasks to workers, including all combinations of which tasks the super-worker takes. For each assignment, check if it's valid and calculate total profit.

Greedy - Sort by Profit

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

Sort tasks by profit in descending order. For each task, try to assign it to a regular worker first. If no regular worker can handle it, assign to the super worker if available.

Optimal - Maximum Bipartite Matching

⏱️ Time: O(n²m) Space: O(nm)

Model as a bipartite matching problem with workers on one side and tasks on the other. Find the maximum weighted matching to get optimal profit assignment. The super worker can be treated as connected to all tasks.

Brute Force - Try All Assignments — Algorithm Steps

Generate all possible task assignments
For each assignment, verify workers can handle their tasks
Calculate total profit for valid assignments
Return maximum profit found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Assignments

Try every possible way to assign tasks

Check Validity

Verify workers can handle assigned tasks

Find Maximum

Return highest profit combination

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int parseArrays(char* input, int*** arrays, int** arraySizes) {
    int arrayCount = 0;
    *arrays = malloc(100 * sizeof(int*));
    *arraySizes = malloc(100 * sizeof(int));
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (!*ptr) return 0;
    ptr++; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // Skip '['
            (*arrays)[arrayCount] = malloc(500 * sizeof(int));
            (*arraySizes)[arrayCount] = 0;
            
            while (*ptr && *ptr != ']') {
                if (isdigit(*ptr) || *ptr == '-') {
                    int num = 0;
                    int sign = 1;
                    if (*ptr == '-') {
                        sign = -1;
                        ptr++;
                    }
                    while (isdigit(*ptr)) {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    (*arrays)[arrayCount][(*arraySizes)[arrayCount]++] = sign * num;
                } else {
                    ptr++;
                }
            }
            if (*ptr == ']') ptr++; // Skip ']'
            arrayCount++;
        } else {
            ptr++;
        }
    }
    
    return arrayCount;
}

int solution(int** arrays, int* arraySizes, int arrayCount) {
    int maxDistance = 0;
    
    for (int i = 0; i < arrayCount; i++) {
        for (int j = 0; j < arrayCount; j++) {
            if (i != j) {
                for (int x = 0; x < arraySizes[i]; x++) {
                    for (int y = 0; y < arraySizes[j]; y++) {
                        maxDistance = max(maxDistance, abs_val(arrays[i][x] - arrays[j][y]));
                    }
                }
            }
        }
    }
    
    return maxDistance;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int** arrays;
    int* arraySizes;
    int arrayCount = parseArrays(input, &arrays, &arraySizes);
    
    if (arrayCount == 0) {
        printf("0\n");
        return 0;
    }
    
    int result = solution(arrays, arraySizes, arrayCount);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n+m))

Must try all possible combinations of task assignments to workers

⚠ Quadratic Growth

Space Complexity

O(n+m)

Recursion stack for generating combinations

⚡ Linearithmic Space

34.2K Views

Medium Frequency

~25 min Avg. Time

890 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