36-2018 蓝桥杯Java B组试题及答案

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

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

用excel算，答案125.

2.标题：方格计数

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

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

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

public class Main {

	public static void main(String[] args) {
		int R=1000;
		int a=1000,b=0,tb=b,count=0;
		for(a=1000;a>=0;a--) {
			while(a*a+b*b<=R*R)b++;
			b--;
			count+=a*(b-tb);
			tb=b;
		}
		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
注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。

 BigInteger 的使用了

注意点：

1.直接在控制台输出的话，因为太大了，不会显示完整数字结果，结果如图，其实，粘贴到记事本就可以看到完整的。

2.或者直接用FileWrite()写入文本。

import java.io.FileWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static Scanner cin = new Scanner(System.in);
	public static void main(String[] args) throws IOException {
//		求 (2+3i)^123456 等于多少？

		//存答案
		BigInteger a = new BigInteger("2");
		BigInteger b = new BigInteger("3");
		//乘数
		BigInteger c = new BigInteger("2");
		BigInteger d = new BigInteger("3");

		//注意我是从第二个开始的：
		for(int i = 1; i < 123456; i++) {
			BigInteger x = a.multiply(c).subtract(b.multiply(d));
			BigInteger y = a.multiply(d).add(b.multiply(c));
			a = x;
			b = y;
		}
//		System.out.println(a + "+" + d + "i");

		//写文件
		FileWriter file = new FileWriter("ans.txt");
		//需要判断虚部的正负号，如果是负的就不需要"+"
		if(b.compareTo(new BigInteger("0")) < 0) {
			System.out.println("b < 0");
			file.write(a + "" + d + "i");
		}
		else if (b.compareTo(new BigInteger("0")) > 0){
			System.out.println("b > 0");
			file.write(a + "+" + d + "i");
		}
		else {
			System.out.println("b = 0");
			file.write(a + "");
		}
		file.close();

	}

}

　　

4.标题：测试次数

x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。
特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。
如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n
为了减少测试次数，从每个厂家抽样3部手机参加测试。
某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
请填写这个最多测试次数。
注意：需要填写的是一个整数，不要填写任何多余内容。

分案一：数学推导：

https://blog.****.net/nka_kun/article/details/79789511

注：

　　

方案二：网上说：这道题其实是需要用动态规划或者记忆化搜索去解的，dp[x][y]表示当前还剩x楼不确定，还有y部手机没爆。

尚未看懂！！！！！！！！！！

#include<stdio.h>
#define Max(a,b) (a>b?a:b)
#define Min(a,b) (a<b?a:b)
int dp[1005][50];
int main(int argc, char* argv[])
{
	int n,m;
	scanf("%d%d",&n,&m);
	for (int i=1;i<=n;i++)
    {
        dp[i][1]=i;
    }
    for (int cnt=2;cnt<=m;cnt++)
    {
        for (int ind=1;ind<=n;ind++)
        {
            dp[ind][cnt]=1+dp[ind-1][cnt];
            for (int k=2;k<=ind;k++)
                dp[ind][cnt]=Min(dp[ind][cnt],1+Max(dp[k-1][cnt-1],dp[ind-k][cnt]));
        }
    }
    printf("%d\n",dp[n][m]);
	return 0;
}

　　

第五题：

标题：快速排序
以下代码可以从数组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  ， 当时跑了下，结果正确就没管了，实际上如果我多测计组就会发现是错的。

答案应该是： a, i + 1, r, k - i + l - 1；

对于那个传过去的 第几大问题，不能直接以为 k - i 就行了，因为 k 是新的，新对于一截数组的元素个数的第几大，

然而 那个下标 i  依然是整个数组的 i，所以 k 有种情况会小于 i ，故应该在数组中找到真实的 第几大，再去减掉 i, 故因为是 k + l  - i + 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

思路： https://blog.****.net/yinxiaobao97/article/details/79929549

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Main{
	public static void main(String args[] ) {
		int n;
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		Integer[] a = new Integer[n];
		Integer[] b = new Integer[n];
		Integer[] c = new Integer[n];

		for(int i = 0; i < n; i++) {
			a[i] = cin.nextInt();
		}
		for(int i = 0; i < n; i++) {
			b[i] = cin.nextInt();
		}
		for(int i = 0; i < n; i++) {
			c[i] = cin.nextInt();
		}
		Comparator<Integer> cmp = new MyComparator();
		Arrays.sort(a, cmp);
		Arrays.sort(b, cmp);
		Arrays.sort(c, cmp);

		int[] bc = new int[n]; //存放bj > ck 的个数
		long[] he = new long[n]; //存放bc的加和
		long ans = 0;
		int i, j;
		for(i = 0; i < n; i++) {
			for(j = 0; j < n; j++) {
				if(b[i] >= c[j]) {
					break;
				}
			}
			bc[i] = j;
			if(i == 0) {
				he[i] = j;
			}
			else {
				he[i] = he[i-1] + j;
			}
//			System.out.print(bc[i] + ",");
		}
		for(i = 0; i < n; i++) {
			for(j = 0; j < n; j++) {
				if(a[i] >= b[j]) {
					break;
				}
			}
			if(j > 0)
				ans += he[j-1];
		}
		System.out.println(ans);
	}
}
class MyComparator implements Comparator<Integer>{
	@Override
	public int compare(Integer o1, Integer o2) {
		return o2 - o1;
	}
}
	/*
3
1 1 1
2 1 2
3 2 3
12
-------
3
1 1 1
2 2 2
3 3 3
27
	 */

　　

第七题

标题：螺旋折线

如图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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
---------------------

思路：记得我去年是分象限讨论的，找了每个对角线的点为基准，然后讨论，细心点也好搞出来，但是比较复杂。今年重新看下，发现有了新思路

（刚刚看到有网上有图，直接搞过来吧，自己懒得画了）：

就是弄成完整的正方形，这样子就好搞多了，也就是说你可以总结出一个公式了：

以（-n, -n）为基准，所以就是最外圈 + 内圈和了。

内圈是： 1*8 + 2 * 8 + 3 * 8 + 。。。+ ( max(abs(x), abs(y) )  -  1) * 8

外圈就是：

if y < x : max(abs(x), abs(y) ) * 8 -  （ abs(x - max(abs(x), abs(y) )  +  abs(y - max(abs(x), abs(y) ) ）

else :  abs(x - max(abs(x), abs(y) )  +  abs(y - max(abs(x), abs(y) )

总数量就是 ： 内圈加外圈之和了。

第八题：日志统计

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

暴力：先按时间排序，然后两重for判断，用了hashmap统计，set去重统计id

后面的代码用了尺取法。

import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;

public class Main{
	public static void main(String args[] ) {
		int n, d, k;
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		d = cin.nextInt();
		k = cin.nextInt();
		zan[] a = new zan[n ];
		for(int i = 0; i < n; i++) {
			a[i] = new zan(cin.nextInt(), cin.nextInt());
		}
		Arrays.sort(a, new Comparator<zan>() {
			public int compare(zan x, zan y) {
				return x.ts - y.ts;
			}
		});
//		for(zan i : a) {
//			System.out.println(i.ts);
//		}
		//用hashmap统计每个时段内每个内容的点赞次数
		HashMap<Integer, Integer> map = new HashMap<>();
		HashSet<Integer> set = new HashSet<>();
		for(int i = a[0].ts; i <= a[n-1].ts; i++) {
			for(int j = 0; j < n; j++) {
				if(a[j].ts >= i && a[j].ts < i + d) {
					if(map.containsKey(a[j].id)) {
						int tm = map.get(a[j].id) + 1;
						if(tm >= k && !set.contains(a[j].id)) {
							set.add(a[j].id);
//							set.
						}
						map.put(a[j].id, tm);
					}
					else {
						map.put(a[j].id, 1);
					}
				}
			}
//			System.out.println(map.values());
			map.clear();
		}
//		System.out.println(set.size() + ": " + set.toString());
		//取出所有的set内容，存入ans中
		Iterator<Integer> it = set.iterator();
		int[] ans = new int[set.size()];
		int ct = 0;
		while(it.hasNext()) {
			ans[ct++] = it.next();
//			System.out.print(it.next() + " ");
		}
		Arrays.sort(ans);
		for(int i = 0; i < ct; i++) {
			System.out.print(ans[i] + " ");
		}
	}
}
class zan{
	public int ts;
	public int id;
	zan(int t, int i){
		this.ts = t;
		this.id = i;
	}
}

	/*
 7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
	 */

　　

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

public class Main{
	public static int n, d, k;
	public static List<Integer>[] list = new ArrayList[100005];
	public static void main(String args[] ) {
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		d = cin.nextInt();
		k = cin.nextInt();
		int Ids = 100005;

		for(int i = 0; i < Ids; i++) {
			list[i] = new ArrayList<Integer>();
		}
		HashSet<Integer> set = new HashSet<>();
		for(int i = 0; i < n; i++) {
			int id, ts;
			ts = cin.nextInt();
			id = cin.nextInt();
			list[id].add(ts);
			set.add(id);
		}
		int cnt = 0, ids = set.size();
		int[] ans = new int[ids];
		Object[] yid = new Object[ids];
		//将集合里面的数据取出来
		yid = set.toArray();
		for(int i = 0; i < ids; i++) {
			if(judge((int) yid[i])) {
				ans[cnt++] = (int)yid[i];
//				System.out.println(yid[i] + "-----");
			}
		}
		for(int i = 0; i < cnt; i++) {
			System.out.print(yid[i] + " ");
		}
	}
	public static boolean judge(int id) {
		int l = 0, r = 0;
		int len = list[id].size();
		int sum = 0;
		if(len < k) {
			return false;
		}
		//对链表排序
		Collections.sort(list[id]);
		//尺取法
		while(l <= r && r < len) {
			if(r - l + 1 >= k) {
				if(list[id].get(r) - list[id].get(l) < d) {
					return true;
				}
				else {
					l++;
				}
			}
			r++;
		}
		return false;
	}
}
	/*
 7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
	 */

　　

第九题 全球变暖
你有一张某海域NxN像素的照片，"."表示海洋、"#"表示陆地，如下所示：
.......
.##....
.##....
....##.
..####.
...###.
.......
其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。  
由于全球变暖导致了海面上升，科学家预测未来几十年，岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋)，它就会被淹没。  
例如上图中的海域未来会变成如下样子：
.......
.......
.......
.......
....#..
.......
.......
请你计算：依照科学家的预测，照片中有多少岛屿会被完全淹没。  
【输入格式】

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

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

照片保证第1行、第1列、第N行、第N列的像素都是海洋。  
【输出格式】
一个整数表示答案。
【输入样例】
7 
.......
.##....
.##....
....##.
..####.
...###.
.......  
【输出样例】
1  
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
思路：

把'.'当做0，把'#'当做-1（化作整数方便标记连通分量）

1.dfs一次，并在dfs的过程中标连通分量（每个岛给一个编号p，p从1开始）

2.在1的过程中，把会被淹没的陆地（如果周围存在海）给予特殊编号-2

3.最后统计非特殊编号个数cnt, 答案就是p-cnt;

注意数据的输入，java 我输入还不是很熟啊！！！

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

public class Main{
	public static int[][] map;
	public static int[][] visit;
	public static int dx[] = {1, -1, 0, 0};
	public static int dy[] = {0, 0, 1, -1};
	public static int n;

	public static void main(String args[] ) {
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
//		cin.nextLine();  //读掉回车
		map = new int[n][n];
		visit = new int[n][n];
		for(int i = 0; i < n; i++) {
			String temp = cin.next();
//			System.out.println("---" + temp + "----");
			for(int j = 0; j < n; j++) {
				if(temp.charAt(j) == '.') {
					map[i][j] = -1; //水
				}
				else {
					map[i][j] = 0;  //土地
				}
				visit[i][j] = 0;
			}
		}
		int cnt = 0; //原来总的岛屿数量
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				if(map[i][j] == 0) {
					cnt++;
					dfs(i, j, cnt);
				}
			}
		}
		int ans = 0;
		HashSet<Integer> set = new HashSet<>();
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				if(map[i][j] > 0) {
					set.add(map[i][j]);
				}
			}
		}
		System.out.println(cnt - set.size());
		System.out.println(set.toString());
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				System.out.print(map[i][j]);
			}
			System.out.println();
		}
	}

	public static void dfs(int x, int y, int bh) {
//		System.out.println("x + y" + x + " " + y);
		map[x][y] = bh;
		visit[x][y] = 1;
		int flag = 0;
		for(int i = 0; i < 4; i++) {
			int xx = x + dx[i];
			int yy = y + dy[i];
			if(xx >= 0 && xx < n &&
					yy >= 0 && yy < n && visit[xx][yy] == 0) {
				if(map[xx][yy] == -1) { //周边有一个是水，则淹没
					map[x][y] = -2; //特殊标记，表示已经淹没的，但不能和水一样，否则会导致他相邻的误判
				}
				else if(map[xx][yy] == 0){
					dfs(xx, yy, bh);
				}
			}
		}
	}

}
	/*

样例1：
7
.......
.##....
.##....
....##.
..####.
...###.
.......

1

样例2：
7
.......
.##....
.####..
....##.
..####.
...###.
.......

0
	 */

　　

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
资源约定： 峰值内存消耗（含虚拟机） < 256M CPU 消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。 不要使用 package 语句。不要使用 jdk1.7 及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。

纯暴力深搜代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;

public class Main{
	public static int[] visit = new int[100005];
	public static int n;
	public static int ans = 0;
	public static int[] tree = new int[100005];

	public static void main(String args[] ) {
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt(); // 树上节点总数
		find(1);

		System.out.println(ans);
	}
	public static void find(int x) {
		if(x == n + 1) {
			for(int i = 1; i <= n; i++) {
				System.out.print(tree[i] + " ");
			}
			System.out.println();
			ans = (ans + 1) % 1000000009;
		}
		int st = x / 2;
		for(int i = tree[st] + 1; i <= n; i++) {
			if(visit[i] == 0) {
				visit[i] = 1;
				tree[x] = i;
				find(x+1);
				visit[i] = 0;
				tree[x] = 0;
			}
		}
	}

}