目录
1.组队
组队 本题总分:5 分
【问题描述】
作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。
每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少?
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
就是直接搜，答案490
#include<bits/stdc++.h>
using namespace std;
int team[20][6];
int vis[20];
int max_sum = 0;
void dfs(int index, int sum){
if(index == 6){
max_sum = max(max_sum, sum);
return;
}
for(int i = 0; i < 20; i++){
if(!vis[i]){
vis[i] = 1;
dfs(index + 1, sum + team[i][index]);
vis[i] = 0;
}
}
}
int main(){
freopen("team.txt", "r", stdin); //这里看一下，19年的蓝桥杯挺多用这个的
for(int i = 0; i < 20; i++)
for(int j = 0; j < 6; j++)
cin>>team[i][j];
dfs(1, 0);
cout<<max_sum<<endl;
return 0;
}2.年号字串
B: 年号字串 本题总分:5 分
【问题描述】
小明用字母 A 对应数字 1，B 对应 2，以此类推，用 Z 对应 26。对于 27 以上的数字，小明用两位或更长位的字符串来对应，例如 AA 对应 27，AB 对 应 28，AZ 对应 52，LQ 对应 329。
请问 2019 对应的字符串是什么?
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个大写英文字符串，在提交答案时只填写这个字符串，注意全部大写，填写多 余的内容将无法得分。
参考十进制转二进制的计算方法，从个位往前算，不用代码的话，自己算也花不了多长时间，结果时BYQ
#include<bits/stdc++.h>
using namespace std;
int main(){
string str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char ans[5];
int index = 0;
int n = 2019;
while(n){
int t = n % 26;
n = n / 26;
ans[index] = str[t - 1];
index++;
}
for(int i = index - 1; i >= 0; i--){
cout<<ans[i];
}
return 0;
}3.数列求值
数列求值 本题总分:10 分
【问题描述】
给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个 4 位整数(提示:答案的千位不为 0)，在提交答案时只填写这个整数，填写 多余的内容将无法得分。
根据题目来，前三位单独给，后面的不断加，同时模上10000就行，结果是4659
#include<bits/stdc++.h>
using namespace std;
int f[20190324];
int main(){
f[0] = f[1] = f[2] = 1;
for(int i = 3; i < 20190324; i++){
f[i] = (f[i - 1] + f[i - 2] + f[i - 3]) % 10000;
}
cout<<f[20190323]<<endl;
return 0;
}4.数的分解
数的分解 本题总分:10 分
【问题描述】
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，一共有多少种不同的分解方法?
注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
不包含2和4的丢进循环里检验，符合条件就加一，不符合就下一个，答案40785
#include<bits/stdc++.h>
using namespace std;
int check(int n){
while(n){
int t = n % 10;
n = n / 10;
if(t == 2 || t == 4)
return 0;
}
return 1;
}
int main(){
int ans = 0;
for(int i = 1; i <2019; i++){
if(check(i))
for(int j = i + 1; j <2019; j++){
if(check(j)){
int k = 2019 - i - j;
if(k > j && check(k))
ans++;
}
}
}
cout<<ans<<endl;
return 0;
}5.迷宫
回头写，我先研究研究
6.特别数求和
时间限制: 1.0s 内存限制: 256.0MB 本题总分:15 分
【问题描述】
小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0)，在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。
请问，在 1 到 n 中，所有这样的数的和是多少? 【输入格式】
输入一行包含两个整数 n。 【输出格式】
输出一行，包含一个整数，表示满足条件的数的和。
【样例输入】
40
【样例输出】
574
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n ≤ 10。 对于 50% 的评测用例，1 ≤ n ≤ 100。 对于 80% 的评测用例，1 ≤ n ≤ 1000。 对于所有评测用例，1 ≤ n ≤ 10000。
这题跟前面那个转换的题差不多，含有2，0，1，9的进去，
#include<bits/stdc++.h> using namespace std; int check(int n){ while(n){ int t = n % 10; n = n / 10; if(t == 2 || t == 0 || t == 1 || t == 9) return 1; } return 0; } int main(){ int n; int sum = 0; cin>>n; for(int i = 1; i <= n; i++){ if(check(i)){ sum += i; } } cout<<sum<<endl; return 0; }
7.完全二叉树的权值
完全二叉树的权值
时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分
【问题描述】
给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从 上到下、从左到右的顺序依次是 A1, A2, · · · AN，如下图所示:
现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点 权值之和最大?如果有多个深度的权值和同为最大，请你输出其中最小的深度。
注:根的深度是 1。 【输入格式】
第一行包含一个整数 N。 第二行包含N个整数A1,A2,··· AN。
【输出格式】
输出一个整数代表答案。
【样例输入】
7
1 6 5 4 3 2 1
【样例输出】
2
【评测用例规模与约定】
对于所有评测用例，1 ≤ N ≤ 100000，−100000 ≤ Ai ≤ 100000。
#include<bits/stdc++.h>
using namespace std;
int Ai[100005];
int main(){
int N;
int deep = 1;
int sum = 0;
long long max_sum = -100000000000;
int max_deep = 1;
cin>>N;
for(int i = 1; i <= N; ++i){
cin>>Ai[i];
sum += Ai[i];
if(i == pow(2, deep) - 1){
if(max_sum < sum){
max_deep = deep;
max_sum = sum;
}
sum = 0;
++deep;
}
}
cout<<max_deep<<endl;
return 0;
}8.等差数列
时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分
【问题描述】
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一 部分的数列，只记得其中 N 个整数。
现在给出这 N 个整数，小明想知道包含这 N 个整数的最短的等差数列有 几项?
【输入格式】
输入的第一行包含一个整数 N。 第二行包含N个整数A1,A2,···,AN。(注意A1 ∼AN并不一定是按等差数
列中的顺序给出) 【输出格式】
输出一个整数表示答案。
【样例输入】
5
2 6 4 10 20
【样例输出】
10
【样例说明】
包含 2、6、4、10、20 的最短的等差数列是 2、4、6、8、10、12、14、16、 18、20。
【评测用例规模与约定】
对于所有评测用例，2 ≤ N ≤ 100000，0 ≤ Ai ≤ 10^9
先从小到大排序，然后求相邻两个数的最大公因数作为公差
#include<bits/stdc++.h>
using namespace std;
int Ai[100005];
int main(){
int N;
cin>>N;
for(int i = 0; i < N; i++)
cin>>Ai[i];
sort(Ai, Ai + N);
int min_d = Ai[1] - Ai[0];
if(min_d == 0)
cout<<N<<endl;
else{
int gcd = min_d;
for(int i = 2; i < N; i++){
min_d = __gcd(min_d, Ai[i] - Ai[i - 1]);
}
cout<<(Ai[N - 1] - Ai[0]) / min_d + 1<<endl;
}
return 0;
}9.后缀表达式
时间限制: 1.0s 内存限制: 256.0MB 本题总分:25 分
【问题描述】
给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1, A2, · · · , AN+M+1，小 明想知道在所有由这 N 个加号、M 个减号以及 N + M + 1 个整数凑出的合法的 后缀表达式中，结果最大的是哪一个?
请你输出这个最大的结果。
例如使用1 2 3 + -，则 “2 3 + 1 -” 这个后缀表达式结果是 4，是最大的。
【输入格式】
第一行包含两个整数 N 和 M。
第二行包含 N + M + 1 个整数 A1, A2, · · · , AN+M+1。
【输出格式】
输出一个整数，代表答案。
【样例输入】
11 123
【样例输出】
4
【评测用例规模与约定】
对于所有评测用例，0 ≤ N, M ≤ 100000，−10^9 ≤ Ai ≤ 10^9。
目标是让绝对值大的数作为正的，让绝对值小的数作为负的或者说被减数
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;
bool cmp(int a, int b){
return abs(a)>abs(b)? true: false;
}
int main(){
int n,m,mid;
long long ans = 0;
vector<int> num;
cin>>n>>m;
for(int i = 0; i < n+m+1; i++){
cin>>mid;
num.push_back(mid);
}
sort(num.begin(),num.end(),cmp);//按照绝对值从大到小排序
vector<int>::iterator it = num.begin();
if(*it<0){//如果第一个数为负数，则我们使用一个减号，然后加上我们加的一个加号，否则消耗一个加号，M、N不需要变
m++;
n--;
}
ans = abs(*it);
it++;
for( ; it != num.end(); it++){
if(*it >= 0){
if(n){//有加号的时候，加正数。
ans += *it;
n--;
} else{//加号用完之后只能减正数
ans -= *it;
m--;
}
} else{
if(m){//有减号的时候 减负数
ans -= *it;
m--;
} else{//没减号的时候 加负数
ans += *it;
n--;
}
}
}
cout<<ans;
return 0;
}
10.灵能传输
题目说的太多，简单意思就是，两边的数可以拿中间的数的能量， 让求他的最小不稳定度
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <iterator>
#include <fstream>
using namespace std;
long long dp[3][305] ={0};
int max_n(int a,int b,int c){
return a>=b&&a>=c ? a :( b >= c ? b :c );
}
bool cmp(int a, int b){
return abs(a) > abs(b) ? true : false;
}
int main(){
int t,n[3],ans[3],mid2;
char z;
cin>>t;
for(int i = 0; i < t; i++){
cin>>n[i];
for(int j = 0; j < n[i]; j++){
scanf("%l64d", &dp[i][j]);//蓝桥杯的long long需要用%l64d才能读
}
}
for(int i = 0; i < t; i++){
for(int j = 1; j < n[i] - 1; j++){
while(max_n(abs(dp[i][j-1]+dp[i][j]),abs(-dp[i][j]),abs(dp[i][j+1]+dp[i][j])) < max_n(abs(dp[i][j-1]),abs(dp[i][j+1]),abs(dp[i][j+1]))){
dp[i][j-1] = dp[i][j-1] + dp[i][j];
dp[i][j+1] = dp[i][j+1] + dp[i][j];
dp[i][j] = -dp[i][j];
}
}
sort(dp[i],dp[i]+n[i],cmp);
ans[i] = abs(dp[i][0]);
}
for(int i = 0; i < t; i++)
cout<<ans[i]<<endl;
return 0;
}
总结来说，我觉得19年的题比20年难了很多，有很多绕的地方，也可能是我掌握的知识点正好适合20年的
1676
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
