【2024年蓝桥杯Java B组】省赛真题详细解析

【2024年蓝桥杯Java B组】省赛真题

距离比赛仅剩5天，大多数省份可能完成3-4题即可拿到省奖，2025年想要拿到省奖，需要高效利用时间，重点突破关键知识点和题型。这里以【2024年蓝桥杯Java B组省赛真题】为例，梳理我们最后5天重点需要攻克的题型~希望大家都可以顺利获奖！

第一题：报数游戏

• 赛题：给定一个数列，第奇数项是20的倍数，第偶数项是24的倍数。求第n项的值，其中n=202420242024。
• 解题思路：通过观察数列规律，发现第n项的值可以通过简单的数学公式计算得出。对于偶数项，答案是n/2乘以24。
• 代码：

  public class Main1 {
      public static void main(String[] args) {
          long n = 202420242024L;
          n /= 2;
          long a = 24;
          long ans = n * 24;
          System.out.println(ans);
      }
  }
  

• 技巧：通过观察数列的规律，快速找到解题的公式，避免复杂的计算。

第二题：类斐波那契循环数

• 赛题：给定一个数N，判断N是否是一个类斐波那契循环数。类斐波那契循环数是指一个数N可以出现在由其各位数字生成的类斐波那契数列中。
• 解题思路：从最大的可能值10^7开始向下遍历，逐个判断每个数是否为类斐波那契循环数。通过模拟生成类斐波那契数列并判断N是否出现在其中。
• 代码：

  public class Main1 {
      static List<Integer> toList(int a) {
          List<Integer> list = new ArrayList<>();
          while (a > 0) {
              int t = a % 10;
              list.add(t);
              a /= 10;
          }
          Collections.reverse(list);
          return list;
      }
  
      static boolean isFab(int a) {
          ArrayList<Integer> list = new ArrayList<>(toList(a));
          int len = list.size();
          while (true) {
              int sum = 0;
              for (int i = list.size() - 1; i > list.size() - 1 - len; i--) {
                  sum += list.get(i);
              }
              if (sum == a) return true;
              if (sum > a) return false;
              list.add(sum);
          }
      }
  
      public static void main(String[] args) {
          int end = (int) 1e7;
          while (end > 0) {
              if (isFab(end)) {
                  System.out.println(end);
                  return;
              }
              end--;
          }
      }
  }
  

• 技巧：通过模拟生成类斐波那契数列，逐个判断每个数是否满足条件，避免复杂的数学推导。

第三题：分布式队列

• 赛题：模拟一个分布式队列的运行状态，主节点添加元素，副节点同步元素，查询当前具有可见性的元素数量。
• 解题思路：通过维护一个数组记录每个副节点的同步状态，每次操作更新对应的状态，查询时计算所有副节点中同步到的最少元素数量。
• 代码：

  import java.util.Arrays;
  import java.util.Scanner;
  
  public class Main {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int n = sc.nextInt();
          int[] index = new int[n];
          Arrays.fill(index, -1);
  
          while (sc.hasNextLine()) {
              String line = sc.nextLine();
              String[] tokens = line.split(" ");
              String s = tokens[0];
  
              if ("query".equals(s)) {
                  int min = Integer.MAX_VALUE;
                  for (int i : index) {
                      if (min > i) min = i;
                  }
                  System.out.println(min + 1);
              } else if ("add".equals(s)) {
                  int element = Integer.parseInt(tokens[1]);
                  index[0]++;
              } else if ("sync".equals(s)) {
                  int followerId = Integer.parseInt(tokens[1]);
                  if (followerId >= 1 && followerId < n) {
                      if (index[followerId] < index[0]) {
                          index[followerId]++;
                      }
                  }
              }
          }
      }
  }
  

• 技巧：通过数组记录每个节点的同步状态。

第四题：食堂

