二期校赛

一桌多少人.c

@@ -0,0 +1,40 @@
+// 【问题描述】
+// 小蓝准备请自己的朋友吃饭。小蓝朋友很多，最终吃饭的人总数达 2024 人（包括他自己）。
+
+// 请问如果每桌最多坐 n 人，最少要多少桌才能保证每个人都能吃饭。
+
+// 【输入格式】
+// 输入一行包含一个整数 n 。
+
+// 【输出格式】
+// 输出一行包含一个整数，表示最少的桌数。
+
+// 【样例输入】
+// 10
+
+// 【样例输出】
+// 203
+
+// 【样例输入】
+// 8
+
+// 【样例输出】
+// 253
+
+// 【评测用例规模与约定】
+// 对于所有评测用例，1 <= n <= 2024。
+
+
+
+#include <stdio.h>
+
+int main() {
+    int n;
+    scanf("%d", &n);
+    int result = 2024 / n;
+    if (2024 % n != 0) {
+        result++;
+    }
+    printf("%d\n", result);
+    return 0;
+}

口矩阵.c

@@ -0,0 +1,106 @@
+// 问题描述】
+// 小蓝有一个 n 行 m 列的矩阵 a[i][j] ，他想在矩阵中找出一个“口”字形状的区域，使得区域上的值的和最大。
+
+// 具体讲，一个“口”字形状的区域可以由两个坐标 (x1, y1) 和 (x2, y2) 确定，满足：
+
+// 1 <= x1 < x2 <= n ；
+// 1 <= y1 < y2 <= m ；
+// x2 - x1 = y2 - y1 。
+// 对应的区域由满足以下条件之一的点 (x, y) 构成：
+
+// x1 <= x <= x2，且 y = y1 ，对应“口”的左边一竖；
+// y1 <= y <= y2，且 x = x1 ，对应“口”的上面一横；
+// x1 <= x <= x2，且 y = y2 ，对应“口”的右边一竖；
+// y1 <= y <= y2，且 x = x2 ，对应“口”的下面一横。
+// 请注意有些点满足以上条件的多个，例如左上角的点 (x1, y1) ，在计算时算为一个点。
+
+// 区域上的值是指对应区域的所有点的值，即“口”字的框上的值，不含框内和框外的值。
+
+// 【输入格式】
+// 输入的第一行包含两个整数 n, m ，分别表示行数和列数。
+
+// 接下来 n 行，每行包含 m 个整数，相邻数之间使用一个空格分隔，依次表示矩阵的每行每列的值，本部分的第 i 行第 j 列表示 a[i][j] 。
+
+// 【输出格式】
+// 输出一行包含一个整数，表示最大的和。
+
+// 【样例输入】
+// 5 6
+// 1 -1 2 -2 3 -3
+// -1 2 -2 3 -3 4
+// 2 -2 3 -3 4 -4
+// -2 3 -3 4 -4 5
+// 3 -3 4 -4 5 -5
+// 【样例输出】
+// 4
+// 【样例说明】
+// 取 (x1, y1) = (1, 1) ， (x2, y2) = (5, 5) 可得到最大值。
+
+// 【评测用例规模与约定】
+// 对于 30% 的评测用例，1 <= n, m <= 30 ，-1000 <= a[i][j] <= 1000 。
+
+// 对于 60% 的评测用例，1 <= n, m <= 100 ，-1000 <= a[i][j] <= 1000 。
+
+// 对于所有评测用例，1 <= n, m <= 300 ，-1000 <= a[i][j] <= 1000 。
+
+#include <stdio.h>
+
+#define MAX 301
+
+int a[MAX][MAX];
+int row_sum[MAX][MAX];
+int col_sum[MAX][MAX];
+
+int main() {
+    int n, m;
+    scanf("%d %d", &n, &m);
+
+    for (int i = 1; i <= n; i++) {
+        for (int j = 1; j <= m; j++) {
+            scanf("%d", &a[i][j]);
+        }
+    }
+
+    for (int i = 1; i <= n; i++) {
+        row_sum[i][0] = 0;
+        for (int j = 1; j <= m; j++) {
+            row_sum[i][j] = row_sum[i][j - 1] + a[i][j];
+        }
+    }
+
+    for (int j = 1; j <= m; j++) {
+        col_sum[j][0] = 0;
+        for (int i = 1; i <= n; i++) {
+            col_sum[j][i] = col_sum[j][i - 1] + a[i][j];
+        }
+    }
+
+    int max_sum = -1000000000;
+
+    int k_max = (n - 1 < m - 1) ? (n - 1) : (m - 1);
+
+    for (int k = 1; k <= k_max; k++) {
+        for (int x1 = 1; x1 <= n - k; x1++) {
+            int x2 = x1 + k;
+            for (int y1 = 1; y1 <= m - k; y1++) {
+                int y2 = y1 + k;
+
+                int sum_left = col_sum[y1][x2] - col_sum[y1][x1 - 1];
+                int sum_top = row_sum[x1][y2] - row_sum[x1][y1 - 1];
+                int sum_right = col_sum[y2][x2] - col_sum[y2][x1 - 1];
+                int sum_bottom = row_sum[x2][y2] - row_sum[x2][y1 - 1];
+
+                int sum_corners = a[x1][y1] + a[x1][y2] + a[x2][y1] + a[x2][y2];
+
+                int total = sum_left + sum_top + sum_right + sum_bottom - sum_corners;
+
+                if (total > max_sum) {
+                    max_sum = total;
+                }
+            }
+        }
+    }
+
+    printf("%d\n", max_sum);
+    return 0;
+}

