蓝桥杯题型

x20ne

已于 2025-04-11 16:48:46 修改

阅读量834

点赞数 5

文章标签：蓝桥杯职场和发展

于 2025-03-06 23:18:05 首次发布

本文链接：https://blog.youkuaiyun.com/2301_79758400/article/details/146082030

版权

蓝桥杯

蓝桥杯题型分类

蓝桥杯题型分类

语法基础

艺术与篮球（日期问题）

在这里插入图片描述

#include <bits/stdc++.h>
using namespace std;
 
map<char,int>myMap;
int basketball,calligraphy;

//日期是否合法模板
int months[13] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
bool check(int date)
{
    int year=date/10000,month=date%10000/100,day=date%100;
    
    if(!month||month>=13||!day)return false;
    if(month!=2&&day>months[month])return false;
    if(month==2)
    {
        int leap=(year%100!=0&&year%4==0)||year%400==0;
        if(day>28+leap)return false;
    }
    return true;
}


int main() 
{
     // 插入数字与笔画数
    myMap['0'] = 13;
    myMap['1'] = 1;
    myMap['2'] = 2;
    myMap['3'] = 3;
    myMap['4'] = 5;
    myMap['5'] = 4;
    myMap['6'] = 4;
    myMap['7'] = 2;
    myMap['8'] = 2;
    myMap['9'] = 2;
    
      // 遍历日期范围，从2000年1月1日到2024年4月13日
    for(int i=20000101;i<=20240413;i++)
    {
        if(check(i))
        {
            string s=to_string(i);
            int num=0;
            for(auto j:s)
            {
                num+=myMap[j];
            }
            if(num>50)
            {
                basketball++;
            }
        }
       
       
    }
    cout<<basketball;
    return 0;
}

时间显示（时间问题）

在这里插入图片描述

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

int main() 
{
    ll x;
    cin >> x;
    
    // 计算小时、分钟、秒数
    ll hh = (x / 3600000) % 24;  // 小时数，取 24 小时制
    ll mm = (x / 60000) % 60;     // 分钟数，取 60 分钟
    ll ss = (x / 1000) % 60;      // 秒数，取 60 秒

    // 输出时间格式
    printf("%02lld:%02lld:%02lld", hh, mm, ss);
    return 0;
}

跑步计划（日期问题）

在这里插入图片描述

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

int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};  // 每个月的天数

// 检查数字是否包含1
bool check(int x) {
    while (x) {
        if (x % 10 == 1) {
            return true;  // 如果数字中包含1，返回true
        }
        x /= 10;  // 去除最后一位
    }
    return false;  // 如果没有1，返回false
}

int main() {
    int ans = 0;  // 总跑步的千米数
    int week = 6;  // 2023年1月1日是星期天，所以初始化为6（星期天）

    // 遍历每个月
    for (int i = 1; i <= 12; i++) {
        // 遍历每个月的每一天
        for (int j = 1; j <= months[i]; j++) {
            week = (week % 7) + 1;  // 更新星期几，确保在1到7之间循环（星期天为7）

            // 如果日期、月份或星期几包含1，跑5千米
            if (check(i) || check(j) || check(week)) {
                ans += 5;
            } else {
                ans += 1;  // 否则跑1千米
            }
        }
    }

    cout << ans;  // 输出小蓝总共跑的千米数
    return 0;
}

偶串(字符）

在这里插入图片描述

使用 Map 或者 unordered_map。
遍历字符串中的每个字符。对每个字符，检查它是否已经在你的数据结构中。如果是，增加它的计数。

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

int main() {
    string str;
    cin >> str;  // 输入字符串

    unordered_map<char, int> char_count;  // 用哈希表存储每个字符的出现次数

    // 遍历字符串并统计每个字符的出现次数
    for (char c : str) {
        char_count[c]++;
    }

    // 检查是否每个字符出现次数为偶数
    bool is_even = true;
    for (auto& pair : char_count) {
        if (pair.second % 2 != 0) {  // 如果出现次数是奇数
            is_even = false;
            break;
        }
    }

    // 输出结果
    if (is_even) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }

    return 0;
}

