2021年第十二届蓝桥杯省赛B组Java题解

2021年第十二届蓝桥杯省赛B组Java题解

---

说明：
2021年蓝桥杯省赛Java B组延续了“暴力杯”的特点，题目难度分层明显，前几题为简单模拟题，后几题涉及动态规划、数学建模和复杂算法设计。从考察内容来看，字符串处理、数论、排列组合、日期计算是重点，对代码实现效率和逻辑严谨性要求较高。本文提供A~J题的核心解法与优化代码，帮助大家快速掌握解题思路。

---

试题A：ASC（5分）

问题描述

求大写字母L的ASCII码值。

题解

直接通过Java类型转换实现：

public class Main {
    public static void main(String[] args) {
        System.out.println((int)'L'); // 输出76
    }
}

优化点：代码简洁，无需额外计算。

---

试题B：卡片（5分）

问题描述

用数字0-9的卡片各2021张拼数字，求能拼到的最大连续整数。

题解

通过哈希表统计卡片消耗：

public class Main {
    public static void main(String[] args) {
        int[] cards = new int[10];
        Arrays.fill(cards, 2021);
        int num = 1;
        while (true) {
            int tmp = num;
            while (tmp > 0) {
                int digit = tmp % 10;
                if (cards[digit] == 0) {
                    System.out.println(num - 1); // 输出3181
                    return;
                }
                cards[digit]--;
                tmp /= 10;
            }
            num++;
        }
    }
}

注释：逐位拆解数字并检查卡片余量，时间复杂度为O(n)。

---

试题C：直线（10分）

问题描述

计算20×21网格点能确定的不同直线数量。

题解

用分数化简避免浮点误差：

public class Main {
    static class Line {
        String k, b; // 斜率k=a/b，截距b=c/d
        public Line(String k, String b) {
            this.k = k;
            this.b = b;
        }
        @Override
        public boolean equals(Object obj) {
            Line line = (Line) obj;
            return k.equals(line.k) && b.equals(line.b);
        }
        @Override
        public int hashCode() {
            return k.hashCode() + b.hashCode();
        }
    }

    static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    public static void main(String[] args) {
        Set<Line> lines = new HashSet<>();
        List<int[]> points = new ArrayList<>();
        for (int x = 0; x < 20; x++) {
            for (int y = 0; y < 21; y++) {
                points.add(new int[]{x, y});
            }
        }
        for (int i = 0; i < points.size(); i++) {
            int[] p1 = points.get(i);
            for (int j = i + 1; j < points.size(); j++) {
                int[] p2 = points.get(j);
                int dx = p1[0] - p2[0], dy = p1[1] - p2[1];
                if (dx == 0) { // 垂直线
                    lines.add(new Line("INF", String.valueOf(p1[0])));
                    continue;
                }
                // 斜率化简
                int g1 = gcd(dy, dx);
                String k = (dy/g1) + "/" + (dx/g1);
                // 截距化简：(y1x2 - y2x1)/(x2 - x1)
                int numerator = p1[1] * dx - dy * p1[0];
                int denominator = dx;
                int g2 = gcd(numerator, denominator);
                String b = (numerator/g2) + "/" + (denominator/g2);
                lines.add(new Line(k, b));
            }
        }
        System.out.println(lines.size()); // 输出40257
    }
}

优化点：通过分数形式避免精度丢失，HashSet去重效率更高。

---

试题D：货物摆放（10分）

问题描述

求n=2021041820210418的因数三元组(a,b,c)满足a×b×c=n的数量。

题解

因数分解+排列组合：

public class Main {
    public static void main(String[] args) {
        long n = 2021041820210418L;
        List<Long> factors = new ArrayList<>();
        for (long i = 1; i <= Math.sqrt(n); i++) {
            if (n % i == 0) {
                factors.add(i);
                if (i != n / i) factors.add(n / i);
            }
        }
        int count = 0;
        for (Long a : factors) {
            for (Long b : factors) {
                if (a * b > n) continue;
                if (n % (a * b) == 0) count++;
            }
        }
        System.out.println(count); // 输出2430
    }
}

注释：先获取所有因数，再遍历三元组，时间复杂度O(m²)，m为因数个数。

---

试题E：路径（15分）

问题描述

求1到2021节点的最短路径，边权为两节点编号的最小公倍数。

题解

Dijkstra算法+堆优化：

public class Main {
    static final int N = 2022;
    static List<int[]>[] graph = new ArrayList[N];
    static int[] dist = new int[N];

    public static void main(String[] args) {
        for (int i = 1; i < N; i++) {
            graph[i] = new ArrayList<>();
            for (int j = i + 1; j <= Math.min(i + 21, N - 1); j++) {
                int w = lcm(i, j);
                graph[i].add(new int[]{j, w});
            }
        }
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[1] = 0;
        PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
        heap.offer(new int[]{1, 0});
        while (!heap.isEmpty()) {
            int[] cur = heap.poll();
            int u = cur[0];
            if (u == 2021) break;
            for (int[] edge : graph[u]) {
                int v = edge[0], w = edge[1];
                if (dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                    heap.offer(new int[]{v, dist[v]});
                }
            }
        }
        System.out.println(dist[2021]); // 输出10266837
    }

    static int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
    static int lcm(int a, int b) { return a * b / gcd(a, b); }
}

优化点：使用优先队列优化，时间复杂度O(E logV)。

---

试题F：时间显示（15分）

问题描述

将毫秒数转换为HH:MM:SS格式。

题解

时间单位转换：

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long ms = sc.nextLong();
        ms %= 86400000; // 去除整天
        long h = ms / 3600000;
        ms %= 3600000;
        long m = ms / 60000;
        ms %= 60000;
        long s = ms / 1000;
        System.out.printf("%02d:%02d:%02d", h, m, s);
    }
}

注释：逐级取模计算时分秒，注意格式化输出。

---

本届省赛题目呈现以下特点：

1. 基础题占比高：前3题均考察基础语法和逻辑；
2. 算法分层明显：后3题需要掌握Dijkstra、数论等进阶知识；
3. 细节易错点多：如直线题中的精度问题、路径题中的LCM计算。

备赛建议：

• 熟练掌握Java集合、日期API等工具类；
• 强化动态规划和图论算法；
• 注重代码调试能力，避免因边界条件失分。