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

最新推荐文章于 2022-11-16 22:07:17 发布
最新推荐文章于 2022-11-16 22:07:17 发布
阅读量153 收藏
点赞数
分类专栏： 牛客网_CSP-J入门组 文章标签： 算法 c++ 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ls_attack/article/details/127560607
版权

[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;
}

Ls_attack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面试--牛客(1).pdf
03-21
C++面试--牛客(1).pdf
web前端-仿牛客答题板子.zip
最新发布
11-06
10. 构建工具：可能使用Webpack或Parcel等工具进行代码打包，优化资源加载速度。 这个项目是学习和提升Web前端全栈技能的好机会，涵盖了从基础的HTML/CSS到复杂的JavaScript交互，再到现代开发工具的使用。通过完成...
剑指offer（java版）----牛客.zip
09-20
- 贪心算法：理解贪心策略，解决部分最优解的问题，如最小生成树、活动安排等。 - 回溯法：用于解决组合问题和约束满足问题，如八皇后问题、N皇后问题。 3. 字符串处理： - KMP算法：了解如何高效地进行字符串...
Java面试宝典--牛客网.zip
07-19
《Java面试宝典--牛客网》是一份针对Java开发者，特别是应届毕业生和在校生进行校招面试准备的重要参考资料。这份资源由知名在线学习平台牛客网提供，旨在帮助求职者提升Java技术能力，顺利通过面试。...
牛客算法竞赛入门课第一节习题 2022.10.3
Ls_attack的博客
10-03 991
01串，即通过二进制位表示当前要选择的行或者列的状态。这样可以等价于进行深度优先搜索的返回结果，但是相较于深度优先搜索写法更加简单，同时对于状态记录更加容易去除一些重复记录的值。对于行或者列，先进行行选取，选择某些行的权值求和，之后再对列进行选取，记录相应的状态并求和。之后对于求和记录最大值。每次对数组中的数据进行操作后，之后都要记得恢复。
牛客-模拟、枚举与贪心 2022.10.19
Ls_attack的博客
10-19 341
递推 用res[i]表示iloveyou匹配了前i个的字符的子序列数，当遇到第i个字符，则之前匹配了前i-1个的字符的子序列都可以变为匹配了前i个的字符的子序列，即res[i]=res[i]+res[i-1]递推+高精度（所以python）
牛客-模拟、枚举与贪心 2022.10.23
Ls_attack的博客
10-23 302
先对数组按照从小打到排序，第一次，先让第一个数和第二个数大小相等，即相加的n-1个数只除了第二个数字，第二次，让第一第二个数和第三个数大小相等，即相加的n-1个数只除了第三个数字，之后每次相加同理，相加n-1次，即可得到答案，最后的结果就是最大的数字加上每次两个数字的差值，做一个前缀和相加。简单模拟输出，一眼可知，凳子消除最贵的商品，所以比较凳子和购物车两者的最小值，即可以得到最终的结果。一开始的想法是从前往后相加相同的数字，然后删除，但是会导致之后的数字也相同，导致并不是最少的次数。
牛客-模拟、枚举与贪心 2022.11.16
Ls_attack的博客
11-16 278
分成三类，稳定值增加，不变，减少。考虑从后往前遍历减少的情况，可以发现最后一个要符号条件，需要当前值大于消耗值，而恢复值是不需要看的，因为消耗完就结束了，所以恢复值不是那么重要。看到异或操作其实第一反应就是将数据改写成二进制形式，之后再观察样例的输出结果，可以发现如果当前二进制位零的个数超过了数据个数的一半，就讲结果这一位二进制写为零，否则写为一（因为需要多组可行解的情况下，数值尽可能小）（零的个数正好为一半时可以为零，也可以为一，但是为了数值尽可能小，所以选择为零）但是直接遍历只能过60%，还需要优化。
牛客-栈、队列和stl 2022.10.12
Ls_attack的博客
10-12 251
一开始的想法是寻找从n开始到1的序列，但是只能过7.51%，题解区的做法是：贪心思想，记录一个后缀的最大值数组，每次将数组元素入栈，然后比较栈顶元素和当前最大值，如果栈顶元素大于当前最大值，则出栈，直到小于为止。（还是没想明白为何一开始做法不对，明后几天继续想想）昨天面试和笔试有点多，没时间刷了，写了两道水题感觉没必要记录，所以没有写。今天面了两家，笔了三家，抽空写了这么一道可以记录的题。
牛客-函数与递归 2022.10.10
Ls_attack的博客
10-10 232
其实就是简单的根据字符串序列，每次使用前半段构建左子树，后半段构建右子树，当前字符串判定是I，B，F串然后按照后序遍历的顺序输出。每次截取可以使用开始下标和结束下标进行标记，在这个范围内判断字符串输出什么即可。
牛客-模拟、枚举、贪心 2022.11.15
Ls_attack的博客
11-15 201
之后对于每个名字的查询，从名字的第一个字母出现的第一个位置开始，二分查找之后每个字母的位置是否大于当前的位置，如果大于，更新当前位置，直至名字数组结束，说明存在子序列，否则不存在。如果二者最高位相同，则比较下一位，直到出现不同的二进制位置，那么从这一位置开始往后到二进制的最低位，存在全为一的最大值，之前的高位置都相同，异或结果为0。对于药剂的数值，按照从大到小排序，对于奶牛的区间，按照区间最小值从大到小排序，之后遍历奶牛，对于每头奶牛，遍历药剂看是否存在符合条件的药剂，记录结果即可。模拟遍历01串即可。
牛客-模拟、枚举与贪心 2022.10.20
Ls_attack的博客
10-20 185
可以看到，当将第一行的答案放在第一列的时候，剩下的就是求的答题卡规模为(n - 1) * (n - 1) 的所有方案,当第一行的答案放在第二列的时候，剩下的就是求答题卡规模为(n - 2) * (n - 2) 的所有方案（因为此时根据答案横竖相同要求的对称性，确定了一行的同时也就确定了一列，所以此时有两行和两列都不能进行选择），同理将第一行的答案放在第三列也是一样的。所以横答题卡某一行的答案确定之后，对应的竖答题卡的某一列的答案也就确定了，并且交于这两个答案的行和列也已经确定了。在棋盘规模为 的情况下，
牛客-语法入门-循环结构程序设计 2022.10.5
Ls_attack的博客
10-05 166
负数进制转换规则：如果余数mod为负数，余数mod减去除数base进制基数，之后数字n减去余数mod再除以进制基数base，循环往复即可。记录上下限求取差值，还需要前缀和进行差值累加。
牛客算法竞赛入门课第一节习题 2022.10.1
Ls_attack的博客
10-01 164
先求取一个前缀和数组，通过前缀和数组求取各个k个数序列的大小。之后先从前往后更新记录k个数序列的最大值，再从后往前更新记录k个数序列的最小值，最后从前往后或者从后往前遍历一次所有序列，对每次能取到的最大值求和，更新，得到最后的结果。通过每次对当前数值n的大小进行更新，从而能够逐步缩小范围从而规避第三种情况。对输入数字进行分解质因数。
牛客-模拟、枚举与贪心 2022.10.31
Ls_attack的博客
10-31 159
当我们希望对原数组的某一个区间[l,r]施加一个增量inc时，差分数组d对应的变化是：d[l]增加inc，d[r+1]减少inc，并且这种操作是可以叠加的。这道题目中，每次增量的数目为1。之后对于每个位置的不同货物的种数，进行一个前缀和，即可得到每个位置的不同货物的数目。当我们需要对原数组的不同区间施加不同的增量，我们只要按规则修改差分数组即可。（新学了差分数组这一数据结构，初次接触，之后好好复习）
牛客算法竞赛入门课第一节习题 2020.10.2
Ls_attack的博客
10-02 153
由于坐标的范围是固定的，所以可以根据固定的坐标范围进行二维前缀和求取在边长R的范围内，能够取到的价值最大值。贪心思想，按照结尾排序，每趟记录开始点和结束点，每趟将已切分开的序列进行标记。在序列的头和尾结点切分不能算切分，不能算。贪心思想，按照结束时间排序，然后统计个数即可。
牛客-语法入门-顺序结构程序设计 2022.10.4
Ls_attack的博客
10-04 144
赛瓦维斯特定理：a,b > 1 gcd(a, b) == 1 使得ax + by = c的最大无整数解C的取值为 a * b - a - b。数学题，比较繁琐的是误差和精度。
牛客 a卷2022q4 华为
05-02
在牛客 a卷2022年第四季度的华为题目中，要求考生设计一种高效的数据结构，能够支持以下几种操作： 1. 添加一个元素 2. 删除一个元素 3. 查找是否存在某个元素 4. 返回元素的总数 该数据结构要求满足空间复杂度较小、时间复杂度较低、能够快速地进行查找和修改等多种操作。 想要编写这样一种数据结构，我们可以参考许多已有的经典算法与数据结构，如二叉树、哈希表、红黑树等，通过综合利用它们的优点来实现这个问题的解决。 例如，我们可以通过哈希表来存储所有元素的值，并在每个哈希链表的元素中再使用红黑树来进行排序与查找。这样，我们既能够轻松地进行元素的添加和删除操作，也能够在查找较大数据范围和数量时保持较高的速度与效率。同时，由于使用了多个数据结构来协同完成这个问题，我们也能够在空间复杂度上适度地进行优化。 当然，在具体设计这个数据结构的过程中，我们还需要考虑一些实践中的细节问题，例如如何避免哈希冲突、如何处理数据丢失与被删除元素所占用的空间等问题，这都需要相应的算法与流程来进行处理。 总体来看，设计这种支持多种操作的高效数据结构，需要我们具备丰富的算法知识和编程实践能力，同时需要我们在具体处理问题时能够将多种算法和数据结构进行有效地结合。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值