蓝桥2020 B组 第一场考试

2. 纪念日

问题描述：

请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包

含多少分钟？

答案提交：

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个

整数。

方法1（也是最快的）

打开电脑的计算器——》查看——》日期计算——》从 1921 年 7 月 23 日 到 2020 年 7 月 1 日一共差了36138天，

36138 * 24*60 = 52038720

方法2（使用“日期类”求解（SimpleDateFormat+Date））

package 第11届01;

import java.sql.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class T2 {

	public static void main(String[] args) throws ParseException {

//		  DateFormat sdf = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
//			Date begin = (Date) sdf.parse("1921-7-23 12:00:00");
//			Date end = (Date) sdf.parse("2020-7-1 12:00:00");
//			long ans = end.getTime() - begin.getTime();
//			System.out.println(ans /1000/60);
		 DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	        Date start = (Date) format.parse("1921-7-23 12:00:00");
	        Date end = (Date) format.parse("2020-7-1 12:00:00");
	        System.out.print(( end.getTime() - start.getTime()) / 1000 / 60  );

	        //Date.getTime()  返回值：是毫秒数 1s = 1000ms  the number of milliseconds since January 1, 1970, 00:00:00 GMTrepresented by this Date object.
	}
}

3. 合并检测

问题描述

新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准

备给大量民众进病毒核酸检测。

然而，用于检测的试剂盒紧缺。

为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k

个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k

个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明

至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看，

如果检测前 k − 1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中

不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用

了 k + 1 个试剂盒完成了 k 个人的检测。

A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能

最节省试剂盒？

方法1(数学推导)：

假设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

方法2（代码实现）：

package 第11届01;

public class T3 {

	public static void main(String[] args) {
		int min = 999999;
		int ans = -1;
		for (int i = 1; i <= 100; i++) { // i个人一块测
			int temp;
			if (100 % i != 0) {
				temp = 100 / i + i + 1;
			} else {
				temp = 100 / i + i;
			}
			if (min > temp) {
				min = temp;
				ans = i;
			}
		}
		System.out.println(ans);
//10
	}
}

4. 分配口罩

某市市长获得了若干批口罩，每一批口罩的数目如下：（如果你把以下文

字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目

录下有一个文件 mask.txt，内容与下面的文本相同）

9090400

8499400

5926800

8547000

4958200

4422600

5751200

4175600

6309600

5865200

6604400

4635000

10663400

8087200

4554000

现在市长要把口罩分配给市内的 2 所医院。由于物流限制，每一批口罩只

能全部分配给其中一家医院。市长希望 2 所医院获得的口罩总数之差越小越好。

请你计算这个差最小是多少？

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个

整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

代码实现：

package 第11届01;
/*要使两家医院的口罩差值最小，是背包问题的一种变形
如果两家医院平均分是sum/2
若不能恰好实现均分，就存在一家医院分多 设为LargeNum ,另一家医院分的少SmallNum
所以差值为=（LageNum-sum/2）*2=(sum/2-SmallNum)*2
每家医院可看作一个容量为sum/2的背包，只有SmallNum尽可能大才能保证差值最小
 */
public class T4 {

	static int[] num = { 9090400, 8499400, 5926800, 8547000, 4958200, 4422600, 5751200, 4175600, 6309600, 5865200,
			6604400, 4635000, 10663400, 8087200, 4554000 };
	static long res = Long.MAX_VALUE;

	/**
	 * @param k    正在处理数字的下标 也是深搜的次数
	 * @param sum1 1号医院的口罩数量
	 * @param sum2 2号医院的口罩数量
	 *  函数体中处理的是不同路径：
	 *  第一个是给1号医院分配
	 *  第二个是给2号医院分配
	 *  经过多次递归回溯，会计算出所有分配情况的最小值
	 */
	public static void dfs(int k, int sum1, int sum2) {
		// 当k=15时，说明所有口罩全部分配完成，此时要确定最小值和当前两个医院数量的差值
		if (k == 15)
		// 刚好一条路走到底（遍历到底）,返回题目所求最小值
		{
			res = res < Math.abs(sum1 - sum2) ? res : Math.abs(sum1 - sum2);
			return;
		}
		// 如果该路径不通，则深搜次数加一，返回前一个节点，继续搜索
		dfs(k + 1, sum1 + num[k], sum2);
		dfs(k + 1, sum1, sum2 + num[k]);
	}

	public static void main(String[] args) {
		dfs(0, 0, 0);
		System.out.println(res);
	}
//2400
}

5. 斐波那契数列最大公约数

斐波那契数列满足 F 1 = F 2 = 1, 从F3开始，F(n) = F(n-1)+F(n-2)

请你计算 请你计算

G C D ( F （2020） , F （520） )

其中 G C D ( A , B ) A 和 B 的最大公约数。

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个

整数

package 第11届01;

import java.math.BigInteger;

/*题目分析:
1. 计算斐波那契数列，f(2020) 和 f(520) 用long必越界，故使用BIgInteger
2. 用BigInteger自带的函数gcd求解最大公约数
3. 计算最大公约数是也要使用BigInteger，直接返回结果
*/
public class T5 {

