Most Profit Assigning Work - Practice Coding Problems

Most Profit Assigning Work - Problem

Imagine you're running a freelance job marketplace where you need to assign workers to projects to maximize total profit! 💼

You have n jobs and m workers. Each job has a specific difficulty level and profit amount. Each worker has a certain ability level - they can only complete jobs with difficulty at most equal to their ability.

Key Rules:

Every worker can be assigned at most one job
One job can be completed by multiple workers (think of it as identical tasks)
If a worker can't complete any job, they earn $0

Goal: Return the maximum total profit you can achieve by optimally assigning workers to jobs.

Example: If you have 3 workers who can all do a job that pays $5, your total profit would be $15!

Input & Output

example_1.py — Basic Assignment

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

› Output: 100

💡 Note: Workers with abilities [4,5,6,7] can do jobs with max difficulties [4,4,6,6] earning profits [20,20,30,30]. Total = 20+20+30+30 = 100.

example_2.py — Some Workers Can't Work

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

› Output: 0

💡 Note: All workers have abilities less than the minimum job difficulty (47), so no one can work. Total profit = 0.

example_3.py — Multiple Workers Same Job

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

› Output: 60

💡 Note: All three workers have ability 4, so they can all do the job with difficulty 4 and profit 20. Total = 20+20+20 = 60.

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⁵
Each worker can be assigned at most one job
Each job can be completed by multiple workers

Asked in

The optimal solution uses sorting + preprocessing + binary search to achieve O(n log n + m log n) time complexity. First, sort jobs by difficulty and precompute maximum profits. Then, for each worker, use binary search to find their optimal job assignment in O(log n) time. This approach scales much better than the brute force O(n × m) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sort + Greedy)	O(n log n + m log n)	O(n)	Sort jobs by difficulty, precompute max profits, then assign optimally
Brute Force (Check Every Job)	O(n × m)	O(1)	For each worker, check all jobs and find the highest profit they can earn
Sorting + Binary Search (Optimal)	O(n log n + m log n)	O(n)	Sort jobs with preprocessing, then use binary search for each worker assignment

Two Pointers (Sort + Greedy) — Algorithm Steps

Create (difficulty, profit) pairs and sort by difficulty
Preprocess to compute maximum profit at each difficulty level
For each worker, find the best job they can handle using the preprocessed data
Sum up all the profits

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Jobs by Difficulty

Arrange jobs in ascending order of difficulty

Precompute Max Profits

For each difficulty level, store the maximum profit achievable

Binary Search Assignment

Each worker quickly finds their optimal job using binary search

Code -

solution.c — C

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

typedef struct {
    int difficulty;
    int profit;
} Job;

int compare(const void* a, const void* b) {
    Job* jobA = (Job*)a;
    Job* jobB = (Job*)b;
    return jobA->difficulty - jobB->difficulty;
}

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

int maxProfitAssignment(int* difficulty, int diffSize, int* profit, int profSize, int* worker, int workSize) {
    // Create jobs array and sort by difficulty
    Job* jobs = (Job*)malloc(diffSize * sizeof(Job));
    for (int i = 0; i < diffSize; i++) {
        jobs[i].difficulty = difficulty[i];
        jobs[i].profit = profit[i];
    }
    qsort(jobs, diffSize, sizeof(Job), compare);
    
    // Preprocess: compute max profit up to each difficulty
    int maxProfitSoFar = 0;
    for (int i = 0; i < diffSize; i++) {
        maxProfitSoFar = max(maxProfitSoFar, jobs[i].profit);
        jobs[i].profit = maxProfitSoFar;
    }
    
    int totalProfit = 0;
    
    // For each worker, find the best job they can do
    for (int i = 0; i < workSize; i++) {
        int w = worker[i];
        int left = 0, right = diffSize - 1;
        int bestProfit = 0;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (jobs[mid].difficulty <= w) {
                bestProfit = jobs[mid].profit;
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        totalProfit += bestProfit;
    }
    
    free(jobs);
    return totalProfit;
}

int main() {
    int difficulty[1000], profit[1000], worker[1000];
    int n, m;
    
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &difficulty[i]);
    }
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &profit[i]);
    }
    
    scanf("%d", &m);
    for (int i = 0; i < m; i++) {
        scanf("%d", &worker[i]);
    }
    
    printf("%d\n", maxProfitAssignment(difficulty, n, profit, n, worker, m));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log n)

O(n log n) to sort jobs, O(n) to preprocess max profits, O(m log n) for binary search per worker

⚡ Linearithmic

Space Complexity

O(n)

Space for storing job pairs and preprocessed maximum profits

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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