创建一个大小为26的整数数组（假设为 cnt），用于存储每个小写字母的出现次数。数组的索引 
0−25 分别对应字母 a-z。
遍历字符串的每一个字符（假设为 c）：
将字符 c 转为其 ASCII 值。
通过计算 c - 'a' 来得到一个从 0
0 到 25 的索引，这个索引对应于字符 c。
使用这个索引来增加 cnt 数组中对应元素的值。
遍历结束后，cnt 数组中的每个元素就存储了对应字母在字符串中的出现次数。

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    string s;
    vector<int> cnt(26);

    cin >> s;
    for (auto c : s)
    {
        cnt[c - 'a']++;
    }

    for (int i = 0; i < 26; ++i)
    {
        if (cnt[i] % 2)
        {
            cout << "NO" << '\n';
            return 0;
        }
    }

    cout << "YES" << '\n';
    return 0;
}

最长子序列（字符）

在这里插入图片描述

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

int main() {
    string s, t;
    int num = 0;
    cin >> s >> t;

    for (char ch : t) {
        // 查找当前字符ch在s中的位置
        size_t pos = s.find(ch);
        if (pos == string::npos) {
            // 如果找不到字符，直接输出已找到的匹配数并结束程序
            cout << num;
            return 0;
        } else {
            // 如果找到了字符，更新字符串s并增加计数
            num++;
            s = s.substr(pos + 1);  // 从pos+1开始截取s
        }
    }

    // 输出最终匹配的字符数
    cout << num;
    return 0;
}

字母数（进制转换）

在这里插入图片描述

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

