第十六届蓝桥杯Java大学A组真题解析

本次蓝桥杯共8题，2道选择题，6道编程题，先写一下我的感受：个人感觉较为简单（最后两题除外），如果想看一下有挑战的题，可以直接看最后两题，有详细解析。前面基本思路较顺，所以下面代码主要是我自己当时的，由ai注释，欢迎讨论。 如果您觉得有帮助，可以点赞收藏关注（狗头保命）后加的话：笔者已查到是省一了，可以关注一下，以后会发国赛的备考题目

答案是 40500

import java.util.*;
public class Main {
    // 统计整数a中每个数字(0-9)出现的次数
    public static int[] solve(int a) {
        int arr[] = new int[10];  // 创建长度为10的数组，索引0-9对应数字0-9的出现次数
        while(a != 0) {
            int k = a % 10;  // 获取当前个位数字
            arr[k]++;  // 对应数字的计数器加1
            a /= 10;   // 移除个位数字
        }
        return arr;  // 返回统计数组
    }
    public static void main(String arg[]) {
        int sum = 0;  // 用于统计符合条件的数的个数
        // 遍历从2025到20250412的所有整数
        for(int i = 2025; i <= 20250412; i++) {
            int arr[] = solve(i);  // 调用solve方法统计每个数字的出现次数
            // 判断是否满足条件：数字2至少出现2次、数字0至少出现1次、数字5至少出现1次
            if(arr[2] >= 2 && arr[0] >= 1 && arr[5] >= 1) {
                sum++;  // 符合条件则计数器加1
            }
        }
        System.out.print(sum);  // 输出结果
    }
}

答案：506754

package t3;
import java.util.*;
public class Main {
    // 计算整数a的二进制表示中1的个数
    public static int solve(int a) {
        int sum = 0;
        while(a != 0) {
            if(a % 2 == 1) {  // 判断当前位是否为1
                sum++;
            }
            a /= 2;  // 右移一位，相当于除以2
        }
        return sum;
    }

    // 对数组中的每个元素执行变换：将元素替换为其"二进制中1的个数 × 自身的值"
    public static int[] solve2(int arr[]) {
        int arr1[] = new int[arr.length];
        for(int i = 0; i < arr.length; i++) {
            arr1[i] = solve(arr[i]) * arr[i];  // 计算变换后的值
        }
        return arr1;  // 返回变换后的数组
    }

    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 输入数组长度

        // 输入原始数组
        int arr[] = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        int m = sc.nextInt();  // 输入变换次数

        // 执行m次变换
        for(int i = 0; i < m; i++) {
            int arr1[] = solve2(arr);  // 执行变换
            for(int j = 0; j < n; j++) {
                arr[j] = arr1[j];  // 更新原数组为变换后的结果
            }
        }

        // 输出最终结果
        for(int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

 

import java.util.*;
import java.math.*;
public class Main {
    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 输入数组长度

        // 定义两个长整型数组
        long sum = 0;  // 用于存储最终结果
        long arr[] = new long[n];  // 第一个数组
        long arr1[] = new long[n];  // 第二个数组

        // 输入第一个数组的元素
        for(int i = 0; i < n; i++) {
            arr[i] = sc.nextLong();
        }

        // 输入第二个数组的元素
        for(int i = 0; i < n; i++) {
            arr1[i] = sc.nextLong();
        }

        // 分别对两个数组进行排序
        Arrays.sort(arr1);
        Arrays.sort(arr);

        // 计算排序后对应位置元素差值的绝对值之和
        for(int i = 0; i < n; i++) {
            sum += Math.abs(arr[i] - arr1[i]);  // 累加每对元素的差值绝对值
        }

        // 输出结果
        System.out.print(sum);
    }
}

 

package t5;
import java.util.*;
public class Main {
    // 定义两个队列：q1和q2
    static Queue<Integer> q1 = new LinkedList<>();
    static Queue<Integer> q2 = new LinkedList<>();
    // 记录两个队列的当前大小
    static int size1 = 0, size2 = 0;

    // 从队列中移除所有值为a的元素
    public static Queue<Integer> remove(int a, Queue<Integer> q1) {
        Queue<Integer> q = new LinkedList<>();
        while (!q1.isEmpty()) {
            int t = q1.poll();
            if (t != a) {
                q.add(t);  // 将不等于a的元素添加到新队列
            }
        }
        return q;
    }

