1. 解密(5分)
问题描述
小明设计了一种文章加密的方法：对于每个字母 c，将它变成某个另外的字符 Tc。下表给出了字符变换的规则：
例如，将字符串 YeRi 加密可得字符串 EaFn。
小明有一个随机的字符串，加密后为EaFnjISplhFviDhwFbEjRjfIBBkRyY（由 30 个大小写英文字母组成，不包含换行符），请问原字符串是多少？
（如果你把以上字符串和表格复制到文本文件中，请务必检查复制的内容
是否与文档中的一致。在试题目录下有一个文件 str.txt，第一行为上面的字符
串，后面 52 行依次为表格中的内容。）
答案提交
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
只包含 30 个大小写英文字母的字符串，在提交答案时只填写这个字符串，填写
多余的内容将无法得分。
答案：AyClthSohkCwnDkbCxAtFtchXXjFeE
2. 纪念日(5分)
2020 年 7 月 1 日是中国共产党成立 99 周年纪念日。
中国共产党成立于 1921 年 7 月 23 日。
请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包
含多少分钟？
答案：52,038,720
3. 合并检测(10分)
新冠疫情由新冠病毒引起，最近在 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
4. 分配口罩(10分)
问题描述
某市市长获得了若干批口罩，每一批口罩的数目如下：（如果你把以下文
字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目
录下有一个文件 mask.txt，内容与下面的文本相同）
9090400
8499400
5926800
8547000
4958200
4422600
5751200
4175600
6309600
5865200
6604400
4635000
10663400
8087200
4554000
现在市长要把口罩分配给市内的 2 所医院。由于物流限制，每一批口罩只
能全部分配给其中一家医院。市长希望 2 所医院获得的口罩总数之差越小越好。
请你计算这个差最小是多少？
答案提交
这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个
整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案：2400
public class Main {
public static void main(String[] args) {
int sum = 0 , su = 0;
int[] nums = {
0, 9090400, 8499400, 5926800, 8547000, 4958200,
4422600, 5751200, 4175600, 6309600, 5865200, 6604400, 4635000,
10663400, 8087200, 4554000};
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
su = sum / 2;
int[] dp = new int[su+1];
for (int i = 1; i < nums.length; i++) {
for (int j = su; j >= nums[i]; j--) {
dp[j] = Math.max(dp[j] , dp[j-nums[i]] + nums[i]);
}
}
System.out.println(2 * (su - dp[su]));
}
}
5. 斐波那契数列最大公约数(15分)
斐波那契数列满足 F1 = F2 = 1，从 F3 开始有 F**n = F**nn 1 + F**nn 2。请你计算
GCD(F2020, F520)，其中 GCD(A, B) 表示 A 和 B 的最大公约数。
答案：6765
package competition4;
import java.math.BigInteger;
public class BigNumber
{
public static void main(String[] args)
{
BigInteger a=new BigInteger("1");
BigInteger b=new BigInteger("1");
BigInteger[] fib=new BigInteger[2030];
fib[1]=a;
fib[2]=b;
for(int x=3;x<fib.length;x++)
{
fib[x]=fib[x-1].add(fib[x-2]);
}
a=fib[2020];
b=fib[520];
BigInteger temp;
while(b!=BigInteger.ZERO)
{
temp=a.mod(b);
a=b;
b=temp;
}
System.out.println(a);
}
}
6. 分类计数(15分)
问题描述
输入一个字符串，请输出这个字符串包含多少个大写字母，多少个小写字
母，多少个数字。
输入格式
输入一行包含一个字符串。
输出格式
输出三行，每行一个整数，分别表示大写字母、小写字母和数字的个数。
样例输入
1+a=Aab
样例输出
1
3
1
package competition4;
import java.util.Scanner;
public class CountAllKind
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String str=in.nextLine();
in.close();
int Big=0;
int small=0;
int digtal=0;
for(int x=0;x<str.length();x++)
{
if(str.charAt(x)>='a' && str.charAt(x)<='z')
{
small++;
}
if(str.charAt(x)>='A' && str.charAt(x)<='Z')
{
Big++;
}
if(str.charAt(x)>='0' && str.charAt(x)<='9')
{
digtal++;
}
}
System.out.println(Big);
System.out.println(small);
System.out.println(digtal);
}
}
7. 八次求和(20分)
问题描述
给定正整数 n, 求 1^8 + 2^8 + · · · + n^8 mod 123456789 。其中 mod 表示取余。
输入格式
输入的第一行包含一个整数 n。
输出格式
输出一行，包含一个整数，表示答案。
样例输入
2
样例输出
257
样例输入
987654
样例输出
43636805
评测用例规模与约定
对于 20% 的评测用例，1 ≤ n ≤ 20。
对于 60% 的评测用例，1 ≤ n ≤ 1000。
对于所有评测用例，1 ≤ n ≤ 1000000。
package competition4;
import java.util.Scanner;
public class SumEight
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
long n=in.nextLong();
in.close();
int mod=123456789;
long result=0;
long temp=1;
for(long x=1;x<=n;x++)
{
//下面一个for循环就是得到x的八次方的值,每一次都初始化temp的值
temp=1;
for(int y=1;y<=4;y++)
{
temp =(temp*((x*x) %mod))%mod;
}
//将x的八次方加起来,进入下一个x的八次方
result =(result+temp)%mod;
}
System.out.println(result);
}
}
8. 字符串编码(20分)
问题描述
小明发明了一种给由全大写字母组成的字符串编码的方法。对于每一个大写字母，小明将它转换成它在 26 个英文字母中序号，即 A → 1, B → 2, … Z →26。
这样一个字符串就能被转化成一个数字序列：比如 ABCXYZ → 123242526。
现在给定一个转换后的数字序列，小明想还原出原本的字符串。当然这样的还原有可能存在多个符合条件的字符串。小明希望找出其中字典序最大的字符串。
输入格式
一个数字序列。
输出格式
一个只包含大写字母的字符串，代表答案
样例输入
123242526
样例输出
LCXYZ
评测用例规模与约定
对于 20% 的评测用例，输入的长度不超过 20。
对于所有评测用例，输入的长度不超过 200000。
package competition4;
import java.util.Scanner;
public class StringCode
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String str=in.nextLine();
String result="";
String temp="";
for(int x=0;x<str.length();)
{
if(str.charAt(x)=='1'&&x+1<str.length())
{
temp +=str.charAt(x);
x++;
temp +=str.charAt(x);
result +=(char)(Integer.valueOf(temp)+65-1);
temp="";
x++;
}
else if(str.charAt(x)=='2'&&x+1<str.length())
{
if(str.charAt(x+1)>='0'&&str.charAt(x+1)<='6')
{
temp +=str.charAt(x);
x++;
temp +=str.charAt(x);
result +=(char)(Integer.valueOf(temp)+65-1);
temp="";
x++;
}
}
else if(x<str.length())
{
temp +=str.charAt(x);
result +=(char)(Integer.valueOf(temp)+65-1);
temp="";
x++;
}
}
System.out.println(result);
in.close();
}
}
9. 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.BufferedInputStream;
import java.util.*;
public class bst插入重写 {
public static void main(String[] args) {
Scanner sc = new Scanner(new BufferedInputStream(System.in));
int N = sc.nextInt();
int findNode = sc.nextInt();
node[] list = new node[N + 1];
for (int i = 1; i < list.length; i++) {
if(i==1){
list[i] = new node(sc.nextInt(), sc.nextInt());
continue;
}
list[i] = new node(sc.nextInt(), sc.nextInt());
node fa = list[list[i].fa];
if (list[i].val > fa.val) {
fa.right = list[i];
} else {
fa.left = list[i];
}
}
int findValue=list[findNode].val;
dfs(list[1]);
int size=li.size();
for(int i =0;i<size;i++){
if(li.get(i)==findValue){
if(i==0||i==size-1){
System.out.println(-1);
return;
}else{
int sum=0;
if(list[findNode].left!=null){
int pre=li.get(i-1);
sum+=findValue-pre-1;
}
if(list[findNode].right!=null){
int la=li.get(i+1);
sum+=la-findValue-1;
}
System.out.println(sum);
return ;
}
}
}
}
static ArrayList<Integer> li=new ArrayList<Integer>();
public static void dfs(node root){
if(root==null)return ;
dfs(root.left);
li.add(root.val);
dfs(root.right);
}
public static class node {
int fa;
int val;
node right;
node left;
public node(int fa, int val) {
this.fa = fa;
this.val = val;
}
}
}
10. 网络分析(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。
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn=10005;
int a[maxn][maxn];
int dfs_vis[maxn];
int n,m;
struct Node{
int data;
}Point[maxn];
void DFS(int a[maxn][maxn],int x,int y)
{
Point[x].data += y;
dfs_vis[x]=1;
for(int i=1;i<=n;i++)
{
if( a[x][i]==1 && dfs_vis[i]==0 )
{
DFS(a,i,y);
}
}
}
int main()
{
cin >> n >> m;
cin.get();
for(int i=1;i<=m;i++)
{
int flag,x1,x2;
scanf("%d %d %d",&flag,&x1,&x2);
if(flag==1)
{
a[x1][x2]=a[x2][x1]=1;
}
else if(flag==2)
{
memset(dfs_vis,0,sizeof(dfs_vis));
DFS(a,x1,x2);
}
}
for(int i=1;i<=n;++i)
{
cout << Point[i].data <<" ";
}
return 0;
}