第十一届蓝桥杯java c组国赛题解
目录
试题 A: 美丽的 2
本题总分：5 分
【问题描述】
小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。
他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中
包含数字 2？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解:不用多说打卡题
答案:563
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
int count=0;
for (int i = 1; i <2021; i++) {
String str=i+"";
if(str.contains("2")) {
count++;
}
}
System.out.println(count);
}
}
试题 B: 合数个数
本题总分：5 分
【问题描述】
一个数如果除了 1 和自己还有其他约数，则称为一个合数。例如：1, 2, 3
不是合数，4, 6 是合数。
请问从 1 到 2020 一共有多少个合数。
题解:就是筛不是质数的很简单
答案:1713
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int count=0;
for (int i = 1; i <2021; i++) {
for (int j = 2; j <=Math.sqrt(i); j++) {
if(i%j==0) {
count++;
break;
}
}
}
System.out.println(count);
}
}
试题 C: 扩散
本题总分：10 分
【问题描述】
小蓝在一张无限大的特殊画布上作画。
这张画布可以看成一个方格图，每个格子可以用一个二维的整数坐标表示。
小蓝在画布上首先点了一下几个点：(0, 0), (2020, 11), (11, 14), (2000, 2000)。
只有这几个格子上有黑色，其它位置都是白色的。
每过一分钟，黑色就会扩散一点。具体的，如果一个格子里面是黑色，它
就会扩散到上、下、左、右四个相邻的格子中，使得这四个格子也变成黑色
（如果原来就是黑色，则还是黑色）。
请问，经过 2020 分钟后，画布上有多少个格子是黑色的。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：
这是一个典型的bfs摸板题，不用多说上代码。
答案:20312088
import java.util.LinkedList;
import java.util.Queue;
public class Main {
static int n = 6400, count = 0;
static int[][] arr = new int[n][n];
public static void main(String[] args) {
// TODO Auto-generated method stub
bfs();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (arr[i][j] < 2021) {
count++;
}
// System.out.print(arr[i][j] + " ");
}
// System.out.println();
}
System.out.println(count );
}
public static void bfs() {
int[] dx = { 0, 1, -1, 0 };
int[] dy = { 1, 0, 0, -1 };
Queue<int[]> queue = new LinkedList<int[]>();
queue.offer(new int[] { 2021, 2021 });
queue.offer(new int[] { 2020 + 2021, 11 + 2021 });
queue.offer(new int[] { 11 + 2021, 14 + 2021 });
queue.offer(new int[] { 2000 + 2021, 2000 + 2021 });
int[] pient = null;
while (!queue.isEmpty()) {
pient = queue.poll();
int x = pient[0], y = pient[1];
for (int i = 0; i < 4; i++) {
int x1 = x + dx[i], y1 = y + dy[i];
if (x1 < 0 || y1 < 0 || x1 >= n || y1 >= n || arr[x1][y1] != 0)
continue;
arr[x1][y1] = arr[x][y] + 1;
queue.offer(new int[] { x1, y1 });
}
}
}
}
试题 D: 阶乘约数
本题总分：10 分
【问题描述】
定义阶乘 n! = 1 × 2 × 3 × · · · × n。
请问 100! （100 的阶乘）有多少个正约数。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解：参考约数个数定理:约数定理
答案:39001250856960000
import java.math.BigInteger;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]=new int[650];
for(int i=2;i<=100;i++){
int x=i;
for(int j=2;Math.sqrt(j)<=i;j++){
while(x%j==0){
arr[j]++;
x/=j;
}
}
if(x!=1) arr[x]++;
}
BigInteger sum=BigInteger.ONE;
for(int i=2;i<=100;i++){
sum=sum.multiply(new BigInteger(arr[i]+1+""));
}
System.out.println(sum);
}
}
试题 E: 本质上升序列
本题总分：15 分
【问题描述】
小蓝特别喜欢单调递增的事物。
在一个字符串中，如果取出若干个字符，将这些字符按照在字符串中的顺
序排列后是单调递增的，则成为这个字符串中的一个单调递增子序列。
例如，在字符串 lanqiao 中，如果取出字符 n 和 q，则 nq 组成一个单
调递增子序列。类似的单调递增子序列还有 lnq、i、ano 等等。
小蓝发现，有些子序列虽然位置不同，但是字符序列是一样的，例如取第
二个字符和最后一个字符可以取到 ao，取最后两个字符也可以取到 ao。小蓝
认为他们并没有本质不同。
对于一个字符串，小蓝想知道，本质不同的递增子序列有多少个？
例如，对于字符串 lanqiao，本质不同的递增子序列有 21 个。它们分别
是 l、a、n、q、i、o、ln、an、lq、aq、nq、ai、lo、ao、no、io、lnq、
anq、lno、ano、aio。
请问对于以下字符串（共 200 个小写英文字母，分四行显示）：（如果你把
以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在
试题目录下有一个文件 inc.txt，内容与下面的文本相同）
tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhf
iadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqij
gihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmad
vrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl
本质不同的递增子序列有多少个？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一
个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
题解:一开始我没有思路直到看到了这个大佬发的题解题解
代码我就不发了去看看这个大佬的博客就明白了
试题 F: 天干地支
时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分
【问题描述】
古代中国使用天干地支来记录当前的年份。
天干一共有十个，分别为：甲（jiǎ）、乙（yǐ）、丙（bǐng）、丁（dīng）、戊
（wù）、己（jǐ）、庚（gēng）、辛（xīn）、壬（rén）、癸（guǐ）。
地支一共有十二个，分别为：子（zǐ）、丑（chǒu）、寅（yín）、卯（mǎo）、
辰（chén）、巳（sì）、午（wǔ）、未（wèi）、申（shēn）、酉（yǒu）、戌（xū）、
亥（hài）。
将天干和地支连起来，就组成了一个天干地支的年份，例如：甲子。
2020 年是庚子年。
每过一年，天干和地支都会移动到下一个。例如 2021 年是辛丑年。
每过 60 年，天干会循环 6 轮，地支会循环 5 轮，所以天干地支纪年每 60
年轮回一次。例如 1900 年，1960 年，2020 年都是庚子年。
给定一个公元纪年的年份，请输出这一年的天干地支年份。
【输入格式】
输入一行包含一个正整数，表示公元年份。
【输出格式】
输出一个拼音，表示天干地支的年份，天干和地支都用小写拼音表示（不
表示声调），之间不要加入任何多余的字符。
【样例输入】
2020
试题F: 天干地支 7第十一届蓝桥杯大赛软件类决赛 Java 大学 C 组
【样例输出】
gengzi
【评测用例规模与约定】
对于所有评测用例，输入的公元年份为不超过 9999 的正整数。
题解:不用多说直接上代码 暴力
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] tian= {"jia","yi","bing","ding","wu","ji","geng","xin","ren","gui"};
String[] di= {"zi","chou","yin","mao","chen","si","wu","wei","shen","you","xu","hai"};
//2020 tian[6]di[0] 2021tian[7]di[1]
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
int year=0;
if(a<2020) {
year=2020-a;
int i=year%10;
int j=year%12;
int c=6-i;
int d=12-j;
if(c<0) {
c=10-Math.abs(c);
}
if(d<0) {
d=12-Math.abs(d);
}
System.out.println(tian[c]+di[d]);
}else {
year=a-2020;
int i=year%10;
int j=year%12;
int c=6+i;
if(c>10) {
c=c-10;
}
System.out.println(tian[c]+di[0+j]);
}
}
}
试题 G: 皮亚诺曲线距离
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
皮亚诺曲线是一条平面内的曲线。
下图给出了皮亚诺曲线的 1 阶情形，它是从左下角出发，经过一个 3 × 3 的
方格中的每一个格子，最终到达右上角的一条曲线。
下图给出了皮亚诺曲线的 2 阶情形，它是经过一个 3^2 × 3^2 的方格中的每一
个格子的一条曲线。它是将 1 阶曲线的每个方格由 1 阶曲线替换而成。
下图给出了皮亚诺曲线的 3 阶情形，它是经过一个 3^3 × 3^3 的方格中的每一
个格子的一条曲线。它是将 2 阶曲线的每个方格由 1 阶曲线替换而成。
皮亚诺曲线总是从左下角开始出发，最终到达右上角。
我们将这些格子放到坐标系中，对于 k 阶皮亚诺曲线，左下角的坐标是
(0, 0)，右上角坐标是 (3k − 1, 3
k − 1)，右下角坐标是 (3k − 1, 0)，左上角坐标是
(0, 3
k − 1)。
给定 k 阶皮亚诺曲线上的两个点的坐标，请问这两个点之间，如果沿着皮
亚诺曲线走，距离是到少？
【输入格式】
输入的第一行包含一个正整数 k，皮亚诺曲线的阶数。
第二行包含两个整数 x1, y1，表示第一个点的坐标。
试题 G: 皮亚诺曲线距离 10第十一届蓝桥杯大赛软件类决赛 Java 大学 C 组
第三行包含两个整数 x2, y2，表示第二个点的坐标。
【输出格式】
输出一个整数，表示给定的两个点之间的距离。
【样例输入】
1
0 0
2 2
【样例输出】
8
【样例输入】
2
0 2
0 3
【样例输出】
13
【评测用例规模与约定】
对于 30% 的评测用例，0 ≤ k ≤ 10。
对于 50% 的评测用例，0 ≤ k ≤ 20。
对于所有评测用例，0 ≤ k ≤ 100, 0 ≤ x1, y1, x2, y2 < 3
k
, x1, y1, x2, y2 ≤ 1018。
数据保证答案不超过 1018。
题解：这里我没有思路然后我身边的一个大佬讲解了一下他的思路，以下是大佬的代码
思路地址
import java.math.BigInteger;
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int k = sc.nextInt();
BigInteger x1 = sc.nextBigInteger();
BigInteger y1 = sc.nextBigInteger();
BigInteger x2 = sc.nextBigInteger();
BigInteger y2 = sc.nextBigInteger();
BigInteger ans = dfs(x2,y2,k).subtract(dfs(x1,y1,k));
System.out.println(ans.compareTo(new BigInteger("0"))>0?ans:ans.abs());
}
public static BigInteger dfs(BigInteger x,BigInteger y,int k){
if(k==0){
return new BigInteger("1");
}
BigInteger tx = x,ty = y,K = Pow(new BigInteger("3"),k-1),cx,cy,ans = new BigInteger("0");
tx = tx.divide(K);
ty = ty.divide(K);
cx = x.mod(K);
cy = y.mod(K);
switch((tx.multiply(new BigInteger("10")).add(ty)).intValue()){
case 0:
ans=dfs(cx,cy,k-1);
break;
case 1:
ans=dfs(K.subtract(new BigInteger("1")).subtract(cx),cy,k-1).add(K.multiply(K));
break;
case 2:
ans=dfs(cx,cy,k-1).add(K.multiply(new BigInteger("2")).multiply(K));
break;
case 10:
ans=dfs(cx,K.subtract(new BigInteger("1")).subtract(cy),k-1).add(K.multiply(new BigInteger("5")).multiply(K));
break;
case 11:
ans=dfs(K.subtract(new BigInteger("1")).subtract(cx),K.subtract(new BigInteger("1")).subtract(cy),k-1).add(K.multiply(new BigInteger("4")).multiply(K));
break;
case 12:
ans=dfs(cx,K.subtract(new BigInteger("1")).subtract(cy),k-1).add(K.multiply(new BigInteger("3")).multiply(K));
break;
case 20:
ans=dfs(cx,cy,k-1).add(K.multiply(new BigInteger("6")).multiply(K));
break;
case 21:
ans=dfs(K.subtract(new BigInteger("1")).subtract(cx),cy,k-1).add(K.multiply(new BigInteger("7")).multiply(K));
break;
case 22:
ans=dfs(cx,cy,k-1).add(K.multiply(new BigInteger("8")).multiply(K));
break;
}
return ans;
}
public static BigInteger Pow(BigInteger x,int k){
if(k==0)
return new BigInteger("1");
if(k==1)
return x;
BigInteger ans = x.pow(k>>1);
ans = ans.multiply(ans);
if((k&1)!=0)
ans = ans.multiply(x);
return ans;
}
}
试题 H: 蓝肽子序列
时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分
【问题描述】
L 星球上的生物由蛋蓝质组成，每一种蛋蓝质由一类称为蓝肽的物资首尾
连接成一条长链后折叠而成。
生物学家小乔正在研究 L 星球上的蛋蓝质。她拿到两个蛋蓝质的蓝肽序列，
想通过这两条蓝肽序列的共同特点来分析两种蛋蓝质的相似性。
具体的，一个蓝肽可以使用 1 至 5 个英文字母表示，其中第一个字母大写，
后面的字母小写。一个蛋蓝质的蓝肽序列可以用蓝肽的表示顺序拼接而成。
在一条蓝肽序列中，如果选取其中的一些位置，把这些位置的蓝肽取出，
并按照它们在原序列中的位置摆放，则称为这条蓝肽的一个子序列。蓝肽的子
序列不一定在原序列中是连续的，中间可能间隔着一些未被取出的蓝肽。
如果第一条蓝肽序列可以取出一个子序列与第二条蓝肽序列中取出的某个
子序列相等，则称为一个公共蓝肽子序列。
给定两条蓝肽序列，找出他们最长的那个公共蓝肽子序列的长度。
【输入格式】
输入两行，每行包含一个字符串，表示一个蓝肽序列。字符串中间没有空
格等分隔字符。
【输出格式】
输出一个整数，表示最长的那个公共蓝肽子序列的长度。
【样例输入】
LanQiaoBei
LanTaiXiaoQiao
试题H: 蓝肽子序列 12第十一届蓝桥杯大赛软件类决赛 Java 大学 C 组
【样例输出】
2
【样例说明】
最长的公共蓝肽子序列为 LanQiao，共两个蓝肽。
【评测用例规模与约定】
对于 20% 的评测用例，两个字符串的长度均不超过 20。
对于 50% 的评测用例，两个字符串的长度均不超过 100。
对于所有评测用例，两个字符串的长度均不超过 1000。
题解:看看最长公共子串就明白今天这个蓝肽子序列差不多
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner = new Scanner(System.in);
char [] s1=scanner.nextLine().toCharArray();
char [] s2=scanner.nextLine().toCharArray();
int len1=s1.length;
int len2=s2.length;
int [][]dp=new int[len1+1][len2+1];
for (int i = 1; i <= len1; i++) {
for (int j = 1; j <= len2; j++) {
if(s2[j-1]==s1[i-1])
{
dp[i][j]=dp[i-1][j-1];
if('A'<=s2[j-1]&&s2[j-1]<='Z') dp[i][j]++;
}
else
{
if(dp[i-1][j]>=dp[i][j-1]) dp[i][j]=dp[i-1][j];
else dp[i][j]=dp[i][j-1];
}
}
}
System.out.println(dp[len1][len2]);
}
}
试题 I: 画廊
时间限制: 1.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
小蓝办了一个画展，在一个画廊左右两边陈列了他自己的作品。为了使画
展更有意思，小蓝没有等距陈列自己的作品，而是按照更有艺术感的方式陈列。
在画廊的左边陈列了 L 幅作品，在画廊的右边陈列了 R 幅作品，左边的作品距
离画廊的起点依次为 u1, u2, · · · , uL，右边的作品距离画廊起点依次为 v1, v2, · · · ,
vR。
每周，小蓝要整理一遍自己的每一幅作品。整理一幅作品的时间是固定的，
但是要带着沉重的工具。从一幅作品到另一幅作品之间的距离为直线段的长度。
小蓝从画廊的起点的正中央（左右两边的中点）出发，整理好每一幅画，
最终到达画廊的终点的正中央。已知画廊的宽为 w。
请问小蓝最少带着工具走多长的距离？
【输入格式】
输入的第一行包含四个整数 L, R, d, w，表示画廊左边和右边的作品数量，
以及画廊的长度和宽度。
第二行包含 L 个正整数 u1, u2, · · · , uL，表示画廊左边的作品的位置。
第三行包含 R 个正整数 v1, v2, · · · , vR，表示画廊右边的作品的位置。
【输出格式】
输出一个实数，四舍五入保留两位小数，表示小蓝最少带着工具走的距离。
【样例输入】
3 3 10 2
1 3 8
2 4 6
试题I: 画廊 14第十一届蓝桥杯大赛软件类决赛 Java 大学 C 组
【样例输出】
14.71
【样例说明】
小蓝从起点开始，首先到达左边第一幅作品（走动距离 √
2），然后到达左
边第二幅作品（走动距离 2），然后到达右边第一幅作品（走动距离 √
5），然后
到达右边第二幅和第三幅作品（走动距离 2 和 2），然后到达左边第三幅作品
（走动距离 2
√
2），最后到达画廊终点（走动距离 √
5）。
总共距离为 √
2 + 2 + √
5 + 2 + 2 + 2 √
2 + √
5 ≈ 14.71。
【评测用例规模与约定】
对于 40% 的评测用例，1 ≤ L, R ≤ 10, 1 ≤ d ≤ 100, 1 ≤ w ≤ 100。
对于 70% 的评测用例，1 ≤ L, R ≤ 100, 1 ≤ d ≤ 1000, 1 ≤ w ≤ 1000。
对于所有评测用例，1 ≤ L, R ≤ 500, 1 ≤ d ≤ 100000, 1 ≤ w ≤ 100000,
0 ≤ u1 < u2 < · · · < uL ≤ d, 0 ≤ v1 < v2 < · · · < vR ≤ d。
import java.util.Scanner;
public class Main {
static int maxn = 512;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
double[][][] dp = new double[maxn][maxn][2];
int[] u = new int[maxn];
int[] v = new int[maxn];
int L = in.nextInt();
int R = in.nextInt();
int d = in.nextInt();
int w = in.nextInt();
for (int i = 1; i <=L ; i++) {
u[i] = in.nextInt();
}
for (int i = 1; i <=R ; i++) {
v[i] = in.nextInt();
}
for (int i = 0; i <=L ; i++) {
for (int j = 0; j <= R; j++) {
dp[i][j][0] = Integer.MAX_VALUE;
dp[i][j][1] = Integer.MAX_VALUE;
}
}
dp[1][0][0] = hypot(w / 2.0,u[1]);
dp[0][1][1] = hypot(w / 2.0,v[1]);
for (int i = 0; i <= L; i++) {
for (int j = 0; j <= R; j++) {
if (i + j > 1){
if (i != 0){
dp[i][j][0] = Math.min(
dp[i - 1][j][0] + u[i] - u[i - 1],
dp[i - 1][j][1] + hypot(w, Math.abs(u[i] - v[j])));
}
if (j != 0) {
dp[i][j][1] = Math.min(
dp[i][j - 1][1] + v[j] - v[j - 1],
dp[i][j - 1][0] + hypot(w, Math.abs(u[i] - v[j])));
}
}
}
}
System.out.printf("%.2f",Math.min(dp[L][R][0] + hypot(w / 2.0, d - u[L]),
dp[L][R][1] + hypot(w / 2.0, d - v[R])));
}
private static double hypot(double v, double i) {
return Math.sqrt(v * v + i * i);
}
}
试题 J: 答疑
时间限制: 3.0s 内存限制: 512.0MB 本题总分：25 分
【问题描述】
有 n 位同学同时找老师答疑。每位同学都预先估计了自己答疑的时间。
老师可以安排答疑的顺序，同学们要依次进入老师办公室答疑。
一位同学答疑的过程如下：
- 首先进入办公室，编号为 i 的同学需要 si 毫秒的时间。
- 然后同学问问题老师解答，编号为 i 的同学需要 ai 毫秒的时间。
- 答疑完成后，同学很高兴，会在课程群里面发一条消息，需要的时间可
以忽略。 - 最后同学收拾东西离开办公室，需要 ei 毫秒的时间。一般需要 10 秒、
20 秒或 30 秒，即 ei 取值为 10000，20000 或 30000。
一位同学离开办公室后，紧接着下一位同学就可以进入办公室了。
答疑从 0 时刻开始。老师想合理的安排答疑的顺序，使得同学们在课程群
里面发消息的时刻之和最小。
【输入格式】
输入第一行包含一个整数 n，表示同学的数量。
接下来 n 行，描述每位同学的时间。其中第 i 行包含三个整数 si
, ai
, ei，意
义如上所述。
【输出格式】
输出一个整数，表示同学们在课程群里面发消息的时刻之和最小是多少。
【样例输入】
3
10000 10000 10000
试题J: 答疑 16第十一届蓝桥杯大赛软件类决赛 Java 大学 C 组
20000 50000 20000
30000 20000 30000
【样例输出】
280000
【样例说明】
按照 1, 3, 2 的顺序答疑，发消息的时间分别是 20000, 80000, 180000。
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ n ≤ 20。
对于 60% 的评测用例，1 ≤ n ≤ 200。
对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ si ≤ 60000，1 ≤ ai ≤ 1000000，
ei ∈ {10000, 20000, 30000}，即 ei 一定是 10000、20000、30000 之一。
题解:没想到这么简单 理解题目意思就是简单的排序就行了
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc =new Scanner(System.in);
int n=sc.nextInt();
long num[][]=new long[n][3];
for(int i=0;i<n;i++) {
num[i][0]=sc.nextLong();
num[i][1]=sc.nextLong();
num[i][2]=sc.nextLong();
}
long num3[]=new long[n];
long num2[]=new long[n];
for(int i=0;i<n;i++) {
num3[i]=num[i][0]+num[i][1]+num[i][2];
num2[i]=num[i][0]+num[i][1];
}
Arrays.sort(num2);
Arrays.sort(num3);
long count=0;
for(int i=0;i<n;i++) {
count+=num2[i];
}
for(int i=0,j=n-1;i<n;i++,j--) {
count+=num3[i]*j;
}
System.out.println(count);
}
}
6728
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
