牛客-模拟、枚举与贪心 2022.10.24

已于 2022-10-24 22:08:26 修改
阅读量108 收藏
点赞数
分类专栏： 牛客网_CSP-J入门组 文章标签： 1024程序员节
于 2022-10-24 11:47:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ls_attack/article/details/127489480
版权

排座椅

记录每行，每列可以分隔的同桌人数，然后按照行号，列号从小到大的顺序输出前k行，前l列最大的数值即可。

#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int,int>& a, const pair<int, int>& b) {
    return a.second > b.second;
}
int main() {
    vector<int> row(1010, 0);
    vector<int> column(1010, 0);
    int m, n, k, l, d;
    cin >> m >> n >> k >> l >> d;
    for(int i = 0; i < d; i++) {
        int x, y, p, q;
        cin >> x >> y >> p >> q;
        //行相同，选择列值中较小的进行分割
        if(x == p)
            column[min(y, q)] += 1;
        //列相同，选择行值中较小的进行分割
        else if(y == q)
            row[min(x, p)] += 1;
    }
    //按照选择行的数目从大到小排序
    vector<pair<int,int>> row1;
    for(int i = 1; i <= m; i++) {
        pair<int,int> k;
        k.first = i, k.second = row[i];
        row1.emplace_back(k);
    }
    sort(row1.begin(), row1.end(), cmp);
    //选取前k个行，按照行号从小到大排序
    vector<int> resrow;
    for(int i = 0; i < k; i++)
        resrow.emplace_back(row1[i].first);
    sort(resrow.begin(), resrow.end());
    
    //按照选择列的数目从大到小排序
    vector<pair<int,int>> column1;
    for(int i = 1; i <= n; i++) {
        pair<int,int> k;
        k.first = i, k.second = column[i];
        column1.emplace_back(k);
    }
    sort(column1.begin(), column1.end(), cmp);
    //选取前l个列，按照列号从小到大排序
    vector<int> rescolumn;
    for(int i = 0; i < l; i++)
        rescolumn.emplace_back(column1[i].first);
    sort(rescolumn.begin(), rescolumn.end());
    
    //输出行号，列号从小到大排序的结果
    for(int i = 0; i < k; i++) {
        if(i == 0)
            cout << resrow[i];
        else
            cout << " " << resrow[i];
    }
    cout << endl;
    for(int i = 0; i < l; i++) {
        if(i == 0)
            cout << rescolumn[i];
        else
            cout << " " << rescolumn[i];
    }
    cout << endl;
    return 0;
}

可持久化动态图上树状数组维护01背包

如果是正数，直接将其放到到第一个进行删除是最优的，如果是负数，将其在当前位置删除则是最优的。

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    long long res = 0;
    for(int i = 0; i < n; i++) {
        long long a;
        cin >> a;
        if(a > 0)
            res = res + a;
        else
            res = res + a * (i + 1);
    }
    cout << res << endl;
    return 0;
}

倒水

直接贪心，直接算出平均的水温,再分类讨论一下即可。假如平均的水温比n个杯子里的都小,那么肯定大水缸是降温的.假如平均的水温比最大的要大,说明大水缸是升温的,不然我的大水缸的温度夹在max和min中间,那么一定是不能调节的

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5+5;
double t[N],c[N];
int main() {
    double T, C;
    int n;
    cin >> n;
    cin >> T >> C;
    double v = 0.0;
    v += T * C;
    double tmx = 0.0, tmi = 1e9, c1 = C;
    for(int i = 1; i <= n; i++) {
        cin >> t[i] >> c[i];
        v += t[i] * c[i];
        c1 += c[i];
        tmx = max(t[i], tmx);
        tmi = min(t[i], tmi);
    }
    double temp = v/c1;
    //假如合并更小.
    if(temp <= tmi) {
        cout << "Possible\n";
        printf("%.4f\n",tmi);
    } else if(temp >= tmx) {
        cout << "Possible\n";
        printf("%.4f\n",temp);
    } else
        cout << "Impossible\n";
    return 0;
}

安卓图案解锁

判断每个数字出现的次数，判断前后两个数字是否合法（一个个单独判断的，但是实际情况只需要单独判定几种即可）

