第十一届蓝桥杯省赛完整解析（Java 大学B组）

最新推荐文章于 2021-04-15 12:34:23 发布

梦码城

最新推荐文章于 2021-04-15 12:34:23 发布

阅读量438

点赞数 1

分类专栏：第十二届/第十一届蓝桥杯备赛文章标签：字符串 java 算法 vba 数据结构

本文链接：https://blog.csdn.net/qq_45724216/article/details/115415567

版权

第十二届/第十一届蓝桥杯备赛专栏收录该内容

36 篇文章 9 订阅

订阅专栏

A 解密

答案提交

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个只包含 30 3030 个大小写英文字母的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分。

代码

public class Main {
	static String s1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; // 原字符
	static String s2 = "yxmdacikntjhqlgoufszpwbrevYXMDACIKNTJHQLGOUFSZPWBREV"; // 加密后的字符
	static String s = "EaFnjISplhFviDhwFbEjRjfIBBkRyY"; // 加密后的字符
	static String ans="";
	public static void main(String[] args) {
		for(int i=0;i<s.length();i++) {
			int j=s2.indexOf(s.charAt(i));
			ans=ans+s1.charAt(j);
		}
		System.out.println(ans);

	}

}

答案

YeRikGSunlRzgDlvRwYkXkrGWWhXaA

B 纪念日

问题描述

2020 年 7 月 1 日是中国共产党成立 99 周年纪念日。中国共产党成立于 1921 年 7 月 23 日。请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包含多少分钟？

答案提交

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分

**思路：**Date对象的使用

代码

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Main {

	public static void main(String[] args) throws ParseException {
		DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
		Date Start = format.parse("1921-7-23 12:00:00");  //parse() 给定字符串解析成一个日期对象
		Date End = format.parse("2020-7-1 12:00:00");
		System.out.println(((End.getTime()-Start.getTime())/1000/60)); //getTime()返回从1970开始的的毫秒数

	}
}

**答案：**52038720

C 合并检测

问题描述

新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准备给大量民众进病毒核酸检测。然而，用于检测的试剂盒紧缺。为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看，如果检测前 k − 1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用了 k + 1 个试剂盒完成了 k 个人的检测。A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能最节省试剂盒？
思路：

均值不等式：假设A国有n个人，感染者有n/100每k个人一组，共n/k组，
共用n/k瓶试剂按照最坏的情况，每多出一个感染者就多用k瓶试剂，
因此共用n/k+(n/100)*k瓶试剂n是定值，所以求(1/k+k/100)最小由于a+b>=2√ab
当且仅当a = b时，取等号即1/k=k/100时，取得最小值解得k = 10

**答案：**10

D 分配口罩

问题描述

某市市长获得了若干批口罩，每一批口罩的数目如下：（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 mask.txt，内容与下面的文本相同）
9090400
8499400
5926800
8547000
4958200
4422600
5751200
4175600
6309600
5865200
6604400
4635000
10663400
8087200
4554000
现在市长要把口罩分配给市内的 2 所医院。由于物流限制，每一批口罩只能全部分配给其中一家医院。市长希望 2 所医院获得的口罩总数之差越小越好。请你计算这个差最小是多少？

**思路：**深搜或者动态规划,这里用深搜

代码

import java.util.Scanner;


public class Main {
	static long[] dp = new long[98090000];
	static Scanner scanner=new Scanner(System.in);
	static long minD=Long.MAX_VALUE;
	static long[] arr=new long[16];
	static long sum=0;
	
	static void DFS(int index,long now) {
		if(index==15) {
			minD=Math.min(minD, Math.abs(sum-2*now));
			}
		else {
			DFS(index+1, now+arr[index]);
			DFS(index+1, now);
		}
	}

	public static void main(String[] args) {
		for(int i=0;i<15;i++) {
			arr[i]=scanner.nextLong();
			sum+=arr[i]; //记录总共的口罩数
		}
		DFS(0,0);
		System.out.println(minD);

	}

}

**答案：**2400

E 斐波那契数列最大公约数

问题描述

求斐波那契数列GCD（F2020,F520)的最大公约数