寻宝.c

@@ -0,0 +1,205 @@
+// 【问题描述】
+// 小蓝正在玩一个寻宝游戏。寻宝游戏在一个方格图上进行。方格图中的每一个格子都有一个坐标 (r, c)，其中越往北 r 越小，越往南 r 越大，越往东 c 越大，越往西 c 越小。南北相邻方格的 c 坐标相同，r 坐标差一。东西相邻方格的 r 坐标相同， c 坐标差一。
+
+// 游戏开始时，小蓝站在 (0, 0) 处，面向北边。游戏区域无限大，且没有障碍。每一步，小蓝控制自己的角色走一步，他可以有如下三种选择：
+
+// 向前走：朝现在的方向前进到相邻的方格中，并保持当前的方向。
+// 向左走：向左转90度，并前进到相邻的方格中（即进入到原来左边的方格），面向的方向变为了原来的左边。
+// 向右走：向右转90度，并前进到相邻的方格中（即进入到原来右边的方格），面向的方向变为了原来的右边。
+// 小蓝玩了一会儿，一共走了 n 步，他记录了自己的每一个动作。但是他没有找到宝藏。他怀疑前面的某一步出现了失误。他想知道，如果他改变之前的某一步，能到的位置有哪些。由于这个太复杂，他想知道最终到的位置（第 n 步后到的位置）有多少种。
+
+// 【输入格式】
+// 输入的第一行包含一个整数 n ，表示小蓝走了 n 步。
+
+// 第二行包含一个长度为 n 的由大写字母组成的字符串，依次表示小蓝走的每一步。字母 F 、 L 、 R 分别表示对应的步是向前走、向左走、向右走。
+
+// 【输出格式】
+// 输出一行，包含一个整数，表示如果改变某一步，可以到的位置的种类数。
+
+// 【样例输入】
+// 3
+// FLR
+// 【样例输出】
+// 6
+// 【样例说明】
+// 如果不改变，三步依次走到：(-1, 0), (-1, -1), (-2, -1) ，最终位置为 (-2, -1) 。
+
+// 如果第一步改成 L，三步依次走到：(0, -1), (1, -1), (1, -2) ，最终位置为 (1, -2) 。
+
+// 如果第一步改成 R，三步依次走到：(0, 1), (-1, 1), (-1, 2) ，最终位置为 (-1, 2) 。
+
+// 如果第二步改成 F，三步依次走到：(-1, 0), (-2, 0), (-2, 1) ，最终位置为 (-2, 1) 。
+
+// 如果第二步改成 R，三步依次走到：(-1, 0), (-1, 1), (0, 1) ，最终位置为 (0, 1) 。
+
+// 如果第三步改成 F，三步依次走到：(-1, 0), (-1, -1), (-1, -2) ，最终位置为 (-1, -2) 。
+
+// 如果第三步改成 L，三步依次走到：(-1, 0), (-1, -1), (0, -1) ，最终位置为 (0, -1) 。
+
+// 共有 6 种不同的最终位置。
+
+// 【样例输入】
+// 4
+// RRRR
+// 【样例输出】
+// 6
+// 【样例说明】
+// 有 8 种改变方法：
+
+// 改为 FRRR ，最终位置为 (0, 0)；
+
+// 改为 LRRR ，最终位置为 (0, 0)；
+
+// 改为 RFRR ，最终位置为 (1, 1)；
+
+// 改为 RLRR ，最终位置为 (0, 2)；
+
+// 改为 RRFR ，最终位置为 (2, 0)；
+
+// 改为 RRLR ，最终位置为 (2, 2)；
+
+// 改为 RRRF ，最终位置为 (1, -1)；
+
+// 改为 RRRL ，最终位置为 (2, 0)。
+
+// 不同的最终位置共有 6 种。
+
+// 【评测用例规模与约定】
+// 对于 30% 的评测用例，1 <= n <= 20。
+
+// 对于 60% 的评测用例，1 <= n <= 1000。
+
+// 对于所有评测用例，1 <= n <= 100000
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MAXN 100000
+
+int n;
+char actions[MAXN + 1];
+int original_dir[MAXN + 1];
+int original_pos_x[MAXN + 1];
+int original_pos_y[MAXN + 1];
+
+int dx[4] = {-1, 0, 1, 0};
+int dy[4] = {0, 1, 0, -1};
+
+void simulate(int step, int new_action, int *final_x, int *final_y) {
+    int dir = original_dir[step];
+    int x = original_pos_x[step];
+    int y = original_pos_y[step];
+
+    if (new_action == 'F') {
+        // 前进，方向不变
+    } else if (new_action == 'L') {
+        // 向左转，方向减一
+        dir = (dir - 1 + 4) % 4;
+    } else if (new_action == 'R') {
+        // 向右转，方向加一
+        dir = (dir + 1) % 4;
+    }
+
+    // 执行新的动作
+    x += dx[dir];
+    y += dy[dir];
+
+    // 继续模拟后续步骤
+    for (int i = step + 1; i < n; i++) {
+        char action = actions[i];
+        if (action == 'F') {
+            // 前进，方向不变
+        } else if (action == 'L') {
+            // 向左转，方向减一
+            dir = (dir - 1 + 4) % 4;
+        } else if (action == 'R') {
+            // 向右转，方向加一
+            dir = (dir + 1) % 4;
+        }
+        x += dx[dir];
+        y += dy[dir];
+    }
+
+    *final_x = x;
+    *final_y = y;
+}
+
+int main() {
+    scanf("%d", &n);
+    scanf("%s", actions);
+
+    // 初始化原始方向和位置
+    original_dir[0] = 0;
+    original_pos_x[0] = 0;
+    original_pos_y[0] = 0;
+
+    // 预计算原始方向和位置序列
+    for (int i = 0; i < n; i++) {
+        char action = actions[i];
+        int dir = original_dir[i];
+        int x = original_pos_x[i];
+        int y = original_pos_y[i];
+
+        if (action == 'F') {
+            // 前进，方向不变
+        } else if (action == 'L') {
+            // 向左转，方向减一
+            dir = (dir - 1 + 4) % 4;
+        } else if (action == 'R') {
+            // 向右转，方向加一
+            dir = (dir + 1) % 4;
+        }
+
+        // 更新位置
+        x += dx[dir];
+        y += dy[dir];
+
+        original_dir[i + 1] = dir;
+        original_pos_x[i + 1] = x;
+        original_pos_y[i + 1] = y;
+    }
+
+    // 使用哈希表存储最终位置
+    int hash[200001][2];
+    int hash_size = 0;
+
+    for (int i = 0; i < n; i++) {
+        char original_action = actions[i];
+        // 可能的动作变化
+        char possible_actions[2];
+        if (original_action == 'F') {
+            possible_actions[0] = 'L';
+            possible_actions[1] = 'R';
+        } else if (original_action == 'L') {
+            possible_actions[0] = 'F';
+            possible_actions[1] = 'R';
+        } else if (original_action == 'R') {
+            possible_actions[0] = 'F';
+            possible_actions[1] = 'L';
+        }
+
+        for (int j = 0; j < 2; j++) {
+            char new_action = possible_actions[j];
+            int final_x, final_y;
+            simulate(i, new_action, &final_x, &final_y);
+
+            // 检查是否已存在该位置
+            int found = 0;
+            for (int k = 0; k < hash_size; k++) {
+                if (hash[k][0] == final_x && hash[k][1] == final_y) {
+                    found = 1;
+                    break;
+                }
+            }
+            if (!found) {
+                hash[hash_size][0] = final_x;
+                hash[hash_size][1] = final_y;
+                hash_size++;
+            }
+        }
+    }
+
+    printf("%d\n", hash_size);
+
+    return 0;
+}

