2019 第十届 蓝桥杯 JavaB组 省赛G题 外卖店优先级

【问题描述】

“饱了么”外卖系统中维护着 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。

思路: 该题只要按照题意一步步写即可,首先要将这M行中的ts和id按ts为标准进行排序,这里我是将ts和id合成一个小数来（即ts.id），这样就可以进行排序。然后对于优先缓存区,这里有一个坑,就是如果该店铺之间已加入了优先缓存中,只要该店铺的优先级不小于等于3则不会清除出去

直接上代码

public class Question07 {
     
    public static void main(String[] args) {
     
        Scanner scanner = new Scanner(System.in);
        int N,M,T;// N-外卖店的个数  M-订单条数  T-时间
        int ts=0,id=0;//表示 ts 时刻编号 id 的外卖店收到 一个订单。
        String str,str1,str2;
        N = scanner.nextInt();//外卖店的个数
        M = scanner.nextInt();//订单条数
        T = scanner.nextInt();//时间
        //表示店铺的优先级数组,数组下标对应相应的店铺
        int[] shop = new int[N+1];
        //二维数组,第一列表示当前时间,第二列表示收到订单的店铺id
        int[][] result = new int[M][2];
        //按时间进行排好序的数组
        int[][] sort_result = new int[M][2];
        //由形如a.b的数组成,其中a表示的是当前时间,b表示当前时间收到订单的店铺id
        double[] arry = new double[M];

        //输入的ts和id,并将其转换成ts.id
        for (int i=0;i<M;i++){
     
            result[i][0]=scanner.nextInt();
            result[i][1]=scanner.nextInt();
            arry[i] = result[i][0]+result[i][1]*0.1;
        }

        //对arry进行排序
        Arrays.sort(arry);

        //再将其转换成二维数组类型
        for(int i=0;i<M;i++){
     
            //将double转换成String类型
            str = String.valueOf(arry[i]);
            //并分别获取时间和店铺id(即小数点之前的数和之后的数)
            str1 = str.substring(0,str.indexOf('.'));
            str2 = str.substring(str.indexOf('.')+1,str.length());
            //将其转换成int
            ts = Integer.parseInt(str1);
            id = Integer.parseInt(str2);
            //最后存入新的二维数组中
            sort_result[i][0]=ts;
            sort_result[i][1]=id;
        }
        //到达T时刻时行含优先缓存店铺的数量
        int count = 0;
        int index = 0;
        //是否加入了优先缓存店铺
        boolean flag = false;

        //对外卖店一一进行遍历
        for(int i=1;i<=N;i++){
     
            //从T=1时开始进行遍历
            for(int j=1;j<=T;j++){
     
                //当前时间该店铺未收到订单
                if (index<M&&sort_result[index][0]>j){
     
                    if (shop[i]>=1){
     
                        shop[i] = shop[i]-1;
                    }
                    continue;
                }
                //判断时间是否相等
                if (index<M&&sort_result[index][0]==j){
     
                    //判断是否为当前的外卖店
                    if (sort_result[index][1]==i){
     
                        shop[i] +=2;
                    }else {
     
                        if (shop[i]>=1){
     
                            shop[i] = shop[i]-1;
                        }
                    }
                    while (true){
     
                        //判断下一个时间是否还是当前的时间(即是否存在当前时间内有多个订单)
                        if ((index+1)<M&&sort_result[index+1][0]==j){
     
                            index++;
                            //判断该店是否还有订单
                            if (sort_result[index][1]==i){
     
                                shop[i]+=2;
                            }
                        }else {
     
                            break;
                        }
                    }
                }
                index++;
                //每经过一个时间单位,对该店铺的优先级进行判断
                if (shop[i]>5){
     
                    //如果优先级大于5说明可以加入优先缓存中,设置flag为true
                    flag = true;
                }
                if (shop[i]<=3&&flag){
     
                    //如果该店铺之前是在缓存区的但由于此时优先级小于等于3,则将其清出优先缓存中,即设置flag为false
                    flag = false;
                }
            }
            //每完成一次T时间内的遍历,将index置为0,重新下一次新店铺的遍历
            index=0;
            //如果为true,则表示可以在T时刻该店铺在优先缓存中,因此数量加一
            if (flag){
     
                count++;
            }
            flag = false;
        }
        System.out.println(T+"时刻存在优先缓存的店铺的数量:"+count);
    }
}