CCF--CSP练习

---

1.202312-1  仓库规划

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 初始化 N 和 M 为 0
    int N = 0, M = 0;
    cin >> N >> M;

    // 创建一个动态二维数组 warehouse，大小为 (N + 1) x M
    vector<vector<int> > warehouse(N + 1, vector<int>(M));

    // 遍历仓库的行
    for (int i = 1; i <= N; i++) {
        // 遍历仓库的列
        for (int j = 0; j < M; j++) {
            cin >> warehouse[i][j];
        }
    }

    // 遍历仓库的行
    for (int i = 1; i <= N; i++) {
        // 初始化结果 res 为 0
        int res = 0;

        // 遍历仓库的行
        for (int j = 1; j <= N; j++) {
            // 如果 i 和 j 不相等
            if (i != j) {
                // 标记为 true
                bool flag = true;

                // 遍历仓库的列
                for (int k = 0; k < M; k++) {
                    // 如果仓库 i 的第 k 个元素大于等于仓库 j 的第 k 个元素
                    if (warehouse[i][k] >= warehouse[j][k]) {
                        // 标记为 false
                        flag = false;
                        // 终止内层循环
                        break;
                    }
                }

                // 如果标记为 true
                if (flag) {
                    // 更新结果 res
                    res = j;
                    // 终止内层循环
                    break;
                }
            }
        }
        // 输出结果 res
        cout << res << endl;
    }

    return 0;
}

2.202309-1  坐标变换（其一）

#include <bits/stdc++.h>  // 包含 C++ 的标准库头文件
using namespace std;  // 使用命名空间 std

int n, m;  // 声明整型变量 n 和 m，用于存储输入的行数和列数
int temp_x = 0, temp_y = 0;  // 声明整型变量 temp_x 和 temp_y，用于存储临时的 x 和 y 坐标
int x, y;  // 声明整型变量 x 和 y，用于存储最终的 x 和 y 坐标

int main()  // 定义主函数
{
    cin >> n >> m;  // 从标准输入流中读取行数和列数，并分别存储在变量 n 和 m 中

    for (int i = 0; i < n; i++)  // 使用循环遍历输入的行数
    {
        cin >> x >> y;  // 从标准输入流中读取行中的 x 和 y 坐标，并分别存储在变量 x 和 y 中
        temp_x += x;  // 将当前行的 x 坐标累加到 temp_x 中
        temp_y += y;  // 将当前行的 y 坐标累加到 temp_y 中
    }

    for (int i = 0; i < m; i++)  // 使用循环遍历输入的列数
    {
        cin >> x >> y;  // 从标准输入流中读取列中的 x 和 y 坐标，并分别存储在变量 x 和 y 中
        x += temp_x;  // 将当前列的 x 坐标加上 temp_x 的值，并存储在变量 x 中
        y += temp_y;  // 将当前列的 y 坐标加上 temp_y 的值，并存储在变量 y 中
        cout << x << " " << y << "\n";  // 输出最终的 x 和 y 坐标
    }

    cout << endl;  // 在输出完所有坐标后，换行输出空行
    return 0;  // 返回 0，表示程序正常结束
}

3.202305-1  重复局面

样例输入

8
********
******pk
*****r*p
p*pQ****
********
**b*B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
******k*
******p*
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
******k*
******p*
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*pQ****
*b******
****B*PP
****qP**
**R***K*
********
******pk
*****r*p
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*
********
******pk
******rp
p*p*****
*b**Q***
****B*PP
****qP**
**R***K*

#include <bits/stdc++.h>  // 包含 C++ 的标准库头文件
using namespace std;  // 使用命名空间 std

int n;  // 声明整型变量 n，用于存储输入的方块数量
char pieces[64];  // 声明一个字符数组 pieces，用于存储方块状态
map<string, int> status_map;  // 声明一个 map 容器 status_map，用于存储方块状态和对应的出现次数

int main()  // 定义主函数
{
    cin >> n;  // 从标准输入流中读取方块数量，并存储在变量 n 中

    for (int i = 0; i < n; i++)  // 使用循环遍历输入的方块数量
    {
        for (int j = 0; j < 64; j++)  // 使用循环遍历 pieces 数组的每个元素
        {
            cin >> pieces[j];  // 从标准输入流中读取方块状态，并存储在 pieces 数组的第 j 个元素中
        }

        if (status_map.count(pieces))  // 检查 status_map 容器中是否存在与 pieces 数组相同的方块状态
        {
            status_map[pieces]++;  // 如果存在，则将该方块状态对应的出现次数加 1
        }
        else  // 如果不存在
        {
            status_map[pieces] = 1;  // 将该方块状态添加到 status_map 容器中，并将出现次数初始化为 1
        }

        cout << status_map[pieces] << endl;  // 输出该方块状态的出现次数
    }

    return 0;  // 返回 0，表示程序正常结束
}