2018年第九届蓝桥杯B组JAVA题解

这是第一次参加蓝桥杯，应该也是最后一次。我参加的B组 JAVA，整体感觉还行吧，只是比赛的时候出了点小意外。本来是下午1点中结束的，因为提前了两分钟开始，然后到12点五十几的时候就交不了了，导致一个大题白白丢掉，当时心里有点炸。不过也没什么，蓝桥杯这种比赛，就当是玩一下吧。然后就说说题目吧，水平有限，错了见谅。
第一题：

标题：第几天

2000年的1月1日，是那一年的第1天。

那么，2000年的5月4日，是那一年的第几天？
注意：需要提交的是一个整数，不要填写任何多余内容。
这个太水了，没什么说的，直接口算就行了。
我的答案：125

第二题 ：
标题：方格计数

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



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

注意：需要提交的是一个整数，不要填写任何多余内容。
比赛的时候以为找到了规律：如果半径为R的话，那么所圈住的小正方形应该是[2 *(R-1)]^2。试了1，2，3都满足，然后就没多想，毕竟才第二个题目。
比赛完了才发现这式子有问题，R>根号2*(R-1)只有在R<4时才成立，唉，当时也没仔细看，就想当然的填了上去。写了个代码跑了一下，发现果然错了，还是太年轻啊...import java.util.Scanner;

public class 方格计数 {
static int N = 10000; // 方格图的大小, 10000够大了
static int X = 5000, Y = 5000; // 圆心坐标
static double[] l = new double
;
static double[] r = new double
;
static int R, ans = 0;

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
R = sc.nextInt();
for (int i = Y - R; i <= Y + R; i++) {
l[i] = X - Math.sqrt(R * R - (Y - i) * (Y - i));
r[i] = Math.min(N, (X << 1) - l[i]);
if (l[i] < 0) {
l[i] = 0;
}
}
for (int i = Y - R; i <= Y - 1; i++) {
int ll = (int) Math.ceil(l[i]), rr = (int) Math.floor(r[i]);
ans += rr - ll;
}
for (int i = Y; i <= Y + R - 1; i++) {
int ll = (int) Math.ceil(l[i + 1]), rr = (int) Math.floor(r[i + 1]);
ans += rr - ll;
}
System.out.println(ans);
}
}
我的答案： 3137548

第三题：
标题：复数幂
设i为虚数单位。对于任意正整数n，(2+3i)^n 的实部和虚部都是整数。
求 (2+3i)^123456 等于多少？ 即(2+3i)的123456次幂，这个数字很大，要求精确表示。
答案写成 "实部±虚部i" 的形式，实部和虚部都是整数（不能用科学计数法表示），中间任何地方都不加空格，实部为正时前面不加正号。(2+3i)^2 写成: -5+12i，
(2+3i)^5 的写成: 122-597i

注意：需要提交的是一个很庞大的复数，不要填写任何多余内容。
这题真的是不想吐槽了，用java大数加快速幂做的，应该是做对了，但是一开始eclipse控制台没显示出来，以为是大数爆了。
代码：import java.math.BigInteger;

public class 复数幂 {
public static void main(String[] args) {
Complex cmp = new Complex(BigInteger.valueOf(2), BigInteger.valueOf(3));
System.out.println(quickPow(cmp, 123456).toString());
}

private static Complex quickPow(Complex cmp, int n) {
if (n == 0) {
return new Complex(BigInteger.valueOf(1), BigInteger.valueOf(0));
}
Complex temp = quickPow(cmp, n / 2);
temp.multiply(temp);
if (n % 2 != 0) {
temp.multiply(cmp);
}
return temp;
}
}

class Complex {
BigInteger a; // 实部
BigInteger b; // 虚部

public Complex(BigInteger a, BigInteger b) {
this.a = a;
this.b = b;
}

public void multiply(Complex cm) {
BigInteger tempa = a.multiply(cm.a).subtract(b.multiply(cm.b));
BigInteger tempb = a.multiply(cm.b).add(b.multiply(cm.a));
a = tempa;
b = tempb;
}

@Override
public String toString() {
String aStr = "" + a;
String bStr = b + "i";
if (b.compareTo(BigInteger.valueOf(0)) > 0) {
bStr = "+" + bStr;
} else if (b.compareTo(BigInteger.valueOf(0)) == 0) {
bStr = "";
}
return aStr + bStr;
}
}eclipse控制台输出的结果是--i，不知道是什么鬼，比赛完了才知道把这个--i是一个超长的字符串。结果就不贴了，太长了，刚刚粘贴的时候浏览器都卡了。反正思路应该不难，如果是c++的话，手写大数应该也还好，然后快速幂就不说了，算法基础。



看一下最右边的滚动滑轮感受一下数字规模。。。

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

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

