蓝桥杯--冲刺题单--随时更新

冲刺题单

感谢up主溶金落梧桐（uid:40733116），我是看了他的视频后总结的。

简单模拟（循环数组日期进制）

1.蓝桥19723–分布式队列

package datasimulation;

import java.util.Scanner;

public class Test3 {
    //计算数组中最小值
    public static int getMin(int[] arr){
        int min = arr[0];//最好设为数组中的某个值
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < min){
                min = arr[i];
            }
        }
        return min;
    }
    //主逻辑函数
    public static void solve(){
        Scanner sc = new Scanner(System.in);
        //输入N
        int N = sc.nextInt();
        //创建一个长度为N的数组，数组元素表示的是每个节点数组的长度
        int[] arr = new int[N];
        //输入?行数据
        while(sc.hasNext()){
            String op = sc.next();
            if(op.equals("add")){
                int opNum = sc.nextInt();
                //主节点数组长度加1
                arr[0]++;
            } else if (op.equals("sync")) {
                int opNum = sc.nextInt();
                //副节点数组长度加1
                //!!!特别注意！！！
                副队列同步主队列，如果在执行这次操作时副队列已经是跟主队列相同了，
                // 此时再加1并不合理，最高就是跟主队列相同
                //其实题目的用例有偷偷暗示
                arr[opNum] = Math.min(arr[opNum] + 1,arr[0]);
            }else{
                //输出可见数
                //其实就是输出arr数组中的最小值--各个节点数组的长度最小值
                System.out.println(getMin(arr));
            }
        }

    }
    public static void main(String[] args) {
        solve();
    }
}

注意：
1.使用一个数组来描述，数组的元素表示的是每个节点数组的长度，可见数其实就是这个数组中最小的元素。
2.要特别注意观察题目给的样例，其中可能暗藏玄机。
最开始我只通过50%，后来才发现给的用例可能会重复，如果遇到sync只是一味加加，那么副节点数组的长度就会超过主节点，这就不对了。
3.学到了一个sc.hasNext()的使用。因为本题不知道输入的操作个数。
4.特别注意数据的输入格式。

2.蓝桥19709–好数

package datasimulation;

import java.util.Scanner;

public class Test4 {
    public static boolean check(int n){
        int count = 1;//表示奇偶数位
        int jicount = 0;
        int oucount = 0;
        while(n != 0){
            int t = n % 10;
            n = n / 10;
            if(count % 2 == 0 && t % 2 == 0){
                oucount++;
            }
            if(count % 2 != 0 && t % 2 != 0){
                jicount++;
            }
            count++;//下一位
        }
        //注意上面循环count多加了1
        if(jicount + oucount + 1 == count)  return true;
        else return false;
    }
    //主逻辑函数
    public static void solve(){
        Scanner sc = new Scanner(System.in);
        //输入N
        int N = sc.nextInt();
        int count = 0;//记录好数
        for (int i = 1; i <= N; i++) {
            if(check(i)) count++;
        }
        System.out.println(count);
    }
    public static void main(String[] args) {
        solve();
    }
}

//判断好数
    //奇数位不能是偶数，偶数位不能是奇数
    public static boolean check(int n){
        int cnt = 1;//位数计数器
        while(n != 0){
            int t = n % 10;
            if(cnt % 2 != 0){
                //奇数位不能偶数
                if(t % 2 == 0) return false;
            }
            if(cnt % 2 == 0){
                //偶数位不能是奇数
                if(t % 2 != 0) return false;
            }
            cnt++;//下一位数
            n = n / 10;
        }
        return true;//都结束了返回true
    }

学到的知识点：
本题使用暴力来做，额我就只想到对于奇数位是奇数的加1，偶数位是偶数的加一，因此要循环全部，效率较低。而且还有一点就是最好的count多加了1。
老师的解法就是奇数位偶数返回错，偶数位奇数返回错。这样提高了效率，也不需要注意太多。

前缀和与差分

1.蓝桥18437–一维前缀和（模板

import java.util.Scanner;

public class Main {
    public static void solve(){
        Scanner sc = new Scanner(System.in);
        //输入n，q
        int n = sc.nextInt();
        int q = sc.nextInt();
        //定义数组
        int[] a = new int[n + 1];
        //输入ai，顺便计算前缀和
        for (int i = 1; i <= n; i++) {
            a[i] = sc.nextInt();
            a[i] = a[i - 1] + a[i];
         }
        //q次查询
        for (int i = 0; i < q; i++) {
            int l = sc.nextInt();
            int r = sc.nextInt();
            //差分？
            System.out.println(a[r] - a[l - 1]);
        }
    }
    public static void main(String[] args) {
        solve();
    }
}