蓝桥杯省赛（2024）总结一下

第二次考...一如既往的low（惨不忍睹，主要是都不是初次写了，那些题目）

根据上面的得分情况，和我对题目的分析，我认为其实下面这些题我应该是能拿满分的，主要还是要细心冷静一点。

问题描述

小明国庆节准备去某星系进行星际旅行，这个星系里一共有 nn 个星球，其中布置了 mm 道双向传送门，第 ii 道传送门可以连接 ai,biai​,bi​ 两颗星球（ai≠biai​=bi​ 且任意两颗星球之间最多只有一个传送门）。

他看中了一款 “旅游盲盒”，一共有 QQ 个盲盒，第 ii 个盲盒里的旅行方案规定了旅行的起始星球 xixi​ 和最多可以使用传送门的次数 yiyi​。只要从起始星球出发，使用传送门不超过规定次数能到达的所有星球都可以去旅行。

小明关心在每个方案中有多少个星球可以旅行到。小明只能在这些盲盒里随机选一个购买，他想知道能旅行到的不同星球的数量的期望是多少。

输入格式

输入共 m+Q+1m+Q+1 行。

第一行为三个正整数 n,m,Qn,m,Q 。

后面 mm 行，每行两个正整数 ai,biai​,bi​ 。

后面 QQ 行，每行两个整数 xi,yixi​,yi​ 。

输出格式

输出共一行，一个浮点数（四舍五入保留两位小数）。

样例输入

3 2 3
1 2
2 3
2 1
2 0
1 1

样例输出

2.00

样例说明

第一个盲盒可以旅行到 1,2,31,2,3。

第二个盲盒可以旅行到 22。

第三个盲盒可以旅行到 1,21,2。

所以期望是 (3+1+2)/3=2.00(3+1+2)/3=2.00。

import java.util.*;

public class CaiYao {
    static int n;
    static List<List<Integer>> list=new ArrayList<>();
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        double ans=0;
        n=scan.nextInt();
        int m=scan.nextInt();
        int q=scan.nextInt();
        for(int i=0;i<=n;i++){
            list.add(new ArrayList<>());
        }
        for(int i=0;i<m;i++){
            int a=scan.nextInt();
            int b=scan.nextInt();
            list.get(a).add(b);
            list.get(b).add(a);
        }
        for(int i=0;i<q;i++){
            int start=scan.nextInt();
            int steps=scan.nextInt();
            ans+=fun(start,steps);
        }
        System.out.printf("%.2f",ans/q);
        scan.close();
    }
    public static double fun(int start,int x){
        boolean[] visited=new boolean[n+1];
        Queue<Integer> queue=new LinkedList<>();
        queue.offer(start);
        int currentStep=0;
        int count=1;
        visited[start]=true;
        while(!queue.isEmpty()&&currentStep<x){
            int size=queue.size();
            for(int i=0;i<size;i++){
                int current=queue.poll();
                for(int neighbor:list.get(current)){
                    if(!visited[neighbor]){
                        visited[neighbor]=true;
                        count++;
                        queue.offer(neighbor);
                    }
                }
            }
            currentStep++;
        }
        return count;
    }
}

不是很难的一个BFS题，当时模拟考的时候想到了一个和BFS思路差不多的解法，当时死活把BFS忘了，搞的一个莫名其妙的思路死磕了半天（好蠢...），感觉还是得冷静一点吧，因为感觉这个题应该是能做出来的。

 

问题描述

小蓝最近学习了一种神奇的队列： 分布式队列。简单来说，分布式队列包含 NN 个节点（编号为 0 至 N−1N−1，其中 0 号为主节点），其中只有一个主节点，其余为副节点。

主/副节点中都各自维护着一个队列，当往分布式队列中添加元素时，都是由主节点完成的（每次都会添加元素到主节点对应的队列的尾部）；副节点只负责同步主节点中的队列。可以认为主/副节点中的队列是一个长度无限的一维数组，下标为 0,1,2,3…0,1,2,3…，同时副节点中的元素的同步顺序和主节点中的元素添加顺序保持一致。

由于副本的同步速度各异，因此为了保障数据的一致性，元素添加到主节点后，需要同步到所有的副节点后，才具有可见性。

给出一个分布式队列的运行状态，所有的操作都按输入顺序执行。你需要回答在某个时刻，队列中有多少个元素具有可见性。

输入格式

第一行包含一个整数 NN，表示节点个数。

接下来包含多行输入，每一行包含一个操作，操作类型共有以下三种： addadd、syncsync 和 queryquery，各自的输入格式如下：

1. addelementaddelement： 表示这是一个添加操作，将元素 elementelement 添加到队列中;

2. syncfolloweridsyncfollowerid​： 表示这是一个同步操作，followeridfollowerid​ 号副节点会从主节点中同步下一个自己缺失的元素;

3. queryquery： 查询操作，询问当前分布式队列中有多少个元素具有可见性。

输出格式

对于每一个 queryquery 操作，输出一行，包含一个整数表示答案。

