力扣2071——你可以安排的最多任务数目（二分答案+贪心）

题目（困难）

给你 n 个任务和 m 个工人。每个任务需要一定的力量值才能完成，需要的力量值保存在下标从 0 开始的整数数组 tasks 中，第 i 个任务需要 tasks[i] 的力量才能完成。每个工人的力量值保存在下标从 0 开始的整数数组 workers 中，第 j 个工人的力量值为 workers[j] 。每个工人只能完成 一个 任务，且力量值需要 大于等于 该任务的力量要求值（即 workers[j] >= tasks[i] ）。

除此以外，你还有 pills 个神奇药丸，可以给 一个工人的力量值 增加 strength 。你可以决定给哪些工人使用药丸，但每个工人 最多 只能使用 一片 药丸。

给你下标从 0 开始的整数数组tasks 和 workers 以及两个整数 pills 和 strength ，请你返回 最多 有多少个任务可以被完成。

示例 1：

输入：tasks = [3,2,1], workers = [0,3,3], pills = 1, strength = 1
输出：3
解释：
我们可以按照如下方案安排药丸：

• 给 0 号工人药丸。
• 0 号工人完成任务 2（0 + 1 >= 1）
• 1 号工人完成任务 1（3 >= 2）
• 2 号工人完成任务 0（3 >= 3）
  示例 2：

输入：tasks = [5,4], workers = [0,0,0], pills = 1, strength = 5
输出：1
解释：
我们可以按照如下方案安排药丸：

• 给 0 号工人药丸。
• 0 号工人完成任务 0（0 + 5 >= 5）
  示例 3：

输入：tasks = [10,15,30], workers = [0,10,10,10,10], pills = 3, strength = 10
输出：2
解释：
我们可以按照如下方案安排药丸：

• 给 0 号和 1 号工人药丸。
• 0 号工人完成任务 0（0 + 10 >= 10）
• 1 号工人完成任务 1（10 + 10 >= 15）
  示例 4：

输入：tasks = [5,9,8,5,9], workers = [1,6,4,2,6], pills = 1, strength = 5
输出：3
解释：
我们可以按照如下方案安排药丸：

• 给 2 号工人药丸。
• 1 号工人完成任务 0（6 >= 5）
• 2 号工人完成任务 2（4 + 5 >= 8）
• 4 号工人完成任务 3（6 >= 5）

提示：

n == tasks.length
m == workers.length
1 <= n, m <= 5 * 10^4
0 <= pills <= m
0 <= tasks[i], workers[j], strength <= 10^9

解题思路

经过上周周赛2141. 同时运行 N 台电脑的最长时间，感觉对于这类分配问题都可以采用二分答案的方法；

这类分配问题的答案个数，天然存在上下界，并有单调性，在范围内二分并不断check更改上下界就能确定答案；
难点在于check函数怎么写，这道题需要贪心的思路；

首先对于每一个二分的mid，其意义是能完成mid个任务，贪心的想（暂时不考虑药），让最强壮的mid个人去做最容易的mid个任务，如果这样都完成不了说明mid定高了，否则mid定低了，所以预处理就对任务升序，工人降序；

现在考虑吃药的情况，具体证明过程不是太会证，但直觉的思路的让药尽量发挥作用，因为药有限，也就是给最适合的人吃，那么谁是最适合的呢，就是吃药后刚刚好能完成任务，最大化药的效用，这样总的结果才会最好。

在实现上，主体部分就是排序预处理和二分答案；
check函数部分，用multiset可重复有序集合来存工人（默认升序），在最简单的mid个任务中，从大到小遍历，如果当前最强工人能干，那就移除这个工人，节省药；如果最强的都不能，那就得吃药了，在这个有序的multiset中二分查找最适合的吃药人，也就是task[i] - s，让他吃药并完成当前任务并移除。如果药没了也没人能干，或者吃药了也干不了，那这些任务就完成不了，如果循环完都能做那就返回true

代码

class Solution {
public:
    int p, s;
    bool check(vector<int>& tasks, vector<int>& workers, int mid) {
        multiset<int> topworker;
        int pn = p;
        for(int i = 0; i < mid; ++i) {
            topworker.insert(workers[i]);
        }
        for(int i = mid - 1; i >= 0; --i) {
            if(*topworker.rbegin() >= tasks[i]) {
                topworker.erase(prev(topworker.end()));
            }
            else {
                if(!pn) return false;
                auto it = topworker.lower_bound(tasks[i] - s);
                if(it == topworker.end()) return false;
                topworker.erase(it);
                --pn;
            }
        }
        return true;
    }

    int maxTaskAssign(vector<int>& tasks, vector<int>& workers, int pills, int strength) {
        int n = tasks.size();
        int m = workers.size();
        int l = 0, r = min(m, n);
        p = pills, s = strength;
        sort(tasks.begin(), tasks.end());   //只做前mid个任务
        sort(workers.begin(), workers.end(), greater<int>());
        while(l <= r) {
            int mid = (l + r) >> 1;
            if(check(tasks, workers, mid)) {
                l = mid + 1;
            }
            else r = mid - 1;
        }
        return l - 1;
    }
};