蓝桥杯刷题笔记

奇怪的捐赠

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
int main(){
    // 初始化变量num为1000000，代表总金额为100万元
    int num = 1000000;
    // 初始化变量cnt为0，用于记录最终划分的份数
    int cnt = 0;
    // 当num不为0时，持续进行循环，此循环的目的是将总金额按七进制拆分
    while(num) {
        // num % 7 计算出当前num在七进制下的最低位数字
        // 这个数字代表了当前7的0次方（即1元）这一份额的数量
        // 将其累加到cnt中
        cnt += num % 7;
        // num /= 7 相当于将num在七进制下右移一位
        // 也就是去掉当前七进制表示中的最低位，继续处理更高位
        num /= 7;
    }
    // 输出最终划分的份数
    cout << cnt;

    return 0;
}

#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;

int main() {
    // 初始金额为100万元，单位为元
    int money = 1000000;
    // 用于记录划分的份数，初始化为0
    int cnt = 0;
    // 从7的0次方到7的7次方进行遍历，这里k表示7的幂次，从大到小遍历
    for(int k = 7; k >= 0; k--) {
        // 计算当前7的k次幂能划分出的份数，即总金额除以当前7的幂次方
        int numitems = money / pow(7, k);
        // 如果划分出的份数大于5份，按照要求最多只能取5份
        if(numitems > 5) numitems = 5;
        // 将当前划分的份数累加到总份数cnt中
        cnt += numitems;
        // 从总金额中减去当前划分所使用的金额
        money -= numitems * pow(7, k);
        // 如果总金额已经为0，说明已经全部分完，跳出循环
        if(money == 0) break;
    }
    // 输出划分的总份数
    cout << cnt;
    return 0;
}

 排序

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

// 自定义比较函数 cmp，用于降序排序
bool cmp(int a, int b) {
    return a > b;
}

int main() {
    int n;
    cin >> n;
    // 使用 vector 动态数组存储输入的整数
    vector<int> a(n);

    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }

    // 升序排序
    sort(a.begin(), a.end());

    for (int i = 0; i < n; i++) {
        cout << a[i];
        if (i < n - 1) {
            cout << " ";
        }
    }
    cout << "\n";

    // 降序排序
    sort(a.begin(), a.end(), cmp);

    for (int i = 0; i < n; i++) {
        cout << a[i];
        if (i < n - 1) {
            cout << " ";
        }
    }

    return 0;
}

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;

// 定义一个常量 maxn，用于数组的最大长度，这里设置为 1e9 + 9
const long long maxn = 5e5+9;
// 定义一个整数数组 a，用于存储输入的整数
long long a[maxn];

// 自定义比较函数 cmp，用于降序排序
bool cmp(long long a, long long b) {
    // 如果 a 大于 b，则返回 true，否则返回 false
    return a > b;
}

int main() {
    // 定义一个整数 n，用于存储输入整数的数量
    long long n;
    // 从标准输入读取整数 n
    cin >> n;

    // 循环读取 n 个整数，并存储到数组 a 中
    for (long long i = 0; i < n; i++) {
        cin >> a[i];
    }

    // 使用 sort 函数对数组 a 进行升序排序，默认情况下 sort 是升序排序
    sort(a, a + n);

    // 循环输出升序排序后的数组元素，元素之间用空格分隔
    for (long long i = 0; i < n; i++) {
        cout << a[i];
        if (i < n - 1) {
            cout << " ";
        }
    }
    // 输出换行符
    cout << "\n";

    // 使用 sort 函数和自定义比较函数 cmp 对数组 a 进行降序排序
    sort(a, a + n, cmp);

    // 循环输出降序排序后的数组元素，元素之间用空格分隔
    for (long long i = 0; i < n; i++) {
        cout << a[i];
        if (i < n - 1) {
            cout << " ";
        }
    }

    return 0;
}

4. 浓缩咖啡液【算法赛】 

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;

