蓝桥杯真题第九届java组

  • Post author:
  • Post category:java


这是第一次参加蓝桥杯,应该也是最后一次。我参加的B组 JAVA,整体感觉还行吧,只是比赛的时候出了点小意外。本来是下午1点中结束的,因为提前了两分钟开始,然后到12点五十几的时候就交不了了,导致一个大题白白丢掉,当时心里有点炸。不过也没什么,蓝桥杯这种比赛,就当是玩一下吧。然后就说说题目吧,水平有限,错了见谅。


第一题:




标题:第几天





2000年的1月1日,是那一年的第1天。

那么,2000年的5月4日,是那一年的第几天?

注意:需要提交的是一个整数,不要填写任何多余内容。



这个太水了,没什么说的,直接口算就行了。



我的答案:125








第二题 :



标题:方格计数





如图p1.png所示,在二维平面上有无数个1×1的小方格。











我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。


你能计算出这个圆里有多少个完整的小方格吗?



注意:需要提交的是一个整数,不要填写任何多余内容。


比赛的时候以为找到了规律:

如果半径为R的话,那么所圈住的小正方形应该是[2 *(R-1)]^2。试了1,2,3都满足,

然后就没多想,毕竟才第二个题目。


比赛完了才发现这式子有问题,R>根号2*(R-1)只有在R<4时才成立,唉,当时也没仔细看,就想当然的填了上去。写了个代码跑了一下,发现果然错了,还是太年轻啊…



  1. import


    java.util.Scanner;




  2. public




    class


    方格计数 {



  3. static




    int


    N =


    10000


    ;


    // 方格图的大小, 10000够大了





  4. static




    int


    X =


    5000


    , Y =


    5000


    ;


    // 圆心坐标





  5. static




    double


    [] l =


    new




    double


    [N];



  6. static




    double


    [] r =


    new




    double


    [N];



  7. static




    int


    R, ans =


    0


    ;




  8. public




    static




    void


    main(String[] args) {


  9. Scanner sc =

    new


    Scanner(System.in);


  10. R = sc.nextInt();


  11. for


    (


    int


    i = Y – R; i <= Y + R; i++) {


  12. l[i] = X – Math.sqrt(R * R – (Y – i) * (Y – i));

  13. r[i] = Math.min(N, (X <<

    1


    ) – l[i]);



  14. if


    (l[i] <


    0


    ) {


  15. l[i] =

    0


    ;


  16. }

  17. }


  18. for


    (


    int


    i = Y – R; i <= Y –


    1


    ; i++) {



  19. int


    ll = (


    int


    ) Math.ceil(l[i]), rr = (


    int


    ) Math.floor(r[i]);


  20. ans += rr – ll;

  21. }


  22. for


    (


    int


    i = Y; i <= Y + R –


    1


    ; i++) {



  23. int


    ll = (


    int


    ) Math.ceil(l[i +


    1


    ]), rr = (


    int


    ) Math.floor(r[i +


    1


    ]);


  24. ans += rr – ll;

  25. }

  26. System.out.println(ans);

  27. }

  28. }



我的答案: 3137548








第三题:



标题:复数幂



设i为虚数单位。对于任意正整数n,(2+3i)^n 的实部和虚部都是整数。


求 (2+3i)^123456 等于多少? 即(2+3i)的123456次幂,这个数字很大,要求精确表示。


答案写成 “实部±虚部i” 的形式,实部和虚部都是整数(不能用科学计数法表示),中间任何地方都不加空格,实部为正时前面不加正号。(2+3i)^2 写成: -5+12i,


(2+3i)^5 的写成: 122-597i



注意:需要提交的是一个很庞大的复数,不要填写任何多余内容。


这题真的是不想吐槽了,用java大数加快速幂做的,应该是做对了,但是一开始eclipse控制台没显示出来,以为是大数爆了。


