第五次周赛

用户11956880

发布于 2025-12-18 18:23:02

1800

1622-文本编辑器

题解都在注释上了，仔细观摩吧

#include <iostream>
#include <cctype>     // 提供 isalpha、islower、isupper、toupper、tolower 等字符函数
#include <algorithm>  // 提供 std::max, std::min
using namespace std;

// 切换字母大小写：如果是小写变大写，大写变小写，否则原样返回
char toggleCase(const char ch) {
    if (islower(static_cast<unsigned char>(ch))) {
        return static_cast<char>(toupper(ch));
    }
    if (isupper(static_cast<unsigned char>(ch))) {
        return static_cast<char>(tolower(ch));
    }
    return ch; // 非字母字符不变
}

int main() {
    int n;
    cin >> n;  // 输入操作次数
    bool cap = false; // 模拟 CapsLock 状态（false 表示关闭，true 表示开启）
    int pos = 0;      // 光标位置
    string text;      // 当前编辑的文本内容

    // 循环处理每个操作
    while (n--) {
        string input;
        cin >> input;  // 输入一条操作命令
        // 情况1：普通字母（例如 "a" 或 "B"）
        if (input.size() == 1 && isalpha(static_cast<unsigned char>(input[0]))) {
            char c = input[0];
            // 如果 CapsLock 打开，则切换大小写
            if (cap) {
                c = toggleCase(c);
            }
            // 在光标位置插入字符
            text.insert(text.begin() + pos, c);
            ++pos; // 光标右移
        }
        // 情况2：Shift+字母（例如 "Shift+a"）
        else if (input.rfind("Shift+", 0) == 0) { // 判断字符串是否以 "Shift+" 开头
            char c = input.back(); // 取出最后一个字符（字母）
            // 如果 CapsLock 没开，则临时切换大小写（模拟真实键盘）
            if (!cap) {
                c = toggleCase(c);
            }
            text.insert(text.begin() + pos, c);
            ++pos;
        }
        // 情况3：Enter 键（换行）
        else if (input == "Enter") {
            text.insert(text.begin() + pos, '\n');
            ++pos;
        }
        // 情况4：CapsLock 键（切换大小写模式）
        else if (input == "CapsLock") {
            cap = !cap; // 状态取反
        }
        // 情况5：左箭头键 "<-" （光标左移）
        else if (input == "<-") {
            pos = max(0, pos - 1); // 光标不能移到负数
        }
        // 情况6：右箭头键 "->" （光标右移）
        else if (input == "->") {
            pos = min(static_cast<int>(text.size()), pos + 1); // 光标不能越界
        }
    }
    // 输出最终文本
    cout << text;
    return 0;
}

1623：day3-dh学姐的报复

n为0，要买0瓶饮料，m为0，不用花钱买饮料，这两种情况的结果都是0。对于其余情况，想想当zyf喝到第n瓶饮料时一共产生了n-1个饮料瓶，拿n减去这n-1个瓶子兑换的就是答案。

#include<iostream>
using namespace std;
int main() {
    long long int m, n;
    cin >> m >> n;
    if (m == 0 || n == 0) {
        cout << 0;
        return 0;
    }
    else {
        cout << n - (n - 1) / m;
    }
    return 0;
}

1625-逃离二维宇宙二

本题是一道BFS（广度优先搜索）模板题，网上已有不少优异的课程，可自行查找学习

#include <bits/stdc++.h>  // 一次性包含所有标准库头文件（竞赛常用）
using namespace std;