int main(){
    // 定义变量 t，用于存储测试用例的数量
    int t;
    // 从标准输入读取测试用例的数量
    cin >> t;

    // 循环处理每个测试用例
    while(t--){
        // 定义变量 n 和 m，n 表示数组的长度，m 是一个比较值
        int n, m;
        // 从标准输入读取数组长度 n 和比较值 m
        cin >> n >> m;

        // 定义一个大小为 n 的整数向量 v，用于存储数组元素
        vector<int> v(n);
        // 循环读取 n 个整数，并将它们存入向量 v 中
        for(int i = 0; i < n; i++) {
            cin >> v[i];
        }

        // 定义两个标志变量 a 和 b，初始值都为 0
        // a 用于标记数组中是否存在小于等于 m 的元素
        // b 用于标记数组中是否存在大于等于 m 的元素
        int a = 0, b = 0;

        // 遍历向量 v 中的每个元素
        for(int i = 0; i < n; i++){
            // 如果当前元素等于 m
            if(v[i] == m){
                // 同时将 a 和 b 置为 1，表示既存在小于等于 m 的元素（就是 m 本身），也存在大于等于 m 的元素（就是 m 本身）
                a = 1;
                b = 1;
            } 
            // 如果当前元素小于 m
            else if(v[i] < m){
                // 将 a 置为 1，表示存在小于等于 m 的元素
                a = 1;
            } 
            // 如果当前元素大于 m
            else if(v[i] > m) {
                // 将 b 置为 1，表示存在大于等于 m 的元素
                b = 1;
            }
        }

        // 如果 a 和 b 都为 1，说明数组中既存在小于等于 m 的元素，又存在大于等于 m 的元素
        if(a && b) {
            // 输出 "YES" 并换行
            cout << "YES\n";
        } 
        // 否则
        else {
            // 输出 "NO" 并换行
            cout << "NO\n";
        }
    }

    return 0;
}

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;

// 定义一个常量 maxn 作为数组的最大长度
const int maxn = 1010;
// 定义一个整型数组 a，用于存储输入的数字，数组大小为 maxn
int a[maxn];

int main()
{
    // 定义变量 t 用于存储测试用例的数量
    int t;
    // 从标准输入读取测试用例的数量
    cin >> t;

    // 循环处理每个测试用例，t-- 表示每次循环后 t 的值减 1，直到 t 为 0 时停止循环
    while(t--){
        // 定义变量 n 用于存储当前测试用例中数组的元素个数，m 用于存储目标值
        int n, m;
        // 从标准输入读取 n 和 m 的值
        cin >> n >> m;

        // 循环读取 n 个整数，将它们依次存入数组 a 中
        for(int i = 0; i < n; i++) {
            cin >> a[i];
        }

        // 使用 sort 函数对数组 a 进行升序排序，a 是数组起始地址，a + n 是数组结束地址的下一个位置
        sort(a, a + n);

        // 判断目标值 m 是否在排序后数组的最小值和最大值之间（包括边界值）
        if(m >= a[0] && m <= a[n - 1]) {
            // 如果满足条件，输出 "YES" 并换行
            cout << "YES\n";
        } else {
            // 如果不满足条件，输出 "NO" 并换行
            cout << "NO\n";
        }
    }
    return 0;
}

破译密码【算法赛】 

#include <bits/stdc++.h>
using namespace std;
// 使用类型别名 ll 来表示 long long 类型，方便后续代码编写
using ll = long long;

// 定义一个结构体 t 来表示芯片
// 每个芯片有两个属性：l 表示解密时间，r 表示传输时间
struct t {
    ll l, r; // l 为解密时间，r 为传输时间
} a[1010];