using ll=long long;
int a[1000];
char ch[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' };

bool solve(int x)//十进制转换为16进制
{
    string ans;
    while(x)
    {
        if(ch[x%16]>='A')
        {
            ans+=ch[x%16];
            x/=16;
        }
        else
        {
            return false;
        }
        
    }
    reverse(ans.begin(),ans.end());
    return true;
}
int main() 
{
   ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
   int i=2022;
    while(true)
    {
        i++;
        if( solve(i))
        {
            cout<<i;
            return 0;
        }
       
    }
    return 0;
}

6个0（进制转换）

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

bool check(int x)
{
    // 检查最低的 5 位是否都为 0
    for(int i = 0; i < 5; i++)
    {
        if(((x >> i) & 1) != 0) // 如果第 i 位不为 0，返回 false
        {
            return false;
        }
    }
    return true;
}

int main() 
{
    int x = 2022; // 从 2022 开始查找
    while(true)
    {
        x++; // 从 2023 开始检查
        if(check(x)) // 如果 x 的最低 5 位全为 0
        {
            cout << x;
            return 0;
        }
    }
    return 0;
}

优秀的拆分（位运算）

在这里插入图片描述

输入输出样例
示例 1
输入

6

输出

4 2

示例 2
输入

7

输出

-1

7的二进制数为（0111），6的二进制数为（0110），可以发现7的二进制位的最低位（第0位）为1，值为
$2^0$ ,所以只要最低位为1，就不是优秀的拆分。我的从最高位开始遍历，只要第i位为1，我们就输出 1<<i ,即为 $2^i$

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

int main() {
    int num;
    cin >> num;

    // 如果最低位为 1，输出 -1
    if (((num >> 0) & 1) == 1) {
        cout << -1 << endl;
        return 0;
    }

    // 从最高位开始遍历，检查每一位
    for (int i = 30; i >= 0; i--) {
        // 如果当前位为 1，输出 2^i
        if (((num >> i) & 1) == 1) {
            cout << (1 << i) << " ";
        }
    }

    return 0;
}

异或数列(位运算)

在这里插入图片描述
示例 1

输入
4
1 1
1 0
2 2 1
7 992438 1006399 781139 985280 4729 872779 563580

输出
1
0
1
1

解题思路

我们设在游戏结束后 Alice 的数变为 c，Bob 的数变为 d。

我们先来解决平局的情况：

根据异或性质可得：若 c = d，则 c ⊕ d = 0。

而 c ⊕ d = X1 ⊕ X2 ⊕ ⋯ ⊕ Xn，所以要使 c = d，当且仅当 X1 ⊕ X2 ⊕ ⋯ ⊕ Xn = 0。

接下来定输赢：

我们将 c, d 转换成二进制数。对于二进制数的比较，我们是从高位往低位开始的。所以要使自己的数最大，就需要从高位开始。

设当前枚举到二进制的第 i 位。设 X1, X2, X3, ..., Xn 中一共有 cnt1 个数在该位的值为 1，cnt2 个数在该位的值为 0。（cnt1 + cnt2 = n）

结论一：

如果 cnt1 为偶数，则 Alice 和 Bob 无法在该位分出胜负。

证明方法和上述平局情况相同。 或者也可以这么想：cnt1 为偶数，那么 Alice 和 Bob 要么都从这 cnt1 个数中分到偶数个，要么 Alice 和 Bob 都在这 cnt1 个数中分到奇数个；所以无论怎么分配，c, d 在该位的异或值都必然相同。

反之当 cnt1 为奇数时，必然能决出胜负。证明方法和上述类似，就不再给出。

那么 cnt1 为奇数时如何判断谁输谁赢呢？

我们先定义，对于当前第 i 位，如果能让自己的数值从 0 → 1，或者能让对手的数值从 1 → 0，则自己的胜率 +1；如果让自己的数值从 1 → 0，或者让对手的数值从 0 → 1，则自己的胜率 -1；如果既不改变自己的数值，也不改变对手的数值，则自己的胜率不变。显然，游戏结束时，胜率越高的一方获胜。

结论二：

当 cnt1 为奇数，cnt2 = 0 时，先手必胜。

证明：

模拟一下可以发现先手后手走的每一步都必然是让自己胜率增加的一步。由于 cnt1 为奇数，所以先手可以比后手多走一步，所以先手的胜率必然会比后手高。

那么什么情况下必然会使自己的胜率减少呢？即当自己的数值为 1，且对手的数值为 0，且公共数列中只有 1 可以选取时。

结论三：

谁的胜率率先减少，则谁必败。

证明： 由于一方胜率减少了，所以可得公共数列中只有 1 可以选取，没有 0 可以选取。

设胜率率先减少的 Alice，那么此时 Alice 和 Bob 的数值只有两种可能：

Alice 的数值为 0，Bob 的数值为 0；
Alice 的数值为 1，Bob 的数值为 1。

由于 Alice 和 Bob 的数值相同，所以公共序列中使用的 1 的个数必然为偶数，剩余的 1 的个数必然为奇数。且此时是 Bob 先手，根据结论二，Bob 必胜，Alice 必败，证明完毕。

那么谁的胜率会先减少的呢？

结论四：

当 cnt1、cnt2 为奇数时且 cnt1 > 1 时，先手的胜率会率先减少。

证明： 当 cnt2 为奇数时，先手第一步只能选取 0 或是 1：

若先手先取 1 则后手取 0。此时先手的数值为 1，后手的数值为 0。为了不让自己的胜率降低，先手只能取 0，而后手也接着取 0。由于 0 个为奇数，所以先手将率先无法取 0，只能取 1，使得自己的胜率降低。
若先手取 0 则后手也取 0。此时场面还是 1 的个数为奇数，0 的个数为奇数的情况。若先手率先取了 1，则就回到了上述的情况，先手必败。所以先手只能不断取 0，而后手也跟着不断取 0。最后先手取完 0，将剩余奇数个 1，回到了结论三的情况。由于此时到了后手的轮次，所以先手必败。

结论五：

当 cnt1 = 1 时，先手必胜。

证明略。

根据上述五个结论，模拟一遍即可。

复杂度为 O(22 ∑ i=1 Tni)。

#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];

signed main() {
    int T = 1;
    cin >> T;
    while(T--) {
        int n, sum = 0, ans = 0;
        cin >> n;
        
        // 读取输入并计算异或和
        for(int i = 1; i <= n; i++) {
            cin >> a[i];
            sum ^= a[i];
        }

        // 结论1:如果异或和为 0，则平局
        if (!sum) {
            cout << 0 << '\n';
            continue;
        }

        // 对每一位进行分析
        for (int j = 20; j >= 0; j--) {
            int one = 0, zero = 0;

            // 统计当前位上的1和0的数量
            for (int i = 1; i <= n; i++) {
                if (a[i] >> j & 1) one++;
                else zero++;
            }

            // 结论2 如果当前位有奇数个1，则确定胜负
            if (one & 1) {
                if (zero % 2 && one != 1) ans = -1;  //结论4 不满足条件，Bob 获胜
                else ans = 1;  // 满足条件，Alice 获胜
                break;
            }
        }

        cout << ans << '\n';  // 输出结果
    }
    return 0;
}

幸运数字的个数(预计算）

在这里插入图片描述

样例输入
6
1 10
1 16
1 17
10 100
100 1000
1000 10000

样例输出
10
15
16
11
13
14

说明
对于所有评测数据：

$1≤T≤10^5,1≤l_i ≤r_i≤10^{12} 。$

要用到的思想是先“离线”预计算所有可能的幸运数字，再用二分查找快速计算每个查询区间内的幸运数字数量。具体做法如下：

先枚举所有“十六进制中由同一字符重复”的数字，排除超过 10^12 的值，并将这些数字存储到一个数组并排序；
对每次给定的范围 [l, r]，使用二分查找定位区间上下界，从而快速统计落在该区间内的幸运数字个数。

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

static const long long MAX_VAL = 1000000000000LL; // 1e12

// 预先生成所有在 [1, 1e12] 范围内 "十六进制由同一数字重复" 的幸运数字
// 注意：digit 取值范围是 [0..15]，长度取值范围适当即可（1~16足够覆盖1e12）
vector<long long> generateLuckyNumbers() {
    vector<long long> luckyNums;
    // 十六进制最大可用字符：0~f (共16个)
    for (int digit = 0; digit < 16; ++digit) {
        for (int length = 1; length <= 16; ++length) {
            // 构建长度为 length 的重复字符
            // 例如若 digit = 12 (十六进制 c)，length = 4，则是"cccc"
            // 然后转为十进制，判断是否 <= 1e12
            // digit 转成对应的16进制字符
            char hexDigit;
            if (digit < 10) {
                hexDigit = char(digit + '0');
            } else {
                hexDigit = char(digit - 10 + 'a');
            }

            // 构建重复串
            string hexStr(length, hexDigit);

            // 转成十进制
            // stoll(hexStr, nullptr, 16) 有可能超范围，用更安全方式
            // 这里用 64位整型计算
            long long num = 0;
            for (char c : hexStr) {
                // digitVal 可以用 c - '0' 或 c - 'a' + 10
                // 但我们已经知道是同一个字符
                int val;
                if (isdigit(c))
                    val = c - '0';
                else
                    val = c - 'a' + 10;
                num = num * 16 + val;

                // 若已经超过范围就中断
                if (num > MAX_VAL) break;
            }

            if (num > 0 && num <= MAX_VAL) {
                luckyNums.push_back(num);
            }
        }
    }
    // 去重并排序
    sort(luckyNums.begin(), luckyNums.end());
    luckyNums.erase(unique(luckyNums.begin(), luckyNums.end()), luckyNums.end());
    return luckyNums;
}

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

    // 预先生成所有可能的幸运数字
    static vector<long long> luckyNumbers = generateLuckyNumbers();

    int T;
    cin >> T;
    while (T--) {
        long long l, r;
        cin >> l >> r;
        // 在 luckyNumbers 中，用二分查找统计区间 [l, r] 内的元素个数
        auto leftIt = lower_bound(luckyNumbers.begin(), luckyNumbers.end(), l);
        auto rightIt = upper_bound(luckyNumbers.begin(), luckyNumbers.end(), r);
        cout << (rightIt - leftIt) << "\n";
    }
    return 0;
}

填空

握手问题

在这里插入图片描述
对于第一个人来说除了自己以外要跟其他49人握手所以第一个是49 ，对于第二个人来说第一个人主动跟我握手了有一次不算所以第二个是48.。以此类推第43个人就是7 到了最后七个人呢因为互相都没有握手并且7个人都被前面的人握过手了所以都是0

#include <iostream>
using namespace std;
int main(){
    int sum=0;
    for(int i=7;i<=49;i++) sum+=i;
    cout<<sum;
    return 0;
}

报数问题

在这里插入图片描述

第1-10个： 20 24 40 48 60 72 80 96 100 120

第11-20个：140 144 160 168 180 192 200 216 220 240

第21-30个：260 264 280 288 300 312 320 336 340 360

第31-40个：380 384 400 408 420 432 440 456 460 480

思路一：发现第10个数，第20个数，第30个数，第40个数......（每十个数为一轮）等等都是120的倍数，

既然题目要求第202420242024个数，那我们不妨先求第202420242020个数，然后再往后再多求4个数就行。

也就是202420242020/10*120=202429042904240，找它之后的四个能被20或24整除的数，也就是

2429042904288

思路二：通过观察发现，第奇数位个数是20的倍数，第偶数位个数是24的倍数。所以第202420242024个数

就是24的倍数，那我们直接除以2（判断是这个数是第几个24的倍数)，然后再乘24就行。

