蓝桥杯2018JAVA_B省赛真题详解

第一题：第几天

题目描述

2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？

解题思路

Calendar 类的考察

import java.util.Calendar;

/**
 * @author sjf
 * @date 2020/3/18 22:31
 */


public class demo01第几天 {
    public static void main(String[] args) {

        Calendar c = Calendar.getInstance();
        //注意 Calenda 类的 月份表达
        c.set(2000,4,4);
        System.out.println(c.get(Calendar.DAY_OF_YEAR));//125

    }
}

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

---

第二题：方格计数

题目描述

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

我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？

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

解题思路

虽然简单 但是易错
找规律 前四个都是 4*（n-1)^2
第五个就不是了。。
这里的思路 很常规 第一象限 与圆心距离最远的正方格的右上顶点距离原点的距离和 R 的关系

import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/18 22:34
 */


public class demo02方格计数 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int R = sc.nextInt();
        int i;
        //算四分之一
        //最后一个小正方形的顶点到原点的距离 与 r 的比较
        for (i = 0; i <R ; i++) {
            double s = Math.sqrt(2*i*i);
            if(s>R)
                break;
        }
        i--;

        System.out.println(i*i*4);  //1999396

    }
}

---

第三题：复数幂

题目描述

设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。

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

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

解题思路

首先 是BigInteger的考察
然后就是 复数的运算规律 具体看代码

import java.math.BigInteger;

/**
 * @author sjf
 * @date 2020/3/8 14:20
 */


public class demo03复数幂 {
    public static void main(String[] args) {
        BigInteger a = new BigInteger("2");
        BigInteger b = new BigInteger("3");
        BigInteger ansa = new BigInteger("2");
        BigInteger ansb = new BigInteger("3");
        for (int i = 1; i < 123456; i++) {
            BigInteger temp = ansa;
            ansa = (ansa.multiply(a).add((ansb.multiply(b).multiply(new BigInteger("-1")))));
            ansb = temp.multiply(b).add(ansb.multiply(a));

        }
        System.out.println(ansa);
        System.out.println("================");
        System.out.println(ansb);

    }
}

---

第四题：测试次数

题目描述

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。

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

如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

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

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

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

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

解题思路

动态规划的考点

题解待更新

---

第五题：快速排序

题目描述

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

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

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

import java.util.Random;
public class Main{
public static int quickSelect(int a[], int l, int r, int k) {
Random rand = new Random();
int p = rand.nextInt(r - l + 1) + l;
int x = a[p];
int tmp = a[p]; a[p] = a[r]; a[r] = tmp;
int i = l, j = r;
while(i < j) {
while(i < j && a[i] < x) i++;
if(i < j) {
a[j] = a[i];
j–;
}
while(i < j && a[j] > x) j–;
if(i < j) {
a[i] = a[j];
i++;
}
}
a[i] = x;
p = i;
if(i - l + 1 == k) return a[i];
if(i - l + 1 < k) return quickSelect( _________________________________ ); //填空
else return quickSelect(a, l, i - 1, k);
}
public static void main(String args[]) {
int [] a = {1, 4, 2, 8, 5, 7};
System.out.println(quickSelect(a, 0, 5, 4));
}
}

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

解题思路

题目很简单 但是可以学习这个思路来解决 TOPK 问题
答案：a, l+1 , r ,k

---

第六题：递增三元组

题目描述

给定三个整数数组
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

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

解题思路

暴力枚举 枚举优化来降低 时间复杂度

import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/8 15:58
 */


public class demo06递增三元组 {
    public static void main(String[] args) {
        int count = 0;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int [] a = new int[n];
        int [] b = new int[n];
        int [] c = new int[n];

        for (int i = 0; i <n ; i++) {
            a[i] = sc.nextInt();
        }
        for (int i = 0; i <n ; i++) {
            b[i] = sc.nextInt();
        }
        for (int i = 0; i <n ; i++) {
            c[i] = sc.nextInt();
        }

        for (int i = 0; i <n ; i++) {
            for (int j = 0; j <n ; j++) {
                if(b[j]>a[i])
                for (int k = 0; k <n ; k++) {
                    if(c[k]>b[j]){
                        count++;
                    }
                }
            }
        }

        System.out.println(count);


    }

}

---

第七题：螺旋折线

题目描述

如图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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

解题思路

这里的思路是模拟走路 只能有个及格分
可以找找公式看看， 那样就AC了

import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/8 16:14
 */


public class demo07螺旋折线 {
    static int[][] next = {{-1,0},{0,1},{1,0},{0,-1}};  //方向数组
    public static void main(String[] args) {
        int count =0;
        Scanner sc =new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        int tx = 0,ty = 0;

        for (int i = 0,step = 1; true; step++) {
            int temp = step;
            int t = i+1;
            //每次循环走两个方向
            while (i<4&&i<=t) {
                while (temp != 0) {
                    tx += next[i][0];
                    ty += next[i][1];
                    count++;
                    if (tx == x && ty == y) {
                        System.out.println(count);
                        break;
                    }
                    temp--;
                }
                i++;
                temp = step;
            }

            if(i==3||i==4)
                i=0;
        }
    }
}

---

第八题：日志统计

题目描述

小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

解题思路

运用到了结构体 利用结构体来存储这些数据
然后进行排序 排好序
就循环一遍就可以检索出来 热帖

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/8 18:01
 */
class log {

     int ts;
     int id;

