蓝桥杯基础总结--模拟题

一、背景

通过观察蓝桥杯真题以及其考纲，可以发现蓝桥杯考察的重点还是在逻辑思维，问题抽象，而逻辑思维更侧重数的处理。在2020年JavaB组中考察内存主要为字符处理、数组遍历（数字）、排序、简单基础编程（精度统计）、DP（难题），而没有复杂的模拟或者高级（需要综合应用集合）一点的编程题。说明蓝桥杯的趋势更加侧重思维了，平时务必注重思维的训练，多刷题，多刷题二叉树->DP。但这种思维题短时间内很难提升，因此我便做了模拟题的总结，顺便巩固基础编程，虽然2020年没有考察，但是按照一年考一年不考的规律估计今年可能会出现模拟（2019年外卖优先级还是较为复杂的模拟题），今年还是即可能考察的。

二、总结

1. 解读问题（抽象提炼属性和操作）
   从抽象到具体，从顶到下，简化问题（递归）。
2. 选择相应的数据结构（set自动去重，map映射关系，list动态数组））
3. 关键步骤：算法思路，和数据结构结合，优先思考常用思路再考虑有无优化（主要从时间上面考虑）。
4. 将函数分为 输入，测试用例，处理，输出几部分方便维护。
5. 熟悉集合的操作（围绕CRUD，查找，遍历）

三、代码（以外卖优先级为例）

在这里插入代码package lq.questions.consolidate.simulate;

import java.util.*;

/**
 * @AUTHOR LYF
 * @DATE 2021/4/14
 * @VERSION 1.0
 * @DESC
 *
 * 外卖优先级
 *
 * 题目描述:
 * n家店，t时刻中有m个订单，每走一时刻则优先级进行下降1个优先级，若对应优先级为0则无法下降
 * 若有订单则优先级+2，当优先级》5则加入缓存，小于等3则清除优先级
 *
 * 问题解决
 * 1.抽象数据结构
 * n,t,m
 * 优先级:数组 下标为店家编号,val为优先级，每过一时刻调整一下优先级在调整过程中 进行判断优先级的大小是否加入缓存或者清除缓存
 * 缓存:数组 下标为对应的店家编号，val为Boolean值是否加入缓存。（方便处理，但是空间销毁略大，若店家多不太实用？）
 * 考虑使用map,满足的则加入，不满足的remove
 * 实际上，使用一个list即可，因为无需知道缓存中店家的优先级，有优先级数组在维护优先级大小，因此缓存只需存储店家编号
 *
 * 时间流:时刻对应店家编号具有的订单量
 * 采用类存储，map存储只能存储一个key，同一时间可以多家有外卖单
 * class{int no,t;}
 *
 *
 * 2.输入
 * n,t,m
 * ...
 * 3.解决规则
 * 遍历时间流（）,判断该时刻每个店家具有的订单量，若无则则判断优先级是否为0，为0继续保持，不为零则-1
 * 有则进行判断订单数量，优先级+订单数量*2
 *
 *
 *
 *
 */

class TimeNode{
    int t,no;

    public TimeNode() {
    }

    public TimeNode(int t, int no) {
        this.t = t;
        this.no = no;
    }

    public int getT() {
        return t;
    }

    public void setT(int t) {
        this.t = t;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    @Override
    public String toString() {
        return "TimeNode{" +
                "t=" + t +
                ", no=" + no +
                '}';
    }
}

public class SellerPrior {


    //private Map<Integer,Integer> cache = new HashMap<>();// 缓存
    private List<Integer> cache = new ArrayList<>();
    private int n;//店家数量
    private int t;//时间
    private int m;//外卖订单量
    private int [] sellerPrior = new int[n];//店家优先级
    private List<TimeNode> timeStream = new ArrayList<>();//时间流

    // 输入数据
    void inputData(){
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        t = scanner.nextInt();

        for(int i =0;i<m;i++)
        {
            timeStream.add(new TimeNode(scanner.nextInt(),scanner.nextInt()));
        }
        //初试优先级
        Arrays.fill(sellerPrior,0);
    }

    // 比较笨的方法
    // 每一个时间去统计该时间各个店家的外卖数量再去维护缓存
    void handle1(){

        for(int i =1;i<=t;i++){//时间
            for(int j = 1;j<=n;j++){//店家
                int finalJ = j;
                int finalI = i;// 三重循环？
                long num = timeStream.stream().filter(tn->tn.t== finalI &&tn.no== finalJ).count();
                System.out.println(i+"时刻"+j+"店家具有"+num+"个外卖");

                if(num==0){//无订单，只需考虑是否清除缓存
                    if(sellerPrior[j-1]!=0){// ==0无需管，保持0
                        sellerPrior[j-1]--;//若该店家优先级非0则 -1
                        // 判断是否在缓存
                        if(sellerPrior[j-1]<=3){
                            int no = j-1;
                            if(cache.contains(no)){// 若该店家在缓存中则清除 map: cache.get((Object)no)!=null
                                 cache.remove((Object)no);
                            }
                        }
                    }
                }else{// 考虑有订单
                    int no = j-1;
                    sellerPrior[no]= (int) (sellerPrior[no]+num*2);

                    // 判断是否加入缓存
                    if(sellerPrior[no]>5){
                        cache.add(no);
                    }

                }

            }
        }


    }
    // 使用双指针，先进行时间按时间排序，再逐一

    void handle2(){

    }

    void outPutData(){
        System.out.println(cache.size());
    }

    void testData(){
        n =2;
        t =6;
        m =6;

        timeStream.add(new TimeNode(1,1));
        timeStream.add(new TimeNode(5,2));
        timeStream.add(new TimeNode(3,1));
        timeStream.add(new TimeNode(6,2));
        timeStream.add(new TimeNode(2,1));
        timeStream.add(new TimeNode(6,2));
        sellerPrior = new int[n];// 需要再构造一下对象，刚开始声明时n默认为0
        //初试优先级
        Arrays.fill(sellerPrior,0);
    }
    void testPrint(){
        System.out.println("n,t,m:"+n+";"+t+";"+m);
        timeStream.stream().forEach(System.out::print);
        System.out.println(sellerPrior.length);
        System.out.println();
        for(int i=0;i<sellerPrior.length;i++){
            System.out.print(sellerPrior[i]+" ");
        }
    }
    // 测试集合的使用
    static void testMap(){
        Map<Integer,Integer> map = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        list.add(3);
        System.out.println(list.size());
        list.remove((Object)3);
        System.out.println(list.size());
        if(map.get((Object)10)!=null){
            System.out.println("非空");
        }else{
            System.out.println("空");
        }

        long t = 12;
        int m = 0;
        m = (int) (t*2+1);
        System.out.println(m);

    }


    public static void main(String[]args){
         SellerPrior sellerPrior = new SellerPrior();
         sellerPrior.testData();
         sellerPrior.testPrint();
         sellerPrior.handle1();
         sellerPrior.outPutData();
    }
}