2018年第九届蓝桥杯Java省赛B组真题个人题解
文章目录
- 1.第几天
- 2.方格计数
- 3.复数幂
- 4.测试次数
- 5.快速排序
- 6.递增三元组
- 7.螺旋折线
- 8.日志统计
- 9.全球变暖
- 10.堆的计数
1.第几天
【题目描述】
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
思路
打开Excel
答案
125天
2.方格计数
【题目描述】
如图所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
思路
取第一象限的圆，枚举每一个方格，如果方格右上角距圆心的距离<半径，则计数+1，最后*4
class Main {
public static void main(String[] args) {
int r = 1000, count = 0;
for (int i = 1; i <= r; i++) {//y
for (int j = 1; j <= r; j++) {//x
if (i * i + j * j <= r * r) {
count += 1;
}
}
}
System.out.println(count*4);
}
}
答案
3137548
3.复数幂
【题目描述】
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
思路
java可以直接使用大整数类，因为答案非常长，可以输出到文件或者直接全选复制
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
import java.math.BigInteger;
class Main {
public static void main(String[] args) throws FileNotFoundException {
//(a+bi)*(c+di) = (a*c - b*d) + (a*d + b*c)i
PrintStream out=new PrintStream(new File("ans.txt"));
//输出到文件中，默认路径是项目路径，参数改为System.out会输出在控制台
BigInteger a = BigInteger.valueOf(2);
BigInteger b = BigInteger.valueOf(3);
BigInteger c = BigInteger.valueOf(2);
BigInteger d = BigInteger.valueOf(3);
BigInteger A, B;
for (int i = 1; i < 123456; i++) {
A = a.multiply(c).subtract(b.multiply(d));
B = a.multiply(d).add(b.multiply(c));
a=A;
b=B;
}
out.println(a.toString());
if (b.signum()!=-1){
//若虚部为正需要一个加号，实际上答案是两个负数
out.print("+");
}
out.print(b.toString()+"i");
out.close();
}
}
答案
4.测试次数
【题目描述】
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
思路
原题出处：leetcode887. 鸡蛋掉落
public class Main {
public static void main(String[] args) {
int res = dp(3, 1000);
System.out.println(res);
}
private static int dp(int K, int N) {
int[][] dp = new int[K + 1][N + 1];
int m = 0;
while (dp[K][m] < N) {
m++;
for (int i = 1; i <= K; i++) {
dp[i][m] = dp[i][m - 1] + dp[i - 1][m - 1] + 1;
}
}
return m;
}
}
答案
19
5.快速排序
【题目描述】
以下代码可以从数组a[]中找出第k小的元素。
它使用了类似快速排序中的分治算法，期望时间复杂度是O(N)的。
请仔细阅读分析源码，填写划线部分缺失的内容。
注意：只提交划线部分缺少的代码，不要抄写任何已经存在的代码或符号。
import java.util.Random;
public class Main {
//输入一个数组给出左右边界下标，求第K大的数
public static int quickSelect(int a[], int l, int r, int k) {
Random rand = new Random();
int p = rand.nextInt(r - l + 1) + l;
//产生一个l~r+1的随机数作为快排基准
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};
//1 2 4 5 7 8 → 5
System.out.println(quickSelect(a, 0, 5, 4));
}
}
思路
随机化的快速排序
答案
a,i+1,r,k-i+l-1
6.递增三元组
【题目描述】
给定三个整数数组
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 <= 1000000 <= Ai, Bi, Ci <= 100000
【输出格式】
一个整数表示答案
【输入样例】
3
1 1 1
2 2 2
3 3 3
【输出样例】
27
思路
直接暴力就是排序后三次遍历，复杂度O(n3)，虽然会超时，但是应该有60%以上的分。优化就是预处理得到 A 小于 Bi 的个数，B 小于 Ci 的个数，然后对应相乘。利用二分或者遍历处理都可以，复杂度都是O(nlongn)。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
//1e6的数据，使用输入挂
class InputReader {
BufferedReader bf;
StringTokenizer st;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
}
boolean hasNext() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bf.readLine());
} catch (Exception e) {
return false;
}
}
return true;
}
String next() {
if (hasNext()) {
return st.nextToken();
}
return null;
}
int nextInt() {
return Integer.parseInt(next());
}
}
public class Main {
public static void main(String[] args) {
InputReader sc = new InputReader();
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();
}
Arrays.sort(A);
Arrays.sort(B);
Arrays.sort(C);
long ans = 0;
int[] res = new int[n];
int i = n - 1, j = n - 1;
while (i >= 0 && j >= 0) {
if (B[j] > A[i]) {
res[j] = i + 1;
j--;
} else {
i--;
}
}
i = 0;
j = 0;
while (i <= n - 1 && j <= n - 1) {
if (C[j] > B[i]) {
ans += (long)res[i] * (n - j);//注意这里需要转为long，否则会丢失精度
i++;
} else {
j++;
}
}
System.out.println(ans);
}
}
7.螺旋折线
【题目描述】
如图所示的螺旋折线经过平面上所有整点恰好一次。
对于整点(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
思路
把每个螺旋线的左下角掰直，就会变成一系列的正方形周长相加。
这样只要算里面的正方形周长和加上（x,y）到折点的距离即可。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long X = sc.nextLong();
long Y = sc.nextLong();
// 判断所在点所在的正方形是第几层
long n = Math.max(Math.abs(X), Math.abs(Y));
//前n-1层正方形变长,每层的变长是等差数列
long res = 4 * n * (n - 1);
//求(x,y)到折点(-n,-n)的路程
long dx = -n, dy = -n;
long d1 = X - dx, d2 = Y - dy;
if (Y > X) {
res += (d1 + d2);
} else {
res += (2 * 4 * n - d1 - d2);
}
System.out.println(res);
}
}
8.日志统计
【题目描述】
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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
思路
先把所有日志按时间排序，然后采取双指针遍历所有日志查看是否超时，利用键值对记录对应id与点赞数，达标的放置在TreeMap中自动排序，最后将答案输出。
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.*;
class log implements Comparable<log> {
int ts, id;
public log(int ts, int id) {
this.ts = ts;
this.id = id;
}
@Override
public int compareTo(log o) {
return this.ts-o.ts;
}
}
public class Main {
static int N, D, K,id,ts;
static ArrayList<log> logs =new ArrayList<>();//记录日志数据
static Map<Integer,Integer> date =new HashMap<>();//记录id与点赞数
static Set<Integer> ids=new TreeSet<>();//记录热帖id，TreeSet可以同时达到去重排序效果
public static void main(String[] args) {
//1e5数据，保险起见采用输入输出挂
InputReader in = new InputReader();
PrintStream out = new PrintStream(System.out);
N = in.nextInt();
D = in.nextInt();
K = in.nextInt();
for (int i = 0; i < N; i++) {
ts=in.nextInt();
id=in.nextInt();
date.put(id,0);//初始化id数据
logs.add(new log(ts,id));
}
Collections.sort(logs);
int lt=logs.get(0).ts,rt=logs.get(0).ts;
int i=0,j=0;
while (j<N){
log now=logs.get(j);
rt=now.ts;
date.put(now.id, date.get(now.id)+1);
while (rt-lt>=D){
log bf=logs.get(i);
date.put(bf.id, date.get(bf.id)-1);
i++;
lt=logs.get(i).ts;
}
if (date.get(now.id)>=K){
ids.add(now.id);
}
j++;
}
for (var x :
ids) {
out.println(x);
}
out.close();
}
}
class InputReader {
private BufferedReader bf;
private StringTokenizer st;
public InputReader() {
bf = new BufferedReader(new InputStreamReader(System.in));
}
boolean hasNext() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(bf.readLine());
} catch (Exception e) {
return false;
}
}
return true;
}
String next() {
if (hasNext()) {
return st.nextToken();
}
return null;
}
int nextInt() {
return Integer.parseInt(next());
}
}
9.全球变暖
【题目描述】
你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
.......
.##....
.##....
....##.
..####.
...###.
.......
【输出样例】
1
思路
将样例对齐更直观一点
遍历所有连通块，对每个连通块记录是否有不会淹没的像素，相减即为答案。
import java.util.Scanner;
public class Main {
static int n, total = 0;
static boolean nf = false;
static char[][] map=new char[1010][1010];
static boolean[][] vis=new boolean[1010][1010];
static int[] dx = {-1, 1, 0, 0};
static int[] dy = {0, 0, -1, 1};
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
for (int i = 0; i < n; i++) {
map[i] = sc.next().toCharArray();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (map[i][j] == '#' && !vis[i][j]) {
vis[i][j]=true;
nf = false;
total += 1;
dfs(i, j);
if (nf) {
total -= 1;
}
}
}
}
System.out.println(total);
}
private static void dfs(int x, int y) {
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isOk(nx, ny) && map[nx][ny] == '#' && !vis[nx][ny]) {
vis[nx][ny] = true;
if (!nf) {
if (!isFlood(nx, ny)) {
nf = true;
}
}
dfs(nx, ny);
}
}
}
private static boolean isFlood(int x, int y) {
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (isOk(nx, ny) && map[nx][ny] == '.') {
return true;
}
}
return false;
}
private static boolean isOk(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < n) {
return true;
}
return false;
}
}
10.堆的计数
【题目描述】
我们知道包含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
思路
数论题，动态规划+阶乘逆元或者Lucas定理求组合数。
import java.util.Scanner;
public class Main {
static int n;
static long mod = 1000000009;
static long[] f;
static long[] inv;
static int[] s;//记录该点的孩子节点+自身的总数
static long[] dp;
static long C(int n, int m) {
return f[n] * inv[m] % mod * inv[n - m] % mod;
}
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--) //类似堆的找孩子
{
s[i] = 1 + (2 * i <= n ? s[2 * i] : 0) + (2 * i + 1 <= n ? s[2 * i + 1] : 0);//c[i]<=n所以不用取余
}
for (int i = 1; i < n + 5; i++) {
dp[i] = 1;
}
for (int i = n; i >= 1; i--) {
if (2 * i + 1 <= n) {
dp[i] = dp[2 * i] * dp[2 * i + 1] % mod * C(s[i] - 1, s[i * 2 + 1]) % mod;//C(s[i]-1,s[i*2+1])和C(s[i]-1,s[i*2])都一样,组合对称
}
}
System.out.println(dp[1]);
}
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;
}
}