0
0

蓝桥杯比赛技巧，第十二届真题解析，温故而知新，省一必拿下

前言

    蓝桥杯第十三届省赛在4月9号开始，按照以往惯例，基本填空题4道，编程题2-3道，省一基本就稳了。

    蓝桥杯省赛考的比较基础，除了最后一题，其他基本都是简单或者中等题，我们不需要所有题都做出来，只需要保证自己会做的不错，那么省一基本没有什么问题。下面是我上一次参加省赛的奖状

考试技巧

    根据我自己参加比赛的经历，省赛整体难度较低，大部分题目都可以暴力得部分分数，对于省赛，我们需要重点复习以下知识点

  1. 对于java组，我们必须要能够熟练掌握BigInteger，BigDecimal这2个类必须掌握，如果不会，马上去学习，这2个类可以实现大数的运算，具有奇效！！！

  2. 在省赛中，基本每次都有关于时间的题目，所以，对于时间的api，我们也必须要能够掌握，在java中，例如Data类，Calendar，LocalDate，LocalDateTime这几个类也必须掌握。

  3. 在省赛中数据结构肯定会考，基本的DFS，BFS必须要会，树的遍历，特点也要熟悉，对于图的几种基本算法也要学一下，如最短路径

  4. 上面的3点是必须掌握的，下面就是提升类的，蓝桥杯在以前一直被称为暴力杯，这是因为在前几届的蓝桥杯确实都是暴力解题，但是现在开始提升难度了，在上一届dp(动态规划)的题就开始增多了，如果想拿个好成绩，别犹豫，马上去刷动态规划的题目吧！！

  5. 接下来就是字符串相关的，这个也考的十分的多，建议去leetcode看一下字符串专栏，大致了解下常见的算法，在比赛时遇到最起码有个方向

  6. 下一点，全排列，不知道大家会不会，由于java没有现成的函数，所以建议现在自己写下函数，这个用到的几率很大

  7. 这点很重要，认真读题，认真读题，认真读题，题目建议多读几遍，彻底弄清楚意思后再开始想解题思路

  8. 对于难题，10分钟没有思路，马上跳过，先把自己能做的全部做了再思考，蓝桥杯的难度一般都是随题目号数递增的，也就是越到后面越难

  9. 做题，如果不是特别有经验，建议第一种解法都从暴力开始，然后进行优化

  10. 最后一点，蓝桥杯的测试案列特别少，你写完代码后可能觉得自己做对了，测试用例也对，然后就直接提交了，比赛结束后才发现自己没有考虑周全，这时已经为时已晚，我们在写完代码后，建议至少编写5个测试用例及以上，对代码进行测试，并且测试用例要数值比较大或者比较刁钻。

    总之，蓝桥杯省赛难度不大，只要学过基本的数据结构和算法，省一基本没问题，省赛的差距就是细心，最后再重复三次，**细心，细心，细心**

真题解析

    **下面对上一届的题目进行讲解说明，也就是第十二届java B组**

第一题 （ASC）

    **这道题送分题，不解释，直接给出答案，76**

第二题 （卡片）

     **这道题就是暴力模拟，我们定义10大小的数组代表0-9，每个值都是2021，然后循环判断，如果数组值都不为0，那么就继续。我们对循环的数字依次得到每个位数，然后再数组中进行相减就行，可能描述有点模糊，下面直接看代码。**

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[10];
        Arrays.fill(nums, 2021);
        int ans = 1;
        //设置标记，是否退出循环
        boolean flag = false;
        while (true) {
            //对于每一个num，通过字符串方式获取每一个数字
            for (char num : (ans + "").toCharArray()) {
                //将对于位置的数字-1，看是否为0
                if (--nums[num - '0'] == 0) {
                    flag = true;
                    break;
                }
            }
            if (flag) break;
            ans++;
        }
        System.out.println(ans);
    }

}

** 答案为：3181**

第三题 （直线）

