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

第1题：数字三角形问题

(图1)
图1给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。 注意：路径上的每一步只能从一个数走到下一层上和它最近的左边的那个数或者右边的那个数。
时间限制：1000
内存限制：65536
输入
输入的是一行是一个整数N (1 < N <= 100)，给出三角形的行数。下面的N行给出数字三角形。数字三角形上的数的范围都在0和100之间。
输出
输出最大的和。
样例输入
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
样例输出
30

以下是解决该问题的C语言代码实现：

#include 

#define MOD 1000007

int ballInBox(int N, int M, int K) {
    int dp[5001][5001] = {0};

    for (int i = 0; i <= N; i++) {
        for (int j = 1; j <= M && j <= i && j <= K; j++) {
            if (i == j || j == 1) {
                dp[i][j] = 1;
            } else {
                dp[i][j] = (dp[i - 1][j - 1] + dp[i - j][j]) % MOD;
            }
        }
    }

    return dp[N][M];
}

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

    int result = ballInBox(N, M, K);
    printf("%d\n", result);

    return 0;
}

该代码使用动态规划的思想来解决问题。定义一个dp数组，其中dp[i][j]表示将i个球放入j个盒子中的方案数。

通过迭代计算dp数组，同时返回dp[N][M]作为结果，其中N表示球的数量，M表示盒子的数量，K表示每个盒子最多放的球的数量。

对于每个位置(i, j)，dp[i][j]的值可以通过以下方式计算：

• 当i等于j或者j等于1时，表示球的数量等于盒子的数量或者只有一个盒子，这种情况下只有一种方案，即dp[i][j]等于1。

• 当i大于j且j大于1时，dp[i][j]等于dp[i-1][j-1] + dp[i-j][j]，即将一个球放入第j个盒子或者将一个盒子空出来，然后将剩余的球放入这j个盒子中的方案数之和。

最后，返回dp[N][M]模1000007后的结果。

希望以上代码和解题思路对你有帮助！

第2题：大盗

阿福是一名经验丰富的大盗。趁着月黑风高，阿福打算今晚洗劫一条街上的店铺。
这条街上一共有 N 家店铺，每家店中都有一些现金。阿福事先调查得知，只有当他同时洗劫了两家相邻的店铺时，街上的报警系统才会启动，然后警察就会蜂拥而至。
作为一向谨慎作案的大盗，阿福不愿意冒着被警察追捕的风险行窃。他想知道，在不惊动警察的情况下，他今晚最多可以得到多少现金?
时间限制：1000
内存限制：65536
输入
输入的第一行是一个整数 T (T <= 50) ，表示一共有 T 组数据。 接下来的每组数据，第一行是一个整数 N (1 <= N <= 100, 000) ，表示一共有 N 家店铺。第二行是 N 个被空格分开的正整数，表示每一家店铺中的现金数量。每家店铺中的现金数量均不超过 1000 。
输出
对于每组数据，输出一行。该行包含一个整数，表示阿福在不惊动警察的情况下可以得到的现金数量。
样例输入
2
3
1 8 2
4
10 7 6 14
样例输出
8
24
提示
对于第一组样例，阿福选择第 2 家店铺行窃，获得的现金数量为 8 。 对于第二组样例，阿福选择第 1 和 4 家店铺行窃，获得的现金数量为 10 + 14 = 24 。

以下是解决该问题的C语言代码实现：

#include 

int maxRobbery(int houses[], int n) {
    int dp[n + 1];
    dp[0] = 0;
    dp[1] = houses[0];

    for (int i = 2; i <= n; i++) {
        dp[i] = (dp[i - 1] > dp[i - 2] + houses[i - 1]) ? dp[i - 1] : dp[i - 2] + houses[i - 1];
    }

    return dp[n];
}

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

    while (T--) {
        int N;
        scanf("%d", &N);

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

        int maxCash = maxRobbery(houses, N);
        printf("%d\n", maxCash);
    }

    return 0;
}

该代码使用动态规划的思想来解决问题。定义一个dp数组，其中dp[i]表示洗劫前i家店铺时可以得到的最大现金数量。通过迭代计算dp数组，最后返回dp[N]作为结果，其中N是店铺数量。

解题思路如下：

（1）首先，我们可以使用动态规划来解决这个问题。定义一个dp数组，其中dp[i]表示洗劫前i家店铺时可以得到的最大现金数量。

（2）初始化dp[0]为0，表示没有店铺可洗劫时，得到的现金数量为0。dp[1]为第一家店铺的现金数量，因为只有一家店铺可洗劫时，得到的现金数量就等于这家店铺的现金数量。

（3）对于每一家店铺，我们有两种选择：洗劫或者不洗劫。如果我们选择洗劫第i家店铺，那么我们就不能洗劫第i-1家店铺（因为相邻店铺会触发报警系统），所以得到的现金数量为dp[i-2] + houses[i-1]。如果我们选择不洗劫第i家店铺，那么得到的现金数量为dp[i-1]。我们选择两者中的较大值作为dp[i]的值。