也就是202420242024÷2×24=2429042904288

杂题

游戏专家（零和博弈）

在这里插入图片描述

输入格式
一行一个字符串
s（1≤∣s∣≤1000）由小写英文字母组成。
样例输入
bazabyakslfd

样例输出
zbybzazazaza

分治思想（交替处理策略）先行者和后行者对应偶数和奇数
我们轮流让小蓝和小桥修改字符串，小蓝尽量将字符变成字典序最大的字母 z，小桥尽量将字符变成字典序最小的字母 a。

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

int main()
{
    string s;
    cin >> s;
    int n = s.size();

    // 轮流修改字符串
    for (int i = 0; i < n; i++)
    {
        if (i % 2 == 0)  // 小蓝的回合，尽量使字典序最大
        {
            if (s[i] != 'z')  // 如果当前字符不是'z'，则将其改为'z'
            {
                s[i] = 'z';
            }
        }
        else  // 小桥的回合，尽量使字典序最小
        {
            if (s[i] != 'a')  // 如果当前字符不是'a'，则将其改为'a'
            {
                s[i] = 'a';
            }
        }
    }

    cout << s;  // 输出最终字符串
    return 0;
}

大衣的异或回文对（回文判断）

在这里插入图片描述

样例输入1
4
13 27 12 26

