2018年第九届Java B组蓝桥杯省赛真题及解析
题目
-
-
-
- 第一题：第几天
- 第二题：方格计数
- 第三题：复数幂
- 第四题：测试次数
- 第五题：快速排序
- 第六题：递增三元组
- 第七题：螺旋折线
- 第八题：日志统计
- 第九题：全球变暖
- 第十题：堆的计数
-
-
所有答案均为个人想法 仅供参考，如有问题 欢迎指正
第一题：第几天
题目描述
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：
需要提交的是一个整数，不要填写任何多余内容。
个人答案：
125
题解：
方法一：
直接数，2000%400=0是闰年直接31+29+31+30+4=125
方法二：
代码
public class Main {
public static void main(String[] args) {
int[] mouth = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int[] runMouth = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int day = 0;
for (int i = 1; i <= 4; ++i) {
if (check(2000)) {
day += runMouth[i];
} else {
day += mouth[i];
}
}
System.out.println(day + 4);
}
public static boolean check(int year) {
return year % 400 == 0 || year % 4 == 0 && year % 100 != 0;
}
}
方法三：
第二题：方格计数
题目描述
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
个人答案：
3137548
思路：
1.先求1/4圆中的方格数目，再乘以4即可
2.方格的最远点如果小于等于半径就说明这个方格在圆中
3.暴力遍历1000*1000正方形中每一个方格
个人代码：
public class Main {
public static void main(String[] args) {
int count = 0;
for (int i = 1; i <= 1000; ++i) {
for (int j = 1; j <= 1000; ++j) {
if (i * j <= 1000) {
count++;
}
}
}
System.out.println(count * 4);
}
}
第三题：复数幂
题目描述
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
个人答案：
4043220979119144065-7374402350132176768i
思路：
个人代码：
public class Test {
final static int x = 2;
final static int y = 3;
public static void main(String[] args) {
Long a = 2L;
Long b = 3L;
Long sum = 0L;
Long pre = 0L;
for (int i = 2; i <= 123456; ++i) {
sum = a * y + b * x;
pre = a * x - b * y;
a = pre;
b = sum;
}
System.out.println(a + " " + b + "i");
}
}
第四题：测试次数
题目描述
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
个人答案：
19
个人代码：
//需要利用到动态规划
public class Main {
public static void main(String[] args) {
int[][] dp = new int[1000 + 1][3 + 1];
//当只有一层的时候不论几部手机都是只需要测试一次就可以得到结果
for (int j = 1; j <= 3; ++j) {
dp[1][j] = 1;
}
//当只有一部手机的时候，有多少层楼，最坏的情况下就需要测试多少次
for (int i = 1; i <= 1000; ++i) {
dp[i][1] = i;
}
int min = 0;
for (int i = 2; i <= 1000; i++) {
for (int j = 2; j <= 3; ++j) {
//每次测试都有两种情况，要么碎了要么没碎
//1.如果碎了就相当于待测试的楼层数为k-1，剩余的手机数-1
//2.如果没有碎，就相当于剩余的楼层i-k，手机数量不变
//dp就等于这两种情况测试次数最多的一个
min = Integer.MAX_VALUE;
for (int k = 1; k <= i; ++k) {
if (min > Math.max(dp[k - 1][j - 1], dp[i - k][j])) {
min = Math.max(dp[k - 1][j - 1], dp[i - k][j]) + 1;
}
}
dp[i][j] = min;
}
}
System.out.println(dp[1000][3]);
}
}
第五题：快速排序
题目描述
以下代码可以从数组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));
}
}
个人答案：
a, i + 1, r, k - (i - l + 1)
第六题：递增三元组
题目描述
给定三个整数数组
A = [A1, A2, … AN],
B = [B1, B2, … BN],
C = [C1, C2, … CN]，
请你统计有多少个三元组(i, j, k) 满足：
1 <= i, j, k <= N
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
个人代码：
import java.util.Scanner;
//直接暴力 简单方便
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] a1 = new int[n + 1];
int[] a2 = new int[n + 1];
int[] a3 = new int[n + 1];
for (int i = 1; i <= n; ++i) {
a1[i] = sc.nextInt();
}
sc.nextLine();
for (int i = 1; i <= n; ++i) {
a2[i] = sc.nextInt();
}
sc.nextLine();
for (int i = 1; i <= n; ++i) {
a3[i] = sc.nextInt();
}
int count = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
if (a1[i] < a2[j] && a2[j] < a3[k]) {
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
解题思路：
这道题可以利用数学知识。
首先判断是哪一条边上的，一共始终可能下边横线，左边竖线，上边横线，右边竖线
让后判断是多少圈，前几圈的长度是(1 + 2 * circle) * 2 * circle/2 *2，利用前n项和等于(a1+an)*n/2
让后再加上多余的长度就可以了。
四个代码块分别代表图中的四个色域,也是对应下面代码里面的四种情况。
个人代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
int y = sc.nextInt();
int circle;
int sum = 0;
if (y <= 0 && x > y - 1 && x <= -y) {
circle = -y;
sum = (1 + 2 * circle) * 2 * circle;
sum += circle - x;
} else if (x < 0 && y >= x + 1 && y < -x) {
circle = -x - 1;
sum = (1 + 2 * circle) * 2 * circle;
sum += 3 * (-x) + y - 2;
} else if (y > 0 && x >= -y && x < y) {
circle = y;
sum = (1 + 2 * circle) * 2 * circle;
sum -= 3 * y - x;
} else if (x > 0 && y > -x && y <= x) {
circle = y;
sum = (1 + 2 * circle) * 2 * circle;
sum -= (x + y);
}
System.out.println(sum);
}
}
第八题：日志统计
题目描述
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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
个人代码：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int d = sc.nextInt();
int k = sc.nextInt();
int[][] log = new int[n + 1][2];
for (int i = 1; i <= n; ++i) {
log[i][0] = sc.nextInt();
log[i][1] = sc.nextInt();
sc.nextLine();
}
int maxTime = 0;
for (int i = 1; i < log.length; ++i) {
if (maxTime < log[i][0]) {
maxTime = log[i][0];
}
}
int t = 0;
HashMap<Integer, Integer> mall = new HashMap<>();
ArrayList<Integer> list = new ArrayList<>();
do {
mall.clear();
for (int i = 1; i <= n; ++i) {
if (log[i][0] >= t && log[i][0] < t + d) {
if (mall.containsKey(log[i][1])) {
mall.put(log[i][1], mall.get(log[i][1]) + 1);
} else {
mall.put(log[i][1], 1);
}
}
}
mall.forEach((key, value) -> {
if (value >= k && !list.contains(key)) {
list.add(key);
}
});
t++;
} while (t <= maxTime - d + 1);
for (Integer l : list) {
System.out.println(l);
}
}
}
第九题：全球变暖
题目描述
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
. . . . . . .
. # # . . . .
. # # . . . .
. . . . # # .
. . # # # # .
. . . # # # .
. . . . . . .
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . # . .
. . . . . . .
. . . . . . .
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
. . . . . . .
. # # . . . .
. # # . . . .
. . . . # # .
. . # # # # .
. . . # # # .
. . . . . . .
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
个人代码：
import java.util.ArrayList;
import java.util.Scanner;
//类似并查集
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
sc.nextLine();
String[] sea = new String[n];
for (int i = 0; i < n; ++i) {
sea[i] = sc.nextLine();
}
char[][] water = new char[n + 1][n + 1];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
water[i][j] = sea[i - 1].charAt(j - 1);
}
}
int[] parent = new int[(n + 1) * (n + 1)];
for (int i = 0; i < parent.length; ++i) {
parent[i] = -1;
}
//更新parent数组，用于判断一共有多少个岛屿
for (int i = 2; i <= n - 1; ++i) {
for (int j = 2; j <= n - 1; ++j) {
if (water[i][j] == '#') {
link(i, j, water, parent);
}
}
}
ArrayList<Integer> list = new ArrayList<>();
//判断有多少个岛屿
for (int i = 0; i < parent.length; ++i) {
if (parent[i] != -1) {
int i1 = parent[i];
if (!list.contains(i1)) {
list.add(i1);
}
}
}
ArrayList<Integer> isletList = new ArrayList<>();
//判断有多少个小岛不会被淹没
for (int i = 2; i <= n - 1; ++i) {
for (int j = 2; j <= n - 1; ++j) {
if (water[i][j] == '#' && check(i, j, water)) {
if (!isletList.contains(parent[(i - 1) * (sea.length - 1) + j])) {
isletList.add((i - 1) * (sea.length - 1) + j);
}
}
}
}
//被淹没小岛的个数
int islet = list.size() - isletList.size();
System.out.println(islet);
}
//判断这个点是否会被淹没
public static boolean check(int x, int y, char[][] sea) {
if (sea[x - 1][y] == '#' && sea[x][y - 1] == '#' && sea[x + 1][y] == '#' && sea[x][y + 1] == '#') {
return true;
}
return false;
}
//如果这个点是岛屿 就判断这个点附近（上边和左边）有没有岛屿，有的话就连接起来
public static void link(int x, int y, char[][] sea, int[] parent) {
if (sea[x - 1][y] == '#' && sea[x][y - 1] == '#') {
if (parent[(x - 1 - 1) * (sea.length - 1) + y] != parent[(x - 1) * (sea.length - 1) + y - 1]) {
int n = parent[(x - 1 - 1) * (sea.length - 1) + y];
int m = parent[(x - 1) * (sea.length - 1) + y - 1];
int tempY = y;
while (parent[(x - 1) * (sea.length - 1) + tempY - 1] == m) {
parent[(x - 1) * (sea.length - 1) + tempY - 1] = n;
tempY--;
}
}
parent[(x - 1) * (sea.length - 1) + y] = parent[(x - 1 - 1) * (sea.length - 1) + y];
} else if (sea[x - 1][y] == '#') {
parent[(x - 1) * (sea.length - 1) + y] = parent[(x - 1 - 1) * (sea.length - 1) + y];
} else if (sea[x][y - 1] == '#') {
parent[(x - 1) * (sea.length - 1) + y] = parent[(x - 1) * (sea.length - 1) + y - 1];
} else {
parent[(x - 1) * (sea.length - 1) + y] = (x - 1) * (sea.length - 1) + y;
}
}
}
第十题：堆的计数
题目描述
我们知道包含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
代码：
//这道题实在想不起来，参考大佬们的代码，大家可以看一下
import java.util.Scanner;
public class Main {
private static int n;
private static long mod = 1000000009;
private static long[] f;
private static long[] inv;
/**
* 记录该点的孩子节点+自身的总数
*/
private static int[] s;
private static long[] dp;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
f = new long[n + 5];
inv = new long[n + 5];
s = new int[n + 5];
dp = new long[n + 5];
f[0] = 1;
for (int i = 1; i < n + 5; i++) {
f[i] = f[i - 1] * i % mod;
inv[i] = mpow(f[i], mod - 2);
}
//类似堆的找孩子
for (int i = n; i >= 1; i--)
{
//C[i]<=n所以不用取余
s[i] = 1 + (2 * i <= n ? s[2 * i] : 0) + (2 * i + 1 <= n ? s[2 * i + 1] : 0);
}
for (int i = 1; i < n + 5; i++) {
dp[i] = 1;
}
for (int i = n; i >= 1; i--) {
if (2 * i + 1 <= n) {
//C(s[i]-1,s[i*2+1])和C(s[i]-1,s[i*2])都一样,组合对称
dp[i] = dp[2 * i] * dp[2 * i + 1] % mod * C(s[i] - 1, s[i * 2 + 1]) % mod;
}
}
System.out.println(dp[1]);
}
static long C(int n, int m) {
return f[n] * inv[m] % mod * inv[n - m] % mod;
}
//求a的n次幂
static long mpow(long a, long n) {
if (n == 0 || a == 1) {
return 1;
}
long ans = 1;
while (n != 0) {
if (n % 2 == 1) {
ans = a * ans % mod;
}
a = a * a % mod;
n >>= 1;
}
return ans;
}
}