2019 第十届蓝桥杯Java省赛B组个人题解
2024-05-07 03:15:54
2019 第十届蓝桥杯Java省赛B组个人题解
前言
以下的第十届蓝桥杯Java B组省赛的题目题解只是我个人的题解，提供一些解题思路，仅作参考，如有错误，望大家指出，不胜感激，我会及时更改。
本来想把比赛题目上传到CSDN上免费下载，上传之后发现默认是5积分（根据下载热度和评星积分会自己调整），后来了解到现在的CSDN向知识付费靠拢，激励用户上传资源，取消了用户自行定价的功能和下架资源的功能（需要找客服下架，客服根本不理啊）。
2019 第十届蓝桥杯Java省赛B组题目——CSDN（需要5或者更多积分（系统自己调的），希望大家尽量下载下面链接的，谁的积分来的都不容易）
2019 第十届蓝桥杯Java省赛B组题目下载——提取码： yukk
试题A：组队——答案：490
import java.util.Scanner;
/*** * @ClassName: Team组队* @Description: 题目不难理解，让有的人迷糊的可能就是一个队员只能选中一次。此题考试手动筛选一下就行，想写程序验证的也可以。* @author: colou* @date: 2019年3月30日 上午8:58:21*/
public class Team组队 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {int[][] team = new int[20][5];for (int i = 0; i < 20; i++) {for (int j = 0; j < 5; j++) {team[i][j] = input.nextInt();}}int maxSum = 0;for (int i = 0; i < 20; i++)for (int j = 0; j < 20; j++)for (int k = 0; k < 20; k++)for (int h = 0; h < 20; h++)for (int g = 0; g < 20; g++)if ((i != j && i != k && i != h && i != g) && (j != k && j != h && j != g)&& (k != h && k != g) && h != g) {int max = team[i][0] + team[j][1] + team[k][2] + team[h][3] + team[g][4];if (max > maxSum)maxSum = max;}System.out.println(maxSum);// 测试用例/** 97 90 0 0 0 92 85 96 0 0 0 0 0 0 93 0 0 0 80 86 89 83 97 0 0 82 86 0 0 0 0 0* 0 87 90 0 97 96 0 0 0 0 89 0 0 95 99 0 0 0 0 0 96 97 0 0 0 0 93 98 94 91 0 0* 0 0 83 87 0 0 0 0 98 97 98 0 0 0 93 86 98 83 99 98 81 93 87 92 96 98 0 0 0 89* 92 0 99 96 95 81*/} catch (Exception e) {input.close();}}
}试题B：不同子串——答案：100
import java.util.HashSet;
import java.util.Set;/*** * @ClassName: DifferentSubstring不同子串* @Description: 审题发现要求是不同的非空子串，则想到Set集合去重，String.substring()方法求子串（一切 为快速解题为前提），然后我们发现它的子串规律为一开始子串长度为1，然后在为2，……，最后为原字符串，这就好 比切豆腐，一开始要求切成每刀间隔为1豆腐块，每次移动距离为1，后来要求切成每刀间隔为2豆腐块，每次移动距离 为1，……，直至为整个大豆腐的大小。* @author: colou*/
public class DifferentSubstring不同子串 {public static void main(String[] args) {String target = "0100110001010001";Set<String> sub = new HashSet<String>();for (int step = 0; step <= target.length() - 1; step++) {for (int beginIndex = 0, endIndex = 1 + step; endIndex <= target.length(); beginIndex++, endIndex++) {sub.add(target.substring(beginIndex, endIndex));}}System.out.println(sub.size());}
}
试题C：数列求值——答案：4659
/*** * @ClassName: SequenceEvaluation数列求值* @Description: 此题类似于斐波那契数列，但是所求20190324项的最后四位数字，要是单纯按照斐波那契数列的* 思想求下去，别说long类型，BigInteger类型都存不了这么大的数，然后我们发现，所求* 20190324项的最后四位数字（也就是变相的告诉我们运算过程只和每个数的后四位有关系），那 么我们只需要保留每次运算结果的后四位就OK了，这样绝对不会溢出。* @author: colou*/
public class SequenceEvaluation数列求值 {public static void main(String[] args) {int a = 1, b = 1, c = 1;// 要是求第四项，则i < 4, 同理推得求20190324，则i < 20190324。for (int i = 3; i < 20190324; i++) {int temp = (a + b + c) % 10000;a = b;b = c;c = temp;}System.out.println(c);}
}
试题D：数的分解——答案：40785
/*** * @ClassName: DecompositionOfNumbers数的分解* @Description: 首先我们分析组成2019的三个数有哪几类？1.ABC类排列方式为六种（ABC，ACB，BAC，BCA，* CAB，CBA），2.AAB类排列方式有三种（AAB，ABA，BAA），3.AAA类排列方式一种。而题目要* 求把 2019 分解成 3 个各不相同的正整数之和也就是说只保留ABC类的组合方式，j = i + 1，减少一半排列方式。* @author: colou*/
public class DecompositionOfNumbers数的分解 {public static void main(String[] args) {int n = 2019;int num = 0;for (int i = 1; i < n; i++) {if ((i + "").indexOf("2") != -1 || (i + "").indexOf("4") != -1)continue;for (int j = i + 1; j < n; j++) {if ((j + "").indexOf("2") != -1 || (j + "").indexOf("4") != -1)continue;int k = n - i - j;if (i == k || j == k || i == j)continue;if (k > 0 && (k + "").indexOf("2") == -1 && (k + "").indexOf("4") == -1)num++;}}System.out.println(num / 3);}
}
试题E：迷宫
答案：DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;/*** @ClassName: LabyrinthProblem迷宫问题* @Description: 广度优先搜索：https://blog.csdn.net/raphealguo/article/details/7523411* https://blog.csdn.net/u011815404/article/details/79582206* @author: colou*/
public class Labyrinth迷宫 {/** 深度优先可以这样想，一个人迷路，遇到很多分叉路口，他只有一个人，并且想走出去，所以只能一个个尝试，* 一条道路走到黑，发现到头了，然后再拐回去走刚才这条路的其他分叉路口，最后发现这条路的所有分叉路口走完了* ，选择另外一条路继续以上操作，直到所有的路都走过了。* 广度优先并不是这样，一个人迷路，但是他有技能（分身术）它遇到分叉路口，不是选一个走，而是分身多个人都试试，* 比如有A、B、C三个分叉路口，它A路走一步，紧接着B路也走一步，然后C路也赶紧走一步，步伐整齐统一，直到所有的路走过了。*/ public static void main(String[] args) {Scanner input = new Scanner(System.in);try {String s = "01010101001011001001010110010110100100001000101010"+ "00001000100000101010010000100000001001100110100101"+ "01111011010010001000001101001011100011000000010000"+ "01000000001010100011010000101000001010101011001011"+ "00011111000000101000010010100010100000101100000000"+ "11001000110101000010101100011010011010101011110111"+ "00011011010101001001001010000001000101001110000000"+ "10100000101000100110101010111110011000010000111010"+ "00111000001010100001100010000001000101001100001001"+ "11000110100001110010001001010101010101010001101000"+ "00010000100100000101001010101110100010101010000101"+ "11100100101001001000010000010101010100100100010100"+ "00000010000000101011001111010001100000101010100011"+ "10101010011100001000011000010110011110110100001000"+ "10101010100001101010100101000010100000111011101001"+ "10000000101100010000101100101101001011100000000100"+ "10101001000000010100100001000100000100011110101001"+ "00101001010101101001010100011010101101110000110101"+ "11001010000100001100000010100101000001000111000010"+ "00001000110000110101101000000100101001001000011101"+ "10100101000101000000001110110010110101101010100001"+ "00101000010000110101010000100010001001000100010101"+ "10100001000110010001000010101001010101011111010010"+ "00000100101000000110010100101001000001000000000010"+ "11010000001001110111001001000011101001011011101000"+ "00000110100010001000100000001000011101000000110011"+ "10101000101000100010001111100010101001010000001000"+ "10000010100101001010110000000100101010001011101000"+ "00111100001000010000000110111000000001000000001011"+ "10000001100111010111010001000110111010101101111000";int[][] labyrinth = new int[30][50];for (int i = 0; i < 30; i++) {for (int j = 0; j < 50; j++) {labyrinth[i][j] = s.charAt(50 * i + j) - '0';}}System.out.println(BFS(labyrinth, 30, 50));} catch (Exception e) {input.close();}}public static String BFS(int[][] labyrinth, int row, int column) {int[][] stepArr = { { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 0 } };String[] direction = { "U", "R", "L","D"}; int[][] visit = new int[row][column];// 标记是否已经访问过StringBuilder sb = new StringBuilder();Node node = new Node(0, 0, -1, -1, 0, null);Queue<Node> queue = new LinkedList<Node>();Stack<Node> stack = new Stack<Node>();queue.offer(node);while (!queue.isEmpty()) {Node head = queue.poll();stack.push(head); // 用于回溯路径visit[head.x][head.y] = 1;for (int i = 0; i < 4; i++) {int x = head.x + stepArr[i][0];int y = head.y + stepArr[i][1];String d = direction[i];// exitif (x == row - 1 && y == column - 1 && labyrinth[x][y] == 0 && visit[x][y] == 0) {// 打印路径Node top = stack.pop();sb.append(d);sb.append(top.direction);int preX = top.preX;int preY = top.preY;while (!stack.isEmpty()) {top = stack.pop();if (preX == top.x && preY == top.y) {if (top.direction != null)sb.append(top.direction);preX = top.preX;preY = top.preY;}}return sb.reverse().toString();}// bfsif (x >= 0 && x < row && y >= 0 && y < column && labyrinth[x][y] == 0 && visit[x][y] == 0) {Node newNode = new Node(x, y, head.x, head.y, head.step + 1, d);queue.offer(newNode);}}}return null;}
}class Node {int x, y;int step;int preX, preY;String direction;Node(int x, int y, int preX, int preY, int step, String direction) {this.x = x;this.y = y;this.preX = preX;this.preY = preY;this.step = step;this.direction = direction;}
}
试题F：特别数的和
import java.util.Scanner;
/*** * @ClassName: SpecialSum特别数的和* @Description: int转String，使用String.indexOf();判断包含不包含"2", "0", "1", "9"，可以使用while循环加%,/运算判断。* @author: colou*/
public class SpecialSum特别数的和 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {int n = input.nextInt();int sum = 0;for (int i = 1; i <= n; i++) {String target = Integer.toString(i);if (target.indexOf("2") != -1 || target.indexOf("0") != -1 || target.indexOf("1") != -1|| target.indexOf("9") != -1) {sum += i;}}System.out.println(sum);} catch (Exception e) {input.close();}}
}
试题G：外卖店优先级
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;/*** @ClassName: TakeawayShopPriority外卖店优先级* @Description: 创建一个记录店铺优先级的数组来存储优先级，另外创建一个用来判断每个时间点是否有订单的数组（1代表有 ，0无）* 这里偷懒使用集合充当缓存，可以使用数组之类的。* @author: colou*/
public class TakeawayShopPriority外卖店优先级 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {Set<Integer> set = new HashSet<Integer>();int N = input.nextInt();int M = input.nextInt();int T = input.nextInt();int[][] orders = new int[M][2];for (int i = 0; i < M; i++) {for (int j = 0; j < 2; j++) {orders[i][j] = input.nextInt();}}int[] priority = new int[N];int[] sign = new int[N];for (int i = 1; i <= T; i++) {for (int j = 0; j < M; j++) {if (orders[j][0] == i) {priority[orders[j][1] - 1] += 2;if (priority[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {set.add(orders[j][1] - 1);}sign[orders[j][1] - 1] = 1;}}for (int j = 0; j < N; j++) {if (sign[j] == 0 && priority[j] > 0)priority[j]--;if (priority[j] <= 3) {set.remove(j);}}sign = new int[N];}System.out.println(set.size());} catch (Exception e) {input.close();}}
}
试题H：人物相关性分析
import java.util.Scanner;
/*** * @ClassName: CharacterCorrelationAnalysis人物相关性分析* @Description: "."和"|"都是转义字符，必须得加"\\"；* @author: colou*/
public class CharacterCorrelationAnalysis人物相关性分析 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {int K = input.nextInt();input.nextLine();String text = input.nextLine();//字符串分割，按照空格和.分割字符，若是（.空格）分割后为空字符串。String[] words = text.split("\\s+|\\.");int[] wordsLength = new int[words.length];//将分割的字符串的长度值存储，避免三重循环中调用String.length();for (int i = 0; i < words.length; i++) {wordsLength[i] = words[i].length();}int num = 0;//Alice ——> Bob的距离for (int i = 0; i < words.length; i++) {if (words[i].equals("Alice")) {for (int j = i + 1; j < words.length; j++) {int sum = 1;if (words[j].equals("Bob")) {for (int k = i + 1; k < j; k++) {//每个单词的长度加空格占据的长度sum += wordsLength[k] + 1;}if (sum <= K) {num++;}}}}}//Bob ——> Alice的距离for (int i = 0; i < words.length; i++) {if (words[i].equals("Bob")) {for (int j = i + 1; j < words.length; j++) {int sum = 1;if (words[j].equals("Alice")) {for (int k = i + 1; k < j; k++) {sum += wordsLength[k] + 1;}if (sum <= K) {num++;}}}}}System.out.println(num);} catch (Exception e) {input.close();}}
}
试题I：后缀表达式
import java.util.Arrays;
import java.util.Scanner;/*** @ClassName: PostfixExpression后缀表达式* @Description: 这道题我的思想是分情况讨论：* 1.如果只有+号，没有-号，则遍历数组累加即可；* 2.如果只有-号，没有+号，首先从小到大排序，然后分两种情况考虑：* （1）.最小值是负数（也就是含有负数），例如[-2, -1, 3, 4, 5]，四个减号，运算过程为5 - (-1) - (-2 - 3 - 4) = 5 + 1 - (-9)* = 5 + 1 + 9 = 15，也就是说只要含有负数，负数转正数，全部相加即可* （2）.最小值是正数（全部是正数），例如[1, 2, 3]，两个减号，运算过程为3 - (1 - 2) = 3 + 2 - 1，也就是说运算规则为除了* 最小值以外的正数相加减去最小值 * 3.如果有+号，有-号，则讨论减号的个数与负数的个数，分两种情况讨论（实际分为三种）：*（ 1）.减号个数大于等于负数个数（则将负数变正数，每一个负数变正数的过程中， 减号的数量需要减一，然后排序,遍历数组从大到小累加，* 直至剩下的数字个数和减号数量相同，然后再减去这些剩下的数字）；* （2）.减号个数小于负数个数，这个时候我们就应该使用+号，消除负数（比如[2, -5 , -6, + , -]，运算过程为2 - ((-5) + (-6)) = * 2 + 11 = 13）,我们可以再分情况讨论：* （2.1）.全是负数，如[-1, -2, -3, -4, -5],其中一个加号三个减号，运算过程为（-1 - ((-4) + (-5)) - (-3) - (-2) = -1 + 9 * + 3 + 2）,则运算规律为首先排序选择其中的最大值，加上其他数字的绝对值就行（可以自行继续证明）。（2.2）.有正数，有负数，* [-1, 19, 17, -4, -5],其中两个加号两个减号，则运算过程为（19 + 17 - ((-4) + (-5)) - (-1) = 19 + 17 + 9 + 1）,则运算* 规律为首先排序选择其中的最大值，加上其他数字的绝对值就行（可以自行继续证明）。所有情况讨论完毕。* @author: colou*/
public class PostfixExpression后缀表达式 {public static void main(String[] args) {Scanner input = new Scanner(System.in);try {int add = input.nextInt();int reduce = input.nextInt();int totalLength = add + reduce + 1;int[] number = new int[totalLength];for (int i = 0; i < totalLength; i++) {number[i] = input.nextInt();}int sum = 0;if (reduce == 0) {for (int i = 0; i < totalLength; i++) {sum += number[i];}}if (add == 0) {Arrays.sort(number);if (number[0] < 0) {for (int i = 0; i <= reduce; i++) {if (number[i] > 0) sum += number[i];elsesum -= number[i];}} else {for (int i = 1; i <= reduce; i++) {sum += number[i];}sum -= number[0];}}if (add != 0 && reduce != 0) {int reduceNum = 0;for (int i = 0; i < totalLength; i++) {if (number[i] < 0) {reduceNum++;}}if (reduce >= reduceNum) {Arrays.sort(number);int temp = reduce;for (int i = 0; i < reduceNum; i++) {number[i] = -number[i];temp--;}Arrays.sort(number);for (int i = totalLength - 1; i >= temp; i--) {sum += number[i];}for (int i = temp - 1; i >= 0; i--) {sum -= number[i];}} else {Arrays.sort(number);sum += number[totalLength - 1];for (int i = 0; i < totalLength - 1; i++) {if (number[i] > 0)sum += number[i];elsesum -= number[i];}}}System.out.println(sum);} catch (Exception e) {input.close();}}
}
至此完毕，最后一题想偷个懒，等看了之后再更新，如果有错误，请阅读者评论指出，不胜感激。
2019 第十届蓝桥杯Java省赛B组个人题解相关推荐
- 蓝桥杯java 大纲,2019 第十届蓝桥杯Java省赛B组个人总结
前言 19年的这场蓝桥杯,对我自己的打击挺大的,以至于时隔多个月之后第十一届蓝桥杯要开始报名的时候,我才敢面对他.报名第十届蓝桥杯的时候我大二,自我感觉学的不错,但事实并非如此,当入了那句话,学术不精 ...
- 2022第13届蓝桥杯Java省赛B组个人题解
文章目录 A. 星期计算 B. 山 C. 字符统计 D. 最少刷题数 E. 求阶乘 F. 最大子矩阵 G. 数组切分 H. 回忆迷宫 I. 红绿灯 J. 拉箱子 个人总结 A. 星期计算 思路解析: ...
- 蓝桥杯java提交格式_2019第十届蓝桥杯JAVA省赛B组
B 不同子串 题目描述 一个字符串的非空子串是指字符串中长度至少为 1 的连续的一段字符组成 的串.例如,字符串aaab 有非空子串a, b, aa, ab, aaa, aab, aaab,一共 7 ...
- 2019第十届蓝桥杯JAVA G组题解
蓝桥杯历年真题及解析. 试题 A: 立方和 本题总分:5 分 [问题描述] 小明对数位中含有 2.0.1.9 的数字很感兴趣,在 1 到 40 中这样的数包 括 1.2.9.10 至 32.39 和 ...
- 2019 第十届蓝桥杯 Java B组 赛后总结
我是大三第一次参加蓝桥杯,也是最后一次参加了(大四应该没时间了).我参加的是java b组,总体来说赛程挺顺利的,第一次参赛觉得四个小时有点不够哈哈哈.不过蓝桥杯这个比赛我是带着试一下的心态去参加的. ...
- 2019第十届蓝桥杯大赛省赛感想——仅以此祭奠我的大学算法竞赛
2019年已经大三的我,第二次踏上了"蓝桥"省赛之旅,这应该是我大学生涯最后一次参加程序算法类竞赛了,心情还是比较平静.第二次的参赛感受还是蛮多的,没有了第一次对这项赛事的新鲜感和 ...
- 2019第十届蓝桥杯比赛总结（B组c/c++）
试题 A: 组队 本题总分:5 分 作为篮球队教练,你需要从以下名单中选出 1 号位至 5 号位各一名球员, 组成球队的首发阵容. 每位球员担任 1 号位至 5 号位时的评分如下表所示.请你计算首发阵 ...
- 2019第十届蓝桥杯JAVA B组题目分析
目录 A:组队(难度:★★★) 分析: 代码 B:不同字串(难度:★) 分析: 代码: C:数列求值(难度:★) 分析: 代码: D:数的分解:(难度:★★) 分析: 代码: E:迷宫:(难度:★★★ ...
- 第十二届蓝桥杯 Java 省赛 B 组部分真题解析
第一题:Char(送分题) char类型以ASCAII值存储,1-9(48~57).A~Z(65~90).a-z(97~122) 第二题:卡牌(送分题,一个顺序循环就可以出来了) package Te ...
- 第十二届蓝桥杯Java省赛A组试题：异或数列
[题目描述] 初始时,Alice和Bob分别有一个整数a和b,有一个给定的长度为n的数列.a和b的初始值均为0.Alice和Bob轮流操作,Alice先手,每步可以从两个选项中选一种: 选项1:从数列 ...
最新文章
- MongoDB简单操作
- WinAPI: PolyBezier - 绘制贝塞尔线
- springboot-springmvc响应json与xml原理-详解数据响应与内容协商（长文预警，收藏慢啃）
- 窗体控件随窗体大小改变（仍有不足）
- centos5.5中安装mysql5.5.3
- django CBV装饰器 自定义django中间件 csrf跨站请求伪造 auth认证模块
- java学习笔记之DBUtils工具包
- 问题二十八：ray tracing中的散焦模糊（defocus blur）
- 丹琦女神的对比学习新SOTA，在中文表现如何？我们补充实验后，惊了！
- Kaggle实战之leaf classification（树叶分类）
- 电商数据库设计——重要概念
- matlab实现马尔可夫链,马尔可夫链matlab源码
- 在字符串中输入回车换行或其它特殊字符
- 24h无人棋牌室预约系统的软硬件开发
- 程序员养生之道：Google 是如何鼓励员工多吃蔬菜的？
- 房产行业数字化转型迷思：技术能提供何种助力？
- TCP协议的粘包问题
- 物联网卡就是不能打电话的电话卡？
- 【Apsara Clouder 认证】API 接口调用真题
- POJ 3054 High Spies 笔记