#include <bits/stdc++.h>
using namespace std;
int main() {
    string s;
    while(cin >> s) {
        vector<int> vis(10, 0);
        bool res = true;
        for(int i = 0; i < s.size() - 1; i++) {
            if(!vis[s[i] - '0']) {
                vis[s[i] - '0'] += 1;
                if(s[i] == '1') {
                    if(s[i + 1] == '1') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        if(vis[2])
                            continue;
                        else {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        if(vis[4])
                            continue;
                        else {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    }
                } else if(s[i] == '2') {
                    if(s[i + 1] == '1') {
                        continue;
                    } else if(s[i + 1] == '2') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '3') {
                        continue;
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        continue;
                    } else if(s[i + 1] == '8') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '9') {
                        continue;
                    }
                } else if(s[i] == '3') {
                    if(s[i + 1] == '1') {
                        if(!vis[2]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        if(!vis[6]) {
                            res = false;
                            break;
                        }
                    }
                } else if(s[i] == '4') {
                    if(s[i + 1] == '1') {
                        continue;
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        continue;
                    } else if(s[i + 1] == '4') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '7') {
                        continue;
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        continue;
                    }
                } else if(s[i] == '5') {
                    if(s[i + 1] == '1') {
                        continue;
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        continue;
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        continue;
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        continue;
                    }
                } else if(s[i] == '6') {
                    if(s[i + 1] == '1') {
                        continue;
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        continue;
                    } else if(s[i + 1] == '4') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '7') {
                        continue;
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        continue;
                    }
                } else if(s[i] == '7') {
                    if(s[i + 1] == '1') {
                        if(!vis[4]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        if(!vis[8]) {
                            res = false;
                            break;
                        }
                    }
                } else if(s[i] == '8') {
                    if(s[i + 1] == '1') {
                        continue;
                    } else if(s[i + 1] == '2') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '3') {
                        continue;
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        continue;
                    } else if(s[i + 1] == '8') {
                        res = false;
                        break;
                    } else if(s[i + 1] == '9') {
                        continue;
                    }
                } else if(s[i] == '9') {
                    if(s[i + 1] == '1') {
                        if(!vis[5]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '2') {
                        continue;
                    } else if(s[i + 1] == '3') {
                        if(!vis[6]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '4') {
                        continue;
                    } else if(s[i + 1] == '5') {
                        continue;
                    } else if(s[i + 1] == '6') {
                        continue;
                    } else if(s[i + 1] == '7') {
                        if(!vis[8]) {
                            res = false;
                            break;
                        }
                    } else if(s[i + 1] == '8') {
                        continue;
                    } else if(s[i + 1] == '9') {
                        res = false;
                        break;
                    }
                }
            } else {
                res = false;
                break;
            }
        }
        vis[s[s.size() - 1] - '0'] += 1;
        for(int i = 1; i <= 9; i++) {
            if(vis[i] >= 2)
                res = false;
        }
        if(res)
            cout << "YES\n";
        else
            cout << "NO\n";
    }
    return 0;
}

从后台研发到跑路

