牛客-模拟、枚举、贪心 2022.10.27

最新推荐文章于 2024-05-09 00:45:37 发布
原创 最新推荐文章于 2024-05-09 00:45:37 发布 · 240 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #c++ #贪心算法

博客提及了两道NOIP题目，分别是[NOIP2007]字符串的展开和[NOIP2010]机器翻译，对于这两道题，均表示简单模拟输出即可。涉及算法相关内容。
部署运行你感兴趣的模型镜像

[NOIP2007]字符串的展开

简单模拟输出即可

#include<bits/stdc++.h>
using namespace std;
int main() {
    int p1, p2, p3;
    cin >> p1 >> p2 >> p3;
    string s;
    cin >> s;
    if(p1 == 1) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }   
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b + 32 - 1; j > a + 32; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    } else if(p1 == 2) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a - 32 + 1; j < b - 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 32 - 1; j > a - 32; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = b - 1; j > a; j--) {
                                    for(int k = 0; k < p2; k++)
                                        cout << j;
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    } else if(p1 == 3) {
        if(p3 == 1) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        } else if(p3 == 2) {
            for(int i = 0; i < s.size(); i++) {
                if(s[i] == '-') {
                    char a = s[i - 1];
                    char b = s[i + 1];
                    if(a >= 'a' && a <= 'z' && b >= 'a' && b <= 'z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else
                            cout << s[i];
                    } else if(a >= 'A' && a <= 'Z' && b >= 'A' && b <= 'Z') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 32 + 1; j < b + 32; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else if(a >= '0' && a <= '9' && b >= '0' && b <= '9') {
                        if(a < b) {
                            if(a + 1 == b)
                                continue;
                            else {
                                for(char j = a + 1; j < b; j++) {
                                    for(int k = 0; k < p2; k++)
                                        cout << "*";
                                }
                            }
                        } else 
                            cout << s[i];
                    } else
                        cout << s[i];
                } else 
                    cout << s[i];
            }
        }
    }
    return 0;
}

[NOIP2010]机器翻译

简单模拟输出即可

#include <bits/stdc++.h>
using namespace std;
int num[5010];
bool vis[1010];
int main() {
    int m, n;
    cin >> m >> n;
    memset(num, 0, sizeof(num));
    memset(vis, false, sizeof(vis));
    int start = 0, end = 0, res = 0;
    for(int i = 0; i < n; i++) {
        int tar;
        cin >> tar;
        if(!vis[tar]) {
            res += 1;
            vis[tar] = true;
            num[end] = tar;
            end += 1;
            if(end - start > m) {
                vis[num[start]] = false;
                start += 1;
            }
        }
    }
    cout << res << endl;
    return 0;
}

您可能感兴趣的与本文相关的镜像

Facefusion

Facefusion

AI应用

FaceFusion是全新一代AI换脸工具，无需安装，一键运行，可以完成去遮挡，高清化，卡通脸一键替换，并且Nvidia/AMD等显卡全平台支持

