2020年12月 C/C++（三级）真题解析#中国电子学会#全国青少年软件编程等级考试

C/C++编程（1~8级）全部真题・点这里

第1题：完美立方

形如 a^3= b^3 + c^3 + d^3的等式被称为完美立方等式。例如 12^3= 6^3 + 8^3 + 10^3 。
编写一个程序，对任给的正整数 N (N≤100)，寻找所有的四元组 (a, b, c, d)，使得 a^3= b^3 + c^3 + d^3 ，其中 a,b,c,d均大于 11, 小于等于 N，且 b≤c≤d 。
时间限制：1000
内存限制：65536
输入
一个正整数 N(N≤100)。
输出
每行输出一个完美立方。输出格式为：
Cube = a, Triple = (b,c,d)
其中 a,b,c,d 所在位置分别用实际求出四元组值代入。
请按照 a 的值，从小到大依次输出。
当两个完美立方等式中 a 的值相同，则 b 值小的优先输出、仍相同则 c 值小的优先输出。
样例输入
24
样例输出
Cube = 6, Triple = (3,4,5)
Cube = 12, Triple = (6,8,10)
Cube = 18, Triple = (2,12,16)
Cube = 18, Triple = (9,12,15)
Cube = 19, Triple = (3,10,18)
Cube = 20, Triple = (7,14,17)
Cube = 24, Triple = (12,16,20)

下面是一个使用C语言实现的解决方案，可以找到满足完美立方等式的四元组 (a, b, c, d)：

#include 

void find_perfect_cubes(int N) {
    for (int a = 2; a <= N; a++) {
        for (int b = 2; b <= N; b++) {
            for (int c = b; c <= N; c++) {
                for (int d = c; d <= N; d++) {
                    if (a * a * a == b * b * b + c * c * c + d * d * d) {
                        printf("Cube = %d, Triple = (%d,%d,%d)\n", a, b, c, d);
                    }
                }
            }
        }
    }
}

int main() {
    int N;
    scanf("%d", &N);

    find_perfect_cubes(N);

    return 0;
}

这个实现中，我们使用四重循环来遍历所有可能的四元组 (a, b, c, d)。其中，a从2到N，b从2到N，c从b到N，d从c到N。对于每个四元组，判断是否满足完美立方等式 a^3 = b^3 + c^3 + d^3 ，如果满足，则输出该四元组。

在main函数中，我们读取输入的N，并调用find_perfect_cubes函数找到满足条件的四元组。然后，我们按照要求输出每个完美立方等式的结果。

注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。

第2题：不定方程求解

给定正整数a，b，c。求不定方程 ax+by=c 关于未知数x和y的所有非负整数解组数。
时间限制：1000
内存限制：65536
输入
一行，包含三个正整数a，b，c，两个整数之间用单个空格隔开。每个数均不大于1000。
输出
一个整数，即不定方程的非负整数解组数。
样例输入
2 3 18
样例输出
4

下面是一个使用C语言实现的解决方案，可以求解不定方程 ax+by=c 的非负整数解组数：

#include 

int count_solutions(int a, int b, int c) {
    int count = 0;
    for (int x = 0; x <= c / a; x++) {
        int remainder = c - a * x;
        if (remainder % b == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    int num_solutions = count_solutions(a, b, c);
    printf("%d\n", num_solutions);

    return 0;
}

这个实现中，我们定义了一个辅助函数count_solutions，用于计算不定方程的非负整数解组数。在函数中，我们使用一个循环来遍历所有可能的x值，其中x的范围是从0到c/a。对于每个x值，我们计算对应的余数remainder = c - a * x，并检查remainder是否能被b整除。如果能整除，则表示存在一个满足条件的非负整数解组，计数器count加1。

在main函数中，我们读取输入的a、b、c，并调用count_solutions函数计算解组数。然后，我们输出解组数。

注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。

第3题：分解因数

给出一个正整数 a ，要求分解成若干个正整数的乘积，即 a = a1· a2 ·a3·…·an，并且 1 注意到 a = a 也是一种分解。
时间限制：1000
内存限制：65536
输入
第 1 行是测试数据的组数 n(1≤n≤1000) ，后面跟着 n 行输入。每组测试数据占 1 行，包括一个正整数 a (1 输出
n 行，每行输出对应一个输入。输出应是一个正整数，指明满足要求的分解的种数。
样例输入
2
2
20
样例输出
1
4

下面是一个使用C语言实现的解决方案，可以计算给定正整数a的分解因数的种数：

#include 

int count_factors(int n) {
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            count++;
        }
    }
    return count;
}

int main() {
    int n;
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        int a;
        scanf("%d", &a);

        int num_factors = count_factors(a);
        printf("%d\n", num_factors);
    }

    return 0;
}

这个实现中，我们定义了一个辅助函数count_factors，用于计算给定正整数n的因数个数。在函数中，我们使用一个循环来遍历从1到n的所有数，如果某个数能整除n，则计数器count加1。

在main函数中，我们首先读取输入的测试数据组数n。然后，使用一个循环来处理每组测试数据。对于每组数据，我们读取输入的正整数a，并调用count_factors函数计算分解因数的种数。最后，我们输出结果。

注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。

第4题：上台阶

