2020年4月蓝桥杯第二次模拟赛解题报告（高职组）Java语言描述

1 进制转换

题目

【问题描述】
请问十六进制数1949对应的十进制数是多少？请特别注意给定的是十六进制，求的是十进制。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答案

System.out.println(9 + 4 * 16 + 9 * (16 * 16) + (16 * 16 * 16));
// 输出：6473

2 互质个数

题目

【问题描述】
不超过19000的正整数中，与19000互质的数的个数是多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

解析

互质：两个数的公约数只有1，等价于：最大公约数为1

答案

   int ans = 0;
   for (int i = 1; i < 19000; i++) {
     if (gcd(i, 19000) == 1)
       ans++;
   }
   System.out.println(ans);
   // 输出7200

3 最大公约数

题目

【问题描述】
70044与113148的最大公约数是多少？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

解析

送分不要太明显。

答案

System.out.println(gcd(70044, 113148));
# 输出：5388

4 最多结点数

题目

【问题描述】
一棵10层的二叉树，最多包含多少个结点？
注意当一棵二叉树只有一个结点时为一层。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

解析

层数固定后，满二叉树的结点数最多；设层数为h，则满二叉树的结点数为2^h - 1，所以答案是2^10-1。

而2的10次方是每个程序员都应该记住的数字。

5 洁净数

题目

【问题描述】
小明非常不喜欢数字 2，包括那些数位上包含数字 2 的数。如果一个数的数位不包含数字 2，小明将它称为洁净数。
请问在整数 1 至 n 中，洁净数有多少个？
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
【样例输出】
18
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。

解析

迭代+check即可。

代码

import java.util.Scanner;

public class _05洁净数 {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int ans = 0;
    for (int i = 1; i <= n; i++) {
      if (("" + i).indexOf('2') == -1)
        ans += 1;
    }
    System.out.println(ans);
  }
}

6 最大距离

题目

【问题描述】
在数列 a_1, a_2, …, a_n中，定义两个元素 a_i 和 a_j 的距离为 |i-j|+|a_i-a_j|，即元素下标的距离加上元素值的差的绝对值，其中 |x| 表示 x 的绝对值。
给定一个数列，请问找出元素之间最大的元素距离。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a_1, a_2, …, a_n，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
5
9 4 2 4 7
【样例输出】
9
【样例说明】
a_1 和 a_3 的距离为 |1-3|+|9-2|=9。
【评测用例规模与约定】
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。

解析

n最大是1000，暴力二重循环即可。

代码

import java.util.Scanner;

public class _06最大距离 {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int[] data = new int[n + 1];
    for (int i = 1; i <= n; i++) {
      data[i] = sc.nextInt();
    }
    int ans = 0;
    for (int i = 1; i < n; i++) {
      for (int j = i + 1; j <= n; j++) {
        int dis = j - i + Math.abs(data[j] - data[i]);
        ans = Math.max(ans, dis);
      }
    }
    System.out.println(ans);
  }
}

7 最长递增

题目

【问题描述】
在数列 a[1], a[2], ..., a[n] 中，如果 a[i] < a[i+1] < a[i+2] < ... < a[j]，则称 a[i] 至 a[j] 为一段递增序列，长度为 j-i+1。
给定一个数列，请问数列中最长的递增序列有多长。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
7
5 2 4 1 3 7 2
【样例输出】
3
【评测用例规模与约定】
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。

解析

此题要求递增序列是连续的，因此每遇到后项比前项小的情况，就可以结算上一段的长度，维护一个递增的序列的最长长度即可。

代码

import java.util.Scanner;

public class _07 {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int[] data = new int[n + 1];
    for (int i = 1; i <= n; i++) {
      data[i] = sc.nextInt();
    }
    int p = 1;
    int ans = 0;
    for (int i = 2; i < n + 1; i++) {
      if (data[i] > data[i - 1]) {
      } else {
        ans = Math.max(ans, i - p);
        p = i;
      }
    }
    System.out.println(ans);
  }
}

8 字符计数

题目

【问题描述】
给定一个单词，请计算这个单词中有多少个元音字母，多少个辅音字母。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出两行，第一行包含一个整数，表示元音字母的数量。
第二行包含一个整数，表示辅音字母的数量。
【样例输入】
lanqiao
【样例输出】
4
3
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。

解析

迭代+统计计数即可。

代码

import java.util.Scanner;

public class _08 {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String s = sc.nextLine();
    int a = 0;
    int b = 0;
    for (char c : s.toCharArray()) {
      if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
        a++;
      } else {
        b++;
      }
    }
    System.out.println(a);
    System.out.println(b);
  }
}

9 练功

题目

【问题描述】
小明每天都要练功，练功中的重要一项是梅花桩。
小明练功的梅花桩排列成 n 行 m 列，相邻两行的距离为 1，相邻两列的距离也为 1。
小明站在第 1 行第 1 列上，他要走到第 n 行第 m 列上。小明已经练了一段时间，他现在可以一步移动不超过 d 的距离（直线距离）。
小明想知道，在不掉下梅花桩的情况下，自己最少要多少步可以移动到目标。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示梅花桩的行数和列数。
第二行包含一个实数 d（最多包含一位小数），表示小明一步可以移动的距离。
【输出格式】
输出一个整数，表示小明最少多少步可以到达目标。
【样例输入】
3 4
1.5
【样例输出】
3
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20，1 <= d <= 20。
对于 60% 的评测用例，2 <= n, m <= 100，1 <= d <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= d <= 100。

