蓝桥杯历年真题及解析.
目录：
A：第几天（难度：★）
2000年的1月1日，是那一年的第1天。
那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
分析：
直接把每个月的天数加起来即可。
代码：
满分
package JB2018;
//125
public class A第几天 {
public static void main(String[] args) {
System.out.println(31+29+31+30+4);
}
}
B：方格计数（难度：★）
如图p1.png所示，在二维平面上有无数个1x1的小方格。
我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。
你能计算出这个圆里有多少个完整的小方格吗？
注意：需要提交的是一个整数，不要填写任何多余内容。
分析：
将网格想象成一个坐标系，然后遍历坐标系的每一个点，最终即为方格的数目
为了简化运算，我们只计算第一象限中的方格数目，最终结果乘四即为解。
代码：
=满分
package JB2018;
//3137548
public class B方格计数 {
public static void main(String[] args) {
int count=0;
for(int i=1;i<1000;i++){
for(int j=1;j<1000;j++){
if(Math.sqrt(i*i+j*j)<=1000)count++;
}
}
System.out.println(count*4);
}
}
C：复数幂（难度：★★）
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 “实部±虚部i” 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
分析：
此题唯一的难点就是数据太过庞大，
所以我们可以直接调用Java特有的大数运算API
然后根据复数运算公式执行题目要求次数即可求解
复数运算公式：
( a + bi ) * ( c + di ) = ( a * c - b * d ) + ( a * d + b * c )i
代码：
代码没有问题，但是编译器的缓存区可能放不下这么大的字符串
package JB2018;
//答案在文件内有135KB，所以能一眼看到头的答案都是错的。
import java.math.BigInteger;
public class C复数幂 {
public static BigInteger shi=new BigInteger("2");
public static BigInteger xu=new BigInteger("3");
public static BigInteger ansshi=new BigInteger("2");
public static BigInteger ansxu=new BigInteger("3");
public static BigInteger z=new BigInteger("0");
public static BigInteger mid;
public static void app(){
mid=ansshi;
ansshi=(ansshi.multiply(shi)).subtract(ansxu.multiply(xu));
ansxu=(ansxu.multiply(shi)).add(mid.multiply(xu));
}
public static void main(String[] args) {
for(int i=1;i<123456;i++){
app();
}
System.out.println(ansshi+((ansxu.compareTo(z))>=0?"+":"")+ansxu+"i");
}
}
D：测试次数（难度：★★★★★）
x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。
分析：
这是一个典型的动态规划问题。
因为我们只有三部手机，所以二分的做法明显是错误的。
首先我们假设我们只有一部手机，那么我们只能一层一层的试，才能保证在手机摔坏之前测出耐摔指数。
再假设我们只有两部手机，假设楼高为 i ，第一次摔手机的楼层为 j。
则有两种情况（手机坏了 or 手机没坏）
手机坏了：则剩余（ j - 1 ）层楼只能一层一层的试上去。
手机没坏：则剩余（ i - j ）层楼依旧可以使用此等跳跃的方式。
三部手机同理。
所以我们可以推导出DP公式
arr[i][k] = Math.min(Math.max(arr[j - 1][k - 1], arr[i - j][k]) + 1, arr[i][k]);
代码：
满分
package JB2018;
//19
import java.util.Arrays;
public class D测试次数 {
public static void main(String[] args) {
int arr[][] = new int[1001][3];
for (int i = 0; i < 1001; i++) {
arr[i][0] = i;
}
for (int k = 1; k < 3; k++) {
for (int i = 0; i < 1001; i++) {
if (i == 0 || i == 1 || i == 2) {
arr[i][k] = i;
} else {
arr[i][k] = Integer.MAX_VALUE;
for (int j = 2; j < i; j++) {
arr[i][k] = Math.min(Math.max(arr[j - 1][k - 1], arr[i - j][k]) + 1, arr[i][k]);
}
}
}
}
for (int i = 0; i < 1001; i++)
System.out.println(Arrays.toString(arr[i]));
System.out.println(arr[1000][2]);
}
}
E：快速排序（难度：★★）
以下代码可以从数组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数组作为参数一直都没有被改变也不需要改变
由空格前条件可知：我们需要查找的范围由左边开始缩小，所以 l 要变， r 不变。
l 变为 i+1，k缩小了范围，k变为k-i+l-1;
代码：
滿分
package JB2018;
import java.util.Random;
public class E快速排序{
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(a,i+1,r,k-i+l-1);
//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));
// int [] a = {1, 4, 2, 8, 5, 7, 23, 58, 16, 27, 55, 13, 26, 24, 12, 2};
// System.out.println(quickSelect(a, 0, a.length-1, 6));
}
}
F：递增三元组（难度：★★★）
给定三个整数数组
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
分析：
这是一个前缀和问题。
首先我们吧数据当作数组下标，数组储存的内容为该数组下摆哦所对应数据的个数。
然后对该数组求前缀和，意思为：小于等于该下标的数据都可以作为该三元组的前缀
然后三个前缀和错位相乘即可求得最终解。
代码：
满分
package JB2018;
import java.util.Scanner;
public class F递增三元組 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
long arr[] = new long[100001];
long brr[] = new long[100001];
long crr[] = new long[100001];
// 录入第一組
for (int i = 0; i < n; i++) {
arr[sc.nextInt()]++;
}
// 求第一组的前缀和
for (int i = 1; i < 100001; i++) {
arr[i] += arr[i - 1];
}
// 录入第二组
for (int i = 0; i < n; i++) {
brr[sc.nextInt()]++;
}
// 计算二元组
for (int i = 1; i < 100001; i++) {
if (brr[i] != 0) {
brr[i] *= arr[i - 1];
}
}
// 计算二元组的前缀和
for (int i = 2; i < 100001; i++) {
brr[i] += brr[i - 1];
}
// 录入第三组
for (int i = 0; i < n; i++) {
crr[sc.nextInt()]++;
}
// 计算三元组
for (int i = 1; i < 100001; i++) {
if (crr[i] != 0) {
crr[i] *= brr[i - 1];
}
}
// 计算三元组的前缀和
for (int i = 3; i < 100001; i++) {
crr[i] += crr[i - 1];
}
System.out.println(crr[100000]);
}
}
G：螺旋折线（难度：★★★★）
如图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
分析：
我们可以把螺旋曲线划分为上下左右四个区域，
求出拐点的 value 再通过简单的加减运算即可得解。
代码：
满分
package JB2018;
import java.util.Scanner;
public class G螺旋折线 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
long x=sc.nextLong();
long y=sc.nextLong();
long ans=0;
if(x+y>=0){
if(x>=y){
ans=2*x*2*x+(x-y);//右边
}else{
ans=2*y*2*y-y+x;//上边
}
}else{
if(x+1>=y){
ans=(-y-y+1)*(-y-y+1)+y-1-x;//下边
}else{
ans=(-x-x-1)*(-x-x-1)-x-1+y;//左边
}
}
System.out.println(ans);
}
}
H：日志统计（难度：★★★）
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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
分析：
首先我们采用邻接表的方式用来存储当前时间的点赞 id，这样可以省去排序时间
然后从零时刻开始不断遍历邻接表，同时迭代 map，
如果发现有热帖出现，立刻放入hashset去重，
最终将hashset内的数据放入ArrayList进行排序。即可得解。
代码：
package JB2018;
import java.util.*;
public class H日志统计{
public static ArrayList<Integer>[] ts=new ArrayList[100002];
public static HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
public static HashSet<Integer> set=new HashSet<Integer>();
public static void main(String[] args) {
Scanner sc= new Scanner(System.in);
int n=sc.nextInt();
int d=sc.nextInt();
int k=sc.nextInt();
for(int i=0;i<100002;i++){
ts[i]=new ArrayList();
}
int t,id;
for(int i=0;i<n;i++){
t=sc.nextInt();
id=sc.nextInt();
ts[t].add(id);
}
int p=0;
for(int i=0;i<100002;i++){
if(i>=d)
for(int tt:ts[i-d]){
if(map.get(tt)>=k){
set.add(tt);
}
map.put(tt, map.get(tt)-1);
}
for(int tt:ts[i]){
if(map.containsKey(tt)){
map.put(tt, map.get(tt)+1);
}else{
map.put(tt, 1);
}
}
}
ArrayList<Integer> ans=new ArrayList<Integer>();
for(int tt:set){
ans.add(tt);
}
Collections.sort(ans);
for(int tt:ans){
System.out.println(tt);
}
}
}
I：全球变暖（难度：★★★★）
你有一张某海域NxN像素的照片，".“表示海洋、”#"表示陆地，如下所示：
…
.##…
.##…
…##.
…####.
…###.
…
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。
例如上图中的海域未来会变成如下样子：
…
…
…
…
…#…
…
…
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。
【输入格式】
第一行包含一个整数N。 (1 <= N <= 1000)
以下N行N列代表一张海域照片。
照片保证第1行、第1列、第N行、第N列的像素都是海洋。
【输出格式】
一个整数表示答案。
【输入样例】
7
…
.##…
.##…
…##.
…####.
…###.
…
【输出样例】
1
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
分析：
这是一个DFS题目，我们录入数据后首先搜索查一下陆地的岛屿数目。
与此同时我们给每一个岛屿进行编号，当我们发现有某个岛屿无法被淹没时加入HashSet。
最终岛屿数减去hashset内的岛屿数量即被淹没的所有岛屿的数量。
代码：
非满分，差一组数据，编译器问题
package JB2018;
//八组数据过了7组，
//最后一组数据不过的原因是陆地的面积达到了1万，而Java的编译器栈递归层数是一万层，
//如果评测机可以进行高强度递归的话，此代码也可以AC
//换成c++或者c语言就是满分。
import java.util.HashSet;
import java.util.Scanner;
public class I全球变暖 {
public static char c[][],d[][];
public static int n,count=0;
public static HashSet<Integer> set=new HashSet<Integer>();
public static void dfs(int x,int y,int k){
c[x][y]='.';
if(d[x][y]=='#'&&x-1>=0&&d[x-1][y]=='#'&&x+1<n&&d[x+1][y]=='#'
&&y-1>=0&&d[x][y-1]=='#'&&y+1<n&&d[x][y+1]=='#'){
set.add(k);
}
if(x+1>=0&&x+1<n&&y>=0&&y<n&&c[x+1][y]=='#')dfs(x+1,y,k);
if(x-1>=0&&x-1<n&&y>=0&&y<n&&c[x-1][y]=='#')dfs(x-1,y,k);
if(x>=0&&x<n&&y+1>=0&&y+1<n&&c[x][y+1]=='#')dfs(x,y+1,k);
if(x>=0&&x<n&&y-1>=0&&y-1<n&&c[x][y-1]=='#')dfs(x,y-1,k);
}
public static void main(String[] args) {
Scanner sc=new Scanner (System.in);
n=sc.nextInt();
c=new char[n][n];
d=new char[n][n];
String s;
for(int i=0;i<n;i++){
s=sc.next();
c[i]=s.toCharArray();
d[i]=s.toCharArray();
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(c[i][j]=='#'){
count++;
dfs(i,j,count);
}
}
}
System.out.println(count-set.size());
}
}
J：堆的计数（难度：★★★★★）
这个题目后续更新或者放在交流群里。
写在最后
本文的所有题目的测试数据均放在交流群内。方便大家一起学习交流。
欢迎大家加QQ群一起玩耍。