Most Profit Assigning Work

Most Profit Assigning Work - Problem

You have n jobs and m workers. You are given three arrays:

difficulty[i] and profit[i] are the difficulty and profit of the i-th job
worker[j] is the ability of the j-th worker (can only complete jobs with difficulty ≤ worker[j])

Rules:

Every worker can be assigned at most one job
One job can be completed multiple times by different workers
If a worker cannot complete any job, their profit is 0

Return the maximum profit we can achieve after assigning workers to jobs optimally.

Input & Output

Example 1 — Basic Assignment

$ Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]

› Output: 100

💡 Note: Worker 1 (ability=4): can do jobs 1,2 → best profit=20. Worker 2 (ability=5): can do jobs 1,2 → best profit=20. Worker 3 (ability=6): can do jobs 1,2,3 → best profit=30. Worker 4 (ability=7): can do jobs 1,2,3 → best profit=30. Total: 20+20+30+30=100

Example 2 — Some Workers Get No Job

$ Input: difficulty = [85,47,57], profit = [24,66,99], worker = [40,25,25]

› Output: 0

💡 Note: All workers have abilities (40,25,25) but minimum job difficulty is 47. No worker can complete any job, so total profit is 0.

Example 3 — Multiple Workers Same Job

$ Input: difficulty = [68,35,52], profit = [90,17,68], worker = [79,45,85]

› Output: 197

💡 Note: Worker 1 (ability=79): can do all jobs → best profit=90. Worker 2 (ability=45): can do job 2 only (diff=35) → profit=17. Worker 3 (ability=85): can do all jobs → best profit=90. Total: 90+17+90=197

Constraints

1 ≤ difficulty.length ≤ 10⁴
1 ≤ profit.length ≤ 10⁴
difficulty.length = profit.length
1 ≤ worker.length ≤ 10⁴
1 ≤ difficulty[i], profit[i], worker[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 12 A Amazon 8 f Facebook 6 M Microsoft 5

The key insight is to preprocess jobs by sorting them by difficulty and precomputing maximum profits at each level. This allows us to use binary search to find the best job for each worker in O(log n) time. Best approach achieves O(n log n + m log n) time complexity with O(n) space.

Common Approaches

✓ Brute Force - Check All Jobs

⏱️ Time: O(n×m) Space: O(1)

For every worker, iterate through all jobs to find those they can complete (difficulty ≤ ability), then select the job with maximum profit.

Precompute Maximum Profits

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

Sort jobs by difficulty and precompute the maximum profit achievable up to each difficulty level. For each worker, use binary search to find the highest difficulty they can handle, then lookup the precomputed maximum profit.

Sort Jobs by Difficulty

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

First sort jobs by difficulty. For each worker, use binary search to find the range of jobs they can do, then scan that range for maximum profit.

Brute Force - Check All Jobs — Algorithm Steps

For each worker
Check all jobs they can complete
Select job with maximum profit
Add to total profit

Visualization

Tap to expand

Step-by-Step Walkthrough

Worker Selection

Pick a worker with specific ability

Job Scanning

Check all jobs to find compatible ones

Profit Maximization

Select job with highest profit among compatible jobs

Code -

solution.c — C

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

int solution(int* difficulty, int diffSize, int* profit, int profitSize, int* worker, int workerSize) {
    int totalProfit = 0;
    
    for (int i = 0; i < workerSize; i++) {
        int maxProfit = 0;
        for (int j = 0; j < diffSize; j++) {
            if (difficulty[j] <= worker[i]) {
                if (profit[j] > maxProfit) {
                    maxProfit = profit[j];
                }
            }
        }
        totalProfit += maxProfit;
    }
    
    return totalProfit;
}

int* parseArray(char* str, int* size) {
    int* arr = malloc(1000 * sizeof(int));
    *size = 0;
    char* token = strtok(str, "[],");
    while (token != NULL) {
        arr[(*size)++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    return arr;
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    int diffSize;
    int* difficulty = parseArray(line, &diffSize);
    
    fgets(line, sizeof(line), stdin);
    int profitSize;
    int* profit = parseArray(line, &profitSize);
    
    fgets(line, sizeof(line), stdin);
    int workerSize;
    int* worker = parseArray(line, &workerSize);
    
    printf("%d\n", solution(difficulty, diffSize, profit, profitSize, worker, workerSize));
    
    free(difficulty);
    free(profit);
    free(worker);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

For each of m workers, we check all n jobs

⚡ Linearithmic

Space Complexity

O(1)

Only using variables to track maximum profit

⚡ Linearithmic Space

32.5K 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 - Check All Jobs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler