师哥带你每天三道蓝桥杯题[冲刺省一]~建议收藏

不要光在脑海中构建宏伟蓝图，俯下身去做才是硬道理；

您的点赞便是对我的最大支持

如果觉得本文还算不错的话，不妨加个关注

本专栏我为大家讲解100道题目的

习惯性的开篇废话

我想说啊这个蓝桥杯啊相对而言还是比较有说服力的,不仅是考研和面试的加分项,也会对你滞后的编程产生良好的正反馈作用,这里为了大家学习方便我分享给大家一个刷题网站~~

http://oj.ecustacm.cn/ 这个刷题网站我觉得很不错哦.有历年的真题和一些常规的题目,十分适合大学生刷题.

这里我再为大家强调一下,一定要去自己码出来,不要光看也不要边看边做

第一题:不同子串🎈

本题总分：5 分

【问题描述】
一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如，字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab，一共 7 个。 注意在计算时，只算本质不同的串的个数。 请问，字符串0100110001010001 有多少个不同的非空子串？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分

解析:我的做题思路

当时我看到这个题目的时候我首先分析了一下aaab 这个字符串的非空子串是怎么产生的.然后我就做出了下面的分析

a aa  aaa   aaab  4
a aa  aab   a aa  这里的 a 和 aa 已经存在所以我们要考虑一下去重
a ab        a 这里也要去一下重
b

    列出这些内容我就觉得我需要做两个循环,一个内层循环用来遍历开始的位置,然后内层循环需要遍历的截取子串,每次循环的时候将截取的范围扩大一个字符,然后对于去重操作我想到了用一个HashSet集合来装我们的数据,因为HashSet集合是一个不允许有重复数据的集合.做完这些分析我开始了写代码.

public static void main(String[] args) {
    String str="0100110001010001";
    int outer= str.length();
    int inner=outer;
    HashSet<String> set = new HashSet<>();
    for (int i = 0; i <outer; i++) {
        for (int i1 = i; i1 < inner; i1++) {
            set.add(str.substring(i,i1+1));
        }
    }
    System.out.println(set.size());
}

答案：100
这个题目说实话就是一个分析题目,我记得没错的话这应该是考场中的第一道题目,难度应该不会太高了,毕竟不能增加竞赛的心里压力嘛,难度等级 ⭐⭐⭐

做完第一道题目的选手们,信心大增满怀激情的向着省一蓄势待发,好的让我们迎来了第二道题目

第二题:数列求值🎈

本题总分：10 分
【问题描述】
给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个 4 位整数（提示：答案的千位不为 0），在提交答案时只填写这个整数，填写 多余的内容将无法得分。

    啊!这不是,对你没有看错这就是我们学习C语言时第一次接触数列时的题目,记得当时课本上的题目好像是求斐波那契数列的第10项,这个虽然和斐波那契数列不太一样但也有着异曲同工之妙,因为斐波那契数列从第 3 项开始，每项都是前 2 项的和嘛,所以啊,你看课本知识多重要,以后可要好好学啦.

解析:我的做题思路

当时我看到这个题目的时候我激动了花花的一顿操作猛如虎,依靠控制台250了.发生了什么呐.

    因为当时在做斐波那契数列相关的题目的时候用的是递归做法,所以我没想三七二十一就将代码写出来了,然后运行…然后就Exception in thread "main" java.lang.StackOverflowError 栈溢出了,然后聪明的我便开始了疯狂的百度.

递归操作导致栈溢出 ？
    在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当程序执行进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，就会导致栈溢出。函数的参数是通过stack栈来传递的，在调用中会占用线程的栈资源。递归调用在到达最后的结束点后，函数才能依次退栈清栈，如果递归调用层数过多，就可能导致占用的栈资源超过线程的最大值，从而导致栈溢出，程序异常退出。

错误代码如下：

  private  static int diGui(int n){

        if (n==1 || n==2 || n==3){
            return n =1;
        }else {
            return (diGui(n-1)+diGui(n-2)+diGui(n-3));
        }
    }

    找到问题的解决办法之后我便换了一种解题思路，回想起老师曾经教过还有一种方法，好像斐波那契数列也可以用for循环来做吧，然后我就开始写起了代码：

