【蓝桥杯研究生组】第14届Java试题答案整理

已于 2025-01-15 20:10:17 修改
阅读量808 收藏 5
点赞数 1
文章标签： 蓝桥杯 java
于 2025-01-04 16:36:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuwanqing233333/article/details/144926598
版权

试题链接：链接

A题

在这里插入图片描述

满足条件的答案有：35813116

public class TianShu {
    public static void main(String[] args) {
        int ans = 0;
        // 2000.1.1 - 2000000.1.1
        // 年份是月份的倍数，也是日的倍数
        for (int year=2000; year<=2000000; year++) {
            for (int month=1; month<=12; month++) {
                if (month == 2) {
                    for (int day=1; day<=28; day++) {
                        if (year % month == 0 && year % day == 0) {
                            ans++;
                        }
                    }
                    if ((year % 4 == 0 && year % 100 != 0) || year % 400 ==  0) { // 闰年补一个2月29日
                        if (year % month == 0 && year % 29 == 0) {
                            ans++;
                        }
                    }
                } else if (month == 1 || month ==3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
                    for (int day=1; day<=31; day++) {
                        if (year % month == 0 && year % day == 0) {
                            ans++;
                        }
                    }
                } else {
                    for (int day=1; day<=30; day++) {
                        if (year % month == 0 && year % day == 0) {
                            ans++;
                        }
                    }
                }
            }
        }
        System.out.println("满足条件的答案有：" + ans);
    }
}

B题

在这里插入图片描述
ii

public class LogicGateSimulation {
    public static void main(String[] args) {
        // 定义输入数组
        int[] input = {1, 0, 1, 0, 1};

        // 数组用于储存中间结果
        int[][] arr = new int[5][5];

        // 初始化输入
        for (int i = 0; i < 5; i++) {
            arr[0][i] = input[i];
        }

        // 计算每一层的结果，并统计满足条件的组合数量
        int count = calculateGatesHelper(arr, 1);
        System.out.println("满足条件的组合数量: " + count);
    }

    // 参数含义：
    // arr 用于存储中间结果的数组
    // layer 当前处理的层数
    private static int calculateGatesHelper(int[][] arr, int layer) {
        // 递归终止条件：到达最后一层
        if (layer == arr.length) {
            // 判断最后的输出值是否为1
            return arr[layer - 1][0] == 1 ? 1 : 0;
        }

        int totalCombinations = 0; // 用于统计满足条件的组合数量

        // 遍历所有可能的逻辑门（AND、OR、XOR）
        for (int gate = 0; gate < 3; gate++) {
            // 遍历当前层的所有列数（有效列数为 5 - layer）
            for (int i = 0; i < (5 - layer); i++) {
                // 根据逻辑门类型计算
                switch (gate) {
                    case 0: // AND 门
                        arr[layer][i] = arr[layer - 1][i] & arr[layer - 1][i + 1];
                        break;
                    case 1: // OR 门
                        arr[layer][i] = arr[layer - 1][i] | arr[layer - 1][i + 1];
                        break;
                    case 2: // XOR 门
                        arr[layer][i] = arr[layer - 1][i] ^ arr[layer - 1][i + 1];
                        break;
                }
            }
            // 递归处理下一层
            totalCombinations += calculateGatesHelper(arr, layer + 1);
        }

        return totalCombinations; // 返回满足条件的组合数量
    }
}

C题

在这里插入图片描述

import java.util.Arrays;
import java.util.Scanner;

public class QiPan {
    public static void main(String[] args) {
        // 二维数组操作
        Scanner scanner = new Scanner(System.in);
        // 棋盘大小 和 操作数
        int len = scanner.nextInt();
        int[][] qipan = new int[len][len];
        int operationNum = scanner.nextInt();
        // 操作
        for (int i=0; i<operationNum; i++) {
            int x1 = scanner.nextInt() - 1;
            int y1 = scanner.nextInt() - 1;
            int x2 = scanner.nextInt() - 1;
            int y2 = scanner.nextInt() - 1;
            // 做操作
            for (int j = x1; j <= x2; j++) {
                for (int k = y1; k <=y2; k++) {
                    qipan[j][k] = qipan[j][k] == 0 ? 1 : 0; // 取反
                }
            }
        }
        for (int i=0; i<len; i++) {
            for (int j=0; j<len; j++) {
                System.out.print(qipan[i][j]);
            }
            System.out.println();
        }
    }
}