    // 向队列添加元素a，并根据k值和队列容量调整队列
    public static Queue<Integer> add(int a, int m1, int m2, Queue<Integer> q1, int k) {
        Queue<Integer> q = new LinkedList<>();
        q.add(a);  // 先添加元素a到队首

        while (!q1.isEmpty()) {
            int t = q1.poll();
            q.add(t);  // 将原队列元素依次添加到新队列

            if (k == 1) {  // 处理q1队列
                m1--;
                if (m1 == 1) {  // 当q1剩余容量为1时
                    if (k == 1 && size2 < m2) {  // 如果q2未满
                        int t1 = q1.poll();  // 从原队列取出下一个元素
                        q2.add(t1);  // 将该元素添加到q2
                    }
                    break;  // 停止处理原队列
                }
            } else {  // 处理q2队列
                m2--;
                if (m2 == 1) {  // 当q2剩余容量为1时
                    break;  // 停止处理原队列
                }
            }
        }
        return q;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m1 = sc.nextInt();  // q1的最大容量
        int m2 = sc.nextInt();  // q2的最大容量
        int n = sc.nextInt();   // 操作次数

        for (int i = 0; i < n; i++) {
            int k = sc.nextInt();  // 输入元素

            if (!q1.contains(k) && !q2.contains(k)) {  // 元素不在任何队列中
                q2 = add(k, m1, m2, q2, 2);  // 添加到q2
                if (size2 < n) {
                    size2++;  // 更新q2大小
                }
            } else {  // 元素已存在
                if (q2.contains(k)) {  // 元素在q2中
                    q2 = remove(k, q2);  // 从q2移除
                    q1 = add(k, m1, m2, q1, 1);  // 添加到q1
                    size2--;  // 更新q2大小
                    if (size1 < m1) {
                        size1++;  // 更新q1大小
                    }
                } else {  // 元素在q1中
                    q1 = remove(k, q1);  // 从q1移除
                    q1 = add(k, m1, m2, q1, 1);  // 重新添加到q1（移至队首）
                }
            }
        }

        // 输出q1的所有元素
        while (!q1.isEmpty()) {
            int t = q1.poll();
            System.out.print(t + " ");
        }
        System.out.println();

        // 输出q2的所有元素
        while (!q2.isEmpty()) {
            int t = q2.poll();
            System.out.print(t + " ");
        }
    }
}

package t6;
import java.util.*;
public class Main {
    // 计算整数a中数字6的出现次数
    public static int c(int a) {
        int size = 0;
        while(a != 0) {
            int k = a % 10;  // 获取当前个位数字
            a /= 10;         // 移除个位数字
            if(k == 6) {     // 如果当前数字是6
                size++;      // 计数器加1
            }
        }
        return size;
    }

    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 输入整数的数量
        int sum = 0;           // 用于统计满足条件的组合数

        // arr[i]表示数字6出现次数为i的整数的数量，i的范围是0到5
        int arr[] = new int[6];

        // 读取输入的n个整数，并统计数字6的出现次数
        for(int i = 0; i < n; i++) {
            int k = sc.nextInt();
            int t = c(k);  // 计算数字6的出现次数

            if(t >= 6) {   // 如果出现次数大于等于6，直接计入结果
                sum++;
            } else {       // 否则，将其计入对应的桶中
                arr[t]++;
            }
        }

        // 处理出现次数3到5的情况，尝试两两组合使其和为6
        for(int i = 5; i >= 3; i--) {
            int t = 6 - i;  // 寻找能与i组合成6的数

            while(arr[i] != 0) {
                if(i == t) {  // 如果i和t相等，无法组合，退出循环
                    break;
                }

                // 计算可以组合的最大对数
                int k = Math.min(arr[i], arr[t]);
                arr[i] -= k;  // 减少对应桶的数量
                arr[t] -= k;
                sum += k;     // 累加组合数
                t++;          // 尝试更大的t值
            }

            // 如果还有剩余的i，且无法再组合，处理剩余的i
            if(arr[i] != 0) {
                sum += arr[i] / 2;  // 每两个i可以组成一个满足条件的组合
                arr[i] = 1;         // 剩余1个无法组合
                break;
            }
        }

        // 特殊情况处理：一个出现3次6的和两个出现2次6的可以组成一个满足条件的组合
        if(arr[3] == 1 && arr[2] >= 2) {
            arr[2] -= 2;
            sum += 1;
        }

        // 处理出现次数为2的情况，每三个出现2次6的可以组成一个满足条件的组合
        if(arr[2] >= 3) {
            int k = arr[2] / 3;
            sum += k;
        }

