ACM寒假集训第一天 题目代码及其思路

一、Easy部分

1.LongLong

思路

（1）首先，根据输入的 N，确定字符串的长度为 N + 3

（2）创建字符串，其中：

        第一个字符为 L

        接下来是 N 个 o

        然后是 n 和 g

（3） 直接输出最终生成的字符

代码

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

int main() {
    int N;
    cin >> N; // 输入正整数 N

    // 初始化结果字符串
    string dragonString = "L"; // 以大写字母 L 开头
    dragonString += string(N, 'o'); // 添加 N 个小写字母 'o'
    dragonString += "n"; // 添加小写字母 'n'
    dragonString += "g"; // 添加小写字母 'g'

    // 输出结果
    cout << dragonString << endl;

    return 0;
}

2.YES or YES

 思路

1. 题目要求判断输入字符串是否是 “YES”，不区分大小写。

2. 每个字符串长度为3，所有字母可能是大写或小写混合形式。

3. 核心思路是将输入字符串统一转换为小写或大写，再与标准字符串 “yes” 或 “YES” 进行比较。

4. 对于多个测试用例，逐一判断并输出结果。

代码

#include <iostream>
#include <string>
#include <algorithm> // 用于 transform 函数
using namespace std;

int main() {
    int t;
    cin >> t; // 输入测试用例数量

    while (t--) {
        string s;
        cin >> s; // 输入长度为3的字符串

        // 将字符串转换为小写
        transform(s.begin(), s.end(), s.begin(), ::tolower);

        // 判断是否为 "yes"
        if (s == "yes") {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }
    }

    return 0;
}

 3.Even？Odd？

思路

题目要求判断多个正整数的奇偶性，并输出 “even” 或 “odd”。数字可能非常大，因此需要特别处理：

1. 由于数字范围高达 10^{60}，无法直接用常规整型变量存储，需要以字符串形式输入。

2. 判断奇偶性只需查看数字的最后一位字符：

• 如果最后一位是 0、2、4、6、8，则为偶数，输出 “even”。

• 如果最后一位是 1、3、5、7、9，则为奇数，输出 “odd”。

代码

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

int main() {
    int n;
    cin >> n; // 输入整数数量

    while (n--) {
        string num;
        cin >> num; // 输入可能很大的正整数，以字符串形式存储

        // 获取最后一位数字
        char last_digit = num[num.size() - 1];

        // 判断奇偶性
        if (last_digit == '0' || last_digit == '2' || last_digit == '4' ||
            last_digit == '6' || last_digit == '8') {
            cout << "even" << endl;
        } else {
            cout << "odd" << endl;
        }
    }

    return 0;
}

二、Medium 部分

1.Problem Generator

思路

1. 统计当前题库中每个难度的题目数量。

2. 检查是否每种难度的题目数量都能满足 m 轮需求。

3. 如果某种难度的题目不足，则计算需要额外补充的题目数量。

4. 输出每个测试用例需要补充的最小题目总数。

代码

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main() {
    int t;
    cin >> t; // 输入测试用例数量

    while (t--) {
        int n, m;
        cin >> n >> m; // 输入题库中题目数量 n 和计划的轮数 m
        string a;
        cin >> a; // 输入题库中的题目难度字符串

        unordered_map<char, int> count; // 用于记录每种难度题目的数量
        for (char c : a) {
            count[c]++; // 统计每种难度题目的数量
        }

        int needed = 0; // 需要补充的题目总数
        for (char difficulty = 'A'; difficulty <= 'G'; difficulty++) {
            if (count[difficulty] < m) {
                needed += (m - count[difficulty]); // 如果题目数量不足，计算需要补充的数量
            }
        }

        cout << needed << endl; // 输出结果
    }

    return 0;
}

 2.Rules

思路

1. 输入 n 表示居民人数，m 表示天数，k 表示待判断的规则编号。

2. 对每一天的规则遵守情况统计遵守规则 k 的人数，判断是否超过一半居民。

3. 统计符合规则编号的天数，如果超过一半的天数符合，则输出 YES，否则输出 NO。

代码

#include <iostream>
using namespace std;

int main() {
    int n, m, k;
    cin >> n >> m >> k; // 输入居民人数、天数和规则编号

    int days_more_than_half = 0; // 记录符合规则编号的天数

    for (int i = 0; i < m; i++) {
        int count_k = 0; // 统计当天遵守规则 k 的居民数量
        for (int j = 0; j < n; j++) {
            int rule;
            cin >> rule; // 输入每位居民当天遵守的规则编号
            if (rule == k) {
                count_k++; // 统计遵守规则 k 的人数
            }
        }
        // 如果当天超过一半的居民遵守规则 k，则认为这一天符合规则编号
        if (count_k > n / 2) {
            days_more_than_half++;
        }
    }

    // 如果符合规则的天数超过一半天数，规则 k 被视为正确
    if (days_more_than_half > m / 2) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }

    return 0;
}

 三、学习总结

通过做题，我学习到了C++的一些基本语法和一些基础编程题目的解题思路

1. 输入输出：

• 使用 cin 和 cout 处理多行和多组输入。

• 针对字符串输入（如大整数场景）可以灵活使用 string 类型。

2. 字符串操作：

• transform 函数：将字符串批量转换为小写或大写。

• 使用 string::back() 或 string[index] 访问字符串的最后一位。

3. 统计频次：

• unordered_map 用于字符频率统计，常见于问题需要快速查询的场景。

• 遍历字符串，统计字符出现次数，复杂度为  O(n) 。

4. 条件判断：

• 通过简单的 if 条件和基本算术操作（如除法判断大于一半的情况），解决逻辑判断问题。

5. 循环嵌套处理二维数据：

• 外层循环处理测试用例或天数，内层循环处理居民、题目等具体信息。

6. 时间复杂度分析：

• 充分结合问题范围，保证代码复杂度可控（如  O(n \cdot m) ）。