解析

题目问用多少步可达一个指定的点，往往都是宽度优先搜索。
本题中，以当前点为圆心，以d为半径的圆内的桩，都是小明一步可达的点；
鉴于要尽快往右下角靠拢，所以只需在右下角的四分之一的圆内搜索，将这些点加入到bfs的队列中。当然，不用把圆内所有的点都加入，只需加入外沿的那些点。

代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Meihuazhuang {
  static class Point {
    int x, y, step;

    public Point(int x, int y, int step) {
      this.x = x;
      this.y = y;
      this.step = step;
    }
  }

  static int[][] vis;

  public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m = sc.nextInt();
    double d = sc.nextDouble();
    // long start = System.currentTimeMillis();
    vis = new int[n][m];
    Queue<Point> q = new LinkedList<>();
    q.add(new Point(0, 0, 0));
    out:
    while (!q.isEmpty()) {
      Point top = q.poll();
      int top_x = top.x;
      int top_y = top.y;
      int step = top.step;
      // # 在半圆内搜索一步可达的点，加入队列
      int delta_y = (int) (d);                                          // y方向的增量（整数）
      for (int delta_x = 0; delta_x < (n - top_x); delta_x++) {         // x方向的增量（整数）
        if (delta_x * delta_x > d * d)
          break;
        // # 计算出可能的最大的delta y
        // # delta_y = int(sqrt(d ** 2 - delta_x ** 2))
        while (delta_x * delta_x + delta_y * delta_y > d * d && delta_y >= 0)  //delta_y最大为d，逐步缩小直到进入圆内
          delta_y -= 1;
        // ### 构造新的点
        int nx = top_x + delta_x;
        int ny = top_y + delta_y;
        if (ny >= m)
          ny = m - 1;
        if (vis[nx][ny] == 0) {
          if (nx == n - 1 && ny == m - 1) {
            System.out.println(step + 1);
            break out;
          }
          vis[nx][ny] = 1;
          q.add(new Point(nx, ny, step + 1));
        }

      }
    }
    // System.out.println("dure:" + (System.currentTimeMillis() - start) / 1000);
  }
}

10 积木

题目

【问题描述】
小明用积木搭了一个城堡。
为了方便，小明在搭的时候用的是一样大小的正方体积本，搭在了一个 n 行 m 列的方格图上，每个积木正好占据方格图的一个小方格。
当然，小明的城堡并不是平面的，而是立体的。小明可以将积木垒在别的积木上面。当一个方格上的积木垒得比较高时，就是一个高塔，当一个方格上没有积木时，就是一块平地。
小明的城堡可以用每个方格上垒的积木层数来表示。例如，下面就表示一个城堡。
9 3 3 1
3 3 3 0
0 0 0 0
这个城堡南面和东面都有空地，西北面有一个大房子，在西北角还有一个高塔，东北角有一个车库。
现在，格格巫要来破坏小明的城堡，他施了魔法水淹小明的城堡。
如果水的高度为1，则紧贴地面的那些积木要被水淹，在上面的例子中，有7块积木要被水淹。
如果水的高度为2，则更多积木要被水淹，在上面的例子中，有13块积木要被水淹。
给定小明的城堡图，请问，水的高度依次为1, 2, 3, ...., H 时，有多少块积木要被水淹。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行 m 个整数，表示小明的城堡中每个位置积木的层数。
接下来包含一个整数 H，表示水高度的上限。
【输出格式】
输出 H 行，每行一个整数。第 i 的整数表示水的高度为 i 时被水淹的积木数量。
【样例输入】
3 4
9 3 3 1
3 3 3 0
0 0 0 0
10
【样例输出】
7
13
19
20
21
22
23
24
25
25
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n, m <= 100，1 <= H <= 100，积木层数不超过100；
对于 70% 的评测用例，1 <= n, m <= 1000，1 <= H <= 1000，积木层数不超过1000；
对于所有评测用例，1 <= n, m <= 1000，1 <= H <= 100000，积木层数不超过1000000000。

解析

是一个排序计数问题

代码

import java.io.*;
import java.util.Arrays;
import java.util.Scanner;

public class _10 {
  public static void main(String[] args) throws IOException {
    // long start = System.currentTimeMillis();
    BufferedWriter bw =new BufferedWriter(new OutputStreamWriter(System.out));
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int m = sc.nextInt();

    int len = n * m;
    int[] a = new int[len];
    int a_index = 0;
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        a[a_index++] = sc.nextInt();
      }
    }
    int H = sc.nextInt();
    Arrays.sort(a);
    int h = 1;
    int pos = 0;
    long last = 0;
    for (int i = 0; i < H; i++) {
      while (pos < len && a[pos] < h) pos++;
      last = len - pos + last;
      bw.write(last+"\n");
      h++;
    }
    bw.flush();
    // System.err.println("dure:" + (System.currentTimeMillis() - start) / 1000);

  }
}