D题

在这里插入图片描述

import com.sun.xml.internal.bind.v2.runtime.reflect.opt.Const;

import java.util.Scanner;

public class ZiJuZhen {
    public static void main(String[] args) {
        int modNum = 998244353;
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int a = scanner.nextInt();
        int b = scanner.nextInt();

        int[][] matrix = new int[m][n];

        for (int i=0; i<m; i++) {
            for (int j=0; j<n; j++) {
                matrix[i][j] = scanner.nextInt();
            }
        }


        int ans = 0;
        // 方法一 暴力穷举所有 a * b 的子数组
        for (int i=0; i <= (m - a); i++) {
            for (int j=0; j <= (n - b); j++) {
                int max = Integer.MIN_VALUE;
                int min = Integer.MAX_VALUE;
                for (int k=0; k < a; k++) {
                    for (int q=0; q < b; q++) {
                        min = Math.min(min, matrix[i+k][j+q]);
                        max = Math.max(max, matrix[i+k][j+q]);
                    }
                }
                ans += min*max;
            }
        }

        System.out.println("价值为 ：" + ans%modNum);

    }
}

试题 E

在这里插入图片描述

import java.util.Scanner;

public class HuZhiShu {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long a = sc.nextLong();
        long b = sc.nextLong();
        long ans = 0;
        long num = (long) Math.pow(a, b);
        for (int i=1; i<num; i++) {
            if (gcd(i,num) == 1) {
                ans++;
            }
        }
        System.out.println("结果为：" + ans % 998244353);

    }

    public static long gcd(long a, long b){
        if(a == 0){
            return b;
        } else {
            return gcd(b % a, a);
        }
    }

}

试题F

在这里插入图片描述
在这里插入图片描述

import java.util.PriorityQueue;
import java.util.Scanner;

public class TravelPlan {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 输入n和m，n为地点数，m为油箱最大容量
        int n = sc.nextInt();
        int m = sc.nextInt();

        // 定义三个数组，分别存储距离Dis、加油费用Cost、加油上限Lim
        int[] Dis = new int[n];
        int[] Cost = new int[n];
        int[] Lim = new int[n];

        for (int i = 0; i < n; i++) {
            Dis[i] = sc.nextInt();
            Cost[i] = sc.nextInt();
            Lim[i] = sc.nextInt();
        }

        // 当前油量
        int currentFuel = m;
        // 当前花费
        long totalCost = 0;

        // 最小堆，用于存储当前可用的加油站 (按加油费用排序)
        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a, b) -> a[0] - b[0]);

        // 遍历每个加油站
        for (int i = 0; i < n; i++) {
            if (i == 0) {
                currentFuel -= Dis[0];
            }
            // 到达下一个加油站需要消耗的油量
            if (i != n - 1) {
                if (Dis[i + 1] > m) { // 需要的油量大于油箱容量，无法完成旅程
                    System.out.println("-1");
                    return;
                }
                currentFuel -= Dis[i + 1];
            }
            // 更新最小堆可加油量
            minHeap.offer(new int[]{Cost[i], Lim[i]});
            // 如果当前油量不足以到达下一站，需要从堆中加油
            while (currentFuel < 0) {
                // 如果堆为空，说明无油可加，无法完成旅程
                if (minHeap.isEmpty()) {
                    System.out.println("-1");
                    return;
                }
                // 从堆中取出最便宜的加油站加油
                int[] station = minHeap.poll();
                int price = station[0];
                int availableFuel = station[1];

                // 需要补足的油量
                int fuelNeeded = Math.min(-currentFuel, availableFuel);
                totalCost += (long) fuelNeeded * price;
                currentFuel += fuelNeeded;

                // 更新加油站剩余可加油量
                if (availableFuel > fuelNeeded) {
                    minHeap.offer(new int[]{price, availableFuel - fuelNeeded});
                }
            }
        }

        // 输出总费用
        System.out.println(totalCost);
    }
}