        // 输出最终结果
        System.out.print(sum);
    }
}

 

 

package t7;
import java.util.*;
public class Main {
    public static void main(String arg[]) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 输入数组的长度
        int m = sc.nextInt();  // 查询的次数

        // 读取数组元素
        int arr[] = new int[n];
        for(int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }

        // 读取m次查询，但未对查询进行任何处理
        for(int i = 0; i < m; i++) {
            int k = sc.nextInt();  // 读取查询值，但未使用
        }

        // 直接输出-1，未对查询进行任何处理
        System.out.print(-1);
    }
}

这题是没思路，dp还不熟练 ，此题要用动态规划

算法思路：

1. 动态规划状态定义：

   • dp[i][h] 表示将第 i 根甘蔗切割为高度 h 时的最小切割次数。

2. 状态转移：

   • 对于每根甘蔗 i，遍历其所有可能的切割高度 h_i。
   • 对于前一根甘蔗的每个可能高度 h_prev，如果高度差 |h_i - h_prev| 属于允许集合 B，则更新 dp[i][h_i]。

3. 初始状态：

   • 第一根甘蔗的切割次数为 0（不切割）或 1（切割）。

4. 结果计算：

   • 遍历最后一根甘蔗的所有可能高度，取最小切割次数。如果所有状态都不可达，则返回 -1。

代码：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();  // 甘蔗数量
        int m = sc.nextInt();  // 允许的高度差数量

        int[] a = new int[n];  // 每根甘蔗的原始高度
        for (int i = 0; i < n; i++) a[i] = sc.nextInt();

        // 存储允许的高度差集合
        Set<Integer> B = new HashSet<>();
        for (int i = 0; i < m; i++) B.add(sc.nextInt());

        int maxH = 1000;  // 最大可能的高度
        // dp[i][h] 表示第i根甘蔗切割为高度h时的最小切割次数
        int[][] dp = new int[n][maxH + 1];
        for (int[] row : dp) Arrays.fill(row, Integer.MAX_VALUE);

        // 初始化第一根甘蔗的dp值
        for (int h = 0; h <= a[0]; h++) {
            // 如果不切割，代价为0；否则代价为1
            dp[0][h] = (h == a[0]) ? 0 : 1;
        }

        // 动态规划填充dp数组
        for (int i = 1; i < n; i++) {  // 遍历每根甘蔗
            for (int h_i = 0; h_i <= a[i]; h_i++) {  // 当前甘蔗的可能高度
                for (int h_prev = 0; h_prev <= a[i-1]; h_prev++) {  // 前一根甘蔗的可能高度
                    // 如果前一个状态不可达，跳过
                    if (dp[i-1][h_prev] == Integer.MAX_VALUE) continue;

                    // 计算高度差
                    int diff = Math.abs(h_i - h_prev);

                    // 如果高度差在允许集合中
                    if (B.contains(diff)) {
                        // 计算当前状态的代价：前一根甘蔗的代价 + 当前是否切割
                        int cost = dp[i-1][h_prev] + ((h_i == a[i]) ? 0 : 1);
                        // 更新最小代价
                        dp[i][h_i] = Math.min(dp[i][h_i], cost);
                    }
                }
            }
        }

        // 查找最后一根甘蔗的所有可能高度中的最小代价
        int res = Integer.MAX_VALUE;
        for (int h = 0; h <= a[n-1]; h++) {
            res = Math.min(res, dp[n-1][h]);
        }

        // 输出结果，如果无法满足条件则返回-1
        System.out.println(res == Integer.MAX_VALUE ? -1 : res);
    }
}

 

package t8;
import java.util.*;

public class Main {
    public static void main(String arg[]) {
        // 创建Scanner对象用于读取输入
        Scanner sc = new Scanner(System.in);
        // 读取采购点的数量n
        int n = sc.nextInt();
        // 读取卡车的容量m
        int m = sc.nextInt();
        // 读取每行驶一单位长度的额外花费o
        int o = sc.nextInt();

        // 创建一个room类型的数组arr，用于存储n个采购点的信息
        room arr[] = new room[n];
        // 创建一个数组sum，用于存储前i个采购点的库存总和，长度为n + 1，sum[0]初始化为0
        int sum[] = new int[n + 1];
        sum[0] = 0;

        // 遍历每个采购点，读取并存储其价格a、库存b、距离c
        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            // 创建room对象并存储到arr数组中
            arr[i] = new room(a, b, c);
            // 计算并更新前i + 1个采购点的库存总和
            sum[i + 1] = b + sum[i];
        }