先判定“号匹配，然后判定/*匹配，其他符号则原样输出

#include <bits/stdc++.h>
using namespace std;
int main() {
    string tmp;
    string s;
    while(getline(cin, tmp)) {
        s = s + tmp + "\n";
    }
    for(int i = 0; i < s.size(); i++) {
        if(s[i] == '\"') {
            cout << s[i];
            //当前是“号但是前一个字符是转义字符
            if(s[i - 1] == '\\')
                continue;
            i += 1;
            //找寻对应的”号
            while(i < s.size()) {
                if(s[i] == '\"') {
                    //当前字符是"号但是前一个字符是转义字符
                    if(s[i - 1] == '\\')
                       cout << s[i];
                    //前一个字符不是转义字符，和第一个"号对应
                    else
                       break;
                } else
                    cout << s[i];
                i += 1;
            }
            cout << s[i];
        //当前是注释的前半部分
        } else if(s[i] == '/' && s[i + 1] == '*') {
            int idx = i;
            i += 2;
            bool flag = false;
            while(i < s.size() - 1) {
                //找到对应的后半部分注释
                if(s[i] == '*' && s[i + 1] == '/') {
                    flag = true;
                    break;
                }
                i += 1;
            }
            if(flag)
                i += 1;
            else {
                //没有找到对应的后半部分注释，返回第一个注释出现的地方
                //输出第一个注释及顺序输出之后的字符
                cout << s[idx] << s[idx + 1];
                i = idx + 1;
            }
        } else
            cout << s[i];
    }
    return 0;
}

Ls_attack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客-模拟、枚举与贪心 2022.11.16
Ls_attack的博客
11-16 278
分成三类，稳定值增加，不变，减少。考虑从后往前遍历减少的情况，可以发现最后一个要符号条件，需要当前值大于消耗值，而恢复值是不需要看的，因为消耗完就结束了，所以恢复值不是那么重要。看到异或操作其实第一反应就是将数据改写成二进制形式，之后再观察样例的输出结果，可以发现如果当前二进制位零的个数超过了数据个数的一半，就讲结果这一位二进制写为零，否则写为一（因为需要多组可行解的情况下，数值尽可能小）（零的个数正好为一半时可以为零，也可以为一，但是为了数值尽可能小，所以选择为零）但是直接遍历只能过60%，还需要优化。
牛客-模拟、枚举与贪心 2022.10.22
Ls_attack的博客
10-22 119
由于全是小写字符串，使用一个数组，记录每个字母存在的最后一个位置。从最大字母开始遍历到最小字符，这一过程中遍历原字符串，输出其中的当前最大字符，即可得到最终的结果。昨天写的题目较为简单，和今天写的一起做一个总结。构建哈夫曼树，哈夫曼编码。
牛客-模拟、枚举与贪心 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.31
Ls_attack的博客
10-31 159
当我们希望对原数组的某一个区间[l,r]施加一个增量inc时，差分数组d对应的变化是：d[l]增加inc，d[r+1]减少inc，并且这种操作是可以叠加的。这道题目中，每次增量的数目为1。之后对于每个位置的不同货物的种数，进行一个前缀和，即可得到每个位置的不同货物的数目。当我们需要对原数组的不同区间施加不同的增量，我们只要按规则修改差分数组即可。（新学了差分数组这一数据结构，初次接触，之后好好复习）
C++面试--牛客(1).pdf
最新发布
03-21
C++面试--牛客(1).pdf
Python牛客初级项目实战视频课程-.rar
05-19
Python牛客初级项目实战视频课程-.rar
牛客-前端布局与事件高频考点
04-03
牛客-前端布局与事件高频考点 前端布局是前端开发中一个非常重要的部分，掌握了前端布局的知识点，对于开发者来说是非常有帮助的。以下是前端布局和事件高频考点的知识点： 一、盒子模型宽度的计算 盒子模型是CSS...
牛客网 牛客Java高级工程师 - 高薪求职项目课vol.4.zip
01-12
软件开发设计：应用软件开发、系统软件开发、移动应用开发、网站开发C++、Java、python、web、C#等语言的项目开发与学习资料 硬件与设备：单片机、EDA、proteus、RTOS、包括计算机硬件、服务器、网络设备、存储设备...
牛客-数据存储与垃圾回收
04-03
牛客-数据存储与垃圾回收 本文将详细介绍JavaScript中的数据存储与垃圾回收机制，从数据类型、内存空间、垃圾回收机制等方面进行了深入探讨。 一、数据类型 JavaScript中有八种基本数据类型：Number、String、...
牛客算法竞赛入门课第一节习题 2022.10.3
Ls_attack的博客
10-03 991
01串，即通过二进制位表示当前要选择的行或者列的状态。这样可以等价于进行深度优先搜索的返回结果，但是相较于深度优先搜索写法更加简单，同时对于状态记录更加容易去除一些重复记录的值。对于行或者列，先进行行选取，选择某些行的权值求和，之后再对列进行选取，记录相应的状态并求和。之后对于求和记录最大值。每次对数组中的数据进行操作后，之后都要记得恢复。
牛客-模拟、枚举与贪心 2022.10.23
Ls_attack的博客
10-23 302
先对数组按照从小打到排序，第一次，先让第一个数和第二个数大小相等，即相加的n-1个数只除了第二个数字，第二次，让第一第二个数和第三个数大小相等，即相加的n-1个数只除了第三个数字，之后每次相加同理，相加n-1次，即可得到答案，最后的结果就是最大的数字加上每次两个数字的差值，做一个前缀和相加。简单模拟输出，一眼可知，凳子消除最贵的商品，所以比较凳子和购物车两者的最小值，即可以得到最终的结果。一开始的想法是从前往后相加相同的数字，然后删除，但是会导致之后的数字也相同，导致并不是最少的次数。
牛客-栈、队列和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的大小进行更新，从而能够逐步缩小范围从而规避第三种情况。对输入数字进行分解质因数。
牛客算法竞赛入门课第一节习题 2020.10.2
Ls_attack的博客
10-02 153
由于坐标的范围是固定的，所以可以根据固定的坐标范围进行二维前缀和求取在边长R的范围内，能够取到的价值最大值。贪心思想，按照结尾排序，每趟记录开始点和结束点，每趟将已切分开的序列进行标记。在序列的头和尾结点切分不能算切分，不能算。贪心思想，按照结束时间排序，然后统计个数即可。
牛客Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
09-23
"Exception in thread "main" java.lang.OutOfMemoryError: Java heap space" 是一种Java中的OOM错误类型。Java堆空间不足导致程序无法分配更多的对象实例，从而抛出此异常。解决这个问题的方法是增加Java堆空间的大小。可以通过调整JVM的启动参数来增加堆空间的大小，例如使用"-Xmx"参数来增加最大堆空间的大小。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值