G题

在这里插入图片描述

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class StrangeNUM {

    static int[] odds = {1,3,5,7,9};
    static int[] evens = {0,2,4,6,8};


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // the length of this number
        int n = scanner.nextInt();
        // The sum of five consecutive digits is not greater than m
        int m = scanner.nextInt();



        // Requirement: Odd bits are odd, even bits are even
        // the first bit - the last bit
        List<String> result = new ArrayList<>();
        getNum(n, "", result, m);
        int ans = 0;
        for (int i=0; i<result.size(); i++) {
            if (isNotGreaterThanM(result.get(i), m)) {
                ans++;
                ans = ans % 998244352;
            }
        }
        System.out.println("ans = " + ans);
    }

    public static void getNum(int n, String cur, List<String> result, int m){
        // 当前数字长度为 n 时输出
        if (cur.length() == n) {
            result.add(cur);
            return;
        }

        if (cur.length() % 2 == 0) { // 下一位是奇数
            for (int bit : odds) {
                if (bit <= m) {
                    getNum(n, cur + bit, result, m);
                }
            }
        } else {
            for (int bit: evens) {
                if (bit <= m) {
                    getNum(n, cur + bit, result, m);
                }
            }
        }
    }

    public static boolean isNotGreaterThanM(String num, int m){
        // 滑动窗口
        int sum = 0;
        int left = -1;
        int right = 0;
        char[] numChar = num.toCharArray();
        while (right < numChar.length) {
            sum += Integer.parseInt(numChar[right] + "");
            if (right - left == 5) {
                if (sum > m) {
                    return false;
                }
                left++;
                sum -= Integer.parseInt(numChar[left] + "");
            }
            right++;
        }
        return true;
    }
}

第H题

在这里插入图片描述

import java.util.PriorityQueue;
import java.util.Scanner;

//6 10 10
//5 3 5
//6 2 4
//0 1 10
//2 11 3
//2 13 3
//2 15 5
//

public class Sun {
    public static void main(String[] args) {
        // 接收输入
        Scanner sc = new Scanner(System.in);
        // 线段个数
        int n = sc.nextInt();
        // 太阳坐标
        int X = sc.nextInt();
        int Y = sc.nextInt();
        // 线段
        // int[]   y坐标 x1, x2
        // 太阳上方按照 Y 从小到大排序
        PriorityQueue<int[]> upPriorityQueue = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        // 太阳下方按照 Y 从大到小排序
        PriorityQueue<int[]> downPriorityQueue = new PriorityQueue<>((a, b) -> b[0] - a[0]);
        for (int i=0; i<n; i++) {
            int[] line = new int[3];
            line[1] = sc.nextInt();
            line[0] = sc.nextInt();
            line[2] = line[1] + sc.nextInt();
            if (line[0] <= Y) {
                downPriorityQueue.add(line);
            } else {
                upPriorityQueue.add(line);
            }
        }

        int ans = 0;
        // 判断遮挡
        // 先假设没有两个线段在同一 y
        // 遮挡范围
        int[] shelter = {Integer.MAX_VALUE, Integer.MIN_VALUE};
        while (!downPriorityQueue.isEmpty()) {
            // 判断是否有遮挡
            int[] curLine = downPriorityQueue.poll();
            if (!(shelter[0] <= curLine[1] && shelter[1] >= curLine[2])) {
                ans++;
            }
            // 更新 shelter
            shelter[0] = Math.min(shelter[0], curLine[1]);
            shelter[1] = Math.max(shelter[1], curLine[2]);
        }
        shelter = new int[]{Integer.MAX_VALUE, Integer.MIN_VALUE};
        while (!upPriorityQueue.isEmpty()) {
            // 判断是否有遮挡
            int[] curLine = upPriorityQueue.poll();
            if (!(shelter[0] <= curLine[1] && shelter[1] >= curLine[2])) {
                ans++;
            }
            // 更新 shelter
            shelter[0] = Math.min(shelter[0], curLine[1]);
            shelter[1] = Math.max(shelter[1], curLine[2]);
        }

        System.out.println("结果为：" + ans);


    }
}