        // 如果所有采购点的库存总和小于卡车容量，无法装满，输出-1
        if (sum[n] < m) {
            System.out.print(-1);
        } else {
            // 初始化最小花费为一个较大的值
            int min = 100000000;

            // 遍历每个采购点
            for (int i = 0; i < n; i++) {
                // 如果所有采购点的库存总和小于卡车容量，跳过本次循环
                if (sum[n] < m) {
                    continue;
                }
                // 创建一个新的room数组arr1，大小为i + 1，用于存储前i + 1个采购点的信息
                room arr1[] = new room[i + 1];
                // 将前i + 1个采购点的信息从arr数组复制到arr1数组
                for (int j = 0; j <= i; j++) {
                    arr1[j] = arr[j];
                }
                // 对arr1数组按采购点的价格a进行升序排序
                Arrays.sort(arr1, (p1, p2) -> p1.a - p2.a);

                // 初始化当前花费为0
                int cost = 0;
                // 剩余需要装载的货物量初始化为卡车容量m
                int k = m;

                // 遍历排序后的arr1数组（前i + 1个采购点）
                for (int j = 0; j <= i; j++) {
                    // 如果剩余需要装载的货物量大于等于当前采购点的库存
                    if (k >= arr1[j].b) {
                        // 从剩余量中减去当前采购点的库存
                        k -= arr1[j].b;
                        // 增加当前采购点的采购花费
                        cost += arr1[j].b * arr1[j].a;
                    } else {
                        // 剩余量小于当前采购点的库存，只采购剩余量
                        cost += k * arr1[j].a;
                        // 已经装满，跳出循环
                        break;
                    }
                }
                // 加上第i个采购点的距离相关花费（距离乘以每单位长度的花费o）
                cost += arr[i].c * o;
                // 如果当前花费小于最小花费，更新最小花费
                if (cost < min) {
                    min = cost;
                }
            }
            // 输出最小花费
            System.out.print(min);
        }
    }
}

// 定义room类，用于存储采购点的信息
class room {
    // 采购点的价格
    int a;
    // 采购点的库存
    int b;
    // 采购点的距离
    int c;

    // 构造函数，用于初始化room对象的属性
    public room(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
}

很明显这只是暴力求解，正确解法如下：

算法思路

1. 问题分析：

   • 卡车必须装满 m 单位的原料。
   • 每次只能选择一个最远的采购点（因为采购后需直接返回工厂）。
   • 总花费 = 原料成本 + 运输成本（仅单程，即到达最远采购点的距离乘以 o）。

2. 关键观察：

   • 选择最远的采购点 i 后，可以采购其左侧所有采购点的原料（因为距离严格递增）。
   • 为了最小化原料成本，应优先选择价格低的采购点。

3. 贪心策略：

   • 枚举每个可能的最远采购点 i。
   • 对所有 j ≤ i 的采购点按价格排序，优先采购低价原料。
   • 计算装满卡车的最小原料成本，并加上运输到 i 的成本。

优化算法实现

import java.util.*;

public class Main {
    static class Point {
        int a, b, c;
        Point(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        long m = sc.nextLong();  // 使用long避免溢出
        int o = sc.nextInt();

        Point[] points = new Point[n];
        long totalSupply = 0;

        for (int i = 0; i < n; i++) {
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = sc.nextInt();
            points[i] = new Point(a, b, c);
            totalSupply += b;
        }

        // 检查总库存是否足够
        if (totalSupply < m) {
            System.out.println(-1);
            return;
        }

        long minCost = Long.MAX_VALUE;

        // 枚举最远的采购点i
        for (int i = 0; i < n; i++) {
            // 复制前i+1个采购点并按价格排序
            Point[] candidates = Arrays.copyOfRange(points, 0, i + 1);
            Arrays.sort(candidates, (p1, p2) -> p1.a - p2.a);

            long remaining = m;
            long currentCost = 0;

            // 贪心选择：优先采购低价原料
            for (Point p : candidates) {
                if (remaining <= 0) break;
                long buy = Math.min(p.b, remaining);
                currentCost += buy * p.a;
                remaining -= buy;
            }

            // 加上运输成本
            currentCost += (long) points[i].c * o;
            minCost = Math.min(minCost, currentCost);
        }

        System.out.println(minCost);
    }
}