    public log(int ts, int id) {
        this.ts = ts;
        this.id = id;
    }


    @Override
    public String toString() {
        return "log{" +
                "ts=" + ts +
                ", id=" + id +
                '}';
    }
}

public class demo08日志统计 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N , K , D;
        N = sc.nextInt();
        D = sc.nextInt();
        K = sc.nextInt();

        ArrayList<log> log1 = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            int tst = sc.nextInt();
            int idt = sc.nextInt();
            log1.add(new log(tst,idt));
        }

        Collections.sort(log1, new Comparator<log>() {
            @Override
            public int compare(log o1, log o2) {
                //首先看 id 的大小
                int result = o1.id - o2.id;
                //id大小相同 看 时刻
                if(result == 0){
                    result = o1.ts - o2.ts;
                }
                return result;
            }
        });

        //System.out.println(log1);
        //[log{ts=0, id=1}, log{ts=9, id=1}, log{ts=10, id=1}, log{ts=100, id=3}, log{ts=100, id=3}, log{ts=0, id=10}, log{ts=10, id=10}]

        int previousid = log1.get(0).id;
        int flag= 0;
        for (int i = 0; i < N-K+1; i++) {
            //记录每次的 id
            int idtemp = log1.get(i).id;
            if(log1.get(i+K-1).id == previousid && log1.get(i+K-1).id == idtemp && flag == 0){
                //如果在距离  K 处有相等的id 那么判断 ts 的关系
                if(log1.get(i).ts+D > log1.get(i+K-1).ts) {
                    flag = 1;
                    System.out.println(idtemp);
                }
            }
            else if(log1.get(i).id != previousid ){
                previousid = idtemp;  //开始一个新的帖子的检查
                flag = 0;
                i--;  // 退回一下 来缓冲掉之后的那个 i++；
            }

        }
	 }
 }

---

第九题：全球变暖

题目描述

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

…
.##…
.##…
…##.
…####.
…###.
…

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

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

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

…
…
…
…
…#…
…
…

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

【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。

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

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

【输入样例】
7
…
.##…
.##…
…##.
…####.
…###.
…

【输出样例】
1

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

解题思路

经典的 dfs题了
1.首先搜索 海岛的个数
2.然后进行淹没
3.然后再搜索 海岛的个数

因为搜索海岛个数的算法 对原 地图有影响 所以 引进一个book数组
对地图进行刻画 在这上面进行计算海岛个数

import java.util.Scanner;

/**
 * @author sjf
 * @date 2020/3/8 18:02
 */
      /*.......
        .##....
        .##....
        ....##.
        ..####.
        ...###.
        .......  */
public class demo09全球变暖 {
    static int N ;  //大小
    static char[][] map = new char[1001][1001];
    static int[][] book = new int[1001][1001];
    static  int[][] next = {{-1,0},{0,-1},{1,0},{0,1}};
    public static void main(String[] args) {

        Scanner sc =new Scanner(System.in);
        //N = sc.nextInt();
        N = 7;
        int total = 0; //总共
        int count = 0; //淹没
        int result = 0;  //结果
        String[] s={".......",
                    ".##....",
                    ".##....",
                    "....##.",
                    "..####.",
                    "...###.",
                    "......."} ;

        for (int i = 0; i <N; i++) {
            //s = sc.next();
            map[i] =s[i].toCharArray();
        }

        for (int i = 0; i <N ; i++) {
            for (int j = 0; j <N ; j++) {
                if(map[i][j]=='#')
                    book[i][j] = 1;
                //System.out.print(book[i][j]);
            }
            //System.out.println();
        }

        //dfs 记录总共岛屿
        for (int i = 0; i <N ; i++) {
            for (int j = 0; j <N ; j++) {
                if(book[i][j]==1){
                    dfs(i,j);
                    total++;
                }
            }
        }



        //淹没过程
        for (int i = 0; i <N ; i++) {
            for (int j = 0; j < N; j++) {
                if(map[i][j]=='#'){
                    int tx=i,ty=j;
                    int k ;
                    for ( k = 0; k <4 ; k++) {
                        tx+=next[k][0];
                        ty+=next[k][1];
                        if(map[tx][ty]!='#')
                            break;
                        tx=i;
                        ty=j;
                    }
                    if(k==4)
                    book[i][j]=1;
                }
            }
        }



        //dfs记录剩余岛屿
        for (int i = 0; i <N ; i++) {
            for (int j = 0; j <N ; j++) {
                if(book[i][j]==1){
                    dfs(i,j);
                    count++;
                }
            }
        }

        result = total - count;
        System.out.println(result);

    }

    public static void  dfs(int x , int y ){
        book[x][y] = 0;  //清除
        int tx,ty;
        for (int i = 0; i <4 ; i++) {
            tx=x+next[i][0];
            ty=y+next[i][1];
            if(tx>=0 && tx<N && ty>=0 && ty<N){
                if(book[tx][ty]==1)
                    dfs(tx,ty);
            }
        }
    }


}

---

第十题：堆的计数

题目描述

我们知道包含N个元素的堆可以看成是一棵包含N个节点的完全二叉树。
每个节点有一个权值。对于小根堆来说，父节点的权值一定小于其子节点的权值。

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

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

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

【输入格式】
一个整数N。
对于40%的数据，1 <= N <= 1000
对于70%的数据，1 <= N <= 10000
对于100%的数据，1 <= N <= 100000

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

【输入样例】
4

【输出样例】
3

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

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

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

题解待更新