（3）最后，返回dp[N]作为结果，其中N是店铺数量。

通过以上步骤，我们可以得到阿福在不惊动警察的情况下可以得到的最大现金数量。

第3题：最大子矩阵

已知矩阵的大小定义为矩阵中所有元素的和。给定一个矩阵，你的任务是找到最大的非空(大小至少是1 * 1)子矩阵。 比如，如下4 * 4的矩阵
0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2
的最大子矩阵是
9 2
-4 1
-1 8
这个子矩阵的大小是15。
时间限制：1000
内存限制：65536
输入
输入是一个N * N的矩阵。输入的第一行给出N (0 < N <= 100)。再后面的若干行中，依次(首先从左到右给出第一行的N个整数，再从左到右给出第二行的N个整数……)给出矩阵中的N2个整数，整数之间由空白字符分隔(空格或者空行)。已知矩阵中整数的范围都在[-127, 127]。
输出
输出最大子矩阵的大小。
样例输入
4
0 -2 -7 0 9 2 -6 2
-4 1 -4 1 -1
8 0 -2
样例输出
15

以下是解决该问题的C语言代码实现：

#include 

int maxSubMatrix(int matrix[][100], int n) {
    int maxSum = matrix[0][0];
    int dp[100][100];

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) {
                dp[i][j] = matrix[i][j];
            } else if (i == 0) {
                dp[i][j] = dp[i][j - 1] + matrix[i][j];
            } else if (j == 0) {
                dp[i][j] = dp[i - 1][j] + matrix[i][j];
            } else {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + matrix[i][j];
            }

            if (dp[i][j] > maxSum) {
                maxSum = dp[i][j];
            }
        }
    }

    return maxSum;
}

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

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

    int maxSum = maxSubMatrix(matrix, N);
    printf("%d\n", maxSum);

    return 0;
}

该代码使用动态规划的思想来解决问题。定义一个dp数组，其中dp[i][j]表示以矩阵中第i行第j列元素为右下角的最大子矩阵的大小。

通过迭代计算dp数组，同时记录最大子矩阵的大小。对于每个位置(i, j)，dp[i][j]的值可以通过以下方式计算：

• 如果(i, j)是矩阵的左上角元素，则dp[i][j]等于matrix[i][j]，即单独一个元素构成的子矩阵的大小。

• 如果(i, j)在第一行上，则dp[i][j]等于dp[i][j-1] + matrix[i][j]，即加上当前列的元素构成的子矩阵的大小。

• 如果(i, j)在第一列上，则dp[i][j]等于dp[i-1][j] + matrix[i][j]，即加上当前行的元素构成的子矩阵的大小。

• 如果(i, j)不在第一行和第一列上，则dp[i][j]等于dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + matrix[i][j]，即加上当前行和当前列的元素构成的子矩阵的大小，同时减去重复计算的部分。

最后，返回dp数组中的最大值作为结果。

第4题：小球放盒子

有N个相同的球，M个不同的盒子，每个盒子最多放K个球
请计算将这N个球全部放入盒子中的方案数模1000007后的结果
时间限制：10000
内存限制：131072
输入
三个正整数，依次为N，M，K
输出
输出方案数模1000007后的结果

样例输入
4 2 3
样例输出
3
提示
总共有3种方案，依次为 { 3 ， 1 }，{ 2 ， 2 }，{ 1 ， 3 }。 对于100%的数据， N，M ≤ 5000

以下是解决该问题的C语言代码实现：

#include 

#define MOD 1000007

int ballInBox(int N, int M, int K) {
    int dp[5001][5001] = {0};

    for (int i = 0; i <= N; i++) {
        for (int j = 1; j <= M && j <= i && j <= K; j++) {
            if (i == j || j == 1) {
                dp[i][j] = 1;
            } else {
                dp[i][j] = (dp[i - 1][j - 1] + dp[i - j][j]) % MOD;
            }
        }
    }

    return dp[N][M];
}

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

    int result = ballInBox(N, M, K);
    printf("%d\n", result);

    return 0;
}

该代码使用动态规划的思想来解决问题。定义一个dp数组，其中dp[i][j]表示将i个球放入j个盒子中的方案数。

通过迭代计算dp数组，同时返回dp[N][M]作为结果，其中N表示球的数量，M表示盒子的数量，K表示每个盒子最多放的球的数量。

对于每个位置(i, j)，dp[i][j]的值可以通过以下方式计算：

• 当i等于j或者j等于1时，表示球的数量等于盒子的数量或者只有一个盒子，这种情况下只有一种方案，即dp[i][j]等于1。

• 当i大于j且j大于1时，dp[i][j]等于dp[i-1][j-1] + dp[i-j][j]，即将一个球放入第j个盒子或者将一个盒子空出来，然后将剩余的球放入这j个盒子中的方案数之和。

最后，返回dp[N][M]模1000007后的结果。