代码

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	static Scanner scanner=new Scanner(System.in);
	public static void main(String[] args) {
		BigInteger aBigInteger=new BigInteger("1");
		BigInteger bigInteger=new BigInteger("1");
		BigInteger cBigInteger=new BigInteger("0");
		BigInteger temp1=cBigInteger;
		for(int i=3;i<=2020;i++) {
			cBigInteger=aBigInteger.add(bigInteger);
			aBigInteger=bigInteger;
			if(i==520) {
				temp1=cBigInteger;
			}
			bigInteger=cBigInteger;
		}
		System.out.println(cBigInteger.gcd(temp1));
	}

}

**答案：**6765

F 分类计数

问题描述

输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字母，多少个数字。

输入格式

输入一行包含一个字符串。

输出格式

输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
**思路：**遍历即可

代码

import java.util.Scanner;

public class Main {
	static Scanner scanner=new Scanner(System.in);
	static String string;
	static int count_num=0;
	static int count_low=0;
	static int count_supper=0;
	public static void main(String[] args) {
		string=scanner.next();
		for (int i = 0; i < string.length(); i++) {
			//为数字
			char temp = string.charAt(i);
			if(temp >= '0' &&temp <='9') {
				count_num++;
			}else if(temp>='A'&&temp<='Z') {
				count_supper++;
			}else if(temp>='a'&&temp<='z'){
				count_low++;
			}
		}
		System.out.println(count_supper);
		System.out.println(count_low);
		System.out.println(count_num);
	}
}

G 八次求和

问题描述

给定正整数 n nn, 求 1^ 8 + 2 ^8 + ⋅ ⋅ ⋅ + n ^8 mod 123456789 。其中 mod 表示取余。

输入格式

输入的第一行包含一个整数 n。

输出格式

输出一行，包含一个整数，表示答案

**思路：**BigInteger使用

代码

import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	static Scanner scanner=new Scanner(System.in);
	static int n;
	static BigInteger sum=new BigInteger("0");
	public static void main(String[] args) {
		n=scanner.nextInt();
		for(int i=1;i<=n;i++) {
			BigInteger tempBigInteger = new BigInteger(String.valueOf(i));
			sum=sum.add(tempBigInteger.pow(8));
		}
		System.out.println(sum.mod(new BigInteger("123456789")));

	}

}

H 字符串编码

问题描述

小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字符串。

输入格式

一个数字序列

输出格式

一个只包含大写字母的字符串，代表答案

**思路：**贪心问题

代码

import java.util.Scanner;

public class Main {
	static Scanner scanner=new Scanner(System.in);
	static String string;
	static String ans="";
	public static void main(String[] args) {
		string = scanner.nextLine();
		for(int i=0;i<string.length();i++) {
			Integer t2=Integer.valueOf(String.valueOf(string.charAt(i)));
			if(i==string.length()-1) {  //为最后一个字符
				ans+=String.valueOf((char)((t2-1) + 'A'));
				break;
			}
			String temp = String.valueOf(string.charAt(i)) + String.valueOf(string.charAt(i+1));
			Integer t=Integer.valueOf(temp);
			//如果大于26
			if(t>26) {
				ans+=String.valueOf((char)((t2-1) + 'A'));
			}else {//如果小于等于26，贪心原则
				ans+=String.valueOf((char)((int)(t-1) + 'A'));
				i++;  //跳过两个字符
			}
		}
		System.out.println(ans);
	}

}

I BST 插入节点问题

问题描述

给定一棵包含 N 个节点的二叉树，节点编号是 1 ∼ N。其中 i 号节点具有权值 Wi，并且这些节点的权值恰好形成了一棵排序二叉树 (BST)。现在给定一个节点编号 K，小明想知道，在这 N 个权值以外，有多少个整数 X (即 X 不等于任何 Wi ) 满足：给编号为 K 的节点增加一个权值为 X 的子节点，仍可以得到一棵 BST。例如在下图中，括号外的数字表示编号、括号内的数字表示权值。即编号1 ∼ 4 的节点权值依次是 0、10、20、30。如果 K = 1，那么答案为 0。因为 1 号节点已经有左右子节点，不能再增加子节点了。如果 K = 2，那么答案为无穷多。因为任何一个负数都可以作为 2 的左子节点。如果 K = 3，那么答案为 9。因为 X = 11, 12, · · · , 19 都可以作为 3 的左子节点。

输入格式

