外卖店优先级

思路

将每个商家的接单时刻用优先队列贮存：

PriorityQueue<Integer>[] arr = new PriorityQueue[N + 1]

其中，arr[i]表示第i个商家的接单时刻记录

随后，检查每个商家的接单记录来判断，在T时刻商家是否处于缓存队列中：

for (int i = 1; i <= N; i++) {
     // 判断每个商家是否在T时刻处于缓存队列中
	boolean flag = check(arr[i]);
	if (flag)
		ans++;
}

check商家优先级的方法：

1. 减去上一接单时刻（prv）到现在接单时刻（cur）的优先级减少量
2. 接一单，优先级+2
3. 判断是否能够进入缓存队列
4. 重复1、2、3步，直到商家的接单记录队列为空
5. 减去cur时刻到T时刻的优先级减少量
6. 判断是否能够进入缓存队列
   Code-Java

import java.util.PriorityQueue;
import java.util.Scanner;

public class G {
     
	static int N;
	static int M;
	static int T;

	public static void main(String[] args) {
     
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
     
			// init=============================
			N = sc.nextInt();
			M = sc.nextInt();
			T = sc.nextInt();
			PriorityQueue<Integer>[] arr = new PriorityQueue[N + 1];// 小顶堆，小的在队首
			for (int i = 0; i < arr.length; i++) {
     
				arr[i] = new PriorityQueue<>();
			}
			for (int i = 0; i < M; i++) {
     
				int time = sc.nextInt();
				int id = sc.nextInt();
				arr[id].add(time);
			}
			// init_end==========================
			int ans = solution(arr);
			System.out.println(ans);
		}
	}

	private static int solution(PriorityQueue<Integer>[] arr) {
     
		int ans = 0;
		for (int i = 1; i <= N; i++) {
     // 判断每个商家是否在T时刻处于缓存队列中
			boolean flag = check(arr[i]);
			if (flag)
				ans++;
		}
		return ans;
	}

	private static boolean check(PriorityQueue<Integer> priorityQueue) {
     
		boolean flag = false;
		int temp = 0;// 表示优先级的数值
		int prv = 0;// 前一个接单时刻
		int cur = 0;// 当前的接单时刻
		while (!priorityQueue.isEmpty()) {
     
			cur = priorityQueue.poll();
			// 计算时间流逝的成本
			int cost = 0;
			if (cur != prv)
				cost = cur - prv - 1;
			temp -= cost;
			// 时间流逝成本计算完毕
			if (temp < 0)// 优先级的数值不能低于0
				temp = 0;
			temp += 2;// 一单加2优先级
			if (temp > 5)// 判断是否进入缓存队列
				flag = true;
			else if (!(flag && temp > 3))// 被踢出缓存队列
				flag = false;
			prv = cur;// 迭代
		}
		temp -= T - cur;// 结算T时刻的优先级是多少
		if (flag && temp > 3)// 判断是否还处于缓存队列中
			return true;
		return false;
	}
}

Code-C++

#include
#include
using namespace std;

int N;
int M;
int T;

bool check(priority_queue<int, vector<int>, greater<int>> priorityQueue) {
     
	bool flag = false;
	int temp = 0;
	int prv = 0;
	int cur = 0;
	while (!priorityQueue.empty()) {
     
		cur = priorityQueue.top();
		priorityQueue.pop();
		// 计算时间流逝的成本
		int cost = 0;
		if (cur != prv)
			cost = cur - prv - 1;
		temp -= cost;
		if (temp < 0)
			temp = 0;
		temp += 2;
		if (temp > 5)
			flag = true;
		else if (!(flag && temp > 3))// 被踢出缓存队列
			flag = false;
		prv = cur;
	}
	temp -= T - cur;
	if (flag && temp > 3)
		return true;
	return false;
}

int solution(priority_queue<int, vector<int>, greater<int>> arr[]) {
     
	int ans = 0;
	for (int i = 1; i <= N; i++) {
     
		bool flag = check(arr[i]);
		if (flag)
			ans++;
	}
	return ans;
}

int main() {
     
	while (cin >> N >> M >> T) {
     
		priority_queue<int, vector<int>, greater<int>>  arr[10000];  //小顶堆
		for (int i = 0; i < M; i++) {
     
			int id, time;
			cin >> time >> id;
			arr[id].push(time);
		}
		// init_end==========================
		int ans = solution(arr);
		cout << ans << endl;
	}
	return 0;
}