蓝桥杯第十届部分题解

试题 A: 组队

本题总分：5 分
【问题描述】 作为篮球队教练，你需要从以下名单中选出 1 号位至 5 号位各一名球员， 组成球队的首发阵容。 每位球员担任 1 号位至 5 号位时的评分如下表所示。请你计算首发阵容 1 号位至 5 号位的评分之和最大可能是多少？

（如果你把以上文字复制到文本文件中，请务必检查复制的内容是否与文 档中的一致。在试题目录下有一个文件 team.txt，内容与上面表格中的相同， 请注意第一列是编号）
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答：97 + 99 + 99 + 97 + 98 = 490

注意：选择各号位置得分最高的，且每个人只能选择一个位置。

试题 B: 年号字串

本题总分：5 分
【问题描述】 小明用字母 A 对应数字 1，B 对应 2，以此类推，用 Z 对应 26。对于 27 以上的数字，小明用两位或更长位的字符串来对应，例如 AA 对应 27，AB 对 应 28，AZ 对应 52，LQ 对应 329。 请问 2019 对应的字符串是什么？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个大写英文字符串，在提交答案时只填写这个字符串，注意全部大写，填写多 余的内容将无法得分。

答：BYQ

可以看做26进制的转换 'A’对应的ascll码是64

#include <stdio.h> 
int main() {
    char a[5] = {0};
    int n = 2019, i = 0;
    //十进制转换为二十六进制 
    for (i = 0; n != 0; i++) {
        a[i] = n % 26 + 64;
        n = n / 26;
    }
    //翻转字符串，并输出 
    while (i >= 0) {
        printf("%c", a[i--]);
    }
    return 0;
}

试题 C: 数列求值

本题总分：10 分
【问题描述】 给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个 4 位整数（提示：答案的千位不为 0），在提交答案时只填写这个整数，填写 多余的内容将无法得分。

答：4659

#include <stdio.h>
int a[20190325] = {0}; //数组空间太大，要放到main外面
int main(){
    a[0] = 1, a[1] = 1, a[2] = 1;
    int i;
    for (i = 3; i < 20190324; i++)
    {
        a[i] = (a[i - 1] + a[i - 2] + a[i - 3]) % 10000;  //只求后四位 
    }
    printf("%d\n",a[20190323]); //从0计数，因此输出20190323 
    return 0;
} 

试题 D: 数的分解

本题总分：10 分
【问题描述】 把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包 含数字 2 和 4，一共有多少种不同的分解方法？ 注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

答：40785

#include <stdio.h>
//检查是否含有2或4 
int check(int n) {
    while (n != 0) {
        int a = n % 10;
        n = n / 10;
        if (a == 2 || a == 4) {
            return 0;
        }
    }
    return 1;
}
int main() {
    int i, j, k;
    int count = 0;
    for (i = 1; i < 2019; i++) {
        for (j = i + 1; j < 2019; j++) {
            k = 2019 - i - j;
            if(check(i) && check(j) && check(k) && k > j) {
                count ++;
            } // i, j, k都不含2或4 且ijk为升序时可以避免重复方法 
        }
    }
    return count;
} 

试题 F: 特别数的和

时间限制: 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。

#include <stdio.h> 
//判断是否含有2、0、1、9 
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, sum = 0;
    scanf ("%d", &n);
    for (int i = 1; i <= n; i++) {
        if (check(i)) {
        sum = sum + i;
        }
    }
    printf ("%d", sum);
    return 0;
}

试题 G: 完全二叉树的权值

时间限制: 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 <stdio.h>
//求a^b函数 
int pow(int a, int b) {
    int t = 1;
    for (int i = 1; i <= b; i++) {
        t = t * a;
    }
    return t;
}
int main() {
    int depth = 0, max_depth = 0;
    int n;
    int sum = 0;
    long long max_sum = -10000000000;
    int arr[100001] = {0}; //定义数组 
    scanf ("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf ("%d", &arr[i]);
        sum = sum + arr[i];
        //分别算出第一项的和，第2-3的和，第4-7的和，等等。深度加一 指数加一 找出最大sum值 
        if (i == pow(2, depth) - 1) {
            if (sum > max_sum) {
                max_depth = depth;
                max_sum = sum;
            }
            depth++;
            sum = 0;
        }
    }
    printf("%d", max_depth);
    return 0;
} 

试题 H: 等差数列

时间限制: 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 ≤109。

#include <stdio.h> 
//快速排序 
void quickSort (int *a, int left, int right) {
    if (left < right) {
        int i = left, j = right, temp = a[left];
        while (i < j) {
            while (i < j && a[j] >= temp) {
                j--;
            }
            if (i < j) {
                a[i] = a[j];
            }
            while (i < j && a[i] <= temp) {
                i++;
            }
            if (i < j) {
                a[j] = a[i];
            }
        }
        a[i] = temp;
        quickSort(a, left, i-1);
        quickSort(a, i+1, right);
    }
}
int main() {
    int N, i, count = 1;
    int arr[100001] = {0};
    scanf ("%d", &N);
    //输入数组 
    for (i = 0; i < N; i++) {
        scanf ("%d", &arr[i]);
    }
    //快排 
    quickSort(arr, 0, N-1);
    //求公差 
    int d = arr[1] - arr[0];
    for (i = 2; i < N; i++) {
        if (arr[i] - arr[i - 1] < d) {
            d = arr[i] - arr[i - 1];
        }
    }
    //求项数 （也可以直接用等差数列求项数公式count = (arr[N-1] - arr[0]) / d + 1）
    while (arr[0] != arr[N-1]) {
        arr[0] = arr[0] + d;
        count++;
    }
    printf ("%d", count);
    return 0;
} 

试题 I: 后缀表达式

时间限制: 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。
【输出格式】
输出一个整数，代表答案。

【样例输入】 1 1 1 2 3
【样例输出】 4

【评测用例规模与约定】 对于所有评测用例，0≤ N,M ≤100000，−109 ≤ Ai ≤109。

#include <stdio.h> 
//快速排序 
void quickSort(int *a, int left, int right) {
    if(left < right) {
        int i = left, j = right, temp = a[left];
        while (i < j) {
            while (i < j && a[j] >= temp) {
                j--;
            }
            if (i < j) {
                a[i] = a[j];
            }
            while (i < j && a[i] <= temp) {
                i++;
            }
            if (i < j) {
                a[j] = a[i];
            } 
        }
        a[i] = temp;
        quickSort(a, left, i - 1);
        quickSort(a, i + 1, right);
    }
}
int main() {
    int N, M;
    scanf("%d %d", &N, &M);
    int sum = 0;
    int arr[200001] = {0};
    //输入数组 
    for (int i = 0; i < N+M+1; i++) {
        scanf ("%d", &arr[i]);
    }
    //排序 
    quickSort(arr, 0, N+M);
    //M个较小数按减法计算 
    for (int i = 0; i < M; i++) {
        sum = sum - arr[i];
    }
 //N个较大数按加法计算 
    for (int i = M; i < N+M+1; i++) {
        sum = sum + arr[i];
    }
    printf ("%d", sum);
    return 0;
}