** 这道题也简单，需要注意的就是浮点数的问题。y=kx+b，思路就是算出所有的直线的斜率k和b，然后放入set去重就行，这里需要重点注意精度问题，注意浮点数误差，我是直接使用java的BigDecimal解决的**

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 21; j++) {
                for (int m = i + 1; m < 20; m++) {
                    for (int n = 0; n < 21; n++) {
                        // y = kx + b通过2个点算出 b和k，然后返回b_k字符串，存入set
                        String bk = getBK(i, j, m, n);
                        hashSet.add(bk);
                    }
                }
            }
        }
        //这里加20是因为有20条直线没有斜率
        System.out.println(hashSet.size() + 20);
    }

    public static String getBK(double x1, double y1, double x2, double y2) {
        // k保留小数点后50位
        BigDecimal k = new BigDecimal(y1 - y2).divide(new BigDecimal(x1 - x2), 50, RoundingMode.FLOOR);
        BigDecimal b = new BigDecimal(y1).subtract(new BigDecimal(x1).multiply(k));
        // b和k都保留15位小数
        b = b.setScale(15, RoundingMode.FLOOR);
        k = k.setScale(15, RoundingMode.FLOOR);
        return b + "_" + k;
    }

}

** 答案为：40257**

第四题 （货物摆放）

** 这道题直接暴力解决即可，没什么难度，算出n的所有因数，然后循环判断就行**

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        long num = 2021041820210418L;
        HashSet<Long> hashSet = new HashSet<>();
        //将num所有因数加入集合
        for (long i = 1; i <= Math.sqrt(num); i++) {
            if (num % i == 0){
                hashSet.add(i);
                hashSet.add(num / i);
            }
        }
        long ans = 0;
        //暴力对所有因数进行循环
        for (Long x : hashSet) {
            for (Long y : hashSet) {
                for (Long z : hashSet) {
                    if (x * y * z == num)ans++;
                }
            }
        }
        System.out.println(ans);
    }

}

**     答案：2430**

第五题 （路径）

  **  这道题就是想考察图里面的最短路径问题，但是我们可以转化为dp来做，首先求出所有点到后面21个的距离，存入数组，然后进行dp即可，dp[i] = min(dp[i],dp[i-k][k]) k范围就是1-21 **

public class Main {
    public static void main(String[] args) {
        long[] dp = new long[2022];
        //存放当前点到后面21个点的距离，下标1开始
        long[][] dis = new long[2022][22];
        for (int i = 1; i < 2022; i++) {
            for (int j = 1; j < 22; j++) {
                if (i + j > 2021) break;
                dis[i][j] = getDis(i, i + j);
            }
        }
        for (int i = 1; i < 2022; i++) {
            long min = Long.MAX_VALUE;
            //求出到当前点的最小值
            for (int j = 1; j <= 21; j++) {
                if (i - j <= 0) break;
                min = Math.min(min, dp[i - j] + dis[i - j][j]);
            }
            if (min != Long.MAX_VALUE) dp[i] = min;
        }
        System.out.println(dp[dp.length - 1]);
    }

    public static long getDis(long a, long b) {
        return a * b / gcd(a, b);
    }

    public static long gcd(long a, long b) {
        return a % b == 0 ? b : gcd(b, a % b);
    }
}

** 答案：10266837**

第六题 （时间显示）

    **送分题，不解释，直接给出代码，注意输出格式，建议使用printf**

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        long time = new Scanner(System.in).nextLong();
        long h = (time / 1000 / 60 / 60) % 24;
        long m = (time / 1000 / 60) % 60;
        long s = (time / 1000) % 60;
        System.out.printf("%02d:%02d:%02d", h, m, s);
    }
}

第七题 （最少砝码）

    ** 这道题怎么说呢，可以动态规划，可以暴力模拟，但是最优解法是平衡3进制模拟，不知道大家听说过3进制没有，这里使用3进制来做，砝码3种状态刚好对应，放左边，放右边，不放，原理就是3进制，两两组合，-1，0，1，组合后可以表示不重复的9个数**

三进制十进制-1-10011-1 -1-4-1 0-3-1 1-21 -121 031 14