// 自定义比较函数 cmp，用于对芯片数组进行排序
// 排序规则决定了芯片处理的顺序，以使得总时间最短
bool cmp(t a1, t a2) {
    // 比较两个芯片的解密时间和传输时间的某种组合
    // 这里的规则是根据 min(a1.l, a2.r) 和 min(a2.l, a1.r) 的大小来排序
    return min(a1.l, a2.r) < min(a2.l, a1.r);
}

// 定义全局变量
// n 表示芯片的数量
// ans 用于记录最终的最小总时间
// sum 用于记录当前累计的解密时间
ll n, ans, sum;

int main() {
    // 从标准输入读取芯片的数量 n
    cin >> n;

    // 循环读取每个芯片的解密时间，并存储在数组 a 中
    for (int i = 1; i <= n; i++) {
        cin >> a[i].l;
    }

    // 循环读取每个芯片的传输时间，并存储在数组 a 中
    for (int i = 1; i <= n; i++) {
        cin >> a[i].r;
    }

    // 使用自定义的比较函数 cmp 对芯片数组 a 进行排序
    // 排序范围是从 a[1] 到 a[n]
    sort(a + 1, a + n + 1, cmp);

    // 遍历排序后的芯片数组
    for (int i = 1; i <= n; i++) {
        // 累加当前芯片的解密时间到 sum 中
        sum += a[i].l;

        // 判断当前累计的解密时间 sum 是否大于等于之前记录的总时间 ans
        if (sum >= ans) {
            // 如果 sum 大于等于 ans，说明当前芯片的解密完成后才开始传输，更新总时间 ans
            ans = sum + a[i].r;
        } else {
            // 如果 sum 小于 ans，说明前一个芯片的传输还未完成，当前芯片的传输接着进行，更新总时间 ans
            ans = ans + a[i].r;
        }
    }

    // 输出最终的最小总时间
    cout << ans << "\n";

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
// 使用typedef为long long定义一个别名ll，方便后续代码书写
typedef long long ll;

// 定义一个结构体t，用于表示芯片，每个芯片有两个属性
struct t {
    ll l, r; // l: 破译时间, r: 传输时间
} a[1010];

// Johnson算法的比较函数，用于对芯片数组进行排序，以找到最优处理顺序
bool cmp(t a1, t a2) {
    // 比较两个芯片的r和另一个芯片的l的较小值
    // 这里是Johnson算法的关键比较部分
    if (min(a1.r, a2.l) == min(a2.r, a1.l)) {
        // 当min(a1.r, a2.l)等于min(a2.r, a1.l)时
        // 按破译时间l升序排列，即a1.l较小的排在前面
        // 若两个芯片比较的关键值相等，则优先处理破译时间短的芯片
        return a1.l < a2.l;
    }
    // 若min(a1.r, a2.l)和min(a2.r, a1.l)不相等
    // 返回min(a2.r, a1.l) < min(a1.r, a2.l) 的结果
    // 这一步是Johnson算法核心比较逻辑，通过这样的比较决定芯片的排序
    // 让满足此条件的芯片a1排在a2前面，以此来优化整体处理时间
    return min(a2.r, a1.l) < min(a1.r, a2.l);
}

int main() {
    int n;
    // 从标准输入读取芯片的数量
    cin >> n;
    // 循环读取每个芯片的破译时间，并存储在数组a中
    for (int i = 1; i <= n; i++) cin >> a[i].l;
    // 循环读取每个芯片的传输时间，并存储在数组a中
    for (int i = 1; i <= n; i++) cin >> a[i].r;

    // 使用自定义的比较函数cmp对芯片数组a进行排序
    // 排序范围是从a[1]到a[n]
    // 经过排序后，芯片会按照能使总处理时间最短的顺序排列
    sort(a + 1, a + n + 1, cmp);

    // sum用于记录累计的破译时间
    // ans用于记录完成所有芯片处理的最小总时间
    ll sum = 0, ans = 0;

    // 遍历排序后的芯片数组
    for (int i = 1; i <= n; i++) {
        // 累加当前芯片的破译时间到sum中
        sum += a[i].l;
        // 计算当前芯片处理完后的总时间
        // 取ans和sum中的较大值，是因为要考虑前一个芯片传输未完成的情况
        // 然后加上当前芯片的传输时间
        // 若前一个芯片传输还未结束，当前芯片需等待，所以取较大值
        ans = max(ans, sum) + a[i].r;
    }
    // 输出完成所有芯片处理的最小总时间
    cout << ans << "\n";
    return 0;
}

插入数字【算法赛】 

#include <cstdio>
#include <iostream>
// 包含 string 头文件，因为代码中使用了 std::string 类型
#include <string>
using namespace std;

int main(){
    // 定义一个字符串变量 s，用于存储从标准输入读取的字符串
    string s;
    // 从标准输入读取一个字符串，并将其存储到变量 s 中
    cin >> s;

    // 判断字符串 s 的长度是否为 1 且该字符串唯一的字符为 '0'
    if(s.size() == 1 && s[0] == '0') {
        // 如果满足条件，输出数字 9
        cout << 9;
    }

    // 计算一个值并存储在变量 sum 中
    // 计算规则是字符串 s 的长度加 1 后再乘以 9
    long long sum = (s.size() + 1) * 9;

    // 输出计算得到的 sum 值
    cout << sum;

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

#include <iostream>
#include <string>
#include <set>

using namespace std;

int main() {
    // 定义一个字符串变量 num_str 用于存储输入的正整数
    string num_str;
    // 从标准输入读取一个正整数，并将其作为字符串存储到 num_str 中
    cin >> num_str;

    // 定义一个集合 unique_nums 用于存储插入数字后得到的不同数字
    // 集合的特性是元素唯一，可自动去重
    set<string> unique_nums;

    // 遍历可插入的数字，范围是 0 到 9
    for (int insert_num = 0; insert_num <= 9; ++insert_num) {
        // 将插入的数字转换为字符形式
        char insert_char = insert_num + '0';

        // 在数字开头插入字符
        // 若插入的数字不是 0 时才进行插入操作，避免生成以 0 开头的无效数字
        if (insert_num != 0) {
            string new_num = string(1, insert_char) + num_str;
            unique_nums.insert(new_num);
        }

        // 在数字结尾插入字符
        string new_num_end = num_str + string(1, insert_char);
        unique_nums.insert(new_num_end);

        // 在数字的相邻数字之间插入字符
        for (int i = 1; i < num_str.length(); ++i) {
            string new_num_middle = num_str.substr(0, i) + string(1, insert_char) + num_str.substr(i);
            unique_nums.insert(new_num_middle);
        }
    }

    // 输出集合中不同数字的数量，即通过插入操作能得到的不同数字的种类数
    cout << unique_nums.size() << endl;

    return 0;
}    

 

试题 A ：跑步训练

【问题描述】

小明要做一个跑步训练。

初始时，小明充满体力，体力值计为 10000 。如果小明跑步，每分钟损耗 600 的体力。如果小明休息，每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。

小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循环。如果某个时刻小明的体力到达 0，他就停止锻炼。请问小明在多久后停止锻炼。

请问小明在多久后停止锻炼。为了使答案为整数，请以秒为单位输出答案。答案中只填写数，不填写单位。

【答案提交】

这是一道结果填空题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include <iostream>
using namespace std;

int main() {
    int n = 10000;
    int i, ans = 0;

    // 检查初始体力值是否为 0
    if (n == 0) {
        cout << ans;
        return 0;
    }

    while (true) {
        for (i = 1; i <= 60; i++) {
            n -= 10;  // 每秒钟损耗 10 的体力
            ans += 1;
            if (n <= 0) {
                cout << ans;
                return 0;  // 体力耗尽，程序结束
            }
        }
        for (i = 1; i <= 60; i++) {
            n += 5;
            ans += 1;
        }
    }

    return 0;
}