楼梯有 n(1≤n≤30) 阶台阶,上楼时可以一步上 1 阶,也可以一步上 2 阶,也可以一步上 3 阶，编程计算共有多少种不同的走法。
时间限制：1000
内存限制：65536
输入
输入的每一行包括一组测试数据，即为台阶数 n(1≤n≤30) 。最后一行为0，表示测试结束。
输出
每一行输出对应一行输入的结果，即为走法的数目。
样例输入
1
2
3
4
0
样例输出
1
2
4
7

下面是一个使用C语言实现的解决方案，可以计算给定台阶数n的不同走法数量：

#include 

int count_ways(int n) {
    if (n <= 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else if (n == 2) {
        return 2;
    } else if (n == 3) {
        return 4;
    } else {
        int ways[n+1];
        ways[1] = 1;
        ways[2] = 2;
        ways[3] = 4;
        for (int i = 4; i <= n; i++) {
            ways[i] = ways[i-1] + ways[i-2] + ways[i-3];
        }
        return ways[n];
    }
}

int main() {
    int n;
    while (1) {
        scanf("%d", &n);
        if (n == 0) {
            break;
        }
        int num_ways = count_ways(n);
        printf("%d\n", num_ways);
    }

    return 0;
}

这个实现中，我们定义了一个辅助函数count_ways，用于计算给定台阶数n的不同走法数量。在函数中，我们使用动态规划的思想来计算走法数量。对于n大于3的情况，我们使用一个数组ways来保存每个台阶数对应的走法数量。初始情况下，我们已知1阶有1种走法，2阶有2种走法，3阶有4种走法。然后，我们从4阶开始迭代计算每个台阶数的走法数量，通过累加前面三个台阶数的走法数量得到当前台阶数的走法数量。最后，我们返回数组ways中n阶对应的走法数量。

在main函数中，我们使用一个循环来读取输入的台阶数n，并调用count_ways函数计算走法数量。当输入的台阶数为0时，表示测试结束，循环结束。

注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。

第5题：田忌赛马

在田忌赛马的故事中，孙膑用自己的下等马对战对手的上等马，自己上等马对阵对手的中等马，自己的中等马对阵对手的下等马，从而赢得了胜利。现在即将进行的是N匹马的赛马比赛。双方队伍的马各分为N等。已知只有当我方马的等级比对方马等级高 X 等以上（包含 X ）时，我方才可以取得这场比赛的胜利。如果在N场比赛中我方的胜场数大于对方，则我方取得最终的胜利。现在已知对方这 N 场比赛的出战方案，请计算所有令我方最终获胜的出战方案。
时间限制：1000
内存限制：65536
输入
第一行两个整数， N 和 X 。0≤X 输出
按字典序输出所有我方最终获胜的方案，每个方案一行。每行是 N 个正整数，两两之间以一个空格分隔，第 i 个数表示我方第 i 场比赛马的等级。
样例输入
样例输入1
3 1
3 2 1
样例输入2
3 0
3 1 2
样例输出
样例输出1
1 3 2
样例输出2
1 2 3
1 3 2
2 1 3
3 1 2
3 2 1

下面是一个使用C语言实现的解决方案，可以计算所有使我方最终获胜的出战方案：

#include 
#include 

int N, X;
int opponent[10];
int used[10];
int my_horses[10];

int compare(const void *a, const void *b) {
    return *(int*)a - *(int*)b;
}

void dfs(int idx) {
    if (idx == N) {
        for (int i = 0; i < N; i++) {
            printf("%d ", my_horses[i]);
        }
        printf("\n");
        return;
    }

    for (int i = 0; i < N; i++) {
        if (!used[i] && my_horses[idx - 1] - opponent[i] >= X) {
            used[i] = 1;
            my_horses[idx] = opponent[i];
            dfs(idx + 1);
            used[i] = 0;
        }
    }
}

int main() {
    scanf("%d %d", &N, &X);

    for (int i = 0; i < N; i++) {
        scanf("%d", &opponent[i]);
    }

    qsort(opponent, N, sizeof(int), compare);

    my_horses[0] = 10; // 设置一个较大的初始值

    dfs(0);

    return 0;
}

这个实现中，我们使用深度优先搜索（DFS）算法来生成所有可能的我方出战方案。我们使用一个全局数组opponent来存储对方马的等级，并根据题目要求进行排序。我们还使用一个全局数组used来标记对方马是否被使用过，以及一个全局数组my_horses来存储我方马的等级。

在dfs函数中，我们通过递归实现深度优先搜索。在每个递归层级中，我们检查所有未被使用的对方马，并且满足我方马的等级比对方马等级高X以上的条件。对于满足条件的对方马，我们将其标记为已使用，并将其添加到我方马的等级数组my_horses中。然后，我们继续递归调用dfs函数，进入下一个递归层级。当递归到最后一层时，即完成了一种出战方案的生成，我们将生成的出战方案输出。

在main函数中，我们首先读取输入的N和X，并读取对方马的等级，并对对方马的等级进行排序。然后，我们调用dfs函数开始进行深度优先搜索，生成所有可能的我方出战方案。

注意：在实际编写和运行代码时，请确保输入数据的格式和范围符合题目要求，并进行必要的错误处理。