数组偶数最小值.c

@@ -0,0 +1,46 @@
+// 【问题描述】
+// 小蓝有一个数组 a[1], a[2], ..., a[n] ，请求出数组中值最小的偶数，输出这个值。
+
+// 【输入格式】
+// 输入的第一行包含一个整数 n 。
+
+// 第二行包含 n 个整数，相邻数之间使用一个空格分隔，依次表示 a[1], a[2], ..., a[n] 。
+
+// 【输出格式】
+// 输出一行，包含一个整数，表示答案。数据保证数组中至少有一个偶数。
+
+// 【样例输入】
+// 9
+// 9 9 8 2 4 4 3 5 3
+// 【样例输出】
+// 2
+// 【样例输入】
+// 5
+// 4321 2143 1324 1243 4312
+// 【样例输出】
+// 1324
+// 【评测用例规模与约定】
+// 对于 30% 的评测用例，1 <= n <= 100，0 <= a[i] <= 1000。
+
+// 对于 60% 的评测用例，1 <= n <= 1000，0 <= a[i] <= 1000。
+
+// 对于所有评测用例，1 <= n <= 10000，0 <= a[i] <= 1000000。
+
+#include <stdio.h>
+
+int main() {
+    int n;
+    scanf("%d", &n);
+    int a[n];
+    for(int i = 0; i < n; i++) {
+        scanf("%d", &a[i]);
+    }
+    int min_even = 1000001;
+    for(int i = 0; i < n; i++) {
+        if(a[i] % 2 == 0 && a[i] < min_even) {
+            min_even = a[i];
+        }
+    }
+    printf("%d\n", min_even);
+    return 0;
+}

