Blue Bridge Cup 2019 Zhenti: Takeaway Priority

topic

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

【问题描述】 
“饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。
每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。 
每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；
而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。
如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；
如果 优先级小于等于 3，则会被清除出优先缓存。 给定 T 时刻以内的 M 条订单信息，
请你计算 T 时刻时有多少外卖店在优 先缓存中。

【输入格式】 
第一行包含 3 个整数 N、M 和 T。 
以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。

【输出格式】
输出一个整数代表答案。
【样例输入】 
2 6 6 
1 1 
5 2 
3 1 
6 2 
2 1 
6 2
【样例输出】 
1
【样例解释】 
6 时刻时，
1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6， 加入优先缓存。
所以是有 1 家店 (2 号) 在优先缓存中。
【评测用例规模与约定】 
对于 80% 的评测用例，1≤ N,M,T ≤10000。 
对于所有评测用例，1≤ N,M,T ≤100000，1≤ts≤T，1≤id ≤ N。

answer

package competition3;

import java.util.Arrays;
import java.util.Scanner;

public class ShopPriority3
{
    
    
	public static void main(String[] args)
	{
    
    
		int N,M,T;
		Scanner in = new Scanner(System.in);
		N=in.nextInt()+1;
		M=in.nextInt();
		T=in.nextInt();
		Order[] order=new Order[M];
		for(int x=0;x<M;x++)
		{
    
    
			order[x]=new Order(in.nextInt(),in.nextInt());
		}
		//这个用来记录上一次last[x],x这家订单的时间T
		int[] last=new int[N];
		//保存每个店的分数
		int[] score=new int[N];
		
		//保存每家店是否在优先队列之中
		boolean[] isPriority=new boolean[N];
		
		Arrays.sort(order);
		for(int x=0;x<M;)
		{
    
    
			int y=x;
			//寻找这家店这个时间有多少单订单
			while(y<M && order[x].id==order[y].id && order[x].time==order[y].time)
			{
    
    
				y++;
			}
			//记录当前店的id和time
			int id=order[x].id;
			int time=order[x].time;
			int sum=y-x;
			//将y赋值给x,y是下一个店的订单或者是下一个时间的订单
			x=y;
			//less是这家店相隔多少时间没有订单了
			int less=time-last[id]-1;
			//多久没有订单就要减少相应的分数
			score[id] -=less;
			if(score[id]<0)
			{
    
    
				score[id]=0;
			}
			if(score[id]<=3)
			{
    
    
				isPriority[id]=false;
			}
			//下面是要加分的,如果达到要求就进去优先队列
			score[id] +=sum*2;
			if(score[id]>5)
			{
    
    
				isPriority[id]=true;
			}
			//保存当前店的最后的订单时间
			last[id]=time;
		}
		/*
		 * 因为后面还有可能就是还没到T的时间,但是某些店已经没有订单了
		 * 后面的每一个时间段都是要扣分的
		 */
		for(int x=0;x<N;x++)
		{
    
    
			int less=T-last[x];
			score[x] -=less;
			if(score[x]<=3)
			{
    
    
				isPriority[x]=false;
			}
		}
		int count=0;
		for (boolean b : isPriority)
		{
    
    
			if(b)
			{
    
    
				count++;
			}
		}
		System.out.println(count);
	}

}
class Order implements Comparable<Order>
{
    
    
	public int time;
	public int id;
	public Order(int time, int id)
	{
    
    
		super();
		this.time = time;
		this.id = id;
	}
	@Override
	public int compareTo(Order o)
	{
    
    
		if(this.time==o.time)
		{
    
    
			if(this.id==o.id)
			{
    
    
				return 0;
			}
			return this.id>o.id?1:-1;
		}
		return this.time>o.time?1:-1;
	}
}