代码:



  1. import


    java.math.BigInteger;




  2. public




    class


    复数幂 {



  3. public




    static




    void


    main(String[] args) {


  4. Complex cmp =

    new


    Complex(BigInteger.valueOf(


    2


    ), BigInteger.valueOf(


    3


    ));


  5. System.out.println(quickPow(cmp,

    123456


    ).toString());


  6. }



  7. private




    static


    Complex quickPow(Complex cmp,


    int


    n) {



  8. if


    (n ==


    0


    ) {



  9. return




    new


    Complex(BigInteger.valueOf(


    1


    ), BigInteger.valueOf(


    0


    ));


  10. }

  11. Complex temp = quickPow(cmp, n /

    2


    );


  12. temp.multiply(temp);


  13. if


    (n %


    2


    !=


    0


    ) {


  14. temp.multiply(cmp);

  15. }


  16. return


    temp;


  17. }

  18. }



  19. class


    Complex {


  20. BigInteger a;

    // 实部




  21. BigInteger b;

    // 虚部






  22. public


    Complex(BigInteger a, BigInteger b) {



  23. this


    .a = a;



  24. this


    .b = b;


  25. }



  26. public




    void


    multiply(Complex cm) {


  27. BigInteger tempa = a.multiply(cm.a).subtract(b.multiply(cm.b));

  28. BigInteger tempb = a.multiply(cm.b).add(b.multiply(cm.a));

  29. a = tempa;

  30. b = tempb;

  31. }



  32. @Override





  33. public


    String toString() {


  34. String aStr =

    “”


    + a;


  35. String bStr = b +

    “i”


    ;



  36. if


    (b.compareTo(BigInteger.valueOf(


    0


    )) >


    0


    ) {


  37. bStr =

    “+”


    + bStr;


  38. }

    else




    if


    (b.compareTo(BigInteger.valueOf(


    0


    )) ==


    0


    ) {


  39. bStr =

    “”


    ;


  40. }


  41. return


    aStr + bStr;


  42. }

  43. }


eclipse控制台输出的结果是–i,不知道是什么鬼,比赛完了才知道把这个–i是一个超长的字符串。结果就不贴了,太长了,刚刚粘贴的时候浏览器都卡了。反正思路应该不难,如果是c++的话,手写大数应该也还好,然后快速幂就不说了,算法基础。






看一下最右边的滚动滑轮感受一下数字规模。。。








第四题:



标题:测试次数



x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机。


各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试,并且评定出一个耐摔指数来,之后才允许上市流通。


x星球有很多高耸入云的高塔,刚好可以用来做耐摔测试。塔的每一层高度都是一样的,与地球上稍有不同的是,他们的第一层不是地面,而是相当于我们的2楼。


如果手机从第7层扔下去没摔坏,但第8层摔坏了,则手机耐摔指数=7。


特别地,如果手机从第1层扔下去就坏了,则耐摔指数=0。


如果到了塔的最高层第n层扔没摔坏,则耐摔指数=n


为了减少测试次数,从每个厂家抽样3部手机参加测试。


某次测试的塔高为1000层,如果我们总是采用最佳策略,在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢?


请填写这个最多测试次数。



注意:需要填写的是一个整数,不要填写任何多余内容。


其实这题在之前碰到过一个差不多的,不过当时没有深究,之前的好像是两个鸡蛋,100层,问最坏情况下最少几次?


这个是最坏情况最多几次,我不知道是不是我多想了,比赛的时候二分答案,错了。。。比赛完结合之前的题目又想了一下,递推了一下,算出来19。


我的答案:19


代码:



  1. public




    class


    摔手机 {



  2. public




    static




    void


    main(String[] args) {


  3. System.out.println(DroppingPhone(

    3


    ,


    1000


    ));


  4. }



  5. private




    static




    long


    DroppingPhone(


    long


    phone,


    long


    floors) {



  6. long


    times =


    1


    ;



  7. while


    (DroppingMax(phone, times) < floors) {


  8. ++times;

  9. }


  10. return


    times;


  11. }



  12. private




    static




    long


    DroppingMax(


    long


    phone,


    long


    times) {



  13. if


    (phone ==


    1


    ) {



  14. return


    times;


  15. }



  16. if


    (phone >= times) {



  17. return


    (


    long


    ) Math.pow(


    2


    , times) –


    1


    ;


  18. }



  19. return


    DroppingMax(phone, times –


    1


    ) + DroppingMax(phone –


    1


    , times –


    1


    ) +


    1


    ;


  20. }

  21. }





第五题:


标题:快速排序



以下代码可以从数组a[]中找出第k小的元素。


它使用了类似快速排序中的分治算法,期望时间复杂度是O(N)的。