是否有字符串.c

@@ -0,0 +1,54 @@
+// 【问题描述】
+// 一个字符串包含LANQIAO是指在字符串中能取出几个字符，将他们按照在原串中的位置顺序摆成一排后字符串为 LANQIAO 。即字符串包含 LANQIAO 是指 LANQIAO 是这个串的子序列。
+
+// 例如：LLLLLANHAHAHAQLANIIIIALANO 中包含 LANQIAO 。
+
+// 又如：OAIQNAL 中不包含 LANQIAO 。
+
+// 给点一个字符串，判断字符串中是否包含 LANQIAO 。
+
+// 【输入格式】
+// 输入一行包含一个字符串。
+
+// 【输出格式】
+// 如果包含 LANQIAO ，输出一个英文单词 YES ，否则输出一个英文单词 NO 。
+
+// 【样例输入】
+// LLLLLANHAHAHAQLANIIIIALANO
+// 【样例输出】
+// YES
+// 【样例输入】
+// OAIQNAL
+// 【样例输出】
+// NO
+// 【评测用例规模与约定】
+// 对于所有评测用例，输入的字符串非空串，由大写字母组成，长度不超过 1000 。
+
+#include <stdio.h>
+#include <string.h>
+
+int main() {
+    char s[1001];
+    fgets(s, 1001, stdin);
+    // 去掉换行符
+    size_t len = strlen(s);
+    if (len > 0 && s[len-1] == '\n') {
+        s[len-1] = '\0';
+    }
+    char t[] = "LANQIAO";
+    int j = 0;
+    for (int i = 0; s[i] != '\0'; i++) {
+        if (s[i] == t[j]) {
+            j++;
+            if (j == 7) {
+                break;
+            }
+        }
+    }
+    if (j == 7) {
+        printf("YES\n");
+    } else {
+        printf("NO\n");
+    }
+    return 0;
+}