蓝桥杯--外卖店优先级别（排序法）详解

题目：

“饱了么”外卖系统中维护着 N家外卖店，编号 1∼N。

每家外卖店都有一个优先级，初始时 (00 时刻) 优先级都为 00。

每经过 11 个时间单位，如果外卖店没有订单，则优先级会减少 11，最低减到 00；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 22。

如果某家外卖店某时刻优先级大于 55，则会被系统加入优先缓存中；如果优先级小于等于 33，则会被清除出优先缓存。

给定 T时刻以内的 M条订单信息，请你计算 T 时刻时有多少外卖店在优先缓存中。

输入格式

第一行包含 33 个整数 N,M,T。

以下 M行每行包含两个整数 ts和 id，表示 ts 时刻编号 id的外卖店收到一个订单。

输出格式

输出一个整数代表答案。

数据范围

1≤N,M,T≤1051≤�,�,�≤105,
1≤ts≤T1≤��≤�,
1≤id≤N1≤��≤�

输入样例：

2 6 6
1 1
5 2
3 1
6 2
2 1
6 2

输出样例：

1

样例解释

66 时刻时，11 号店优先级降到 33，被移除出优先缓存；22 号店优先级升到 66，加入优先缓存。

所以是有 11 家店 (22 号) 在优先缓存中。

思路分析：

     暴力想法：将所有的订单按照时间顺序排列，没有订单的时刻就减一（最低不小于0），有订单的时候就加2。计算完之后判断一下在不在优先队列里面

   优化部分：引入last[id]数组，用来计算这个店最后一次有订单是什么时候，这样计算，中间一大段没有订单的时间计算一次就可以了。一直有订单的时间也是通过这种方式被优化，一个一个的时间点，被划分成一段一段。

代码加注释

import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		int n=scan.nextInt();//有几家店
		int m=scan.nextInt();//有几个时间点有订单
		int T=scan.nextInt();//时间范围
		int N=100010;
		int score[]=new int[N];//表示优先级
		int last[]=new int[N];//表示这家店最后一次有订单是什么时候
		boolean st[]=new boolean[N];//表示是否在优先级领先的范围内
		Node order[]=new Node[N];//结构体，用来存储两个数
		for(int i=0;i<m;i++)
		{
			int a=scan.nextInt();
			int b=scan.nextInt();
			order[i]=new Node(a,b);
		}//订单
		Arrays.sort(order,0,m);//在结构内部写函数来规定排序方式
		for(int i=0;i<m;i++) {
			int j=i;//找第i个订单之后，和第i个订单一样的订单一起处理，这样可以优化一部分
			while(j<m&&order[j].equals(order[i])) j++;
			int id=order[i].y,t=order[i].x,cnt=j-i;
			i=j-1;
			score[id]-=t-last[id]-1;
			if(score[id]<0) score[id]=0;
			if(score[id]<=3) st[id]=false;
			score[id]+=cnt*2;
			if(score[id]>5) st[id]=true;
			last[id]=t;
		}
		int res=0;
		for(int i=1;i<=n;i++)
		{
			if(last[i]<T) {
			    score[i]-=T-last[i];
			    if(score[i]<=3) st[i]=false;
			}
			if(st[i]) res++;
		}
		System.out.println(res);
}


static  class Node implements Comparable<Node>{
	int x,y;
	Node(int a,int b) {
		x=a; y=b;
	}
	public int compareTo(Node io) {//定义排序的规则
		if(this.x==io.x) return this.y-io.y;
		return this.x-io.x;
	}
	public boolean equals(Node io) {//定义比较的规则
		return x==io.x&&y==io.y;
	}
}
}

：