请仔细阅读分析源码,填写划线部分缺失的内容。



  1. import


    java.util.Random;



  2. public




    class


    Main{



  3. public




    static




    int


    quickSelect(


    int


    a[],


    int


    l,


    int


    r,


    int


    k) {


  4. Random rand =

    new


    Random();



  5. int


    p = rand.nextInt(r – l +


    1


    ) + l;



  6. int


    x = a[p];



  7. int


    tmp = a[p]; a[p] = a[r]; a[r] = tmp;



  8. int


    i = l, j = r;



  9. while


    (i < j) {



  10. while


    (i < j && a[i] < x) i++;



  11. if


    (i < j) {


  12. a[j] = a[i];

  13. j–;

  14. }


  15. while


    (i < j && a[j] > x) j–;



  16. if


    (i < j) {


  17. a[i] = a[j];

  18. i++;

  19. }

  20. }

  21. a[i] = x;

  22. p = i;


  23. if


    (i – l +


    1


    == k)


    return


    a[i];



  24. if


    (i – l +


    1


    < k)


    return


    quickSelect( _________________________________ );


    //填空





  25. else




    return


    quickSelect(a, l, i –


    1


    , k);


  26. }


  27. public




    static




    void


    main(String args[]) {



  28. int


    [] a = {



    1


    ,


    4


    ,


    2


    ,


    8


    ,


    5


    ,


    7


    };


  29. System.out.println(quickSelect(a,

    0


    ,


    5


    ,


    4


    ));


  30. }

  31. }


  32. 注意:只提交划线部分缺少的代码,不要抄写任何已经存在的代码或符号。


这题也不是什么新题,利用快排的partition思想进行”选择”,是解决这类问题的高效方法,可以把复杂度从O(nlongn)(直接排序求a[k – 1])降到O(n)(利用快排分组时左边刚好k-1个元素)。注意题目要求是O(n),这题如果只求运行正确有几种写法,如果不注意直接写partition 的分治可能还是O(nlogn)。


我的答案:a, i + 1, r, k – i + l – 1



———————————–分割线——————————————-



编程题就懒得去码代码了,不太喜欢重复性的劳动,就大致说一下我的思路,菜鸡一只,错了请见谅。。。



第六题:



标题:递增三元组



给定三个整数数组


A = [A1, A2, … AN],


B = [B1, B2, … BN],


C = [C1, C2, … CN],


请你统计有多少个三元组(i, j, k) 满足:


1. 1 <= i, j, k <= N


2. Ai < Bj < Ck




【输入格式】


第一行包含一个整数N。


第二行包含N个整数A1, A2, … AN。


第三行包含N个整数B1, B2, … BN。


第四行包含N个整数C1, C2, … CN。


对于30%的数据,1 <= N <= 100


对于60%的数据,1 <= N <= 1000


对于100%的数据,1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000


【输出格式】


一个整数表示答案






【输入样例】


3


1 1 1


2 2 2


3 3 3




【输出样例】


27




资源约定:


峰值内存消耗(含虚拟机) < 256M


CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。



这道题的话,比赛的时候应该是gg了。不过下来又想了一下,可以先排序,然后直接三个for循环(两层):以B数组为标杆,对于B的每一个元素Bi,二分统计A中比Bi小的元素,C中比Bi大的元素,然后相乘,最后把乘积累加起来。也不知道蓝桥的判题机怎么样,O(nlogn)对于1e5的数据规模,勉勉强强能过。






第七题



标题:螺旋折线








如图p1.pgn所示的螺旋折线经过平面上所有整点恰好一次。


对于整点(X, Y),我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。




例如dis(0, 1)=3, dis(-2, -1)=9




给出整点坐标(X, Y),你能计算出dis(X, Y)吗?






【输入格式】


X和Y




对于40%的数据,-1000 <= X, Y <= 1000


对于70%的数据,-100000 <= X, Y <= 100000


对于100%的数据, -1000000000 <= X, Y <= 1000000000




【输出格式】


输出dis(X, Y)




【输入样例】


0 1




【输出样例】



3


资源约定:


峰值内存消耗(含虚拟机) < 256M


CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。






这题考察的不是算法吧,就是思维,方法应该挺多的。我用的方法是把螺旋折线转变成一个个的同心正方形,像下面这样,






注意转化关系,然后就好算多了。其实实在不行,分象限讨论,肯定能做出来,这题难度不大,细心一点,问题不大。



w第八题



标题:日志统计



小明维护着一个程序员论坛。现在他收集了一份”点赞”日志,日志共有N行。其中每一行的格式是:


ts id