• 赛题：给定不同类型的寝室和食堂的桌子，安排寝室成员到食堂用餐，最大化同时用餐的学生人数。
• 解题思路：通过贪心算法，优先安排满桌、小桌、人多的寝室，最后考虑空少的情况，逐步尝试不同的组合，计算最大用餐人数。
• 代码：

  import java.util.Scanner;
  
  public class Main {
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int q = sc.nextInt();
          while (q-- > 0) {
              int a2 = sc.nextInt();
              int a3 = sc.nextInt();
              int a4 = sc.nextInt();
              int b4 = sc.nextInt();
              int b6 = sc.nextInt();
  
              long ans = 0;
              int t;
  
              t = Math.min(a4, b4);
              ans += t * 4;
              a4 -= t;
              b4 -= t;
  
              t = Math.min(a2 / 2, b4);
              ans += t * 4;
              a2 -= t * 2;
              b4 -= t;
  
              t = Math.min(b6, Math.min(a4, a2));
              ans += t * 6;
              a4 -= t;
              a2 -= t;
              b6 -= t;
  
              t = Math.min(b6, a3 / 2);
              ans += t * 6;
              a3 -= t * 2;
              b6 -= t;
  
              t = Math.min(b6, a2 / 3);
              ans += t * 6;
              a2 -= t * 3;
              b6 -= t;
  
              t = Math.min(b6, Math.min(a3, a2));
              ans += t * 5;
              a3 -= t;
              a2 -= t;
              b6 -= t;
  
              t = Math.min(b4, a3);
              ans += t * 3;
              a3 -= t;
              b4 -= t;
  
              t = Math.min(b6, a4);
              ans += t * 4;
              a4 -= t;
              b6 -= t;
  
              t = Math.min(b6, a2 / 2);
              ans += t * 4;
              a2 -= t * 2;
              b6 -= t;
  
              t = Math.min(b4, a2);
              ans += t * 2;
              a2 -= t;
              b4 -= t;
  
              t = Math.min(b6, a3);
              ans += t * 3;
              a3 -= t;
              b6 -= t;
  
              t = Math.min(b6, a2);
              ans += t * 2;
              a2 -= t;
              b6 -= t;
  
              System.out.println(ans);
          }
      }
  }
  

• 技巧：通过贪心算法，逐步尝试不同的组合，确保每一步都尽可能最大化用餐人数。

第五题：最优分组

• 赛题：给定N个宠物和感染概率p，将宠物分组进行检测，最小化检测剂的期望消耗数量。
• 解题思路：通过计算不同分组大小K的期望消耗数量，选择最小的期望值对应的K。
• 代码：

  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Scanner;
  
  public class Main {
      static int N, ans;
      static double p, min = Double.MAX_VALUE / 2;
      static ArrayList<Integer> factors = new ArrayList<>();
  
      static double calculateExpected(int K) {
          if (K == 1) return N;
          double probabilityAllNegative = Math.pow(1 - p, K);
          double expectedTestsPerGroup = probabilityAllNegative * 1 + (1 - probabilityAllNegative) * (1 + K);
          return expectedTestsPerGroup * ((double) N / K);
      }
  
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          N = sc.nextInt();
          p = sc.nextDouble();
  
          for (int i = 1; i <= Math.sqrt(N); i++) {
              if (N % i == 0) {
                  factors.add(i);
                  if (N / i != i) {
                      factors.add(N / i);
                  }
              }
          }
  
          Collections.sort(factors);
  
          for (int K : factors) {
              double currentExpected = calculateExpected(K);
              if (currentExpected < min) {
                  ans = K;
                  min = currentExpected;
              }
          }
  
          System.out.println(ans);
      }
  }
  

• 技巧：通过数学期望的计算，选择最优的分组大小K。

第六题：星际旅行