	public static void main(String[] args) {
		BigInteger[] dp=new BigInteger[2021];
		dp[1]=BigInteger.ONE;  //BigInteger.ONE就是常量1
		dp[2]=BigInteger.ONE;
		for(int i=3;i<2021;i++) {
			dp[i]=dp[i-1].add(dp[i-2]);
		}
		System.out.println(gcd(dp[2020],dp[520]));

	}

	public static BigInteger gcd(BigInteger a,BigInteger b) {
		//1.递归出口
		if(b.equals(BigInteger.ZERO)) {//BigInteger.ZERO 就是常量0 判断两个数相等用equals方法
			return a;
		}
		//2.递推
		return gcd(b,a.mod(b)); //取余 用mod方法
	}
//6765	

//	public static int f(int n) {
//		if(n==1||n==2) return 1;
//		return f(n-1)+f(n-2);
//	}
//	public static int gcd(int a,int b) {
//		return b==0?a:gcd(b, a%b);
//	}
}

6.分类计数

时间限制: 1.0s 内存限制: 512.0MB 本题总分：15 分

问题描述

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

母，多少个数字。

---

输入格式

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

---

输出格式

输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。

样例：

Input：
1+a=Aab

Output：
1
3
1

评测用例规模与约定

对于所有评测用例，字符串由可见字符组成，长度不超过 100。

代码实现：

package 第11届01;

import java.util.Scanner;

public class T6 {

	public static void main(String[] args) {
		 Scanner scanner = new Scanner(System.in);
		 String string = scanner.next();
		 int large = 0;
		 int small = 0;
		 int shu = 0;
		 char[] str = string.toCharArray();
		 for(int i=0;i<str.length;i++) {
			//怎么表示大写字母、小写字母和数字的集合呢？  if(str[i]=='a'||)不是哦
			 if(str[i]>='a'&& str[i]<='z') {
				 small++;
			 }
			 else if(str[i]>='A'&& str[i]<='Z') {
				 large++;
			 }
			 else if(str[i]>='0'&& str[i]<='9') {
				 shu++;
			 }
			 else {
				 continue;
			 }
		 }
		 System.out.println(large+"\n"+small+"\n"+shu);
	}
}

7. 八次求和

时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分

问题描述:

给定正整数 n ,

求1的八次方 + 2的八次方 + 3的八次方+........+n的八次方 mod 123456789 。其中 mod 表示取余。

输入格式:

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

输出格式:

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

测试样例 1:

Input：
2
Output：
257

测试样例 2:

Input：
987654

Output：
43636805

评测用例规模与约定

对于 20% 的评测用例，1 ≤ n ≤ 20。

对于 60% 的评测用例，1 ≤ n ≤ 1000。

对于所有评测用例，1 ≤ n ≤ 1000000。

代码实现：

package 第11届01;

import java.math.BigInteger;
import java.util.Scanner;
//此题是先求出1到n 各自的8次方后，再相加 最后求余数
//因为n的八次方的数值过大，所以求和结果用BigInteger
//但n的值对于所有评测用例，1 ≤ n ≤ 1000000。 可以用int 来接收
public class T7 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		  int n = scanner.nextInt();
		 BigInteger sum  = BigInteger.ZERO;
		for(int i=1;i<=n;i++) {
			BigInteger temp = BigInteger.valueOf(i);
			sum = sum.add(temp.pow(8));
		}
		System.out.println(sum.mod(new BigInteger("123456789")));
	}
}
/*BigInteger abs() 返回大整数的绝对值
BigInteger add(BigInteger val) 返回两个大整数的和
BigInteger divide(BigInteger val) 返回两个大整数的商
BigInteger gcd(BigInteger val) 返回大整数的最大公约数
BigInteger max(BigInteger val) 返回两个大整数的最大者
BigInteger min(BigInteger val) 返回两个大整数的最小者
BigInteger mod(BigInteger val) 用当前大整数对val求模
BigInteger multiply(BigInteger val) 返回两个大整数的积
 */

字符串编码:

小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, ... Z → 26。

这样一个字符串就能被转化成一个数字序列：

比如 ABCXYZ → 123242526。

现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字符串。

【输入格式】

一个数字序列。

【输出格式】

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

【样例输入】

123242526

【样例输出】

LCXYZ

【评测用例规模与约定】

对于 20% 的评测用例，输入的长度不超过 20。

对于所有评测用例，输入的长度不超过 200000。

代码实现：

package 第11届01;

import java.util.Scanner;

public class T8 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String string = scanner.next();
		char[] str = string.toCharArray();
		char result;
		int len = string.length();
		int i;
		for (i = 0; i < len - 1; i++) {
			int a = str[i] - '0';
			int b = str[i + 1] - '0';
			int ans = a * 10 + b;
			if (ans < 27) {
				result = (char) (ans + 64);
				System.out.print(result);
				i++;
			} else {
				result = (char) (a + 64);
				System.out.print(result);
			}
		}

		if (i < len) {
			result = (char) (str[i] - '0' + 64);
			System.out.print(result);
		}
	}
}