LeetCode 826. 安排工作以达到最大收益

826. 安排工作以达到最大收益

你有 n 个工作和 m 个工人。给定三个数组： difficulty, profit 和 worker ，其中:

• difficulty[i] 表示第 i 个工作的难度，profit[i] 表示第 i 个工作的收益。
• worker[i] 是第 i 个工人的能力，即该工人只能完成难度小于等于 worker[i] 的工作。

每个工人 最多 只能安排 一个 工作，但是一个工作可以 完成多次 。

• 举个例子，如果 3 个工人都尝试完成一份报酬为 $1 的同样工作，那么总收益为 $3 。如果一个工人不能完成任何工作，他的收益为 $0 。

返回 在把工人分配到工作岗位后，我们所能获得的最大利润 。

示例 1：

输入: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
输出: 100 
解释: 工人被分配的工作难度是 [4,4,6,6] ，分别获得 [20,20,30,30] 的收益。

示例 2:

输入: difficulty = [85,47,57], profit = [24,66,99], worker = [40,25,25]
输出: 0

提示:

• n == difficulty.length
• n == profit.length
• m == worker.length
• 1 <= n, m <= 10^4
• 1 <= difficulty[i], profit[i], worker[i] <= 10^5

解法1：排序 + 贪心 + 双指针

同类题型：LeetCode 2071. 你可以安排的最多任务数目-CSDN博客

解题思路

1. 排序：首先将任务按照难度进行排序，同时将工人的能力值也进行排序。

2. 双指针：使用双指针方法，一个指针 idx 遍历任务，另一个指针遍历工人的能力值。

3. 贪心选择：对于每个工人，找到能够完成的最大收益的任务，并累加到总收益中。

算法逻辑

• 初始化：将难度和利润组合成二维数组，并按照难度排序。同时，将工人的能力值排序。

• 遍历工人：对于每个工人，使用指针 idx 从当前最小难度的任务开始向后查找，找到所有难度不大于工人能力的任务。

• 更新最大收益：在查找的过程中，更新当前能够获得的最大收益。

• 累加收益：将找到的最大收益累加到总收益中。

• 返回结果：遍历完所有工人后，返回总收益。

深入理解

• 为什么排序：排序是为了能够快速找到对于每个工人来说难度合适的任务，以及快速更新最大收益。

• 贪心选择：在每一步选择当前能够获得的最大收益，而不是固定选择难度最低的任务，这样可以最大化总收益。

贪心双指针法是一种在解决优化问题时常用的策略，特别是在有多个选择并且需要在每一步做出最优选择的情况下。通过这种方法，可以在多项选择中快速收敛到全局最优解或近似最优解。 

1. 贪心：算法在每一步选择当前最优的解，即对于每个工人，选择当前能够获得的最大收益，而不是固定选择难度最低的任务。

2. 双指针：算法使用两个指针，一个用于遍历工人的能力值列表，另一个用于遍历按难度排序的任务列表。通过双指针的方式，可以高效地找到每个工人能够完成的最大收益任务。

Java版：

class Solution {
    public int maxProfitAssignment(int[] difficulty, int[] profit, int[] worker) {
        int n = difficulty.length;
        int[][] arr = new int[n][2];
        for (int i = 0; i < n; i++) {
            arr[i][0] = difficulty[i];
            arr[i][1] = profit[i];
        }
        Arrays.sort(arr, (a, b) -> a[0] - b[0]);
        Arrays.sort(worker);
        int idx = 0;
        int ans = 0;
        int maxprofit = 0;
        for (int w : worker) {
            while (idx < n && w >= arr[idx][0]) {
                maxprofit = Math.max(maxprofit, arr[idx][1]);
                idx++;
            }
            ans += maxprofit;
        }
        return ans;
    }
}

Python3版：

class Solution:
    def maxProfitAssignment(self, difficulty: List[int], profit: List[int], worker: List[int]) -> int:
        arr = [(d, p) for d, p in zip(difficulty, profit)]
        arr.sort(key = lambda x : x[0])
        worker.sort()
        maxprofit = 0
        ans = 0
        idx = 0
        for w in worker:
            while idx < len(profit) and w >= arr[idx][0]:
                maxprofit = max(maxprofit, arr[idx][1])
                idx += 1
            ans += maxprofit
        return ans

复杂度分析

• 时间复杂度：O(nlogn + mlogm)，其中 n 是任务的数量，m 是工人的数量。排序的时间复杂度是 O(nlogn) 和 O(mlogm)，遍历的时间复杂度是 O(n)。总的时间复杂度是O(nlogn + mlogm + n)，即 O(nlogn + mlogm)。

• 空间复杂度：O(n)，用于存储组合后的难度和利润数组。