以下是针对蓝桥杯Java组备赛的增强版工具类及代码模板，包含详细注释和扩展内容，整合自多个真题解析和备赛资料（[3] [11] [17] [21]）：

一、核心工具类模板

1. 快速输入输出（必会技巧 [11] [21]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.io.*;
import java.util.StringTokenizer;

public class FastIO {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));

    // 读取整数（比Scanner快5倍）
    static int nextInt() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return Integer.parseInt(st.nextToken());
    }

    // 读取长整型（处理大数）
    static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    // 快速输出（自动刷新缓冲区）
    static void print(Object obj) {
        pw.print(obj);
    }

    static void flush() {
        pw.flush(); // 比赛结束前必须调用
    }
}

二、算法模板

1. BFS最短路径（迷宫问题 [13]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 方向数组：上下左右四个方向
int[][] dirs = {{-1,0}, {1,0}, {0,-1}, {0,1}};

void bfs(int[][] grid, int startX, int startY) {
    Queue<int[]> queue = new LinkedList<>();
    boolean[][] visited = new boolean[grid.length][grid[0].length];
    
    queue.offer(new int[]{startX, startY});
    visited[startX][startY] = true;
    
    while (!queue.isEmpty()) {
        int[] curr = queue.poll();
        for (int[] dir : dirs) {
            int x = curr[0] + dir[0];
            int y = curr[1] + dir[1];
            // 边界检查 + 访问标记 + 障碍判断
            if (x >=0 && x < grid.length && y >=0 && y < grid[0].length 
                && !visited[x][y] && grid[x][y] != 1) {
                visited[x][y] = true;
                queue.offer(new int[]{x, y});
            }
        }
    }
}

2. 动态规划（背包问题 [16]）

1
2
3
4
5
6
7
8
9
10
// 完全背包问题模板（物品无限取用）
int knapsack(int[] weights, int[] values, int capacity) {
    int[] dp = new int[capacity + 1];
    for (int i = 0; i < weights.length; i++) {
        for (int j = weights[i]; j <= capacity; j++) { // 正序循环实现重复选取
            dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
        }
    }
    return dp[capacity];
}

三、数学工具类

1. 质数筛法（埃氏筛 [5]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 生成n以内的质数表（时间复杂度O(n loglogn)）
boolean[] sieveOfEratosthenes(int n) {
    boolean[] isPrime = new boolean[n+1];
    Arrays.fill(isPrime, true);
    isPrime[0] = isPrime[1] = false;
    
    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {
            // 标记i的倍数为非质数
            for (int j = i*i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
    return isPrime;
}

2. 组合数学（杨辉三角 [6]）

1
2
3
4
5
6
7
8
9
10
11
// 生成组合数C(n,k)的预处理表
int[][] initCombination(int maxN) {
    int[][] C = new int[maxN+1][maxN+1];
    for (int i = 0; i <= maxN; i++) {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++) {
            C[i][j] = C[i-1][j-1] + C[i-1][j]; // 递推公式
        }
    }
    return C;
}

四、竞赛技巧

1. 日期处理（闰年判断 [8]）

1
2
3
4
5
6
7
8
9
10
11
// 判断闰年（蓝桥杯日期题高频考点）
boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}

// 计算某年某月天数
int getMonthDays(int year, int month) {
    int[] days = {31,28,31,30,31,30,31,31,30,31,30,31};
    if (month == 2 && isLeapYear(year)) return 29;
    return days[month-1];
}

2. 位运算技巧（[20]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 统计二进制中1的个数（比遍历快10倍）
int countBits(int n) {
    int count = 0;
    while (n != 0) {
        n &= (n - 1); // 每次消除最后一个1
        count++;
    }
    return count;
}

// 快速判断是否为2的幂次
boolean isPowerOfTwo(int n) {
    return n > 0 && (n & (n - 1)) == 0;
}

五、真题实战示例

1. Fibonacci数列取模（[9]）

1
2
3
4
5
6
7
8
9
10
11
// 避免递归的O(n)解法（处理n≤1e6）
int fibMod(int n, int mod) {
    if (n == 1 || n == 2) return 1 % mod;
    int a = 1, b = 1, c = 0;
    for (int i = 3; i <= n; i++) {
        c = (a + b) % mod; // 每次计算都取模防止溢出
        a = b;
        b = c;
    }
    return c;
}

2. 字符串编码转换（[10]）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 数字序列转字典序最小字符串
String decode(String s) {
    StringBuilder sb = new StringBuilder();
    int i = 0;
    while (i < s.length()) {
        // 优先尝试取两位数字（保证字典序最小）
        if (i+1 < s.length() && Integer.parseInt(s.substring(i,i+2)) <= 26) {
            sb.append((char)('A' + Integer.parseInt(s.substring(i,i+2)) - 1));
            i += 2;
        } else {
            sb.append((char)('A' + s.charAt(i) - '1'));
            i += 1;
        }
    }
    return sb.toString();
}

扩展建议：

  1. 创建AlgorithmUtils.java整合上述代码模板
  2. 重点练习近3年真题中的排序、DP和搜索题型（[3] [6]）
  3. 注意蓝桥杯的特殊要求：
    • 主类必须命名为Main（[4]）
    • 使用System.out输出时要及时刷新缓冲区
    • 大数处理优先使用long类型（范围-9e18~9e18）

附真题资源导航：