样例输出1
8

样例输入2
3
2 2 2

样例输出2
6

使用字符判断回文

// 判断整数 x 是否是回文
bool isPalindrome(int x) {
    string s = to_string(x);
    string rev_s(s.rbegin(), s.rend());
    return s == rev_s;
}

使用数字判断回文

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

const int N = 2e4 + 10;

ll a[N];
ll ans;

// 判断是否是回文数
bool hw(ll n) {
    ll sum = 0;
    ll k = n;
    while (n != 0) {
        sum = (sum * 10) + (n % 10);  // 反转数字
        n /= 10;
    }
    return sum == k;  // 如果反转的数字等于原数字，则为回文数
}

int main() {
    ll n;
    cin >> n;
    
    
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    
    // 遍历所有对 (i, j) 计算异或并判断是否是回文数
    for (int i = 1; i <= n; i++) {
        for (int j = i; j <= n; j++) {
            if (hw(a[i] ^ a[j])) {
                ans++;
            }
        }
    }
    
   
    cout << ans << endl;
    return 0;
}

寻找至宝的奥秘（数学）

在这里插入图片描述

最大公因数的基本概念：
最大公因数（GCD）是指两个数的最大共有因子。比如，gcd(12, 15) = 3，因为 12 和 15 都能被 3 整除，而没有比 3 更大的共同因子。