• 赛题：给定一个星系的星球和传送门，计算从某个星球出发，使用不超过一定次数的传送门，可以到达的星球数量的期望值。
• 解题思路：通过Floyd-Warshall算法计算所有星球之间的最短路径，然后统计每个旅行方案可以到达的星球数量，计算期望值。
• 代码：

  import java.util.Scanner;
  
  public class Main {
      static long INF = Long.MAX_VALUE / 2;
  
      public static void main(String[] args) {
          long[][] g = new long[1010][1010];
          Scanner in = new Scanner(System.in);
          int n = in.nextInt();
          int m = in.nextInt();
          int q = in.nextInt();
  
          for (int i = 0; i < g.length; i++) {
              Arrays.fill(g[i], INF);
              g[i][i] = 0;
          }
  
          for (int i = 0; i < m; i++) {
              int u = in.nextInt();
              int v = in.nextInt();
              g[u][v] = 1;
              g[v][u] = 1;
          }
  
          for (int k = 1; k <= n; k++) {
              for (int i = 1; i <= n; i++) {
                  for (int j = 1; j <= n; j++) {
                      if (g[i][k] != INF && g[k][j] != INF) {
                          if (g[i][j] > g[i][k] + g[k][j]) {
                              g[i][j] = g[i][k] + g[k][j];
                          }
                      }
                  }
              }
          }
  
          long ans = 0;
          for (int i = 0; i < q; i++) {
              int start = in.nextInt();
              int k = in.nextInt();
              for (int j = 1; j <= n; j++) {
                  if (g[start][j] <= k) ans++;
              }
          }
          System.out.printf("%.2f", 1.0 * ans / q);
      }
  }
  

• 技巧：通过Floyd-Warshall算法计算最短路径。

第七题：俄罗斯方块

• 赛题：给定一个N×N的格子图，判断是否可以放置四种不同的俄罗斯方块图案，使得它们不重叠。
• 解题思路：通过暴力枚举所有可能的图形排列组合，尝试放置每种图形，判断是否满足条件。
• 代码：

  import java.util.Scanner;
  
  public class Main {
      private static int[][][][] lits = {
          // L形状的4种旋转状态
          {
              {{0, 0}, {0, -1}, {-1, -1}, {-2, -1}},
              {{0, 0}, {-1, 0}, {-1, 1}, {-1, 2}},
              {{0, 0}, {-1, 0}, {-2, 0}, {-2, -1}},
              {{0, 0}, {0, -1}, {0, -2}, {-1, 0}}
          },
          // I形状的2种旋转状态
          {
              {{0, 0}, {-1, 0}, {-2, 0}, {-3, 0}},
              {{0, 0}, {0, -1}, {0, -2}, {0, -3}}
          },
          // T形状的4种旋转状态
          {
              {{0, 0}, {-1, 0}, {-1, -1}, {-1, 1}},
              {{0, 0}, {-1, 0}, {-2, 0}, {-1, -1}},
              {{0, 0}, {0, -1}, {0, -2}, {-1, -1}},
              {{0, 0}, {-1, 0}, {-2, 0}, {-1, 1}}
          },
          // S形状的2种旋转状态
          {
              {{0, 0}, {0, -1}, {-1, 0}, {-1, 1}},
              {{0, 0}, {-1, 0}, {-1, -1}, {-2, -1}}
          }
      };
  
      static int[] pos = new int[4];
      static boolean flag = false;
      static boolean[] vis = new boolean[4];
  
      static boolean success() {
          for (boolean t : vis) if (!t) return false;
          return true;
      }
  
      static void fill(int x, int y, int k, int[][] map, int val) {
          for (int i = 0; i < 4; i++) {
              int xx = x + lits[k][pos[k]][i][0];
              int yy = y + lits[k][pos[k]][i][1];
              map[xx][yy] = val;
          }
      }
  
      static boolean check(int x, int y, int k, int[][] map) {
          int N = map.length;
          for (int i = 0; i < 4; i++) {
              int xx = x + lits[k][pos[k]][i][0];
              int yy = y + lits[k][pos[k]][i][1];
              if (xx >= N || xx < 0 || yy >= N || yy < 0 || map[xx][yy] != 1) return false;
          }
          return true;
      }
  
      static void dfs(int x, int y, int[][] map) {
          int N = map.length;
          if (success()) {
              flag = true;
              return;
          }
  
          if (flag || x == N) return;
  
          if (y == N) {
              dfs(x + 1, 0, map);
              return;
          }
  
          if (map[x][y] != 1) {
              dfs(x, y + 1, map);
              return;
          }
  
          for (int i = 0; i < 4; i++) {
              if (!vis[i] && check(x, y, i, map)) {
                  fill(x, y, i, map, 2);
                  vis[i] = true;
  
                  dfs(x, y + 1, map);
                  if (flag) return;
  
                  fill(x, y, i, map, 1);
                  vis[i] = false;
              }
          }
          dfs(x, y + 1, map);
      }
  
      static boolean solve(int[][] map) {
          for (int l = 0; l < 4; l++) {
              for (int i = 0; i < 2; i++) {
                  for (int t = 0; t < 4; t++) {
                      for (int s = 0; s < 2; s++) {
                          Arrays.fill(vis, false);
                          flag = false;
                          pos[0] = l;
                          pos[1] = i;
                          pos[2] = t;
                          pos[3] = s;
                          dfs(0, 0, map);
                          if (flag) return true;
                      }
                  }
              }
          }
          return false;
      }
  
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int t = sc.nextInt();
          while (t-- > 0) {
              int n = sc.nextInt();
              int[][] g = new int[n][n];
              for (int i = 0; i < n; i++) {
                  for (int j = 0; j < n; j++) {
                      g[i][j] = sc.nextInt();
                  }
              }
  
              boolean ans = solve(g);
              System.out.println(ans ? "Yes" : "No");
          }
      }
  }
  

