Leetcode 2071你可以安排的最多任务数目 （二分+贪心+双向队列）

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

问题描述

tasks表示需要被安排的工作， workers表示所有工人的体力值。pills 表示药片的数量， strength表示一个药片能提供的体力值。需要输出能够安排的最大的任务数。

问题分析1 二分（leetcode官方给出的题解）

1. 如果我们一定可以完成$k$个任务，则task中最小的k个任务一定可以被workers中体力最大的k个工人完成。（当任务可以被完成的时候， 我们的最强战力一定是可以完成的）
2. 如果我们可以完成k个任务，那么一定可以完成k-1个任务。并且k-1个最小的任务一定可以被体力最大的k-1个任务完成。

注意1的逆否命题就是：
如果task中最小的k个任务无法被体力最强的k个工人完成，则我们无法完成k个任务。

k个任务可以被完成->最强k个一定能完成k个最小的任务
k个最小的任务不能被最强的k个完成->k个任务一定完不成。

设可以完成的工作数量为ans
最强的k个工人完成最小的k个任务 -> ans>= k。
最强的k个工人无法完成最小的k个任务-> ans < k

所以我们应该考虑最小的k个任务与体力最好的k个工人。从1开始 到 N= min(tasks.size() , workers.size() )。k = 0:N ，存在一个$k^{{}^{\prime }}$使得 $k^{{}^{\prime }}$个体力最大的工人可以完成$k^{{}^{\prime }}$个最小的任务，但是$k^{{}^{\prime }}+1$个体力最好的工人无法完成$k^{{}^{\prime }}+1$个最小的任务。

问题分析2 k个体力最好的工人完成k个最小的任务

考虑值最大的那个任务t
1.如果有工人的值大于等于该任务的值，则不使用药丸，一定让值最大的工人来完成t。
2.如果所有的工人的值都小于该任务的值，当前一定要吃药了， 也就是目标值变为 t - strength。
找到第一个 >= t-strength的那个工人来完成这个任务。

此时就可以写代码实现了，以下是leetcode的官方题解：

bool check(int mid, int& pills, int& strength, vector<int>& workers, vector<int>& tasks)
{
	//用lambda表达式可以避免传值
	int p = pills;
	multiset<int> ws;
	for(int i = m-mid; i< m;i++)
	{
		//workers的后mid个
		ws.insert(workers[i]);
	}
	
	for(int i = mid -1; i >=0; i++)
	{
		multiset<int>::iterator it = prev(ws.end()); //ws 最大的工人
		if(*it>= tasks[i])
		{
			ws.erase(it);
		}
		else
		{
			if(!p)//没药了
			{
				return false;
			}
			else
			{
				auto rep = ws.lower_bound(tasks[i]);
				if(rep == ws.end()) //吃了药也不行
				{
					return false;
				}
				else{
					ws.erase(rep);
					p--;
				}
			}
		}
		return true; //所有mid个任务被安排了
	}
	
}
int maxTaskAssign(vector<int>& tasks, vector<int>& workers, int pills, int strength)
{
	int n = tasks.size(), m = tasks.size();
	//将tasks 和 workers 都排序
	sort(tasks.begin(), tasks.end());
	sort(workers.begin() , workers.end());
	
	//二分
	int left = 1, right = min(m,n);
	int ans = 0;
	while(left <= right)
	{
		int mid = (left+ right)/2;
		if(check(mid, pills, strength, workers,tasks))
		{
			ans = mid;
			left = mid+1;
		}
		else
		{
			right = mid-1;
		}
	}
	return ans;
}

可以看出整体来说是一个二分过程。

时间与空间复杂度分析

用一个双向队列来优化

int maxTasksAssign(vector<int>& tasks, vector<int>& worker, int pills, int strength )
{
	int n = tasks.size(), m = workers.size();
	sort(tasks.begin(), tasks.end());
	sort(workers.begin(),workers.end());
	
	auto check = [&](int mid)->bool
	{
		int p = pills;
		deque<int> ws;
		int ptr = m-1; //队尾
		for(int i = mid -1; i>=0; i--)
		{
			while(ptr >= m-mid && workers[ptr] >= (tasks[i]-strength)  )
			{
				ws.push_front(workers[ptr]);
				--ptr;
				//所有能吃药把任务完成的工人入队
				//队尾是最强的工人
			}
			if(ws.empty())
			{
				return false;//一个能吃药完成任务的工人都没有
			}
			
			if(ws.back() >= tasks[i]) //不吃药就直接完成
			{
				ws.pop_back();
			}
			else{
				//要吃药了
					if(!p)
					{
						return false;
					}
					ws.pop_front();
					p--;
			}
		}
		return true;
	};
	int left = 1, right = min(m,n);
	int ans = 0;
	while(left <= right)
	{
		int mid = (left+ right)/2;
		if(check(mid, pills, strength, workers,tasks))
		{
			ans = mid;
			left = mid+1;
		}
		else
		{
			right = mid-1;
		}
	}
	return ans;
}

每次进入队列的都是吃了药能完成当前t的工人，由于task是非严格递减的，当前进入队列的工人吃了药之后也能完成下一个任务。当然对于下一个任务又有一些新的工人会加进来。
设集合$A_i$为吃了药之后能完成第i 个任务的工人组成的集合，则有：
$A_i\subset A_{i-1}$ 。

这道题的二分与贪心

贪心

这道题中的贪心应该是check函数的建立时使用了贪心的原则。

1. 不吃药的时候尽量用体力最大的工人完成此任务。
2. 吃药的时候尽量用能完成任务的体力最小的工人来完成此任务。

二分

checkh函数相当于一个偏序。

类似的一道题

之前遇到的一个动态规划的问题，有个大神也用了贪心+二分。可以对比一下：

最长上升子序列

dp[len] 表示长度为len的上升序列的最小末尾

#define MAXN 10005
int LIS(vector<int>& nums)
{
	int dp[MAXN];
	dp[0] = 0;
	int len = 0;
	for(int i = 0;i < nums.size(); i++ )
	{
		if(nums[i] > dp[len])
		{
			dp[++len] = nums[i];
		}
		else
		{
			*lower_bound(dp+1,dp +len, nums[i]) = nums[i];
		}
	}
	return ans;
}