int main() {
    int n;
    cin >> n;  // 输入网格的大小（n × n）
    // grid：存放地图信息（0 表示可走，1 表示障碍，2 表示起点，3 表示终点）
    vector<vector<int>> grid(n, vector<int>(n));
    // dist：存放每个格子到起点的距离，初始为 0
    vector<vector<int>> dist(n, vector<int>(n, 0));
    pair<int, int> start, goal; // 起点与终点坐标
    queue<pair<int, int>> q;    // BFS 队列
    // 输入地图，同时记录起点与终点位置
    for (int x = 0; x < n; ++x) {
        for (int y = 0; y < n; ++y) {
            cin >> grid[x][y];
            if (grid[x][y] == 2)
                start = {x, y}; // 起点
            else if (grid[x][y] == 3)
                goal = {x, y};  // 终点
        }
    }
    // BFS 初始化
    q.push(start);                               // 起点入队
    dist[start.first][start.second] = 0;         // 起点距离为 0
    // 广度优先搜索（BFS）遍历
    while (!q.empty()) {
        auto [x, y] = q.front(); // 取出队首元素
        q.pop();
        // 四个方向的偏移量：右、左、下、上
        constexpr array<int, 4> dy = {0, 0, 1, -1};
        constexpr array<int, 4> dx = {1, -1, 0, 0};
        for (int dir = 0; dir < 4; ++dir) {
            int nx = x + dx[dir]; // 新位置 x
            int ny = y + dy[dir]; // 新位置 y
            // 越界检查
            if (nx < 0 || nx >= n || ny < 0 || ny >= n)
                continue;
            // 如果是障碍（1）或者已经访问过（dist != 0），跳过
            if (grid[nx][ny] == 1 || dist[nx][ny] != 0)
                continue;
            // 记录距离（前一个格子的距离 + 1）
            dist[nx][ny] = dist[x][y] + 1;
            q.emplace(nx, ny); // 新格子入队
        }
    }
    // 如果终点的距离仍为 0，说明无法到达
    if (dist[goal.first][goal.second] == 0) {
        cout << "nonono";
    } else {
        // 输出路径长度（减 1 是因为起点距离为 0）
        cout << dist[goal.first][goal.second] - 1;
    }
    return 0;
}

1626-逃离二维宇宙三

本题可以先用一个数组记录炸弹的位置，再用一个二维数组记录炸弹影响的方格（当然也可以用一个数组，保证更新炸弹影响区域时不覆盖炸弹即可，这里用两个数组的方法）。先输入，将空地与炸弹的数据记录到一个二维数组中，再创建一个大小相同的二维数组并全初始化为0来记录炸弹影响区域，遍历第一个数组，当遇到炸弹（值为1）时，在第二个数组中记录炸弹影响区域，更新逻辑：

如果炸弹坐标为(i,j),因为炸弹影响范围为5*5，又为了不数组访问越界，所以就数组二中

(max(0, i - 2)~min(n, i + 3) , max(0, j - 2) ~ min(n, j + 3)) 的元素改为非0数

将数组更新完毕后，记录第二个数组中有几个0即可

#include <bits/stdc++.h>  // 一次性引入所有标准库（竞赛常用写法）
using namespace std;

int main() {
    ios::sync_with_stdio(false); // 关闭 C 与 C++ 标准流同步，加快输入输出
    cin.tie(nullptr);            // 解除 cin 与 cout 的绑定，提高性能
    int n;
    cin >> n; // 输入网格大小 n（即 n×n）
    // grid 用于存放输入的地图
    vector<vector<int>> grid(n, vector<int>(n));
    for (auto &row : grid) {
        for (auto &x : row) {
            cin >> x; // 读入每个格子的值（0 表示空地，1 表示有炸弹）
        }
    }
    // unsafe 用于标记“不安全区域”，初始为全 0（安全）
    vector<vector<int>> unsafe(n, vector<int>(n, 0));
    // 遍历整个网格，找出每个炸弹（值为 1）的位置
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (grid[i][j] == 1) { // 找到一个炸弹
                // 炸弹会影响自己以及周围 2 格范围内的所有格子
                // 所以我们要标记 (i-2) ~ (i+2)、(j-2) ~ (j+2) 之间的区域
                for (int x = max(0, i - 2); x < min(n, i + 3); ++x) {
                    for (int y = max(0, j - 2); y < min(n, j + 3); ++y) {
                        unsafe[x][y] = 1; // 标记为不安全
                    }
                }
            }
        }
    }
    // 统计安全格数量（值仍为 0 的格子）
    int safe_count = 0;
    for (auto &row : unsafe) {
        for (const auto x : row) {
            if (x == 0) {
                ++safe_count;
            }
        }
    }
    // 输出安全格数量
    cout << safe_count << '\n';
}