第一行包含 2 个整数 N 和 K。以下 N 行每行包含 2 个整数，其中第 i 行是编号为 i 的节点的父节点编号Pi 和权值 Wi 。注意 Pi = 0 表示 i 是根节点。输入保证是一棵 BST。

输出格式

一个整数代表答案。如果答案是无穷多，输出 −1。

代码

import java.io.*;
import java.util.Arrays;

public class Main {

    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        in.nextToken();
        int n = (int)in.nval, v, w;
        in.nextToken();
        int k = (int)in.nval;
        Node[] tree = new Node[n + 1];
        tree[0] = new Node(0);
        for (int i = 1; i <= n; i++){
            in.nextToken();
            w = (int)in.nval;
            in.nextToken();
            v = (int)in.nval;
            if (v < tree[w].value) tree[i] = tree[w].left = new Node(v);
            else tree[i] = tree[w].right = new Node(v);
        }
        if (tree[k].left != null && tree[k].right!= null) System.out.print('0');
        else {
            Node node = tree[k];
            Arrays.sort(tree);
            int left = 1, right = n, mid = 0;
            while (left <= right) {
                mid = (left + right) / 2;
                if (tree[mid].value < node.value) left = mid + 1;
                else if (tree[mid].value > node.value) right = mid - 1;
                else break;
            }
            if (mid == 1 || mid == n) System.out.print("-1");
            else {
                left = node.left == null? tree[mid - 1].value: node.value;
                right = node.right == null? tree[mid + 1].value: node.value;
                System.out.print(right - left - 1);
            }
        }
    }

    static class Node implements Comparable<Node> {

        int value;

        Node left, right;

        Node(int value) { this.value = value; }

        public int compareTo(Node node) {
            return this.value - node.value;
        }
    }
}

J 网络分析

问题描述

小明正在做一个网络实验。他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。一条信息只存储一次。给出小明连接和测试的过程，请计算出每个节点存储信息的大小。

输入格式

输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从1 至 n 编号。接下来 m 行，每行三个整数，表示一个操作。如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b时，表示连接了一个自环，对网络没有实质影响。如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。

输出格式

输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行
完上述操作后节点 1 至节点 n 上存储信息的大小。

**思路：**BFS

代码

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	private static final String Integer = null;
	static Scanner scanner=new Scanner(System.in);
	static int m,n;
	static boolean [][]map=new boolean[10001][10001];
	static int []ans=new int[10001];
	static int t=0;
	static void BFS(int v) {
		boolean []visted = new boolean[n+1]; //标记数组
		Arrays.fill(visted, false);  //全部赋值为false
		visted[v]=true;
		Queue<Integer> queue=new LinkedList<Integer>();
		queue.offer(v);
		while(!queue.isEmpty()) {
			Integer now=queue.poll();
			ans[now]+=t; //当前节点加 t 
			for(int i=1;i<=n;i++) {
				if((map[i][now]==true||map[now][i]==true)&&visted[i]==false) { //i 与 now 是连通的并且i点没有访问过
					queue.offer(i);
					visted[i]=true;
				}
			}
		}
	}
	public static void main(String[] args) {
		n=scanner.nextInt();
		m=scanner.nextInt();
		while((m--)!=0) {
			int a;
			a=scanner.nextInt();  //输入操作码
			if(a==1) {  //打通这条路
				int b,c;
				b=scanner.nextInt();
				c=scanner.nextInt();
				map[b][c]=map[c][b]=true;
			}
			if(a==2) {
				int v=scanner.nextInt();
				t=scanner.nextInt();
				BFS(v);
			}
		}
		for(int i=1;i<=n;i++) {
			System.out.print(ans[i] + " ");
		}

	}

}

结语

如果你发现文章有什么问题，欢迎留言指正。
如果你觉得这篇文章还可以，别忘记点个赞加个关注再走哦。
如果你不嫌弃，还可以关注微信公众号———梦码城（持续更新中）。
梦码在这里感激不尽！！

梦码城

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
第十一届蓝桥杯省赛完整解析（Java 大学B组）

A 解密本题总分：5 分问题描述小明设计了一种文章加密的方法：对于每个字母 c cc，将它变成某个另外的字符 Tc下表给出了字符变换的规则：例如，将字符串 YeRi 加密可得字符串 EaFn。小明有一个随机的字符串，加密后为EaFnjISplhFviDhwFbEjRjfIBBkRyY（由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符串，后
复制链接

扫一扫