• 技巧：通过暴力枚举所有可能的图形排列组合，使用深度优先搜索（DFS）尝试放置每种图形。

第八题：拼十字

• 赛题：给定N个矩形，每个矩形有长度、宽度和颜色，计算可以拼成十字的矩形对数量。
• 解题思路：通过排序和树状数组（Fenwick Tree）维护宽度信息，快速统计满足条件的矩形对数量。
• 代码：

  import java.io.*;
  import java.util.*;
  
  public class Main {
      static class FenwickTree {
          int n;
          int[] tree;
  
          public FenwickTree(int n) {
              this.n = n;
              tree = new int[n + 1];
          }
  
          int lowbit(int i) {
              return i & -i;
          }
  
          void add(int i, int val) {
              for (; i <= n; i += lowbit(i)) {
                  tree[i] += val;
              }
          }
  
          int preSum(int i) {
              int ret = 0;
              for (; i > 0; i -= lowbit(i)) {
                  ret += tree[i];
              }
              return ret;
          }
  
          int rangeSum(int l, int r) {
              return preSum(r) - preSum(l - 1);
          }
      }
  
      static int maxn = 100010;
      static int ans = 0;
      static int mod = (int) 1e9 + 7;
  
      public static void main(String[] args) {
          Scanner sc = new Scanner(System.in);
          int n = sc.nextInt();
          List<int[]> arr = new ArrayList<>();
  
          for (int i = 0; i < n; i++) {
              int l = sc.nextInt();
              int w = sc.nextInt();
              int c = sc.nextInt();
              arr.add(new int[]{l, w, c});
          }
  
          arr.sort((o1, o2) -> {
              if (o1[0] != o2[0]) return Integer.compare(o1[0], o2[0]);
              else return Integer.compare(o1[1], o2[1]);
          });
  
          FenwickTree[] tree = new FenwickTree[3];
          for (int i = 0; i < 3; i++) tree[i] = new FenwickTree(maxn);
  
          for (int[] a : arr) {
              int l = a[0];
              int w = a[1];
              int c = a[2];
              for (int i = 0; i < 3; i++) {
                  if (c == i) continue;
                  ans = (ans + tree[i].rangeSum(w + 1, maxn)) % mod;
              }
              tree[c].add(w, 1);
          }
          System.out.println(ans);
      }
  }
  

• 技巧：通过排序和树状数组维护宽度信息，快速统计满足条件的矩形对数量，避免直接暴力枚举。