** 三进制数可以表示所有 [-\frac{3^n-1}{2},\frac{3^n-1}{2}](n\in Z)的数，又因为题目需要满足条件为\frac{3^n-1}{2}\geq N，通过计算，可以求出n≥log3​(2N+1)，所以我们需要的砝码重量就是3^{x}，x>=0，下面就可以很容易的写代码了，我说的可能不是很清楚，可以看下下面的解释，如果不理解，直接跳过也没关系，暴力，dp都能得大部分分。**

举个例子，平衡3进制的1和3，也就是 1 和 10这2个数就可以表示到11，也就是可以表示到4

十进制1，3，9，平衡三进制表示为 1 10 100，
这3个数通过加减运算就可以表示到-1-1-1到111的所有范围，也就是 （-14，14）

十进制1，3，9，27，平衡三进制表示为 1 10 100 1000，
这4个数就可以表示 -1-1-1-1到1111的所有范围也就是（-40，40）

** 如果还不明白，可以参考 对称三进制数详解 **

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        long n = new Scanner(System.in).nextLong();
        int count = 1;
        int i;
        for (i = 1; count < n; i++) {
            count += Math.pow(3, i);
        }
        System.out.println(i);
    }
}

第八题 （杨辉三角形）

  **   这道题涉及到数学推导，下面给出2种解放，第一种暴力，可以得一半的分**

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        if (n == 1) {
            System.out.println(1);
            return;
        }
        //动态dp，2行进行切换
        int[][] dp = new int[2][100000];
        long count = 1;
        dp[0][1] = 1;
        int i = 1, j = 1;
        //当前层数
        for (int layer = 2; ; layer++) {
            //每层的数量和当前层数相同
            for (int k = 0; k < layer; k++) {
                //简单dp
                if (layer % 2 == 0) dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                else dp[i][j] = dp[i + 1][j] + dp[i + 1][j - 1];
                count++;
                if (dp[i][j++] == n) {
                    System.out.println(count);
                    return;
                }
            }
            //根据层数判断是从0开始还是1开始
            i = layer % 2 != 0 ? 1 : 0;
            j = 1;
        }
    }
}


     如果想要得全部分，那么就要进行数学推导，从数学的方面来考虑，由于过程比较复杂，篇幅有限，直接给出推导的链接，很详细，可以自己进行查看 数学推导 得分为100

第九题 （双向排序）

**     这道题也是用到数学，但是我们暴力解决可以获得60分，也还行，下面给出暴力解法的代码和数学推导的链接**

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

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Integer[] arr = new Integer[n+1];
        for (int i = 1; i < arr.length; i++) {
            arr[i] = i;
        }
        for (int i = 0; i < m; i++) {
            int num1 = scanner.nextInt();
            int num2 = scanner.nextInt();
            //直接调用api
            if (num1 == 0){
                Arrays.sort(arr, 1, num2+1, (o1, o2) -> o2-o1);
            }else {
                Arrays.sort(arr, num2, n+1);
            }
        }
        for (int i = 1; i <= n; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}


    ** 由于博客已经很长了，数学推导不做结束，给出链接自行查看即可 数学推导，这个就可以得到100分**

第十题 （括号序列）

    ** 最后一题很难，一般都是留给打 ACM 的做的，如果不是打acm的直接跳过，对成绩没有任何影响，这道题就不进行解释了，如果感兴趣，参考 括号序列详解，这位大佬给出了详细的解法，可以参考一下**

总结

** 蓝桥杯难度主要集中在后面几题，最后一题直接放弃，我们如果没有思路，那么就使用暴力即可，能得多少分算多少，大家要相信，你觉得难，其他人也觉得难，蓝桥杯省赛，填空题4道，编程题3道，省一肯定没问题。**

** 最后再说一点，省赛不难，最重要的就是认真读题，认真读题，认真读题，细心，细心，再细心。祝愿大家都能在蓝桥杯中取得好成绩！！！**

标签： 蓝桥杯 算法 java
本文转载自: https://blog.csdn.net/m0_51545690/article/details/123979651
版权归原作者 秃头披风侠. 所有， 如有侵权，请联系我们删除。
登录后发布评论

“蓝桥杯比赛技巧，第十二届真题解析，温故而知新，省一必拿下”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航