华为od机考攻略，参考资料
VAN
10-18 8万+
华为od机考攻略
牛客算法竞赛入门课第一节习题 2022.10.3
Ls_attack的博客
10-03 1111
01串，即通过二进制位表示当前要选择的行或者列的状态。这样可以等价于进行深度优先搜索的返回结果，但是相较于深度优先搜索写法更加简单，同时对于状态记录更加容易去除一些重复记录的值。对于行或者列，先进行行选取，选择某些行的权值求和，之后再对列进行选取，记录相应的状态并求和。之后对于求和记录最大值。每次对数组中的数据进行操作后，之后都要记得恢复。
牛客-模拟、枚举与贪心 2022.10.19
Ls_attack的博客
10-19 542
递推 用res[i]表示iloveyou匹配了前i个的字符的子序列数，当遇到第i个字符，则之前匹配了前i-1个的字符的子序列都可以变为匹配了前i个的字符的子序列，即res[i]=res[i]+res[i-1]递推+高精度（所以python）
牛客-模拟、枚举与贪心 2022.10.25
Ls_attack的博客
10-25 227
根据这个关注点可以知道，这里我们不用从后先前逐个进行四舍五入。a.i-1位的值为9，那么将该位置置0，向前进1；如果首位为9加1那么先输出一个1在输出数字。1、若i 的值是四，那么可以继续五入并继续检查i-1是否为4，如果为4那么继续进行五入。2、i的值为小数点，那么将此位置为结束位。同时查看i-1位即小数点前一位的值。先mark，还在求解中，感觉这周可能都调试不出，提高组水平的题。b.i-1的值不为9，该位加1.让他的成绩可以在小数点后的。
牛客-模拟、枚举与贪心 2022.10.22
Ls_attack的博客
10-22 196
由于全是小写字符串，使用一个数组，记录每个字母存在的最后一个位置。从最大字母开始遍历到最小字符，这一过程中遍历原字符串，输出其中的当前最大字符，即可得到最终的结果。昨天写的题目较为简单，和今天写的一起做一个总结。构建哈夫曼树，哈夫曼编码。
牛客-模拟、枚举与贪心 2022.10.31
Ls_attack的博客
10-31 240
当我们希望对原数组的某一个区间[l,r]施加一个增量inc时，差分数组d对应的变化是：d[l]增加inc，d[r+1]减少inc，并且这种操作是可以叠加的。这道题目中，每次增量的数目为1。之后对于每个位置的不同货物的种数，进行一个前缀和，即可得到每个位置的不同货物的数目。当我们需要对原数组的不同区间施加不同的增量，我们只要按规则修改差分数组即可。（新学了差分数组这一数据结构，初次接触，之后好好复习）
牛客-模拟、枚举与贪心 2022.10.23
Ls_attack的博客
10-23 435
先对数组按照从小打到排序，第一次，先让第一个数和第二个数大小相等，即相加的n-1个数只除了第二个数字，第二次，让第一第二个数和第三个数大小相等，即相加的n-1个数只除了第三个数字，之后每次相加同理，相加n-1次，即可得到答案，最后的结果就是最大的数字加上每次两个数字的差值，做一个前缀和相加。简单模拟输出，一眼可知，凳子消除最贵的商品，所以比较凳子和购物车两者的最小值，即可以得到最终的结果。一开始的想法是从前往后相加相同的数字，然后删除，但是会导致之后的数字也相同，导致并不是最少的次数。
牛客-模拟、枚举与贪心-2022.10.18
Ls_attack的博客
10-18 213
输出第一个最小的非零的数字，如果存在零，只输出一个，然后输出零个数的一半，之后继续从小到大输出即可。昨天和今天写的题都比较简单，本来都不想挂，但是还是觉得浅浅记录一下。
牛客-模拟、枚举与贪心 2022.10.24
Ls_attack的博客
10-24 191
直接贪心，直接算出平均的水温,再分类讨论一下即可。假如平均的水温比n个杯子里的都小,那么肯定大水缸是降温的.假如平均的水温比最大的要大,说明大水缸是升温的,不然我的大水缸的温度夹在max和min中间,那么一定是不能调节的。记录每行，每列可以分隔的同桌人数，然后按照行号，列号从小到大的顺序输出前k行，前l列最大的数值即可。如果是正数，直接将其放到到第一个进行删除是最优的，如果是负数，将其在当前位置删除则是最优的。
牛客-模拟、枚举与贪心 2022.10.20
Ls_attack的博客
10-20 297
可以看到，当将第一行的答案放在第一列的时候，剩下的就是求的答题卡规模为(n - 1) * (n - 1) 的所有方案,当第一行的答案放在第二列的时候，剩下的就是求答题卡规模为(n - 2) * (n - 2) 的所有方案（因为此时根据答案横竖相同要求的对称性，确定了一行的同时也就确定了一列，所以此时有两行和两列都不能进行选择），同理将第一行的答案放在第三列也是一样的。所以横答题卡某一行的答案确定之后，对应的竖答题卡的某一列的答案也就确定了，并且交于这两个答案的行和列也已经确定了。在棋盘规模为 的情况下，
牛客-模拟、枚举、贪心 2022.11.15
Ls_attack的博客
11-15 347
之后对于每个名字的查询，从名字的第一个字母出现的第一个位置开始，二分查找之后每个字母的位置是否大于当前的位置，如果大于，更新当前位置，直至名字数组结束，说明存在子序列，否则不存在。如果二者最高位相同，则比较下一位，直到出现不同的二进制位置，那么从这一位置开始往后到二进制的最低位，存在全为一的最大值，之前的高位置都相同，异或结果为0。对于药剂的数值，按照从大到小排序，对于奶牛的区间，按照区间最小值从大到小排序，之后遍历奶牛，对于每头奶牛，遍历药剂看是否存在符合条件的药剂，记录结果即可。模拟遍历01串即可。
2022牛客暑期多校训练营训练日志
qq_43003147的博客
10-10 903
点石成我的训练日志
长沙学院2022蓝桥杯模拟赛一
qq_49593247的博客
12-19 1712
A.因子和 B.找数 C.数与连分数 D.文件查找 E.多米诺骨牌 F.财富分配 G.分数鄙视 A.因子和 B.找数 C.数与连分数 D.文件查找 E.多米诺骨牌 F.财富分配 G.分数鄙视
【算法题】机试指南-基础篇
专注大前端
05-09 1256
STL定义了强大的、基于模板的、可复用的组件，实现了许多通用的数据结构及处理这些数据结构的算法。其中包含三个关键组件——容器（container，流行的模板数据结构）、迭代器（iterator）和算法（algorithm）。容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。评判结果就是提交代码后系统返回的结果，这个不仅仅只是一个结果，还可以是一个debug的提示。迭代器 用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
牛客-模拟、枚举与贪心 2022.11.16
Ls_attack的博客
11-16 434
分成三类，稳定值增加，不变，减少。考虑从后往前遍历减少的情况，可以发现最后一个要符号条件，需要当前值大于消耗值，而恢复值是不需要看的，因为消耗完就结束了，所以恢复值不是那么重要。看到异或操作其实第一反应就是将数据改写成二进制形式，之后再观察样例的输出结果，可以发现如果当前二进制位零的个数超过了数据个数的一半，就讲结果这一位二进制写为零，否则写为一（因为需要多组可行解的情况下，数值尽可能小）（零的个数正好为一半时可以为零，也可以为一，但是为了数值尽可能小，所以选择为零）但是直接遍历只能过60%，还需要优化。
牛客-栈、队列和stl 2022.10.12
Ls_attack的博客
10-12 356
一开始的想法是寻找从n开始到1的序列，但是只能过7.51%，题解区的做法是：贪心思想，记录一个后缀的最大值数组，每次将数组元素入栈，然后比较栈顶元素和当前最大值，如果栈顶元素大于当前最大值，则出栈，直到小于为止。（还是没想明白为何一开始做法不对，明后几天继续想想）昨天面试和笔试有点多，没时间刷了，写了两道水题感觉没必要记录，所以没有写。今天面了两家，笔了三家，抽空写了这么一道可以记录的题。
牛客-函数与递归 2022.10.10
Ls_attack的博客
10-10 331
其实就是简单的根据字符串序列，每次使用前半段构建左子树，后半段构建右子树，当前字符串判定是I，B，F串然后按照后序遍历的顺序输出。每次截取可以使用开始下标和结束下标进行标记，在这个范围内判断字符串输出什么即可。
牛客算法竞赛入门课第一节习题 2022.10.1
Ls_attack的博客
10-01 304
先求取一个前缀和数组，通过前缀和数组求取各个k个数序列的大小。之后先从前往后更新记录k个数序列的最大值，再从后往前更新记录k个数序列的最小值，最后从前往后或者从后往前遍历一次所有序列，对每次能取到的最大值求和，更新，得到最后的结果。通过每次对当前数值n的大小进行更新，从而能够逐步缩小范围从而规避第三种情况。对输入数字进行分解质因数。
牛客-语法入门-循环结构程序设计 2022.10.5
Ls_attack的博客
10-05 268
负数进制转换规则：如果余数mod为负数，余数mod减去除数base进制基数，之后数字n减去余数mod再除以进制基数base，循环往复即可。记录上下限求取差值，还需要前缀和进行差值累加。
牛客 2021秋季算法入门班第一章习题：模拟、枚举、贪心
最新发布
07-16
牛客网的算法入门班通常会围绕模拟、枚举和贪心这三种基础但重要的算法思想展开，尤其是在秋季训练营中，这类内容往往被安排在第一章或早期阶段，以便为新手打下扎实的基础。虽然无法直接提供2021秋季算法入门班的具体题目链接或完整题集，但可以结合常见的典型习题及解析方式来帮助理解这些算法的应用。 ### 模拟类题目 模拟类题目通常是根据题意进行一步步操作模拟，比如处理队列、栈的操作，或者按照某种规则进行状态更新的问题。 **示例题目：** - 题目描述：给定一个整数序列和一个操作次数 k，每次操作将数组中的每个元素替换为其后一个元素的值（最后一个元素变为第一个元素）。 - 解法思路：使用循环和数组拷贝即可实现，也可以通过数学推导优化成 O(n) 的时间复杂度。 - 示例代码： ```cpp #include <bits/stdc++.h> using namespace std; void rotateArray(vector<int>& nums, int k) { int n = nums.size(); vector<int> temp = nums; for (int i = 0; i < n; ++i) { nums[(i + k) % n] = temp[i]; } } int main() { vector<int> nums = {1, 2, 3, 4, 5}; int k = 2; rotateArray(nums, k); for (int num : nums) cout << num << " "; return 0; } ``` ### 枚举类题目 枚举类问题的核心是找出所有可能的情况，并从中筛选出满足条件的解。常见于子数组、子字符串、排列组合等问题。 **示例题目：** - 题目描述：给定一个整数数组，求出所有连续子数组的和，并找出最大值。 - 解法思路：暴力枚举所有子数组起点和终点，计算其和并维护最大值。 - 更优解法可使用 Kadane 算法实现 O(n) 时间复杂度[^1]。 - 示例代码（暴力枚举）： ```cpp #include <bits/stdc++.h> using namespace std; int maxSubArraySum(int arr[], int n) { int max_sum = INT_MIN; for (int i = 0; i < n; ++i) { int current_sum = 0; for (int j = i; j < n; ++j) { current_sum += arr[j]; max_sum = max(max_sum, current_sum); } } return max_sum; } int main() { int arr[] = {-2, -1, -3, 4, -1, 2, 1, -5, 4}; int n = sizeof(arr) / sizeof(arr[0]); cout << "Maximum subarray sum is " << maxSubArraySum(arr, n) << endl; return 0; } ``` ### 贪心类题目 贪心算法的关键在于每一步都选择当前状态下最优的选择，希望最终结果全局最优。这类问题常用于活动选择、任务调度、硬币找零等场景。 **示例题目：** - 题目描述：给定一组物品的价值与重量，以及背包的最大承重，求能装入背包的最大总价值（每种物品可取部分）。 - 解法思路：计算每个物品的单位重量价值，按从高到低排序，优先选取性价比高的物品。 - 示例代码： ```cpp #include <bits/stdc++.h> using namespace std; struct Item { int value, weight; double ratio; }; bool compare(Item a, Item b) { return a.ratio > b.ratio; } double fractionalKnapsack(int capacity, vector<Item>& items) { sort(items.begin(), items.end(), compare); double totalValue = 0.0; for (const auto& item : items) { if (capacity == 0) break; double take = min((double)item.weight, (double)capacity); totalValue += take * item.ratio; capacity -= take; } return totalValue; } int main() { vector<Item> items = {{60, 10}, {100, 20}, {120, 30}}; int capacity = 50; for (auto& item : items) item.ratio = (double)item.value / item.weight; cout << "Maximum value in Knapsack: " << fractionalKnapsack(capacity, items) << endl; return 0; } ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值