2071. 你可以安排的最多任务数目

题目描述

有n任务，有m工人，有p药丸，问最多能完成多少个任务？

f1 二分+二分

基本分析

1. 总的来说为啥是二分做？最多能完成的任务具有二段性，剩下需要处理的就是写check函数，看check(x)是不是成立
2. 怎么是一个好的安排任务的策略？假设需要处理x个任务，那么选的人肯定是最强的ws[m- x:]个人, 任务是最菜的t[:x]个。
3. 怎么是一个好的判断策略？先看最难的任务，如果最强的人能做就让这个人去做，否则也是浪费，做了之后弹出这个强人；如果这个人不能做，就找一个合适的人吃药去做，如果没药或者吃药也没人能做，表示x个是完成不了的，如果能做就二分找这个合适的人，做了之后弹出这个人，维护药的个数

代码

from sortedcontainers import SortedList as SL
class Solution:
    def maxTaskAssign(self, tasks: List[int], workers: List[int], pills: int, strength: int) -> int:
        
        n, m = len(tasks), len(workers)
        tasks.sort()
        workers.sort()
        
        def check(x):
            p = pills
            # 后面x个最强的
            ws = SL(workers[m - x:])
            # 此时任务是倒序遍历，先碰到的是最强的
            for i in range(x-1, -1, -1):
                # 最强的人能处理最难的任务
                if ws[-1] >= tasks[i]:
                    ws.pop()
                else:
                    # 如果没有药了或者最强的吃药都不能处理，返回False
                    if p == 0 or ws[-1] + strength < tasks[i]:
                        return False
                    # 存在完成的可能，找到一个吃药能完成任务的能量最小的人(找>=值的最小，二分1)
                    # rep = ws.bisect_left(tasks[i] - strength)
                    l, r = 0, len(ws)-1
                    while l < r:
                        mid = l + r >> 1
                        if ws[mid] + strength >= tasks[i]:
                            r = mid
                        else:
                            l = mid + 1
                    ws.pop(l)
                    p -= 1
            return True
        
        l, r = 0, min(n, m)
        ans = 0
        # 找满足 条件的最大
        while l < r:
            mid = l + r + 1 >> 1
            if check(mid):
                l = mid
            else:
                r = mid - 1
        return l

总结

1. 外层的二分逻辑：找能满足条件的最大的值，用二分2
2. 内层找吃药人的二分逻辑：找能满足条件的最菜的人，用二分1

f2 二分 + 单调队列

基本分析

1. 二分找吃药的能干的人时候，不能O（1），用什么办法可以优化？不是直接全把m个人放进来，而是遍历时候放进有效的人，这样从两端进行处理：单调队列

代码

class Solution:
    def maxTaskAssign(self, tasks: List[int], workers: List[int], pills: int, strength: int) -> int:
        n, m = len(tasks), len(workers)
        tasks.sort()
        workers.sort()
 
        def check(x):
            p = pills
            ws = deque()
            # 最开始指针指向最强的工人
            ptr = m - 1
            # 分析简单的x个任务，难度从难到简单
            for i in range(x-1, -1, -1):
                # 只用考虑最强的m-x 到 m-1的x个人, 
                # 保证放进去的人吃药就能干当前任务, 后面的简单一些的任务更不在话下
                while ptr >= m - x and workers[ptr] + strength >= tasks[i]:
                    ws.appendleft(workers[ptr])
                    ptr -= 1
                # 吃药都没人能干，False
                if not ws:
                    return False
                # 看不吃药能干不？
                if ws[-1] >= tasks[i]:
                    ws.pop()
                # 必须吃药的话，让最菜的去干
                else:
                    if p == 0:
                        return False
                    ws.popleft()
                    p -= 1
            return True
        
        l, r = 0, min(m, n)
        while l < r:
            mid = l + r + 1 >> 1
            if check(mid):
                l = mid
            else:
                r = mid - 1
        
        return l

总结

1.这里用单调队是怎么优化的？利用二分找的时候，不能O(1)的找到吃药去完成task[i]的那个人。而在单调队列中，人的能力值是有序的，且保证了在队列中，下限就是吃药就能干。所以对不吃药干或者吃药干的情况都能O(1）的找到。