样例输入

3
add 1
add 2
query
add 1
sync 1
sync 1
sync 2
query
sync 1
query
sync 2
sync 2
sync 1
query

样例输出

0
1
1
3

样例说明

执行到第一个 queryquery 时，队列内容如下：

00： [1,2][1,2]

11： [][]

22： [][]

两个副节点中都无元素，因此答案为 00。

执行到第二个 queryquery 时，队列内容如下：

00： [1,2,1][1,2,1]

11： [1,2][1,2]

22： [1][1]

只有下标为 00 的元素被所有节点同步，因此答案为 11 。

执行到第三个 queryquery 时，队列内容如下：

00： [1,2,1][1,2,1]

11： [1,2,1][1,2,1]

22： [1][1]

只有下标为 00 的元素被所有节点同步，因此答案为 11。

执行到第四个 queryquery 时，队列内容如下：

00： [1,2,1][1,2,1]

11： [1,2,1][1,2,1]

22： [1,2,1][1,2,1]

三个元素都被所有节点同步，因此答案为 33。

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n=scan.nextInt();
        int[] a=new int[n];
        while(scan.hasNext()){
            String operate=scan.next();
            if(operate.equals("add")){
                int bh=scan.nextInt();
                a[0]++;
            }else if(operate.equals("sync")){
                int bh=scan.nextInt();
                a[bh]=Math.min(a[bh]+1,a[0]);
            }else if(operate.equals("query")){
                int min=a[0];
                for(int j=1;j<n;j++){
                    min=Math.min(min,a[j]);
                }
                System.out.println(min);
            }
        }
    }
}

这个题也不难，思路对了，就是忘记了细节 ，副队列同步时大小不能超过主队列。

问题描述

SS 学校里一共有 a2a2​ 个两人寝、a3a3​ 个三人寝，a4a4​ 个四人寝，而食堂里有 b4b4​ 个四人桌和 b6b6​ 个六人桌。学校想要安排学生们在食堂用餐，并且满足每个寝室里的同学都在同一桌就坐，请问这个食堂最多同时满足多少同学用餐？

输入格式

采用多组数据输入。

输入共 q+1q+1 行。

第一行为一个正整数 qq 表示数据组数。

后面 qq 行，每行五个非负整数 a2,a3,a4,b4,b6a2​,a3​,a4​,b4​,b6​ 表示一组数据。

输出格式

输出共 qq 行，每行一个整数表示对应输入数据的答案。

样例输入

2
3 0 1 0 1
0 2 2 1 1

样例输出

6
10

样例说明

对于第一组数据，只有一个六人桌，因此最多安排三个两人寝的同学就餐，答案为 (2+2+2)=6(2+2+2)=6 。

对于第二组数据，用一个六人桌安排两个三人寝的同学，用一个四人桌安排一个四人寝的同学，答案为 (3+3)+(4)=10(3+3)+(4)=10 。

评测用例规模与约定

对于 20%20% 的评测用例，保证 a2+a3+a4≤8a2​+a3​+a4​≤8 。

对于 100%100% 的评测用例，保证 q≤100,b4+b6≤a2+a3+a4≤100q≤100,b4​+b6​≤a2​+a3​+a4​≤100 。

 

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int q=scan.nextInt();
        int ans;
        for(int i=0;i<q;i++){
            ans=0;
            int a2=scan.nextInt();
            int a3=scan.nextInt();
            int a4=scan.nextInt();
            int b4=scan.nextInt();
            int b6=scan.nextInt();
            while(a4>0&&b4>0){
                a4--;
                b4--;
                ans+=4;
            }
            while(a2>=2&&b4>0){
                a2-=2;
                b4--;
                ans+=4;
            }
             while(a3>=2&&b6>0){
                a3-=2;
                b6--;
                ans+=6;
            }
            while(a2>0&&a4>0&&b6>0){
                a2--;
                a4--;
                b6--;
                ans+=6;
            }
            while(a2>=3&&b6>0){
                a2-=3;
                b6--;
                ans+=6;
            }
            while(a2>0&&a3>0&&b6>0){
                a2--;
                a3--;
                b6--;
                ans+=5;
            }
            while(a4>0&&b6>0){
                a4--;
                b6--;
                ans+=4;
            }
            while(a2>=2&&b6>0){
              a2-=2;
              b6--;
              ans+=4;
            }
            while(a3>0&&b4>0){
                a3--;
                b4--;
                ans+=3;
            }
            while(a3>0&&b6>0){
                a3--;
                b6--;
                ans+=3;
            }
            while(a2>0&&b4>0){
                a2--;
                b4--;
                ans+=2;
            }
            while(a2>0&&b6>0){
                a2--;
                b6--;
                ans+=2;
            }
            System.out.println(ans);
        }

        scan.close();
    }
}

模拟时，漏了一个情况，只过了80%，还是要细心，要不然提交以后丢分了也不知道。 

其他的可能确实不太会，上面这三个丢分很可惜吧。