思路分析：

最大公因数的性质：
- 假设我们有两个正整数 a 和 b，如果它们的 GCD 很大，那么这两个数的因子也应该尽量重合。
- 如果我们选取 a = n 和 b = n / 2，那么它们的 GCD 通常会比较大。具体来说，gcd(n, n/2) 总是 n/2（这是因为 n/2 是 n 的因子，并且它们共享 n/2 作为共同因子）。
为什么选择 n 和 n / 2：
- 选择 n 和 n / 2 作为候选：
  - 如果我们选择两个数 a = n 和 b = n / 2，这两个数之间的最大公因数是 n / 2。这是因为：
    - n 是 n / 2 的倍数，n 和 n / 2 的最大公因数就是 n / 2。
  - 例如，当 n = 10 时，n = 10 和 n / 2 = 5，这两个数的 GCD 是 5。
- 为什么 n / 2 会是最大值：
  - 当我们选择两个数时，我们希望它们的最大公因数尽可能大。n / 2 是 n 最大的因子之一，所以选择 n 和 n / 2 总是能得到最大的 GCD。
其他可能的组合：
- 如果选择 a = n 和 b = n - 1，它们的最大公因数一般会较小，因为相邻的整数的 GCD 总是 1。
- 同理，其他的一些数对，如 a = n 和 b = n - 2 等，都会比 n / 2 和 n 的 GCD 小。

例子：

例子 1：
输入：n = 10
- 我们选择 a = 10 和 b = 10 / 2 = 5，计算 gcd(10, 5)，结果是 5。
- 因为 10 和 5 的最大公因数是 5，这是最大的 GCD。
例子 2：
输入：n = 12
- 我们选择 a = 12 和 b = 12 / 2 = 6，计算 gcd(12, 6)，结果是 6。
- 因为 12 和 6 的最大公因数是 6，这是最大的 GCD。

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    
    // 输出 n / 2 即可得到最大公因数
    cout << n / 2 << endl;
    
    return 0;
}

小蓝的战斗计划

在这里插入图片描述

优先尝试消灭需要 2 个单位时间的怪物：遍历排序后的所有时间段 b[i]，如果 b[i] ≥ 2，就尽可能使用该时间段来消灭“需要 2 个单位时间”的怪物（min(cnt2, b[i]/2)）。在此操作中，消灭多少头怪物，就从 cnt2 和 b[i] 各自对应的“数量”中减去相应数值。
然后尝试消灭需要 1 个单位时间的怪物：再次遍历同一个排序后的时间段数组，如果 b[i] ≥ 1，就用这个时间段去消灭尽量多的 cnt1 怪物（min(cnt1, b[i])）。
最后检查 cnt1 和 cnt2 是否都被消灭（即 cnt1 == 0 && cnt2 == 0）。若全部消灭则输出 “Y”，否则输出 “N”。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;

int n, m;
int cnt1 = 0, cnt2 = 0;
int a[N], b[N];