// 上述思路只能解决 没有两个线段在同一 y 的情况
// 有两个线段在同一 y 的情况 —— 应该算透光部分解决 - 太麻烦了，不做
斯晴晚
关注
2023年第十四届蓝桥杯JavaB组省赛真题及全部解析（上）
2301_80035594的博客
06-28 1853
2023年第十四届蓝桥杯Java B组省赛全部解析（上）。
第十四届蓝桥杯大赛软件赛省赛（C/C++ 研究生组）
NOW I GOT ONE WAY
06-06 5077
第十四届蓝桥杯大赛软件赛省赛 C/C++ 研究生组
第十四届蓝桥杯省赛真题 Java 研究生 组【原卷】
HHX_01的博客
03-14 3705
# 发现宝藏 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。【[宝藏入口](https://www.captainbed.cn/dl)】。 ------------- 第十四届蓝桥杯大赛软件赛省赛 Java 研究生组
第十四届蓝桥杯大赛软件赛省赛 Java 研究生组 参考答案
m0_55895748的博客
12-12 341
​
2023第十四届蓝桥杯Java研究生组真题？（真题+附链接）
m0_74939018的博客
04-19 1212
其中 arr[0] = (In[0], In[1], In[2], In[3], In[4]) 表示的是输入数据，对于某 个 arr[i][ j](i ≤ 0)，计算方式为 arr[i][ j] = arr[i − 1][ j] op arr[i − 1][ j + 1]，其中 op 表示的是将 arr[i − 1][ j]、arr[i − 1][ j + 1] 作为输入，将 arr[i][ j] 作为输出的那个门电路，与门、或门、异或门分别对应于按位与 (&)、按位或 (|)、按位异或 (^) 运算符。
第十三届蓝桥杯大赛软件赛省赛（C++研究生组）
qq_44729222的博客
03-02 1838
第十三届蓝桥杯大赛软件赛省赛ABCDEFGHIJ题个人题解，c++研究生组
蓝桥杯第十四届程序C组试题B自行整理（包括答案）
09-19
蓝桥杯全国软件和信息技术专业人才大赛是一项面向高校学生的专业竞赛，旨在通过竞赛...而蓝桥杯第十四届程序C组试题B自行整理以及参考答案，为参赛者提供了宝贵的学习资源，有助于他们更好地准备比赛，取得优异成绩。
第十二届蓝桥杯 2021年国赛真题 (Java 大学B组)
NOW I GOT ONE WAY
10-20 9650
蓝桥杯 2021年国赛真题（Java 大学 B 组 ）
第十三届蓝桥杯大赛软件赛省赛（Java 大学A组）
热门推荐
NOW I GOT ONE WAY
04-11 3万+
第十三届蓝桥杯大赛软件赛省赛 Java 大学 A 组
蓝桥杯历年真题及答案汇总整理（Java、C语言、Python）
weixin_47367099的博客
04-24 2万+
本文是蓝桥杯历年的题目及答案汇总整理，耗时两周，精心整理了往年真题以及答案。 因为网上的大多数蓝桥杯历年的真题都只有真题没有答案，很难受！所以打算自己亲自整理一下，真的是求人不如求己啊，一方面方便自己学习，另外也希望能帮助到C站上跟我一样的朋友。 先给大家看一下蓝桥杯历年省赛真题大纲吧： 1、Java语言 A组省赛真题： 2012第三届Java A组蓝桥杯省赛真题 2013第四届Java A组蓝桥杯省赛真题 2014第五届Java A组蓝桥杯省赛真题 2015第六届Java A组蓝桥杯省赛真题
2015年蓝桥杯C组试题及答案
08-13
2015年蓝桥杯C组试题及答案，
2019年第十届蓝桥杯A组题目
03-24
2019年第十届蓝桥杯A组题目。全国软件专业人才设计与创业大赛，又名“蓝桥杯”大赛，是由工业和信息化部人才交流中心举办的年度赛事。其中，软件组分为 C/C++ 组和 Java 组，以考察选手算法设计和程序设计能力为主。
第十五届蓝桥杯大赛-软件赛知识点大纲《PPT文档》
05-08
自2010年创办以来，该赛事已举办至第十五届，吸引了众多学子参与。这次提供的《PPT文档》是大赛的软件赛知识点大纲，对于参赛者和对IT技术感兴趣的人员来说，它是一份非常有价值的参考资料。 **一、编程语言基础** ...
第十一届蓝桥杯第二次省赛Java研究生组 Python版
Castle Yeager 成长之路
04-08 2195
引言 博主尝试用Python语言去写其他语言组别的试题，按逆序刷的话，今天先做一套十一届Java研究生组的试题。 试题A：约数个数 本题考察的是质因数的知识，由于是填空题，所以直接从1开始遍历到根号78120，判断每一个数是否能整除78120即可。比较基础。 res = 0 for i in range(1, 78120+1): res += 1 if 78120 % i == 0 else 0 print(res) # 输出 96 注意Python遵循左闭右开的原则，所以右边是78120 +
蓝桥杯2023年第十四届省赛真题------第十四届蓝桥杯本科A组/研究生组2023年省赛题解--全部采用Java语言实现
Wzideng@qq.com
04-21 3910
今天现在这里 挖个坑，太忙了，这个专题不一样有时间补完，但我会尽力而为的。记录一下今天的日子：2023/04/21看看这个坑要什么时候自己才能补完。的文章参考。
第十四届蓝桥杯省赛Java大学A组题解
2203_75477002的博客
03-03 2999
第十四届蓝桥杯省赛Java大学A组题解
2023蓝桥杯Java研究生组赛题
weiambt的博客
04-11 2030
第一次参加了Java研究生组，Java组应该没有C/C++那么卷吧，主要是觉得Java组可以避开很多ACM大佬，前面几题感觉难度还行没有特别难，后面几个大题依旧是没法做，不知道多少分能拿省一，有参加过的大佬可以说一说吗。n是 10^5 级别的，用dp做的，时间复杂度O( n ^ 3），能过30%维护二维子矩阵的最大最小值，暴力做的，能过30%。准备了半天图论又白看hhh，题目和Java A基本一样，不知道有没有省一的机会。第六题 ：奇怪的数。暴搜十个门电路 30528。第五题 ：互质数的个数。
第十四届蓝桥杯大赛软件赛省赛Java 研究生组B题
最新发布
Java爱好者，热爱分享，信仰开源！
04-07 304
题目描述了一个5层金字塔结构的门电路网络，每层有不同数量的门电路。已知输入层的5个值(1,0,1,0,1)，需要通过4层门电路计算，最终得到一个输出值。题目要求计算有多少种不同的门电路组合方式可以使最终输出为1。该解法通过DFS遍历所有可能的门电路组合，并验证每种组合的最终输出，统计满足条件的组合数。
第十三届蓝桥杯大赛C++研究生组 试题B：超级质数
weixin_41895477的博客
05-15 3411
文章目录前言题目一、常规暴力解法，时间复杂度O（n²），空间复杂度O（1）二、空间换时间的办法，时间复杂度为o(n)，空间复杂度为o(n)三、位置重排，时间复杂度为o(n)，空间复杂度为o(1) 前言 提示：本系列所有相关代码都以C++为编程语言进行讲解。且格式采用牛客网的给定格式。 本文是作者在牛客网上刷剑指offer题目之后，发现即使是一道简单题也仍有许多很好的解题思路，看完之后深感自己的的不足，故在此写下题目中的各个解法及思路，方便日后回顾总结，如果错漏或者概念混淆之处，烦请各位看官不吝赐教，多加指
第十四届蓝桥杯Java研究生组
04-13
很高兴回答你的问题。关于第十四届蓝桥杯Java研究生组比赛，我了解到这是一项全国性的竞赛，旨在推广 Java 语言的应用和发展 Java 技术人才。该竞赛包括在线测试、编程练习和设计题目，主要考察参赛者的程序设计能力、算法设计能力以及编程实现能力。如果你想要参加这个比赛，建议你多加练习，提高自己的编程技能，加强对 Java 语言的掌握。希望我的回答对你有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值