1627-大数相加

就是个高精度的模板

#include<bits/stdc++.h>
using namespace std;
const int N = 10000010;
int a[N],b[N],c[N];
int la,lb,lc;//每个数组的长度 
void add(int c[],int a[],int b[]){
    for(int i=0;i<lc;i++){
        c[i]+=a[i]+b[i];
        c[i+1]=c[i]/10;
        c[i]%=10;
    }
    if(c[lc]) lc++;//如果lc位置有数，也就是进到了最高位，就++ 
}
int main(){
    //字符串 12345 个位是在字符串结尾 x.size() ,而数组 123456 
    //我们后面计算，应该把个位仍在开头 54321， 
    string x,y;
    cin>>x>>y;
    la=x.size();
    lb=y.size();
    lc=max(la,lb);
    for(int i=lb-1;i>=0;i--) b[lb-i-1]=y[i]-'0'; 
    for(int i=la-1;i>=0;i--) a[la-i-1]=x[i]-'0';//把个位仍在数组的首位 
    add(c,a,b); 
    for(int i=lc-1;i>=0;i--) cout<<c[i]; 
}

1628-合成

最少的武器的数量就是可合成的数量

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    vector<int> v(10,0);
    int n;
    cin>>n;
    while (n--) {
        string s;
        cin>>s;
        if (s == "tlr") {
            ++v[0];
        }else if (s == "chmzr") {
            ++v[1];
        }else if (s == "kxzn") {
            ++v[2];
        }else if (s == "byzr") {
            ++v[3];
        }else if (s == "wtqsj") {
            ++v[4];
        }else if (s == "zzwd") {
            ++v[5];
        }else if (s == "xn") {
            ++v[6];
        }else if (s == "yfr") {
            ++v[7];
        }else if (s == "fmj") {
            ++v[8];
        }else if (s == "tdj") {
            ++v[9];
        }
    }
    cout<<*min_element(v.begin(),v.end());
    return 0;
}

1629-环

循环一个下标即可，下标到末尾时回到开始，注意开始与结束的边界处理

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    int a, b;
    cin >> a >> b;
    while (a != b) {
        cout << s[a];
        if (++a == n) {
            a = 0;
        }
    }
    cout << s[b];
    return 0;
}

1634-不行

模拟题，注意分析每种情况

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int count = 0;
    while (true) {
        string s;
        cin >> s;
        ++count;
        if (s == "byebye") {
            return 0;
        }
        if (count < 10) {
            if (s.size() <= 10) {
                cout<<"buxing\n";
            }else {
                cout<<"buxing bizuiba\n";
            }
        }else if (count == 10) {
            cout<<"fanbufan?\n";
        }else {
            cout<<"!\n";
        }
    }
}

1636-非整除

#include <iostream>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    int n;
    cin >> n;
    while (n--) {
        int l, r, k;
        cin >> k >> l >> r;
        cout << (r - l + 1) - ((r / k) - ((l - 1) / k)) << '\n';
    }
    return 0;
}

1637：偷窃的problem

这其实是斐波那契，我们可以通过类推得到答案，多在演草纸上写几个例子就行 a b 每一对a+b都要保证和最小 8 5 5 3 3 2 2 1 1 0 就最开始不是1 0吗，然后gcd的递归是当前的a是继承上一个b的值，当前的b的值是上一个a%b的值，那谁模1都是0，所以上一个2是最小的值，然后依次类推

#include<bits/stdc++.h>
using namespace std;
#define int long long
int ans=INT_MAX;
pair<int,int>a[100];
signed main(){
    int t,n;
    cin>>t;
    while(t--){
        cin>>n;
        a[0].first=1,a[0].second=0;
        a[1].first=2,a[1].second=1;
        for(int i=2;i<=100;i++){
            a[i].first=a[i-1].first+a[i-1].second;
            a[i].second=a[i-1].first;
        }
        cout<<a[n].first+a[n].second<<endl;
    }
    //gcd(a,b);
}

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-11-13，如有侵权请联系 cloudcommunity@tencent.com 删除

int