int main() {
    cin >> n >> m;

    // 输入怪物的战斗时间，并统计需要时间1和时间2的怪物数量
    for (int i = 1; i <= n; i++) {
        int x;
        cin >> x;
        if (x == 1) {
            cnt1++;
        } else {
            cnt2++;
        }
    }

    // 输入时间段的长度
    for (int i = 1; i <= m; i++) {
        cin >> b[i];
    }

    // 对时间段进行降序排序
    sort(b + 1, b + 1 + m, [](int u, int v) { return u > v; });

    // 优先使用时间段消灭需要时间2的怪物
    //由于已通过 b[i]/2 把每只“2单位时长”怪物向下折算成占 1 个“怪物位置”的逻辑，
    //因此只需要在放入 x 只后执行 b[i] -= x（而不是 b[i] -= 2*x）
    for (int i = 1; i <= m && cnt2 > 0; i++) {
        if (b[i] >= 2) {  // 如果时间段长度>=2，可以消灭一个需要时间2的怪物
            int x = min(cnt2, b[i] / 2);  // 计算能消灭多少个怪物
            cnt2 -= x;  // 更新需要消灭时间2的怪物数量
        }
    }

    // 使用剩余的时间段消灭需要时间1的怪物
    for (int i = 1; i <= m && cnt1 > 0; i++) {
        if (b[i] >= 1) {  // 如果时间段长度>=1，可以消灭一个需要时间1的怪物
            int x = min(cnt1, b[i]);  // 计算能消灭多少个怪物
            cnt1 -= x;  // 更新需要消灭时间1的怪物数量
        }
    }

    // 判断是否所有怪物都被消灭
    if (cnt1 == 0 && cnt2 == 0) {
        cout << "Y" << endl;
    } else {
        cout << "N" << endl;
    }

    return 0;
}

公司名称（字符串）

在这里插入图片描述

样例输入
5
7
Lqaaoin
7
Lanqiao
8
Lanqiaoo
2
ac
7
niLaqqa

样例输出
YES
YES
NO
NO
NO

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

int main() {
    string name = "Lanqiao";
    int t;
    cin >> t;
    
    while (t--) {
        int n;
        cin >> n;
        string s;
        cin >> s;
        
        if (name.length() == s.length()) {
            for (char j : name) {
                int pos = s.find(j);
                if (pos != string::npos) {
                    s.erase(pos, 1); // 从pos开始删除一个字符
                }
            }
            
            if (s.empty()) 
                cout << "YES" << endl;
            else 
                cout << "NO" << endl;
        } else {
            cout << "NO" << endl;
        }
    }
    
    return 0;
}

蓝桥杯题型

蓝桥杯

蓝桥杯题型分类

语法基础

艺术与篮球（日期问题）

时间显示（时间问题）

跑步计划（日期问题）

偶串(字符）

最长子序列（字符）

字母数（进制转换）

6个0（进制转换）

优秀的拆分（位运算）

异或数列(位运算)

幸运数字的个数(预计算）

填空

握手问题

报数问题

杂题

游戏专家（零和博弈）

大衣的异或回文对（回文判断）

寻找至宝的奥秘（数学）

小蓝的战斗计划

公司名称（字符串）

航班时间（字符串读取+方程式）

蓝桥村的神秘信件（字符串）

打开石门

诺伊的神秘密码(字符串切割）

超级的大串 （字符组合）

食堂活动 （哈希字符）

特殊日期

高斯日记（日期差值）

跑步锻炼（日期问题）

回文日期

特殊时间（枚举日期）

高精度

进制转换

前缀和和差分

求和（前缀和）

重新排序

光骓者的荣耀（一维前缀和）

领地的选择（二维前缀和）

地毯（差分）

卡牌游戏

二分

求阶乘

青蛙过河

管道

技能升级

分巧克力

跳石头

可凑成的最大花束数

最大通过数

蓝桥A梦做铜锣烧

肖恩的苹果林

妮妮的月饼工厂

一元三次方程求解

123

贪心

部分背包问题

线段覆盖（不相交区间问题）

区间覆盖

区间覆盖（加强版）

填充

买二赠一

购物（可组成范围）

三国游戏

平均

答疑

搬砖

卡牌游戏

小蓝的旅行计划

防御力

排座椅

母舰

dfs

寒假作业

剪格子

分考场

像素放置

迷宫（2017）

超级的大串（字符组合）

食堂活动（哈希字符）