表示在ts时刻编号id的帖子收到一个”赞”。


现在小明想统计有哪些帖子曾经是”热帖”。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞,小明就认为这个帖子曾是”热帖”。


具体来说,如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞,该帖就曾是”热帖”。


给定日志,请你帮助小明统计出所有曾是”热帖”的帖子编号。






【输入格式】


第一行包含三个整数N、D和K。


以下N行每行一条日志,包含两个整数ts和id。




对于50%的数据,1 <= K <= N <= 1000


对于100%的数据,1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000




【输出格式】


按从小到大的顺序输出热帖id。每个id一行。






【输入样例】


7 10 2


0 1


0 10


10 10


10 1


9 1


100 3


100 3




【输出样例】


1


3


资源约定:


峰值内存消耗(含虚拟机) < 256M


CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。



这题用的优先队列加hash(或者直接写一个二维的排序也行吧),感觉是没问题,造了几组数据都过了,然而前面说到有一题最后到时间没交,就是这题。。。这题计算点赞量,应该是以每一个点赞时间Ti为为起点,计算[Ti,D)的点赞数(i = 1, 2, 3, …, n),然后求最大值与K比较。






第九题



标题:全球变暖


你有一张某海域NxN像素的照片,”.”表示海洋、”#”表示陆地,如下所示:



…….


.##….


.##….


….##.


..####.


…###.


…….



其中”上下左右”四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。


由于全球变暖导致了海面上升,科学家预测未来几十年,岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋),它就会被淹没。


例如上图中的海域未来会变成如下样子:



…….


…….


…….


…….


….#..


…….


…….



请你计算:依照科学家的预测,照片中有多少岛屿会被完全淹没。


【输入格式】



第一行包含一个整数N。  (1 <= N <= 1000)


以下N行N列代表一张海域照片。


照片保证第1行、第1列、第N行、第N列的像素都是海洋。


【输出格式】


一个整数表示答案。


【输入样例】


7



…….


.##….


.##….


….##.


..####.


…###.


…….



【输出样例】


1


资源约定:


峰值内存消耗(含虚拟机) < 256M


CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。



这题当时也是想的比较简单,dfs求联通分量,并且在求联通分量的时候做个标记,判断这个联通分量(岛屿)中是否存在不临海的陆地,存在的话,这样的联通分量(岛屿)才不会完全消失。还有就是,下面这两种都算不完全消失(都是0个岛屿被淹没)吧?虽然岛屿数量变多了。







第十题



标题:堆的计数



我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。


每个节点有一个权值。对于小根堆来说,父节点的权值一定小于其子节点的权值。


假设N个节点的权值分别是1~N,你能求出一共有多少种不同的小根堆吗?


例如对于N=4有如下3种:




1


/ \


2   3


/


4




1


/ \


3   2


/


4




1


/ \


2   4


/


3




由于数量可能超过整型范围,你只需要输出结果除以1000000009的余数。


【输入格式】


一个整数N。


对于40%的数据,1 <= N <= 1000


对于70%的数据,1 <= N <= 10000


对于100%的数据,1 <= N <= 100000


【输出格式】


一个整数表示答案。


【输入样例】


4


【输出样例】


3


资源约定:


峰值内存消耗(含虚拟机) < 256M


CPU消耗  < 1000ms


请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。



这题之前是在哪看到过,(好像是阿里)的面试题。不过不完全一样,想了一会,写了一个递推式,只验证了4,5两种,后面的没有去验证,不过应该是错了,就不贴了。感觉应该是组合数求和的问题,具体怎么个组合没想清楚,比赛的时候时间有限,没想太多。




总结:


其实从上一届蓝桥杯开始,题目难度就慢慢上升了。今年的题目除了第一题,之后每一题想拿到满分都不是那么的容易,质量还行,不过也不是说很难,真的需要很仔细。虽然只参加了这一次,但我感觉蓝桥杯这种,读题很重要,有时候你做了半天觉得做对了然后发现题目理解错了….至于能不能省一,都无所谓了,蓝桥杯虽然在不断发展,但目前这种级别的奖项拿出去没什么含金量。不过在校内还是认可的,大一大二没事参加着玩一下,就当练练手,毕竟ACM,NOIP对于我这种菜鸡来说,门槛太高了。

很少在csdn上写东西,也是第一次写这么多。emmm,就先说到这吧,蓝桥杯,再见了,应该不会再见了。。。