精华内容
下载资源
问答
  • 2019第十届蓝桥杯省赛真题.zip
  • 蓝桥杯2013-2019省赛七届赛真题一览-JavaB组 包含7年所有的省赛真题解析以及试题分析,值得收藏备赛!

    A.序章

    自己对算法并不擅长,跟ACM选手比更是相差甚远,但是确实比较喜欢算法,喜欢一些经典有趣的算法,太难的我目前可能需要花费很多时间,所以暂时不打算接触ACM级别的一些算法思想和模板。听说蓝桥杯刚好适合我这种了解一些算法,喜欢算法,但并不打算学习很难的算法思想的人。所以就报了名,当前自己并不是什么有算法天赋的选手,所以当然不能裸考,于是前段时间把往届的7年真题做了一下,下面是我的一些记录,包含了所有题的解析。有几个我暂时不太懂了就没能解释清楚,但是找了大佬的AC代码。
    关于这些代码和解析的由来:

    • 一般的题都是自己做过的,并且敲出了代码。
    • 有些题可能觉得我的思路不太好的,参考了蓝桥杯官方培训给出的代码和思想。
    • 还有一些题,自己并不是很会,于是找到了一些能够AC的代码,并加入了自己的理解,一般的都给出了出处,忘给出出处的请私聊我添加。

    B.感受

    做了7年的真题,我也谈谈我对蓝桥杯的一个感受吧。

    • 必须承认的事实是,难度比起ACM确实是远远不足,很多题是可以暴力做出来的,编程题也可以通过普通的暴力和遍历拿到一部分分数。
    • 虽然如此,但是它也有它好的地方。
    • 喜欢算法,但不想太过深究的,真的是一次很好的历练机会。里面基本上还是包括了一些常见的算法思想的,dp,递归,DFS,BFS,二分,快速幂等等,也保包含了一些常见的数据结构,二叉树,线段树,图,堆等等。
    • 题目的难度有一定的过度,整体难度应该说是中等,偶尔也会有一些ACM/OI大佬都很难做出来的题。如果自己没有能力拿到全部的分数,又有什么资格说这比赛太简单了呢,事实上,我发现历年满分的选手也都是屈指可数,就连一些ACM选手也很少有能拿到满分的。
    • 也是第一次参加这个比赛,不知道这个奖的含金量高不高,所以不做任何评判。

    C.题型走向

    再来谈谈自己对蓝桥杯这七年题型走向的看法吧。仅针对JavaB组

    • 2019年以前,Java组一直都是有代码填空这个题的,2019之后就没有了,可能觉得这种题有些好猜了?确实,是可以根据上下代码,结合一些测试用例去猜出来。
    • 2013-2017年,这5年,都是填空题数量居多,编程题一般只有3-4个,但是占的分数却很高,基本上编程题占到50%以上的分数。2018年后编程题数目逐渐多起来了。
    • 我觉得还是编程题多一点要好些,更能体现选手的水平,不至于一个题没做出来而导致整个比赛的失败。
    • 填空题前几年主要喜欢考全排列问题,最近几年喜欢考枚举。都需要很细心才行。填空的压轴难度一直在提升。
    • 编程题逐渐朝算法优化上面转,压轴题需要一些特别的思维才能做出来。
    • 总的来说,试题在往好的方向发展,往灵活的方向发展。

    D.目录一览

    • 以下是2013-2019年省赛七届赛真题解析的文章目录。
    • 前面三篇篇幅有点大,后面的分开了。
    • 上篇一般是所有填空类题目,下篇一般是所有编程类题目。
    蓝桥杯专辑
    年份 链接
    2013 蓝桥杯2013年省赛[第四届]-JavaB组赛题解析
    2014 蓝桥杯2014年省赛[第五届]-JavaB组赛题解析
    2015 蓝桥杯2015年省赛[第六届]-JavaB组赛题解析
    2016 蓝桥杯2016年省赛[第七届]-JavaB组赛题解析(上)
    蓝桥杯2016年省赛[第七届]-JavaB组赛题解析(下)
    2017 蓝桥杯2017年省赛[第八届]-JavaB组赛题解析(上)
    蓝桥杯2017年省赛[第八届]-JavaB组赛题解析(下)
    2018 蓝桥杯2018年省赛[第九届]-JavaB组赛题解析(上)
    蓝桥杯2018年省赛[第九届]-JavaB组赛题解析(下)
    2019 蓝桥杯2019年省赛[第十届]-JavaB组赛题解析(上)
    蓝桥杯2019年省赛[第十届]-JavaB组赛题解析(下)

    E.逐年分析

    • 比赛时长都是4小时。
    • 2013和2014年官网没有公布分数分布情况,其余全部取自官网。有分数的总分均是150分。
    • 每年的总结在每一年文章的末尾。
    • 代码及答案均经过了官方提供的所有测试点的测试,一般都是能保证100%分数的,如果有问题,请私聊我。
    • 难度仅供参考。

    2013

    蓝桥杯2013年省赛[第四届]-JavaB组赛题解析
    序号 名称 类型 考点 难度
    1 世纪末的星期 结果填空 日期API的使用
    2 马虎的算式 结果填空 枚举
    3 振兴中华 结果填空 递归 ★★
    4 黄金连分数 结果填空 大数类的使用 ★★
    5 有理数类 代码填空 构造器的理解
    6 三部排序 代码填空 排序思想
    7 错误票据 程序设计 简单数组应用
    8 幸运数 程序设计 数组元素的挪动 ★★
    9 带分数 程序设计 全排列+check ★★★
    10 连号区间数 程序设计 区间问题 ★★

    2014

    蓝桥杯2014年省赛[第五届]-JavaB组赛题解析
    序号 名称 类型 考点 难度
    1 武功秘籍 结果填空 常识
    2 切面条 结果填空 找规律
    3 猜字母 结果填空 数组元素的挪动 ★★
    4 大衍数列 代码填空 常识
    5 圆周率 代码填空 数学计算
    6 奇怪的分式 结果填空 枚举+分数相等的判断
    7 扑克排序 结果填空 带重复元素的全排列 ★★
    8 分糖果 程序设计 过程模拟 ★★
    9 地宫取宝 程序设计 DFS+缓存优化 ★★★★
    10 矩阵翻硬币 程序设计 数学思维+大数开方 ★★★★

    2015

    蓝桥杯2015年省赛[第六届]-JavaB组赛题解析
    序号 名称 类型 分值 考点 难度
    1 三角形面积 结果填空 3 分 常识
    2 立方变自身 结果填空 5 分 枚举
    3 三羊献瑞 结果填空 9 分 枚举
    4 循环节长度 代码填空 11 分 除法模拟
    5 九数组分数 代码填空 15 分 全排列+check
    6 加法变乘法 结果填空 17 分 枚举
    7 牌型种数 结果填空 21 分 全排列 ★★
    8 饮料换购 程序设计 13 分 过程模拟
    9 垒骰子 程序设计 25 分 动态规划+矩阵快速幂 ★★★★★
    10 生命之树 程序设计 31 分 无根树应用 ★★★★

    2016

    蓝桥杯2016年省赛[第七届]-JavaB组赛题解析(上)
    蓝桥杯2016年省赛[第七届]-JavaB组赛题解析(下)
    序号 名称 类型 分值 考点 难度
    1 煤球数目 结果填空 3 分 找规律
    2 生日蜡烛 结果填空 5 分 枚举
    3 凑算式 结果填空 9 分 全排列+check
    4 分小组 代码填空 11 分 代码分析
    5 抽签 代码填空 13 分 递归
    6 方格填数 结果填空 15 分 全排列+check
    7 剪邮票 结果填空 19 分 全排列+DFS连通块检查 ★★★
    8 四平方和 程序设计 21 分 哈希枚举优化 ★★
    9 取球博弈 程序设计 23 分 博弈框架+缓存优化 ★★★★
    10 压缩变换 程序设计 31 分 线段树+前缀和 ★★★★

    2017

    蓝桥杯2017年省赛[第八届]-JavaB组赛题解析(上)
    蓝桥杯2017年省赛[第八届]-JavaB组赛题解析(下)
    序号 名称 类型 分值 考点 难度
    1 购物单 结果填空 5 分 常识
    2 纸牌三角形 结果填空 11 分 全排列+check
    3 承压计算 结果填空 13 分 精度丢失问题 ★★
    4 魔方状态 结果填空 17 分 状态转换+BFS ★★★★★
    5 取数位 代码填空 7 分 递归
    6 最大公共子串 代码填空 9 分 动态规划 ★★
    7 日期问题 程序设计 19分 枚举+日期判断 ★★
    8 包子凑数 程序设计 21 分 数论+完全背包 ★★★★
    9 分巧克力 程序设计 23 分 二分枚举优化 ★★★
    10 k倍区间 程序设计 25 分 前缀和+枚举+数学思维优化 ★★★★

    2018

    蓝桥杯2018年省赛[第九届]-JavaB组赛题解析(上)
    蓝桥杯2018年省赛[第九届]-JavaB组赛题解析(下)
    序号 名称 类型 分值 考点 难度
    1 第几天 结果填空 3 分 常识
    2 方格计数 结果填空 7 分 代数几何
    3 复数幂 结果填空 13 分 数值估计+大数类使用 ★★
    4 测试次数 结果填空 17 分 动态规划+极限思想 ★★★
    5 快速排序 代码填空 9 分 分治思想 ★★
    6 递增三元组 程序设计 11 分 前缀和+二分法 ★★★
    7 螺旋折线 程序设计 19 分 找规律 ★★★
    8 日志统计 程序设计 21 分 滑动窗口 ★★★
    9 全球变暖 程序设计 23 分 DFS ★★★★
    10 堆的计数 程序设计 25 分 堆+乘法逆元 ★★★★★

    2019

    蓝桥杯2019年省赛[第十届]-JavaB组赛题解析(上)
    蓝桥杯2019年省赛[第十届]-JavaB组赛题解析(下)
    序号 名称 类型 分值 考点 难度
    A 组队 结果填空 5 分 枚举
    B 不同子串 结果填空 5 分 枚举
    C 数列求值 结果填空 10 分 大数末位处理
    D 数的分解 结果填空 10 分 枚举
    E 迷宫 结果填空 15 分 DFS迷宫问题 ★★★
    F 特别数的和 程序设计 15 分 枚举
    G 外卖店优先级 程序设计 15 分 过程模拟优化 ★★
    H 人物相关性 程序设计 20 分 差分数+前缀和 ★★★
    I 后缀表达式 程序设计 20 分 后缀表达式+数学思维 ★★★
    J 灵能传输 程序设计 25 分 前缀和+数学思维 ★★★★

    F.写在最后的话

    • 分析往年试题能够清楚这个比赛主要倾向于考察什么,但永恒不变的就是个人的编码能力,调试能力,算法思维,数学思维。
    • 其实比赛最重要的不是拿奖,更不是看这个奖的含金量有多高,而是为比赛准备的过程中所学习到的知识。

    ATFWUS --Writing 2021-2-2

    展开全文
  • 2019第十届蓝桥杯省赛真题 试题 A: 组队 配套文档 team.txt
  • 2019第十届蓝桥杯省赛真题 试题 E: 迷宫 配套资源 maze.txt
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题C/C++(A组)!
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(G组)
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(C组)
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(B组)!
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题JAVA(A组)!
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题C/C++(G组)!
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题C/C++(C组)!
  • 2019年4月1日蓝桥杯省赛第十届蓝桥杯真题C/C++(B组)!
  • 由于蓝桥官网并未在练习系统挂上19年题目评测,故此博客大多数题目代码是通过一些非官方数据进行了评测,省赛题目大部分写完了,小部分过几天再更。如果在阅读的过程中发现有些数据过不了,欢迎大佬们留言指正!!!...

    更新一波前年蓝桥杯C++A组省赛真题。由于蓝桥官网并未在练习系统挂上19年题目评测,故此博客大多数题目代码是通过一些非官方数据进行了评测,省赛题目大部分写完了,小部分过几天再更。如果在阅读的过程中发现有些数据过不了,欢迎大佬们留言指正!!!

    以下题目与官方pdf给出顺序略有差别,为方便读者评测,留下new oj网址供读者测试代码:

    不同子串
    一个字符串的非空子串是指字符串中长度至少为1 的连续的一段字符组成的串。
    例如,字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab,一共7 个。
    注意在计算时,只算本质不同的串的个数。
    请问,字符串0100110001010001 有多少个不同的非空子串?

    #include <bits/stdc++.h>
    using namespace std;
    int main()
    {
        cout<<100;
        return 0;
    }
    
    

    Fibonacci数列与黄金分割
    在这里插入图片描述

    #include <bits/stdc++.h>
    using namespace std;
    double a[10000005];
    int m,n;
    int main()
    {
       a[1]=1.00;a[2]=1.00;
       a[3]=2.00;
       cin>>n;
       int i=4;
       while(abs((1.0*a[i-2]/a[i-1])-(1.0*a[i-3]/a[i-2]))>1e-8&&i<=n+1)
       {
           a[i]=a[i-1]+a[i-2];
           i++;
       }
       if(n>i)
        printf("%.8lf\n",1.00*a[i-2]/a[i-1]);
        else printf("%.8lf\n",1.00*a[n]/a[n+1]);
        return 0;
    }
    
    

    最短路
    在这里插入图片描述

    #include <bits/stdc++.h>
    
    using namespace std;
    int main()
    {
        cout<<6;
    }
    

    字串数字
    在这里插入图片描述

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
       cout<<3725573269;
        return 0;
    
    }
    
    

    立方和

    #include <bits/stdc++.h>
    
    using namespace std;
    int judge(int n)
    {
        while(n)
        {
            int t=n%10;
            if(t==2||t==0||t==1||t==9)return 1;
            n/=10;
        }
        return 0;
    }
    int main()
    {
        unsigned long long ans=0;
        for(long long i=1;i<=2019;i++)
            if(judge(i))ans+=i*i*i;
        cout<<ans;
        return 0;
    
    }
    
    

    旋转
    在这里插入图片描述

    #include <bits/stdc++.h>
    using namespace std;
    int m,n,a[105][105];
    int main()
    {
        scanf("%d %d",&n,&m);
        for(int i=n;i>=1;i--)
            for(int j=1;j<=m;j++)
            cin>>a[j][i];
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++)
            printf("%d ",a[i][j]);
            printf("\n");}
        return 0;
    }
    
    

    质数

    print("17569")
    

    矩形切割
    在这里插入图片描述

    print("21")
    

    求和

    print("1905111")
    

    等差数列

    #include <bits/stdc++.h>
    
    using namespace std;
    int a[100005],n;
    long long ans;
    int main()
    {
        scanf("%d",&n);
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        sort(a,a+n);
        int k=100005;
        for(int i=1;i<n;i++)
            k=min(k,a[i]-a[i-1]);
        if(k==0)ans=n;
        else ans=(a[n-1]-a[0])/k+1;
        cout<<ans<<endl;
        return 0;
    }
    
    

    特别数的和

    #include <bits/stdc++.h>
    
    using namespace std;
    int n;
    int fun(int x)
    {
        while(x)
        {
            int k=x%10;
            if(k==2||k==0||k==1||k==9)
                return 1;
            x/=10;
        }
        return 0;
    }
    int ans;
    int main()
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            if(fun(i))ans+=i;
        }
        cout<<ans<<endl;
    }
    
    

    数的分解

    print("40785")
    

    年号字串
    话说这个可以用Excel直接模拟?

    print("BYQ")
    

    组队

    print("490")
    

    糖果

    #include<bits/stdc++.h>
    #define x first
    #define y second
    #define MP make_pair
    using namespace std;
    typedef long long LL;
    typedef pair<int, int> PII;
    //树形dp
    int n, m, k;
    int can[100][20], dp[1 << 20];
    
    int main(void){
        cin >> n >> m >> k;
        memset(can, 0, sizeof(can));
        memset(dp, -1, sizeof(dp));
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < k; ++j){
                cin >> can[i][j];
                can[i][j]--;
            }
    
    
        int lim = 1 << m;
        dp[0] = 0;
        for (int i = 0; i < n; ++i){
            int t = 0;
            for (int j = 0; j < k; ++j) t |= (1 << can[i][j]);
            for (int st = 0; st < lim; ++st){
                if (dp[st] == -1) continue;
                int nst = st | t;
                if (dp[nst] == -1 || dp[nst] > dp[st] + 1) dp[nst] = dp[st] + 1;
            }  
        }
        cout << dp[lim - 1];
        return 0;
    }
    
    
    

    修改数组

    #include <bits/stdc++.h>
    //单链并查集
    using namespace std;
    const int N=1e6+5;
    int n,S[N],d;
    int find_(int x)
    {
        if(x!=S[x])S[x]=find_(S[x]);
        return S[x];
    }
    int main()
    {
        scanf("%d",&n);
       for(int i=1;i<=N;i++)
       {
           S[i]=i;
       }
       for(int i=1;i<=n;i++)
       {
           scanf("%d",&d);
           d=find_(d);
           cout<<d<<" ";
           S[d]++;
       }
        return 0;
    }
    
    

    外卖店优先级
    “饱了么”外卖系统中维护着N 家外卖店,编号1~N。
    每家外卖店都有一个优先级,初始时(0 时刻) 优先级都为0。
    每经过1 个时间单位,如果外卖店没有订单,则优先级会减少1,最低减到0;
    而如果外卖店有订单,则优先级不减反加,每有一单优先级加2。
    如果某家外卖店某时刻优先级大于5,则会被系统加入优先缓存中;
    如果优先级小于等于3,则会被清除出优先缓存。
    给定T 时刻以内的M 条订单信息,请你计算T 时刻时有多少外卖店在优先缓存中。

    #include <bits/stdc++.h>
    
    using namespace std;
    int n,t,m,ans;
    int id[100005],tag[100005];
    struct node
    {
        int no,t1;
    }a[100005];
    bool cmp(node &a,node &b)
    {
       if(a.no!=b.no)return a.no<b.no;
       return a.t1<b.t1;
    }
    int main()
    {
       scanf("%d %d %d",&n,&m,&t);
       for(int i=1;i<=m;i++)
       {
           scanf("%d %d",&a[i].t1,&a[i].no);
       }
       sort(a+1,a+1+m,cmp);
       int t2=a[1].t1;
       for(int i=1;i<=m&&a[i].t1<=t;i++)
       {
           if(a[i].t1-t2-1>0)
            id[a[i].no]-=(a[i].t1-t2-1);
           if(id[a[i].no]<0)id[a[i].no]=0;
           t2=a[i].t1;
           id[a[i].no]+=2;
           if(id[a[i].no]>5)tag[a[i].no]=t2;
           else if(id[a[i].no]<4)tag[a[i].no]=0;
       }
       //printf("%d %d\n",id[1],id[2]);
       for(int i=1;i<=n;i++)
       {
           if(id[i]-(t-tag[i])>3)
            ans++;
       }
       printf("%d\n",ans);
        return 0;
    }
    
    

    完全二叉树的权值

    #include <bits/stdc++.h>
    
    using namespace std;
    const int N=1e5+10;
    long long a[105];
    int t,d;
    int main()
    {
        scanf("%d",&t);
        int n=t;
        t=ceil(1.0*log2(t+1));
        for(int i=0;i<t;i++)
        {
            int l=pow(2,i);
            for(int j=1;j<=l&&n>0;j++)
            {
              scanf("%d",&d);
              n--;
              a[i]+=d;
            }
        }
        int k=0;
        for(int i=1;i<t;i++)
        {
            if(a[i]>a[k])k=i;
        }
        cout<<k+1<<endl;
        return 0;
    }
    
    

    最大降雨量

    print(34)
    

    数列求值

    #include <bits/stdc++.h>
    
    using namespace std;
    
    int main()
    {
        int a,b,c,d;
        a=b=c=1;
        for(int i=4;i<=20190324;i++)
        {
            d=a+b+c;
            a=b;
            b=c;
            c=d%10000;
        }
        cout<<d%10000<<endl;
        return 0;
    
    }
    
    

    平方和
    小明对数位中含有2、0、1、9 的数字很感兴趣,在1 到40 中这样的数包
    括1、2、9、10 至32、39 和40,共28 个,他们的和是574,平方和是14362。
    注意,平方和是指将每个数分别平方后求和。
    请问,在1 到2019 中,所有这样的数的平方和是多少?

    #include <bits/stdc++.h>
    
    using namespace std;
    int judge(int n)
    {
        while(n)
        {
            int t=n%10;
            if(t==2||t==0||t==1||t==9)return 1;
            n/=10;
        }
        return 0;
    }
    int main()
    {
        unsigned long long ans=0;
        for(long long i=1;i<=2019;i++)
            if(judge(i))ans+=i*i;
        cout<<ans;
        return 0;
    
    }
    
    

    。。剩下几题补完再更

    展开全文
  • 2019第十届蓝桥杯省赛真题(JavaB组题解)试题 A: 组队试题 B: 不同子串试题 C: 数列求值试题 D: 数的分解试题 E: 迷宫试题 F: 特别数的和试题 G: 外卖店优先级试题 H: 人物相关性分析试题 I: 后缀表达式试题 J: 灵...

    试题 A: 组队

    本题总分:5 分

    【问题描述】
    作为篮球队教练,你需要从以下名单中选出 1 号位至 5 号位各一名球员, 组成球队的首发阵容。
    每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1
    号位至 5 号位的评分之和最大可能是多少?
    1

    (如果你把以上文字复制到文本文件中,请务必检查复制的内容是否与文 档中的一致。在试题目录下有一个文件 team.txt,内容与上面表格中的相同, 请注意第一列是编号)

    team.txt文件下载

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    //第十届蓝桥杯省赛真题 试题 A: 组队
    public class Main{
        public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int[][] team=new int[20][5];
        for (int i=0;i<20;i++){
            for (int j=0;j<5;j++){
                team[i][j]=sc.nextInt();
            }
        }
        int maxSum=0;
        for (int i=0;i<20;i++)
            for (int j=0;j<20;j++)
                for (int k=0;k<20;k++)
                    for (int l=0;l<20;l++)
                        for (int m=0;m<20;m++){
                            if ((i != j && i != k && i != l && i != m) && (j != k && j != l && j != m) && (k != l && k != m) &&( l != m) ){
                                int max=team[i][0]+team[j][1]+team[k][2]+team[l][3]+team[m][4];
                                if (max>maxSum)
                                    maxSum=max;
                            }
                        }
            System.out.println(maxSum);
            sc.close();
        }
    }
    

    答案:490

    试题 B: 不同子串

    本题总分:5 分

    【问题描述】
    一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成的串。例如,字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab,一共 7 个。注意在计算时,只算本质不同的串的个数。
    请问,字符串0100110001010001 有多少个不同的非空子串?

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    //第十届蓝桥杯省赛真题 试题 B: 不同子串
    public class Main{
        public static void main(String[] args) {
            String target = "0100110001010001";
            //Set不允许有重复元素
            Set<String> sub = new HashSet<>();
            for(int i = 0; i < target.length(); i++) {
                for(int begin = 0, end = 1 + i; end <= target.length(); begin++, end++) {
                    sub.add(target.substring(begin, end));
                }
            }
            System.out.println(sub.size());
        }
    }
    

    答案:100

    试题 C: 数列求值

    本题总分:10 分

    【问题描述】
    给定数列 1, 1, 1, 3, 5, 9, 17, …,从第 4 项开始,每项都是前 3 项的和。求第 20190324 项的最后 4 位数字。

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个 4 位整数(提示:答案的千位不为 0),在提交答案时只填写这个整数,填写多余的内容将无法得分。

    //第十届蓝桥杯省赛真题 试题 C: 数列求值
    public class Main {
        public static void main(String[] args) {
            int[] a = new int[20190324];
            a[0] = a[1] = a[2] = 1;
            //只与最后四位数字有关
            for(int i = 3; i < 20190324; i++) {
                a[i] = (a[i - 3] + a[i - 2] + a[i - 1]) % 10000;
            }
            System.out.println(a[20190323]);
            }
    }
    

    答案:4659

    试题 D: 数的分解

    本题总分:10 分

    【问题描述】
    把 2019 分解成 3 个各不相同的正整数之和,并且要求每个正整数都不包含数字 2 和 4,一共有多少种不同的分解方法?
    注意交换 3 个整数的顺序被视为同一种方法,例如 1000+1001+18 和1001+1000+18 被视为同一种。

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    //第十届蓝桥杯省赛真题  试题 D: 数的分解
    public class Main {
        public static void main(String[] args) {
            //求把 2019 分解成 3 个各不相同的正整数之和也就是说只保留ABC类的组合方式
            int n = 2019;
            int num = 0;
            for (int i = 1; i < n; i++) {
                //要求每个正整数都不包含数字2和4
                if ((i + "").indexOf("2") != -1 || (i + "").indexOf("4") != -1)
                    continue;
                for (int j = i + 1; j < n; j++) {
                    if ((j + "").indexOf("2") != -1 || (j + "").indexOf("4") != -1)
                        continue;
                    int k = n - i - j;
                    if (i == k || j == k || i == j)
                        continue;
                    if (k > 0 && (k + "").indexOf("2") == -1 && (k + "").indexOf("4") == -1)
                        num++;
                }
            }
            //因为A、B、C三个数的排列可能位置是ABC、ACB、CAB可能这三种重复的情况,所以需要除3
            System.out.println(num / 3);
        }
    }
    
    

    答案:40785

    试题 E: 迷宫

    本题总分:15 分

    【问题描述】

    下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可以通行的地方。

    010000
    000100
    001001
    110000

    迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这 个它的上、下、左、右四个方向之一。
    对于上面的迷宫,从入口开始,可以按DRRURRDDDR 的顺序通过迷宫, 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。
    对于下面这个更复杂的迷宫(30 行 50 列),请找出一种通过迷宫的方式,其使用的步数最少,在步数最少的前提下,请找出字典序最小的一个作为答案。请注意在字典序中D<L<R<U。(如果你把以下文字复制到文本文件中,请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt, 内容与下面的文本相同)

    maze.txt文件下载

    01010101001011001001010110010110100100001000101010
    00001000100000101010010000100000001001100110100101
    01111011010010001000001101001011100011000000010000
    01000000001010100011010000101000001010101011001011
    00011111000000101000010010100010100000101100000000
    11001000110101000010101100011010011010101011110111
    00011011010101001001001010000001000101001110000000
    10100000101000100110101010111110011000010000111010
    00111000001010100001100010000001000101001100001001
    11000110100001110010001001010101010101010001101000
    00010000100100000101001010101110100010101010000101
    11100100101001001000010000010101010100100100010100
    00000010000000101011001111010001100000101010100011
    10101010011100001000011000010110011110110100001000
    10101010100001101010100101000010100000111011101001
    10000000101100010000101100101101001011100000000100
    10101001000000010100100001000100000100011110101001
    00101001010101101001010100011010101101110000110101
    11001010000100001100000010100101000001000111000010
    00001000110000110101101000000100101001001000011101
    10100101000101000000001110110010110101101010100001
    00101000010000110101010000100010001001000100010101
    10100001000110010001000010101001010101011111010010
    00000100101000000110010100101001000001000000000010
    11010000001001110111001001000011101001011011101000
    00000110100010001000100000001000011101000000110011
    10101000101000100010001111100010101001010000001000
    10000010100101001010110000000100101010001011101000
    00111100001000010000000110111000000001000000001011
    10000001100111010111010001000110111010101101111000

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个字符串,包含四种字母 D、U、L、R,在提交答案时只填写这个字符串,填写多余的内容将无法得分。

    //第十届蓝桥杯省赛真题  试题 E: 迷宫
    public class Main {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            try {
                String s = "01010101001011001001010110010110100100001000101010"
                         + "00001000100000101010010000100000001001100110100101"
                         + "01111011010010001000001101001011100011000000010000"
                         + "01000000001010100011010000101000001010101011001011"
                         + "00011111000000101000010010100010100000101100000000"
                         + "11001000110101000010101100011010011010101011110111"
                         + "00011011010101001001001010000001000101001110000000"
                         + "10100000101000100110101010111110011000010000111010"
                         + "00111000001010100001100010000001000101001100001001"
                         + "11000110100001110010001001010101010101010001101000"
                         + "00010000100100000101001010101110100010101010000101"
                         + "11100100101001001000010000010101010100100100010100"
                         + "00000010000000101011001111010001100000101010100011"
                         + "10101010011100001000011000010110011110110100001000"
                         + "10101010100001101010100101000010100000111011101001"
                         + "10000000101100010000101100101101001011100000000100"
                         + "10101001000000010100100001000100000100011110101001"
                         + "00101001010101101001010100011010101101110000110101"
                         + "11001010000100001100000010100101000001000111000010"
                         + "00001000110000110101101000000100101001001000011101"
                         + "10100101000101000000001110110010110101101010100001"
                         + "00101000010000110101010000100010001001000100010101"
                         + "10100001000110010001000010101001010101011111010010"
                         + "00000100101000000110010100101001000001000000000010"
                         + "11010000001001110111001001000011101001011011101000"
                         + "00000110100010001000100000001000011101000000110011"
                         + "10101000101000100010001111100010101001010000001000"
                         + "10000010100101001010110000000100101010001011101000"
                         + "00111100001000010000000110111000000001000000001011"
                         + "10000001100111010111010001000110111010101101111000";
                        int[][] labyrinth = new int[30][50];
                        for (int i = 0; i < 30; i++) {
                            for (int j = 0; j < 50; j++) {
                                labyrinth[i][j] = s.charAt(50 * i + j) - '0';
                            }
                        }
                        System.out.println(BFS(labyrinth, 30, 50));
                    } catch (Exception e) {
                        input.close();
                    }
                }
    
                public static String BFS(int[][] labyrinth, int row, int column) {
                    int[][] stepArr = { { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 0 } };
                    String[] direction = { "U", "R", "L","D"};
                    int[][] visit = new int[row][column];// 标记是否已经访问过
                    StringBuilder sb = new StringBuilder();
                    Node node = new Node(0, 0, -1, -1, 0, null);
                    Queue<Node> queue = new LinkedList<Node>();
                    Stack<Node> stack = new Stack<Node>();
                    queue.offer(node);
                    while (!queue.isEmpty()) {
                        Node head = queue.poll();
                        stack.push(head); // 用于回溯路径
                        visit[head.x][head.y] = 1;
                        for (int i = 0; i < 4; i++) {
                            int x = head.x + stepArr[i][0];
                            int y = head.y + stepArr[i][1];
                            String d = direction[i];
                            // exit
                            if (x == row - 1 && y == column - 1 && labyrinth[x][y] == 0 && visit[x][y] == 0) {
                                // 打印路径
                                Node top = stack.pop();
                                sb.append(d);
                                sb.append(top.direction);
                                int preX = top.preX;
                                int preY = top.preY;
                                while (!stack.isEmpty()) {
                                    top = stack.pop();
                                    if (preX == top.x && preY == top.y) {
                                        if (top.direction != null)
                                            sb.append(top.direction);
                                        preX = top.preX;
                                        preY = top.preY;
                                    }
    
                                }
                                return sb.reverse().toString();
                            }
                            // bfs
                            if (x >= 0 && x < row && y >= 0 && y < column && labyrinth[x][y] == 0 && visit[x][y] == 0) {
                                Node newNode = new Node(x, y, head.x, head.y, head.step + 1, d);
                                queue.offer(newNode);
                            }
                        }
                    }
                    return null;
                }
            }
    
            class Node {
                int x, y;
                int step;
                int preX, preY;
                String direction;
    
                Node(int x, int y, int preX, int preY, int step, String direction) {
                    this.x = x;
                    this.y = y;
                    this.preX = preX;
                    this.preY = preY;
                    this.step = step;
                    this.direction = direction;
                }
            }
    
    

    答案:DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

    试题 F: 特别数的和

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:15 分

    【问题描述】
    小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。请问,在 1 到 n 中,所有这样的数的和是多少?
    【输入格式】
    输入一行包含一个整数n。

    【输出格式】
    输出一行,包含一个整数,表示满足条件的数的和。

    【样例输入】
    40

    【样例输出】
    574

    【评测用例规模与约定】
    对于 20% 的评测用例,1 ≤ n ≤ 10。对于 50% 的评测用例,1 ≤ n ≤ 100。对于 80% 的评测用例,1 ≤ n ≤ 1000。对于所有评测用例,1 ≤ n ≤ 10000。

    //第十届蓝桥杯省赛真题  试题 F: 特别数的和
    public class Main {
        public static void main(String[] args) {
                Scanner sc = new Scanner(System.in);
                int n = sc.nextInt();
                int sum = 0;
                for (int i = 1; i <= n; i++) {
                    int b = i;
                    while (b != 0) {
                        int a = b % 10;
                        if (a == 2 || a == 0 || a == 1 || a == 9) {
                            sum += i;
                            break;
                        }
                        b /= 10;
                    }
                }
                System.out.println(sum);
            }
       }
    

    试题 G: 外卖店优先级

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分

    【问题描述】
    “饱了么”外卖系统中维护着 N 家外卖店,编号 1 ∼ N。每家外卖店都有一个优先级,初始时 (0 时刻) 优先级都为 0。
    每经过 1 个时间单位,如果外卖店没有订单,则优先级会减少 1,最低减到 0;而如果外卖店有订单,则优先级不减反加,每有一单优先级加 2。
    如果某家外卖店某时刻优先级大于 5,则会被系统加入优先缓存中;如果优先级小于等于 3,则会被清除出优先缓存。
    给定 T 时刻以内的 M 条订单信息,请你计算 T 时刻时有多少外卖店在优先缓存中。

    【输入格式】
    第一行包含 3 个整数 N、M 和 T 。
    以下 M 行每行包含两个整数 ts 和 id,表示 ts 时刻编号 id 的外卖店收到一个订单。

    【输出格式】
    输出一个整数代表答案。

    【样例输入】
    2 6 6
    1 1
    5 2
    3 1
    6 2
    2 1
    6 2

    【样例输出】
    1

    【样例解释】
    6 时刻时,1 号店优先级降到 3,被移除出优先缓存;2 号店优先级升到 6, 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
    【评测用例规模与约定】
    对于 80% 的评测用例,1 ≤ N, M, T ≤ 10000。
    对于所有评测用例,1 ≤ N, M, T ≤ 100000,1 ≤ ts ≤ T ,1 ≤ id ≤ N。

    //第十届蓝桥杯省赛真题  试题 G: 外卖店优先级
    public class Main{
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            try {
                Set<Integer> set = new HashSet<Integer>();
                int N = input.nextInt();
                int M = input.nextInt();
                int T = input.nextInt();
                int[][] orders = new int[M][2];
                for (int i = 0; i < M; i++) {
                    for (int j = 0; j < 2; j++) {
                        orders[i][j] = input.nextInt();
                    }
                }
                int[] priority = new int[N];
                int[] sign = new int[N];
                for (int i = 1; i <= T; i++) {
                    for (int j = 0; j < M; j++) {
                        if (orders[j][0] == i) {
                            priority[orders[j][1] - 1] += 2;
                            if (priority[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {
                                set.add(orders[j][1] - 1);
                            }
                            sign[orders[j][1] - 1] = 1;
                        }
                    }
                    for (int j = 0; j < N; j++) {
                        if (sign[j] == 0 && priority[j] > 0)
                            priority[j]--;
                        if (priority[j] <= 3) {
                            set.remove(j);
                        }
                    }
                    sign = new int[N];
                }
                System.out.println(set.size());
            } catch (Exception e) {
                input.close();
            }
        }
    }
    

    试题 H: 人物相关性分析

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:20 分

    【问题描述】
    小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob
    有多少次同时出现。
    更准确的说,小明定义 Alice 和 Bob“同时出现”的意思是:在小说文本中 Alice 和 Bob 之间不超过 K 个字符。
    例如以下文本:
    This is a story about Alice and Bob. Alice wants to send a private message to Bob.
    假设 K = 20,则 Alice 和 Bob 同时出现了 2 次,分别是”Alice and Bob”
    和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符,后者有 2 个字符。注意:
    1.Alice 和 Bob 是大小写敏感的,alice 或 bob 等并不计算在内。
    2.Alice 和 Bob 应为单独的单词,前后可以有标点符号和空格,但是不能有字母。例如 Bobbi 並不算出现了 Bob。
    【输入格式】
    第一行包含一个整数 K。
    第二行包含一行字符串,只包含大小写字母、标点符号和空格。长度不超 过 1000000。
    【输出格式】
    输出一个整数,表示 Alice 和 Bob 同时出现的次数。

    【样例输入】
    20
    This is a story about Alice and Bob. Alice wants to send a private message to Bob.

    【样例输出】
    2

    【评测用例规模与约定】
    对于所有评测用例,1 ≤ K ≤ 1000000。

    //第十届蓝桥杯省赛真题  试题 H: 人物相关性分析
    public class Main{
        public static void main(String[] args)  {
            Scanner reader=new Scanner(System.in);
            int res=0;    //save result
            int K=reader.nextInt();
            reader.nextLine();    //nextLine吸取回车键
            String str=reader.nextLine();
            String words[]=str.split("\\s+|\\.");    //以空格和.分割出来,注意.空格的组合存放为空字符串
    
            //    Alice------>Bob
            for(int i=0;i<words.length;i++){
                if(words[i].equals("Alice")){
                    for(int j=i+1;j<words.length;j++){
                        if(words[j].equals("Bob")){
                            int sum=1;    //这里要等于1
                            for(int k=i+1;k<j;k++){
                                sum+=words[k].length()+1;
                            }
                            if(sum<=K){
                                res++;
                            }
                        }
                    }
                }
            }
    
            //Bob--------->Alice
            for(int i=0;i<words.length;i++){
                if(words[i].equals("Bob")){
                    for(int j=i+1;j<words.length;j++){
                        if(words[j].equals("Alice")){
                            int sum=1;    //这里要等于1
                            for(int k=i+1;k<j;k++){
                                sum+=words[k].length()+1;
                            }
                            if(sum<=K){
                                res++;
                            }
                        }
                    }
                }
            }
            System.out.println(res);
        }
    }
    

    试题 I: 后缀表达式

    时间限制: 1.0s 内存限制: 512.0MB 本题总分:25 分

    【问题描述】
    给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1, A2, · · · , AN+M+1,小明想知道在所有由这 N 个加号、M 个减号以及 N + M + 1 个整数凑出的合法的后缀表达式中,结果最大的是哪一个?
    请你输出这个最大的结果。
    例如使用1 2 3 + -,则 “2 3 + 1 -” 这个后缀表达式结果是 4,是最大的。

    【输入格式】
    第一行包含两个整数 N 和 M。
    第二行包含 N + M + 1 个整数 A1, A2, · · · , AN+M+1。
    【输出格式】
    输出一个整数,代表答案。

    【样例输入】
    1 1
    1 2 3

    【样例输出】
    4

    【评测用例规模与约定】
    对于所有评测用例,0 ≤ N, M ≤ 100000,−109 ≤ Ai ≤ 109。

    //第十届蓝桥杯省赛真题  试题 I: 后缀表达式
    public class Main {
        public static void main(String[] args) {
            Scanner input = new Scanner(System.in);
            try {
                int add = input.nextInt();
                int reduce = input.nextInt();
                int totalLength = add + reduce + 1;
                int[] number = new int[totalLength];
                for (int i = 0; i < totalLength; i++) {
                    number[i] = input.nextInt();
                }
                int sum = 0;
                if (reduce == 0) {
                    for (int i = 0; i < totalLength; i++) {
                        sum += number[i];
                    }
                }
                if (add == 0) {
                    Arrays.sort(number);
                    if (number[0] < 0) {
                        for (int i = 0; i <= reduce; i++) {
                            if (number[i] > 0)
                                sum += number[i];
                            else
                                sum -= number[i];
                        }
                    } else {
                        for (int i = 1; i <= reduce; i++) {
                            sum += number[i];
                        }
                        sum -= number[0];
                    }
                }
                if (add != 0 && reduce != 0) {
                    int reduceNum = 0;
                    for (int i = 0; i < totalLength; i++) {
                        if (number[i] < 0) {
                            reduceNum++;
                        }
                    }
                    if (reduce >= reduceNum) {
                        Arrays.sort(number);
                        int temp = reduce;
                        for (int i = 0; i < reduceNum; i++) {
                            number[i] = -number[i];
                            temp--;
                        }
                        Arrays.sort(number);
                        for (int i = totalLength - 1; i >= temp; i--) {
                            sum += number[i];
                        }
                        for (int i = temp - 1; i >= 0; i--) {
                            sum -= number[i];
                        }
                    } else {
                        Arrays.sort(number);
                        sum += number[totalLength - 1];
                        for (int i = 0; i < totalLength - 1; i++) {
                            if (number[i] > 0)
                                sum += number[i];
                            else
                                sum -= number[i];
                        }
                    }
                }
                System.out.println(sum);
            } catch (Exception e) {
                input.close();
            }
        }
    }
    

    试题 J: 灵能传输

    时间限制: 5.0s 内存限制: 512.0MB 本题总分:25 分

    【题目背景】
    在游戏《星际争霸 II》中,高阶圣堂武士作为星灵的重要 AOE 单位,在游戏的中后期发挥着重要的作用,其技能”灵能风暴“可以消耗大量的灵能对 一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的 刺蛇飞龙等低血量单位。

    【问题描述】
    你控制着 n 名高阶圣堂武士,方便起见标为 1, 2, · · · , n。每名高阶圣堂武士需要一定的灵能来战斗,每个人有一个灵能值 ai 表示其拥有的灵能的多少(ai 非负表示这名高阶圣堂武士比在最佳状态下多余了 ai 点灵能,ai 为负则表示这名高阶圣堂武士还需要 −ai 点灵能才能到达最佳战斗状态)。现在系统赋予了 你的高阶圣堂武士一个能力,传递灵能,每次你可以选择一个 i ∈ [2, n − 1],若ai ≥ 0 则其两旁的高阶圣堂武士,也就是 i − 1、i + 1 这两名高阶圣堂武士会从i 这名高阶圣堂武士这里各抽取 ai 点灵能;若 ai < 0 则其两旁的高阶圣堂武士, 也就是 i − 1, i + 1 这两名高阶圣堂武士会给 i 这名高阶圣堂武士 −ai 点灵能。形式化来讲就是 ai−1+ = ai, ai+1+ = ai, ai− = 2ai。
    灵能是非常高效的作战工具,同时也非常危险且不稳定,一位高阶圣堂 武士拥有的灵能过多或者过少都不好,定义一组高阶圣堂武士的不稳定度为

    n i=1

    |ai|,请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武

    士的不稳定度最小。

    【输入格式】
    本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。接下来依次输入每一组询问。
    每组询问的第一行包含一个正整数 n,表示高阶圣堂武士的数量。接下来一行包含 n 个数 a1, a2, · · · , an。

    【输出格式】
    输出 T 行。每行一个整数依次表示每组询问的答案。

    【样例输入】
    3
    3
    5 -2 3
    4
    0 0 0 0
    3
    1 2 3

    【样例输出】
    3
    0
    3

    【样例说明】
    对于第一组询问:
    对 2 号高阶圣堂武士进行传输操作后 a1 = 3,a2 = 2,a3 = 1。答案为 3。对于第二组询问:
    这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。

    【样例输入】
    3
    4
    -1 -2 -3 7
    4
    2 3 4 -8
    5
    -1 -1 6 -1 -1

    【样例输出】
    5
    7
    4

    【样例输入】
    见文件trans3.in。

    【样例输出】
    见文件trans3.ans。

    【数据规模与约定】
    对于所有评测用例,T ≤ 3,3 ≤ n ≤ 300000,|ai| ≤ 109。
    评测时将使用 25 个评测用例测试你的程序,每个评测用例的限制如下:

    2

    注意:本题输入量较大请使用快速的读入方式。

    2019第十届蓝桥杯省赛真题相关资源(免费的!)

    ···

    展开全文
  • 2019年第十届java B组蓝桥杯省赛真题及题解 题目 第一题:组队 第二题:不同子串 第三题:数列求值 第四题:数的分解 第五题:迷宫 第六题:特别数的和 第七题:外卖店优先级 第八题:人物相关性分析 第九题:后缀...


    所有答案均为个人想法 仅供参考,如有问题 欢迎指正

    第一题:组队

    题目描述
    作为篮球队教练,你需要从以下名单中选出 1 号位至 5 号位各一名球员, 组成球队的首发阵容。
    每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少?
    在这里插入图片描述


    个人答案:

    490

    思路:

    1号位 1 号选手 97
    2号位 10号选手 99
    3号位 17号选手 99
    4号位 11号选手 97
    5号位 12号选手 98
    总合:97+99+99+97+98=490




    第二题:不同子串

    题目描述
    一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串。例如,字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab,一共 7 个。 注意在计算时,只算本质不同的串的个数。
    请问,字符串0100110001010001 有多少个不同的非空子串?

    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。


    个人答案:

    100

    个人代码:

    import java.util.*;
    
    public class Main {
        public static void main(String[] args) {
            String s="0100110001010001";
            List<String> count = new ArrayList<>();
            for (int i=0;i<s.length();++i){
                for (int j=i;j<s.length();++j){
                    for (int k=i;k<=j;++k){
                        if (!count.contains(s.substring(i, k+1))){
                            count.add(s.substring(i,k+1));
                        }
                    }
                }
            }
    //        for (String s1 : count) {
    //            System.out.println(s1);
    //        }
            System.out.println(count.size());
            
        }
    }
    




    第三题:数列求值

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


    个人答案:

    4659

    个人代码:

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




    第四题:数的分解

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


    个人答案:

    40785

    个人代码:

    
    public class Main {
    
    //直接用暴力解的
        public static void main(String[] args) {
            int count = 0;
            for (int i = 1; i <= 2019; ++i) {
                for (int j = i + 1; j <= 2019; ++j) {
                    for (int k = j + 1; k <= 2019; ++k) {
                        if (check(i) && check(j) && check(k) && i + j + k == 2019) {
                            count++;
                            break;
    
                        }
    
                    }
                }
            }
            System.out.println(count);
        }
        
        public static boolean check(int n) {
            String s = n + "";
            boolean is = true;
            for (int i = 0; i < s.length(); ++i) {
                if (s.charAt(i) == '2' || s.charAt(i) == '4') {
                    is = false;
                    break;
                }
            }
            return is;
        }
        
    }
    




    第五题:迷宫

    题目描述
    下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可
    以通行的地方。
    010000
    000100
    001001
    110000
    迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这
    个它的上、下、左、右四个方向之一。
    对于上面的迷宫,从入口开始,可以按DRRURRDDDR 的顺序通过迷宫,
    一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。
    对于下面这个更复杂的迷宫(30 行 50 列) ,请找出一种通过迷宫的方式,
    其使用的步数最少,在步数最少的前提下,请找出字典序最小的一个作为答案。
    请注意在字典序中D<L<R<U。(如果你把以下文字复制到文本文件中,请务
    必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt,
    内容与下面的文本相同)
    01010101001011001001010110010110100100001000101010
    00001000100000101010010000100000001001100110100101
    01111011010010001000001101001011100011000000010000
    01000000001010100011010000101000001010101011001011
    00011111000000101000010010100010100000101100000000
    11001000110101000010101100011010011010101011110111
    00011011010101001001001010000001000101001110000000
    10100000101000100110101010111110011000010000111010
    00111000001010100001100010000001000101001100001001
    11000110100001110010001001010101010101010001101000
    00010000100100000101001010101110100010101010000101
    11100100101001001000010000010101010100100100010100
    00000010000000101011001111010001100000101010100011
    10101010011100001000011000010110011110110100001000
    10101010100001101010100101000010100000111011101001
    10000000101100010000101100101101001011100000000100
    10101001000000010100100001000100000100011110101001
    00101001010101101001010100011010101101110000110101
    11001010000100001100000010100101000001000111000010
    00001000110000110101101000000100101001001000011101
    10100101000101000000001110110010110101101010100001
    00101000010000110101010000100010001001000100010101
    10100001000110010001000010101001010101011111010010
    00000100101000000110010100101001000001000000000010
    11010000001001110111001001000011101001011011101000
    00000110100010001000100000001000011101000000110011
    10101000101000100010001111100010101001010000001000
    10000010100101001010110000000100101010001011101000
    00111100001000010000000110111000000001000000001011
    10000001100111010111010001000110111010101101111000
    【答案提交】
    这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个字符串,包含四种字母 D、U、L、R,在提交答案时只填写这个字符串,填 写多余的内容将无法得分。


    个人答案:

    DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

    个人代码:

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.util.*;
    
    public class Main {
        //走的顺序 下->左->右->上
        static int[][] trval = {{1, 0}, {0, -1}, {0, 1}, {-1, 0}};
        //判断某个点是否走过
        static int[][] tunal = new int[30][50];
        static Path[] paths = new Path[2000];
        //起点坐标
        static int start_X = 0;
        static int start_Y = 0;
        //终点坐标
        static int end_X = 29;
        static int end_Y = 49;
    
        public static void main(String[] args) throws FileNotFoundException {
            Scanner sc = new Scanner(new File("D:\\maze.txt"));
            int[][] grap = new int[30][50];
            String s = "";
            for (int i = 0; i < grap.length; ++i) {
                s = sc.nextLine();
                for (int j = 0; j < grap[i].length; ++j) {
                    grap[i][j] = s.charAt(j) - 48;
                }
            }
            bfs(grap);
    
        }
    
        public static void bfs(int[][] grap) {
    
            paths[0] = new Path(' ', start_X, start_Y, null);
            tunal[0][0] = 1;
            int head = 0;
            int index = 1;
            while (tunal[end_X][end_Y] != 1) {
                for (int i = 0; i < trval.length; ++i) {
                    int cur_x = paths[head].x + trval[i][0];
                    int cur_y = paths[head].y + trval[i][1];
    
                    if (check(grap, cur_x, cur_y)) {
                        tunal[cur_x][cur_y] = 1;
                        if (i == 0) {
                            paths[index] = new Path('D', cur_x, cur_y, paths[head]);
                        } else if (i == 1) {
                            paths[index] = new Path('L', cur_x, cur_y, paths[head]);
                        } else if (i == 2) {
                            paths[index] = new Path('R', cur_x, cur_y, paths[head]);
                        } else if (i == 3) {
                            paths[index] = new Path('U', cur_x, cur_y, paths[head]);
                        }
                        index++;
                    }
    
    
                }
    
                head++;
                if (head >= paths.length) {
                    System.out.println("失败!");
                    break;
                }
    
            }
    
            print(paths[index - 1]);
    
        }
    
        public static boolean check(int[][] grap, int x, int y) {
            boolean is = true;
            if (x < 0 || x >= grap.length || y < 0 || y >= grap[0].length || tunal[x][y] == 1 || grap[x][y] == 1) {
                is = false;
            }
            return is;
        }
    
        public static void print(Path p) {
            if (p.pre == null) {
                System.out.print("开始->");
                return;
            } else {
                print(p.pre);
                System.out.print(p.c + "");
            }
        }
    
    
    }
    
    class Path {
        char c;
        int x;
        int y;
        Path pre;
    
        public Path(char c, int x, int y, Path pre) {
            this.c = c;
            this.x = x;
            this.y = y;
            this.pre = pre;
        }
    }
    
    




    第六题:特别数的和

    题目描述
    小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。
    请问,在 1 到 n 中,所有这样的数的和是多少?
    【输入格式】
    输入一行包含两个整数 n。
    【输出格式】
    输出一行,包含一个整数,表示满足条件的数的和。
    【样例输入】
    40
    【样例输出】
    574
    【评测用例规模与约定】
    对于 20% 的评测用例,1≤n≤10。
    对于 50% 的评测用例,1≤n≤100。
    对于 80% 的评测用例,1≤n≤1000。
    对于所有评测用例,1≤n≤10000。


    个人代码:

    import java.util.*;
    
    public class Main {
    
     public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            sc.close();
            int sum = 0;
            for (int i = 1; i <= n; ++i) {
                if (String.valueOf(i).contains("2") ||
                        String.valueOf(i).contains("0") ||
                        String.valueOf(i).contains("1") ||
                        String.valueOf(i).contains("9")) {
                    sum += i;
                }
            }
            System.out.println(sum);
        }
    
    }
    
    

    第七题:外卖店优先级

    题目描述
    “饱了么”外卖系统中维护着 N 家外卖店,编号 1 ∼ N。每家外卖店都有 一个优先级,初始时 (0 时刻) 优先级都为 0。
    每经过 1 个时间单位,如果外卖店没有订单,则优先级会减少 1,最低减 到 0;而如果外卖店有订单,则优先级不减反加,每有一单优先级加 2。
    如果某家外卖店某时刻优先级大于 5,则会被系统加入优先缓存中;如果 优先级小于等于 3,则会被清除出优先缓存。
    给定 T 时刻以内的 M 条订单信息,请你计算 T 时刻时有多少外卖店在优 先缓存中。
    【输入格式】
    第一行包含 3 个整数 N、M 和 T。
    以下 M 行每行包含两个整数 ts 和 id,表示 ts 时刻编号 id 的外卖店收到 一个订单。
    【输出格式】
    输出一个整数代表答案。
    【样例输入】
    2 6 6
    1 1
    5 2
    3 1
    6 2
    2 1
    6 2
    【样例输出】
    1
    【样例解释】
    6 时刻时,1 号店优先级降到 3,被移除出优先缓存;2 号店优先级升到 6, 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
    【评测用例规模与约定】
    对于 80% 的评测用例,1≤ N,M,T ≤10000。
    对于所有评测用例,1≤ N,M,T ≤100000,1≤ts≤T,1≤id ≤ N。
    时间限制:1.0s
    内存限制:512.0MB


    个人代码:

    import java.util.*;
    
    public class Main {
    
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();	//外卖店数量
            int m = sc.nextInt();	//订单条数
            int t = sc.nextInt();	//t时刻
            //保存每个店铺在某时刻的优先级
            int[] shop = new int[n + 1];
            //订单记录
            int[][] order = new int[m][2];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < 2; ++j) {
                    order[i][j] = sc.nextInt();
                }
            }
    
    		//每个时刻,只要有店铺有订单就加入到集合,优先级不会被减少
            ArrayList<Integer> list = new ArrayList<>();
           //优先级达到5就会被加入到priority的队列中,低于3会被删除
            ArrayList<Integer> priority = new ArrayList<>();
    		//从第一时刻开始遍历
            for (int i = 1; i <= t; ++i) {
                list.clear();
                //遍历每个时刻 的订单
                for (int j = 0; j < order.length; ++j) {
                    if (order[j][0] == i) {
                        list.add(order[j][1]);
                        shop[order[j][1]] += 2;
                        if (shop[order[j][1]] > 5 && !priority.contains(order[j][1])) {
                            priority.add(order[j][1]);
                        }
                    }
                }
    			//遍历店铺,没有订单且优先级大于一就会减少优先级
                for (int k = 1; k < shop.length; ++k) {
                    if (!list.contains(k) && shop[k] > 0) {
                        shop[k]--;
                    }
                    if (priority.contains(k) && shop[k] <= 3) {
                        priority.remove((Object) k);
                    }
                }
    
            }
            System.out.println(priority.size());
    
        }
    
    }
    




    第八题:人物相关性分析

    题目描述
    小明正在分析一本小说中的人物相关性。他想知道在小说中 Alice 和 Bob 有多少次同时出现。
    更准确的说,小明定义 Alice 和 Bob“同时出现”的意思是:在小说文本 中 Alice 和 Bob 之间不超过 K 个字符。
    例如以下文本:
    ThisisastoryaboutAliceandBob.AlicewantstosendaprivatemessagetoBob.
    假设 K = 20,则 Alice 和 Bob 同时出现了 2 次,分别是”Alice and Bob” 和”Bob. Alice”。前者 Alice 和 Bob 之间有 5 个字符,后者有 2 个字符。
    注意:

    Alice 和 Bob 是大小写敏感的,alice 或 bob 等并不计算在内。
    Alice 和 Bob 应为单独的单词,前后可以有标点符号和空格,但是不能 有字母。例如 Bobbi 並不算出现了 Bob。
    【输入格式】
    第一行包含一个整数 K。
    第二行包含一行字符串,只包含大小写字母、标点符号和空格。长度不超 过 1000000。
    【输出格式】
    输出一个整数,表示 Alice 和 Bob 同时出现的次数。
    【样例输入】
    20
    This is as tory about Alice and Bob. Alice wants to send a private mess age to Bob.
    【样例输出】
    2
    【评测用例规模与约定】
    对于所有评测用例,1≤ K ≤1000000。


    个人代码:

    import java.util.*;
    
    public class Test {
    
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int k = sc.nextInt();
            sc.nextLine();
            String s = sc.nextLine();
            String[] strings = s.split(" ");
            //Alice 和 Bob
            int j = 0;
            int count = 0;
            for (int i = 0; i < strings.length; ++i) {
                j = i + 1;
                if (strings[i].equals("Alice")) {
                    while (j < strings.length) {
                        if (strings[j].equals("Bob") || strings[j].equals("Bob.")) {
                            int distance = j - i;
                            for (int i1 = i + 1; i1 < j; ++i1) {
                                distance += strings[i1].length();
                            }
                            if (distance <= k) {
                                count++;
                            } else {
                                break;
                            }
                        }
                        if (j - k > k) {
                            break;
                        }
                        j++;
                    }
                }
                if (strings[i].equals("Alice.")) {
                    while (j < strings.length) {
                        if (strings[j].equals("Bob") || strings[j].equals("Bob.")) {
                            int distance = j - i + 1;
                            for (int i1 = i + 1; i1 < j; ++i1) {
                                distance += strings[i1].length();
                            }
                            if (distance <= k) {
                                count++;
                            } else {
                                break;
                            }
                        }
                        if (j - k > k) {
                            break;
                        }
                        j++;
                    }
                }
                if (strings[i].equals("Bob")) {
                    while (j < strings.length) {
                        if (strings[j].equals("Alice") || strings[j].equals("Alice.")) {
                            int distance = j - i;
                            for (int i1 = i + 1; i1 < j; ++i1) {
                                distance += strings[i1].length();
                            }
                            if (distance <= k) {
                                count++;
                            } else {
                                break;
                            }
                        }
                        if (j - k > k) {
                            break;
                        }
                        j++;
                    }
                }
    
                if (strings[i].equals("Bob.")) {
                    while (j < strings.length) {
                        if (strings[j].equals("Alice") || strings[j].equals("Alice.")) {
                            int distance = j - i + 1;
                            for (int i1 = i + 1; i1 < j; ++i1) {
                                distance += strings[i1].length();
                            }
                            if (distance <= k) {
                                count++;
                            } else {
                                break;
                            }
                        }
                        if (j - k > k) {
                            break;
                        }
                        j++;
                    }
                }
    
            }
            System.out.println(count);
            
        }
    
    }
    




    第九题:后缀表达式

    题目描述
    给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1,A2,··· ,AN+M+1,小 明想知道在所有由这 N 个加号、M 个减号以及 N + M +1 个整数凑出的合法的后缀表达式中,结果最大的是哪一个?
    请你输出这个最大的结果。
    例如使用1 2 3 + -,则 “2 3 + 1 -” 这个后缀表达式结果是 4,是最大的。
    【输入格式】
    第一行包含两个整数 N 和 M。 第二行包含 N + M + 1 个整数 A1,A2,··· ,AN+M+1。
    【输出格式】
    输出一个整数,代表答案。
    【样例输入】
    1 1
    1 2 3
    【样例输出】
    4
    【评测用例规模与约定】
    对于所有评测用例,0≤ N,M ≤100000,−109 ≤ Ai ≤109。


    个人代码:

    import java.util.*;
    
    public class Main {
    
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[] num = new int[n + m + 1];
            for (int i = 0; i < num.length; ++i) {
                num[i] = sc.nextInt();
            }
    
            Arrays.sort(num);
            Stack<Integer> number = new Stack<>();
            for (int i = 0; i < num.length; ++i) {
                number.add(num[i]);
            }
    
            LinkedList<Character> characters = new LinkedList<>();
            for (int i = 0; i < n; ++i) {
                characters.add('+');
            }
            for (int i = 0; i < m; ++i) {
                characters.add('-');
            }
    
            while (number.size() > 1) {
                int calcultor = calcultor(number.pop(), number.pop(), characters.pop());
                number.add(calcultor);
            }
    
            System.out.println(number.pop());
    
    
        }
    
        public static int calcultor(int x, int y, char c) {
            int sum = 0;
            switch (c) {
                case '+':
                    sum = x + y;
                    break;
                case '-':
                    //原本按照后缀表达式 应该是y-x的,但是咱们排序的时候是从小到大排的 所以这里只能是x-y才可以
                    sum = x - y;
                    break;
            }
            return sum;
        }
    
    
    }
    




    第十题:灵能传输

    题目描述
    【题目背景】

    在游戏《星际争霸 II》中,高阶圣堂武士作为星灵的重要 AOE 单位,在 游戏的中后期发挥着重要的作用,其技能”灵能风暴“可以消耗大量的灵能对 一片区域内的敌军造成毁灭性的伤害。经常用于对抗人类的生化部队和虫族的 刺蛇飞龙等低血量单位。

    【问题描述】

    你控制着 n 名高阶圣堂武士,方便起见标为 1,2,··· ,n。每名高阶圣堂武士 需要一定的灵能来战斗,每个人有一个灵能值 ai 表示其拥有的灵能的多少(ai 非负表示这名高阶圣堂武士比在最佳状态下多余了 ai 点灵能,ai 为负则表示这 名高阶圣堂武士还需要 −ai 点灵能才能到达最佳战斗状态)。现在系统赋予了 你的高阶圣堂武士一个能力,传递灵能,每次你可以选择一个 i ∈ [2,n−1],若 ai ≥ 0 则其两旁的高阶圣堂武士,也就是 i−1、i + 1 这两名高阶圣堂武士会从 i 这名高阶圣堂武士这里各抽取 ai 点灵能;若 ai < 0 则其两旁的高阶圣堂武士, 也就是 i−1,i+1 这两名高阶圣堂武士会给 i 这名高阶圣堂武士 −ai 点灵能。形 式化来讲就是 ai−1+ = ai,ai+1+ = ai,ai−= 2ai。

    灵能是非常高效的作战工具,同时也非常危险且不稳定,一位高阶圣堂 武士拥有的灵能过多或者过少都不好,定义一组高阶圣堂武士的不稳定度为 maxn i=1|ai|,请你通过不限次数的传递灵能操作使得你控制的这一组高阶圣堂武 士的不稳定度最小。

    【输入格式】

    本题包含多组询问。输入的第一行包含一个正整数 T 表示询问组数。 接下来依次输入每一组询问。 每组询问的第一行包含一个正整数 n,表示高阶圣堂武士的数量。 接下来一行包含 n 个数 a1,a2,··· ,an。

    【输出格式】

    输出 T 行。每行一个整数依次表示每组询问的答案。

    【样例输入】

    3
    3
    5 -2 3
    4
    0 0 0 0
    3
    1 2 3
    【样例输出】

    3
    0
    3

    【样例说明】

    对于第一组询问:
    对 2 号高阶圣堂武士进行传输操作后 a1 = 3,a2 = 2,a3 = 1。答案为 3。

    对于第二组询问:
    这一组高阶圣堂武士拥有的灵能都正好可以让他们达到最佳战斗状态。

    【样例输入】
    3
    4
    -1 -2 -3 7
    4
    2 3 4 -8
    5
    -1 -1 6 -1 -1

    【样例输出】

    5
    7
    4
    在这里插入图片描述


    个人代码:

    //实在想不到这个题怎么写,等想起来了会立马更新
    
    展开全文
  • 2019第十届Java A组蓝桥杯省赛真题

    千次阅读 2020-12-31 11:40:58
    这里是蓝桥杯历年的题目专栏,将会陆续更新将往年真题以及解答发布出来,欢迎各位小伙伴关注我吖,你们的点赞关注就是给我最好的动力!!! 每天更新一届真题,敬请期待 蓝桥杯历年真题及详细解答 目录第一题:平方...
  • 2019年第十届C/C++ B组蓝桥杯省赛真题

    千次阅读 多人点赞 2020-12-16 14:27:16
    这里是蓝桥杯历年的题目专栏,将会陆续更新将往年真题以及解答发布出来,欢迎各位小伙伴关注我吖,你们的点赞关注就是给我最好的动力!!! 每天更新一届真题解析,敬请期待 蓝桥杯历年真题及详细解答 目录第一题:...
  • 2013 T1 给定相差天数求具体日期 // // Created by CP3. // /* 题目标题: 高斯日记 大数学家高斯有个好习惯:无论如何都要记日记。 ... 他的日记有个与众不同的地方,他从不注明年月日,而是用一个整数代替,比如:...
  • 文档包含第十届(2019蓝桥杯省赛软件类所有组别的C/C++以及Java真题和参考答案 分为真题及评判标准两部分 真题及评判标准每个组别一个文件夹,共8个 评判标准中填空题直接给出正确答案,程序题给出测试数据...
  • 2019年第八届java B组蓝桥杯省赛真题

    千次阅读 2020-12-23 20:35:09
    这里是蓝桥杯历年的题目专栏,将会陆续更新将往年真题以及解答发布出来,欢迎各位小伙伴关注我吖,你们的点赞关注就是给我最好的动力!!! 每天更新一届真题,敬请期待 蓝桥杯历年真题及详细解答 目录第一题:组队...
  • 2019年第十届蓝桥杯省赛 Java B 组真题 第一题 第二题 import java.util.HashSet; import java.util.Set; public class Q2 { static String s = "0100110001010001"; static Set<String> set = new ...
  • 2019年第十届C/C++ A组蓝桥杯省赛真题

    千次阅读 2020-12-20 22:09:00
    这里是蓝桥杯历年的题目专栏,将会陆续更新将往年真题以及解答发布出来,欢迎各位小伙伴关注我吖,你们的点赞关注就是给我最好的动力!!! 每天更新一届真题,敬请期待 蓝桥杯历年真题及详细解答 目录第一题:平方...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 285
精华内容 114
关键字:

蓝桥杯省赛2019真题