本文介绍了多个编程挑战，包括字符串加密的解密方法、纪念日的分钟数计算，以及合并检测、口罩分配、斐波那契数列最大公约数、分类计数、八次求和、字符串编码、BST插入节点和网络分析等算法问题的解决方案，涉及到了Map映射、排列组合、回溯、大数字操作等多个编程知识点。
目录
第一题： 解密(5分)
题目描述
小明设计了一种文章加密的方法：对于每个字母 c，将它变成某个另外的字符 Tc。下表给出了字符变换的规则：
例如，将字符串 YeRi 加密可得字符串 EaFn。
小明有一个随机的字符串，加密后为EaFnjISplhFviDhwFbEjRjfIBBkRyY由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符串，后面 52 行依次为表格中的内容。）
【答案提交】
YeRikGSunlRzgDlvRwYkXkrGWWhXaA【考查知识】Map映射
第二题：纪念日（5分）
题目描述
2020 年 7 月 1 日是中国共产党成立 99 周年纪念日。
中国共产党成立于 1921 年 7 月 23 日。
请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包含多少分钟？
【答案提交】52038720
public static void main(String[] args) throws IOException {
Scanner scanner=new Scanner(System.in);
//定义总日子
long sun=0;
//平年的总天数
long allYear=31+28+31+30+31+30+31+31+30+31+30+31;
//先把1921合2020对应日子合算出
sun=sun+1+8+31+30+31+30+31 + 31+29+31+30+31+30;
//1921-2019间直接按平年闰年算日子数
for (int i = 1922; i <=2019 ; i++) {
sun+=(isLeap(i)?allYear+1:allYear);
}
//最后计算分钟数
sun=sun*24*60;
System.out.println(sun);
}
static boolean isLeap(int year) {
//四百年一闰 或者 四年一闰且不为百年
return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
}【考查知识】平年与闰年
第三题：合并检测（10分）
题目描述
新冠疫情由新冠病毒引起，最近在 A 国蔓延，为了尽快控制疫情，A 国准
备给大量民众进病毒核酸检测。
然而，用于检测的试剂盒紧缺。
为了解决这一困难，科学家想了一个办法：合并检测。即将从多个人（k个）采集的标本放到同一个试剂盒中进行检测。如果结果为阴性，则说明这 k个人都是阴性，用一个试剂盒完成了 k 个人的检测。如果结果为阳性，则说明至少有一个人为阳性，需要将这 k 个人的样本全部重新独立检测（从理论上看，如果检测前 k − 1 个人都是阴性可以推断出第 k 个人是阳性，但是在实际操作中不会利用此推断，而是将 k 个人独立检测），加上最开始的合并检测，一共使用了 k + 1 个试剂盒完成了 k 个人的检测。A 国估计被测的民众的感染率大概是 1%，呈均匀分布。请问 k 取多少能最节省试剂盒？
【答案提交】10
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
/**
* 因为是均匀分布的,不管一共有多少人,每100人里面就有一个呈现阳性
* 设总人数为n,一共是 n/k组,有0.99*n/k个组呈阳性，有0.01*n/k各组成阴性
* 总共需要的试剂盒个数为: 0.99*n/k+0.01*n/k*(k+1);
*/
int n = 100;//假设一共有100人需要检测
int min = 100; //假设当k=1的时候需要测试100次
int min_k = 1;//记录K的最佳取值
int group;//分多少组
int temp;//记录上一次的数据
for (int k = 2; k <= n; k++) {//这里的向上去整建议不要用ceil函数 可能会因为某些精度的愿意，导致数据有出入
//向上取整分的组数
group = n % k == 0 ? n / k : n / k + 1;
//阳性组所用的检测试剂
int x = group * 0.99 > (int) (group * 0.99) ? (int) (group * 0.99) + 1 : (int) (group * 0.99);
//阴性组所用的检测试剂
int y = (group * 0.01 > (int) (group * 0.01) ? (int) (group * 0.01) + 1 : (int) (group * 0.01)) * (k + 1);
temp = x + y;
if (temp < min) {
min = temp;
min_k = k;
}
}
System.out.println(min_k);
}【考查知识】均匀分布，余数向上取整
第四题：分配口罩（10分）
题目描述
某市市长获得了若干批口罩，每一批口罩的数目如下：（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 mask.txt，内容与下面的文本相同）
9090400
8499400
5926800
8547000
4958200
4422600
5751200
4175600
6309600
5865200
6604400
4635000
10663400
8087200
4554000
现在市长要把口罩分配给市内的 2 所医院。由于物流限制，每一批口罩只能全部分配给其中一家医院。市长希望 2 所医院获得的口罩总数之差越小越好。请你计算这个差最小是多少？
【答案提交】2400
public class Main {
static int middle=Integer.MAX_VALUE;//定义一方与均值的差
static int min;//获取最小差值
static int sum_n=0;//口罩总数
static int sum=0;//递归回溯中一方实时的口罩数
public static void main(String []args) {
int []nums= {9090400,
8499400,
5926800,
8547000,
4958200,
4422600,
5751200,
4175600,
6309600,
5865200,
6604400,
4635000,
10663400,
8087200,
4554000};
for(int i:nums) {
sum_n+=i;
}
getMin(nums, 0);
System.out.println(min);
}
static void getMin(int []nums,int n) {
if(Math.abs(sum_n/2-sum)<middle) {
//当一方的口罩离均值越近，那么两者相差越少
middle=Math.abs(sum_n/2-sum);
min=sum_n-sum-sum;
}
//递归回溯
for(int i=n;i<nums.length;i++) {
sum+=nums[i];
getMin(nums,i+1);
sum-=nums[i];
}
}
}public class Main {
static int middle=Integer.MAX_VALUE;//定义一方与均值的差
static int min;//获取最小差值
static int sum_n=0;//口罩总数
static int sum=0;//递归回溯中一方实时的口罩数
public static void main(String []args) {
int []nums= {9090400,
8499400,
5926800,
8547000,
4958200,
4422600,
5751200,
4175600,
6309600,
5865200,
6604400,
4635000,
10663400,
8087200,
4554000};
for(int i:nums) {
sum_n+=i;
}
getMin(nums,0);
System.out.println(min);
}
//对于每一批口罩，我们设置0和1，代表被选的不同医院，那么共有2**15种组成方案
static void getMin(int []nums,int index) {
if(index>nums.length-1) return;
//离均值越紧则差值越小
if(Math.abs(sum-sum_n/2)<middle) {
middle=Math.abs(sum-sum_n/2);
min=sum_n-sum-sum;
}
for(int i=0;i<=1;i++) {
int temp=i==0?0:nums[index];
sum+=temp;
getMin(nums,index+1);
sum-=temp;
}
}
}
【考查知识】排列问题，回溯
第五题：斐波那契数列最大公约数（15分）
题目描述
public static void main(String[] args) throws IOException {
Scanner scanner=new Scanner(System.in);
BigInteger F2020=getFB(BigInteger.valueOf(1),BigInteger.valueOf(1),2020,2);
BigInteger F520=getFB(BigInteger.valueOf(1),BigInteger.valueOf(1),520,2);
System.out.println(getGCD(F2020,F520));
}
//求斐波那契数列
static BigInteger getFB(BigInteger first, BigInteger second, int target, int now){
if (target==now) return second;
return getFB(second,first.add(second),target,now+1);
}
/**
* @描述 欧几里得算法（非递归式）, 也叫辗转相除法, 高效稳定
* 原理： gcd(a, b) = gcd(b, a mod b)
* @param num1
* @param num2
* @return 最大公约数
*/
static BigInteger getGCD(BigInteger num1,BigInteger num2){
// 先获得绝对值，保证负数也可以求
num1 = num1.abs();
num2 = num2.abs();
// 假定第一个数较大；如果第二个较大，在第二轮会颠倒过来
// 如果第二个数为 0，则第一个数就是最大公约数
while (num2!=BigInteger.valueOf(0)) {
// 求余
BigInteger[] bigIntegers = num1.divideAndRemainder(num2);
// 交换数，等同递归调用
num1 = num2;
num2 = bigIntegers[1];
}
return num1;
}
【考查知识】斐波那契数列，最大公约数，大数字
第六题：分类计数（15分）
题目描述
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字母，多少个数字。
【输入格式】
输入一行包含一个字符串。
【输出格式】
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
【样例输入】
1+a=Aab
【样例输出】
1
3
1
【评测用例规模与约定】
对于所有评测用例，字符串由可见字符组成，长度不超过 100。
【答案提交】
import java.util.Scanner;
public class Main {
public static void main(String []args) {
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
int Up=0,Low=0,Dig=0;
for (int i =0;i<s.length();i++) {
if(Character.isUpperCase(s.charAt(i))) Up++;
if(Character.isLowerCase(s.charAt(i))) Low++;
if(Character.isDigit(s.charAt(i))) Dig++;
}
System.out.println(Up);
System.out.println(Low);
System.out.println(Dig);
}
}
第七题：八次求和（20分）
题目描述
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行，包含一个整数，表示答案。
【样例输入】
2
【样例输出】
257
【样例输入】
987654
【样例输出】
43636805
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n ≤ 20。
对于 60% 的评测用例，1 ≤ n ≤ 1000。
对于所有评测用例，1 ≤ n ≤ 1000000。
import java.util.Scanner;
public class Main {
public static void main(String []args) {
/**
* 几个数相乘求模相当于每个数取模的积再模
* 几个数相加求模相当于每个数取模的和再取模
* mod(n,x)=mod(...(...(mod(n,x)))),一个数反复求模仍等于本身
*/
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
long sum=0;
for(long j=1;j<=n;j++) {
sum+=(getSum(j));
}
System.out.println(sum%123456789);
}
//为避免最坏情况出现123456788*123456788直接超过int上限，这里使用long
static long getSum(long n) {
long sum=1;
long a=123456789;
for(int i=0;i<8;i++) {
sum*=(n%a);
sum=sum%a;
}
return (sum%123456789);
}
}
第八题：字符串编码（20分）
题目描述
小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字
符串。
【输入格式】
一个数字序列。
【输出格式】
一个只包含大写字母的字符串，代表答案
【样例输入】
123242526
【样例输出】
LCXYZ
【评测用例规模与约定】
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
import java.util.Scanner;
public class Main {
public static void main(String []args) {
Scanner sc=new Scanner(System.in);
char []chars= {0, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
StringBuilder builder=new StringBuilder();
String str=sc.nextLine();
//历遍字符,1X一定大于1+X;2X一定大于2+X。按照该规律即可得出最大字典序的字符串
for(int i=0;i<str.length();i++) {
if(str.charAt(i)=='1' &&i<str.length()-1) {
builder.append(chars[(str.charAt(i)-'0')*10+(str.charAt(i+1)-'0')]);
i++;
}else if(str.charAt(i)=='2' &&i<str.length()-1) {
builder.append(chars[(str.charAt(i)-'0')*10+(str.charAt(i+1)-'0')]);
i++;
}else {
builder.append(chars[(str.charAt(i)-'0')]);
}
}
System.out.println(builder);
}
}
第九题：BST 插入节点问题（25分）
题目描述
给定一棵包含 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。
【样例输入】
4 3
0 10
1 0
1 20
3 30
【样例输出】
9
【评测用例规模与约定】
对于 60% 的评测用例，1 ≤ K ≤ N ≤ 100，0 ≤ Wi ≤ 200，且 Wi 各不相同。
对于所有评测用例，1 ≤ K ≤ N ≤ 10000，0 ≤ Wi ≤ 100000000，且 Wi 各不相同。
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
public class LQ {
static class Node {//定义二叉树节点
int id;
int weight;
Node left;
Node right;
public Node(int id, int weight) {
this.id = id;
this.weight = weight;
}
boolean equal(Node a) {
if (this.id == a.id && this.weight == a.weight) {
return true;
}
return false;
}
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//n行数
int k = sc.nextInt();//目标节点编号k
int[][] arr = new int[n + 1][2];//记录数据，第一个数代表其父节点的id,第二个数代表其权值
for (int i = 1; i < arr.length; ++i) {
for (int j = 0; j < arr[i].length; ++j) {
arr[i][j] = sc.nextInt();
}
sc.nextLine();
}
//初始化所有的结点，定义其id和weight
Node[] nodes = new Node[n + 1];
for (int i = 1; i < arr.length; ++i) {
nodes[i] = new Node(i, arr[i][1]);
}
//历遍节点，将结点构建成二叉树
for (int i = 1; i < arr.length; ++i) {
//只要当前结点不是根节点就有父结点
if (arr[i][0] != 0) {
//如果当前结点的父结点权值大于当前结点的权值，说明该结点是父节点的左子结点
if (nodes[arr[i][0]].weight > arr[i][1]) {
nodes[arr[i][0]].left = nodes[i];
}
//如果当前结点的父结点权值小于当前结点的权值，说明该结点是父节点的右子结点
if (nodes[arr[i][0]].weight < arr[i][1]) {
nodes[arr[i][0]].right = nodes[i];
}
}
}
//获取k结点
Node nodeK = nodes[k];
System.out.println(inOrder(nodes[1],nodeK));
}
//中序历遍（左中右），由于其为BST数，故按中序历遍后的节点权值按升序排列
static int inOrder(Node root, Node K) {
List<Node> list = new ArrayList<>();
Stack<Node> stack = new Stack<>();
Node cur = root;
while (cur != null || !stack.isEmpty()) {
if (cur != null) {
stack.push(cur);
cur = cur.left;
} else {
cur = stack.pop();
list.add(cur);
cur = cur.right;
}
}
int num = -1;//定义可插入的节点数
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equal(K)) {//当找到K节点时
if (K.left != null && K.right != null) {//若两边具有节点则无法插入
num = 0;
} else if (K.left == null && K.right == null) {//若两边均无节点
if (i == 0 || i == list.size() - 1) {
num = -1;
} else {
num = (list.get(i + 1).weight - K.weight - 1) + (K.weight - list.get(i - 1).weight - 1);
}
} else if (K.left == null) {//若仅左边无节点
if (i == 0) {
num = -1;
} else {
num = (K.weight - list.get(i - 1).weight - 1);
}
} else {
if (i == list.size()-1) {//若仅右边无节点
num = -1;
} else {
num = (list.get(i + 1).weight - K.weight - 1);
}
}
break;
}
}
return num;
}
第十题：网络分析（25分）
题目描述
小明正在做一个网络实验。他设置了 n 台电脑，称为节点，用于收发和存储数据。初始时，所有节点都是独立的，不存在任何连接。小明可以通过网线将两个节点连接起来，连接后两个节点就可以互相通信了。两个节点如果存在网线连接，称为相邻。小明有时会测试当时的网络，他会在某个节点发送一条信息，信息会发送到每个相邻的节点，之后这些节点又会转发到自己相邻的节点，直到所有直接或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。一条信息只存储一次。给出小明连接和测试的过程，请计算出每个节点存储信息的大小。
【输入格式】
输入的第一行包含两个整数 n, m，分别表示节点数量和操作数量。节点从1 至 n 编号。接下来 m 行，每行三个整数，表示一个操作。如果操作为 1 a b，表示将节点 a 和节点 b 通过网线连接起来。当 a = b时，表示连接了一个自环，对网络没有实质影响。如果操作为 2 p t，表示在节点 p 上发送一条大小为 t 的信息。
【输出格式】
输出一行，包含 n 个整数，相邻整数之间用一个空格分割，依次表示进行完上述操作后节点 1 至节点 n 上存储信息的大小。
【样例输入】
4 8
1 1 2
2 1 10
2 3 5
1 4 1
2 2 2
1 1 2
1 2 4
2 2 1
【样例输出】
13 13 5 3
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ n ≤ 20，1 ≤ m ≤ 100。
对于 50% 的评测用例，1 ≤ n ≤ 100，1 ≤ m ≤ 1000。
对于 70% 的评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 10000。
对于所有评测用例，1 ≤ n ≤ 10000，1 ≤ m ≤ 100000，1 ≤ t ≤ 100。
import java.io.IOException;
import java.util.Scanner;
import java.util.Stack;
public class Main{
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//n台电脑
int m = sc.nextInt();//操作次数
int[][] contract = new int[n + 1][n + 1];
int[] combine = new int[n + 1];
int info[][] = new int[m][3];
for (int i = 0; i < m; i++) {//记录操作信息
info[i][0] = sc.nextInt();
info[i][1] = sc.nextInt();
info[i][2] = sc.nextInt();
}
for (int i = 0; i < info.length; i++) {
if (info[i][0] == 1) {//连接网线
contract[info[i][1]][info[i][2]] = 1;
contract[info[i][2]][info[i][1]] = 1;
} else {//发送信息
getMes(contract, info[i][1], info[i][2], combine);
}
}
for (int i = 1; i < combine.length; i++) {
System.out.print(combine[i] + " ");
}
}
//使用BFS广度优先历遍，将每次发文件的操作在当前的关系图进行发送
static void getMes(int contract[][], int n1, int kb, int combine[]) {
int temp[][] = new int[contract.length][contract.length];
for (int i = 0; i < contract.length; i++) {
for (int i1 = 0; i1 < contract.length; i1++) {
temp[i][i1] = contract[i][i1];
}
}
Stack<Integer> stack = new Stack();
stack.push(n1);
combine[n1] += kb;
int total = 0;
int flag[]=new int[contract.length];//用于记录在本次历遍该节点十分已经接收过文件
while (!stack.isEmpty()) {
int node = stack.pop();
for (int i = 1; i < temp[node].length; i++) {
if (temp[node][i] == 1 && i != node ) {
if(flag[i]==0){//若还未接收过则进行接收，否则不在接收
combine[i] += kb;
}
flag[i]=1;
temp[node][i] = 0;//将两点的关系谱清除，以免重复发送
temp[i][node] = 0;//注意这里未无向图，两者是相互的
stack.push(i);
}
}
}
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
