LeetCode 826. Most Profit Assigning Work

原题链接在这里：https://leetcode.com/problems/most-profit-assigning-work/

题目：

We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job. 

Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i]. 

Every worker can be assigned at most one job, but one job can be completed multiple times.

For example, if 3 people attempt the same job that pays $1, then the total profit will be $3.  If a worker cannot complete any job, his profit is $0.

What is the most profit we can make?

Example 1:

Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Output: 100 
Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.

Notes:

• 1 <= difficulty.length = profit.length <= 10000
• 1 <= worker.length <= 10000
• difficulty[i], profit[i], worker[i]  are in range [1, 10^5]

题解：

Pair the difficulty and profit into job.

Sort jobs based on difficulty. And sort the worker.

Get the first worker, go through jobs from beginning and update its best profit as long as worker could accomplish job difficulity.

For the next worker, it doesn't need to iterate from beginning again, it could start from previous position, because it can do more difficult job than previous worker. So, we only need to iterate jobs once.

Like there are two pointers, one pointing at job and the other pointing at worker. For next pointer at worker, job pointer only need to move forward, not backword.

Time Complexity: O(nlogn + wlogw). n = difficulty.length. w = worker.length.

Space: O(n).

AC Java: 

class Solution {
    public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
        int n = difficulty.length;
        Job [] jobs = new Job[n];
        for(int i = 0; i<n; i++){
            jobs[i] = new Job(difficulty[i], profit[i]);
        }
        
        Arrays.sort(jobs, (a, b) -> a.diff-b.diff);
        Arrays.sort(worker);
        int i = 0;
        int best = 0;
        int res = 0;
        for(int w : worker){
            while(i<n && w>=jobs[i].diff){
                best = Math.max(best, jobs[i].profit);
                i++;
            }
            
            res += best;
        }
        
        return res;
    }
}

class Job{
    int diff;
    int profit;
    public Job(int diff, int profit){
        this.diff = diff;
        this.profit = profit;
    }
}