其实这题在之前碰到过一个差不多的，不过当时没有深究，之前的好像是两个鸡蛋，100层，问最坏情况下最少几次？这个是最坏情况最多几次，我不知道是不是我多想了，比赛的时候二分答案，错了。。。比赛完结合之前的题目又想了一下，递推了一下，算出来19。
我的答案：19
代码：public class 摔手机 {
public static void main(String[] args) {
System.out.println(DroppingPhone(3, 1000));
}

private static long DroppingPhone(long phone, long floors) {
long times = 1;
while (DroppingMax(phone, times) < floors) {
++times;
}
return times;
}

private static long DroppingMax(long phone, long times) {
if (phone == 1) {
return times;
}

if (phone >= times) {
return (long) Math.pow(2, times) - 1;
}

return DroppingMax(phone, times - 1) + DroppingMax(phone - 1, times - 1) + 1;
}
}
第五题：
标题：快速排序
以下代码可以从数组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));
}
}

注意：只提交划线部分缺少的代码，不要抄写任何已经存在的代码或符号。这题也不是什么新题，利用快排的partition思想进行"选择"，是解决这类问题的高效方法，可以把复杂度从O（nlongn）（直接排序求a[k - 1]）降到O（n）（利用快排分组时左边刚好k-1个元素）。注意题目要求是O(n)，这题如果只求运行正确有几种写法，如果不注意直接写partition 的分治可能还是O（nlogn）。
我的答案：a, i + 1, r, k - i + l - 1  
-----------------------------------分割线-------------------------------------------
编程题就懒得去码代码了，不太喜欢重复性的劳动，就大致说一下我的思路，菜鸡一只，错了请见谅。。。
第六题：
标题：递增三元组
给定三个整数数组
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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

这道题的话，比赛的时候应该是gg了。不过下来又想了一下，可以先排序，然后直接三个for循环（两层）：以B数组为标杆，对于B的每一个元素Bi，二分统计A中比Bi小的元素，C中比Bi大的元素，然后相乘，最后把乘积累加起来。也不知道蓝桥的判题机怎么样，O(nlogn)对于1e5的数据规模，勉勉强强能过。

第七题
标题：螺旋折线



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

这题考察的不是算法吧，就是思维，方法应该挺多的。我用的方法是把螺旋折线转变成一个个的同心正方形，像下面这样，



注意转化关系，然后就好算多了。其实实在不行，分象限讨论，肯定能做出来，这题难度不大，细心一点，问题不大。
w第八题
标题：日志统计
小明维护着一个程序员论坛。现在他收集了一份"点赞"日志，日志共有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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
这题用的优先队列加hash（或者直接写一个二维的排序也行吧），感觉是没问题，造了几组数据都过了，然而前面说到有一题最后到时间没交，就是这题。。。这题计算点赞量，应该是以每一个点赞时间Ti为为起点，计算[Ti,D)的点赞数（i = 1, 2, 3, ..., n），然后求最大值与K比较。

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

第一行包含一个整数N。  (1 <= N <= 1000)  
以下N行N列代表一张海域照片。  
照片保证第1行、第1列、第N行、第N列的像素都是海洋。  
【输出格式】
一个整数表示答案。
【输入样例】
7 
.......
.##....
.##....
....##.
..####.
...###.
.......  
【输出样例】
1  
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗  < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
这题当时也是想的比较简单，dfs求联通分量，并且在求联通分量的时候做个标记，判断这个联通分量（岛屿）中是否存在不临海的陆地，存在的话，这样的联通分量（岛屿）才不会完全消失。还有就是，下面这两种都算不完全消失（都是0个岛屿被淹没）吧？虽然岛屿数量变多了。



第十题
标题：堆的计数
我们知道包含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
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

这题之前是在哪看到过，（好像是阿里）的面试题。不过不完全一样，想了一会，写了一个递推式，只验证了4，5两种，后面的没有去验证，不过应该是错了，就不贴了。感觉应该是组合数求和的问题，具体怎么个组合没想清楚，比赛的时候时间有限，没想太多。

总结：其实从上一届蓝桥杯开始，题目难度就慢慢上升了。今年的题目除了第一题，之后每一题想拿到满分都不是那么的容易，质量还行，不过也不是说很难，真的需要很仔细。虽然只参加了这一次，但我感觉蓝桥杯这种，读题很重要，有时候你做了半天觉得做对了然后发现题目理解错了....至于能不能省一，都无所谓了，蓝桥杯虽然在不断发展，但目前这种级别的奖项拿出去没什么含金量。不过在校内还是认可的，大一大二没事参加着玩一下，就当练练手，毕竟ACM，NOIP对于我这种菜鸡来说，门槛太高了。
很少在csdn上写东西，也是第一次写这么多。emmm，就先说到这吧，蓝桥杯，再见了，应该不会再见了。。。

-------4月9日更新----------
今天结果出来了，竟然水了个省一，好吧，又可以去水一下国赛了（其实是想着去旅游...）。。。