不是让我做第 20190324 项的最后 4 位数字。不妨我就申请一个20190324 大小的数组，然后用循环不断的进行累加，将最终的结果除以一万不就OK了嘛，对于除以一万很多人不是很理解，我这里就浅浅的为大家讲一下，大家可以举一个例子，比如说101然后我现在需要101的最后一位怎么做，101 % 100不就可以了嘛。然后我就这样写出了代码：

public static void main(String[] args) {
    int[] a =new int[20190324];
    a[0]=1;
    a[1]=1;
    a[2]=1;
    for (int i = 3; i < 20190324; i++) {
        a[i]=(a[i-1]+a[i-2]+a[i-3])%10000;
    }
    System.out.println("====="+a[20190323]);
}

答案： 4659 你做对了吗
做完这个题大家的心里感觉五味杂陈，虽然不是太难，但是过程却是有些惊心动魄，稍不留神就会error，或者直接out，路还长，大家还得且听且看，且虚心。

难度等级 ⭐⭐⭐⭐

好的做完两道题目的我们心情大爽，心里想着嗨蓝桥杯不过如此嘛，真的吗?那你还得看下一题

第三题:数的分解🎈

本题总分：10 分
【问题描述】
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，一共有多少种不同的分解方法？ 注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

    先说一下我当时看到这个题目的时候的感受，当时看到要将2019分解成三个正整数之和，当时就觉得需要进行循环和判断了。所以我就先就可能的循环写了写，并做了些分析和判断。

        1  2  2019-3      2  3  2019-5   ....
        1  3  2019-4      2  4  2019-6
        1  4  2019-5      2  5  2019-7
        1  5  2019-6      2  6  2019-8
        ...               ...

    大致的写了一下我觉得我确定了我需要做的两件事，一个是如何保证不会出现重复，如何不包含正整数2和4，第一件事：我思考了一下我们先定义一个外层循环让它从1到2019进行循环，然后再内层我们将循环的开始每次都比内层大一也就是+1，条件的话我认为应该第三个数还要大于第二个数（这个大家可以那支笔画画就可以分析出来了），并且循环不可以超过2019次。好了弄完了循环，我知道我还要进行一次过滤，当时第一反应就是将数字转换为String类型，然后再用API将其筛选。

    public static void main(String[] args) {
//        把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，
//        一共有多少种不同的分解方法？ 注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
//        过程分析 0 不是正整数
//        1  2  2019-3      2  3  2019-5   ....
//        1  3  2019-4      2  4  2019-6
//        1  4  2019-5      2  5  2019-7
//        1  5  2019-6      2  6  2019-8
//        ...               ...
//       这里我们为了保证是三个正整数之和，所以需要前两个数之和要小于 2019 因为我们的思路是用循环做的
//       所以第一个正整数不应该大于 1009  所以最大应该为 1008 1009 2  但是这个数字之前 在 2 1008 1009 中已经出现了
//        定义一个 统计变量 =====1012036  =====1016064   672  673  674
        
        int count =0;
//       外层循环从 1 -->  2019=
        int n=2019;
        for (int i = 1; i < n; i++) {
            if (Integer.toString(i).contains("2")||Integer.toString(i).contains("4")){
            }else {
                for (int j=i+1; n-i-j>j&&j<n;j++){
                    if (Integer.toString(j).contains("2")||Integer.toString(j).contains("4")){
                    }else {
                        if (Integer.toString(n-i-j).contains("2")||Integer.toString(n-i-j).contains("4")){
                        }else {
                            count++;
                        }
                    }
                }
            }
        }
        System.out.println("====="+count);
    }

其实这里有好多种做法这里我再为大家提供一种，说一下大致思路：循环过程没有差别，就是在判断时我重新写了个方法，这个方法帮我们去判断是否包含着2或者4.

    public static void main(String[] args) {
        int count=0,n=2019;
        for (int i = 1; i <=2019 ; i++) {
            for (int j = i+1; n-j-i>j&&j<n; j++) {
                if (f(i)&&f(j)&&f(n-i-j)){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
    private static boolean f(int x) {
        while (x != 0) {
            if (x % 10 == 2 || x % 10 == 4) {
                return false;
            }
            x = x / 10;
        }
        return true;
    }

    做完这个题大家是不是松了一口气啊，因为这几个题目如果在规定的时间内做出的话，起码省三等奖还是可以够得着的。

最后总结一下：看完这些，是不是感觉自己又可以了呀，但是千万不可以掉以轻心，因为我们可是要冲刺省一的呀。