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

Ls_attack Ls_attack 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 200+累计阅读 214平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 2022-10-24 22:08:26 214 阅读 AI 写同款· GEO 优化 ›
excel wind插件使用_Python和wind的交互—在债券中的应用 个人认为学会了怎么用python和wind交互以及怎么用python处理Excel数据，就基本能替换日常很多琐碎的债券工作，还不用担心Excel某个值改变了导致整个报表都毁了。事实上在python调用wind函数和在Excel中调用函数一样简单，只要会基本的操作就够了。下面详细的介绍如何用python和wind进行交互。首先安装好python+pycharm+wind。因为python... 阅读详情

排座椅

记录每行，每列可以分隔的同桌人数，然后按照行号，列号从小到大的顺序输出前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;
}

收录于
牛客网_CSP-J入门组

当前文章被收录于：

牛客网_CSP-J入门组
29 篇文章 0 人学习
订阅专栏 查看详情
标签
#1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
STM32实战：电容触摸屏I2C转USB HID设备全解析 本文详细解析了基于STM32的电容触摸屏I2C转USB HID设备实现方案。通过硬件选型、协议分析和代码实现，展示了如何将GT911触摸屏数据转换为标准USB HID协议，并提供了关键调试经验与性能优化技巧，为智能家居控制面板等应用提供高性价比解决方案。 阅读详情

相关推荐

【Stata双重差分模型】双重差分DID的具体操作步骤

本案例将详细阐述如何使用双重差分法进行实证分析，并展示具体的STATA操作代码。

a519573917的博客 2万+

美团校招第6场笔试复盘：四道算法题吃透字符串、DP、贪心与最短路

大厂校招笔试看似业务名词满天飞，实则万变不离算法与数据结构。字符串状态机通过逐字符切换高效清洗脏数据；动态规划利用无后效性，将网格路径问题转化为递推；贪心调度借助交换论证推导最优排序；堆优化Dijkstra则保障大规模图最短路计算。这些技术模型广泛应用于日志解析、路径规划、任务调度等真实场景。在美团2023校招第6场笔试中，像“美团代付”这类热词只是外壳，真正需要吃透的是字符串、DP、贪心与最短路四类模型。结合Python完整复盘题型与解题套路，为备战大厂笔试提供高效思路。

weixin_34293059的博客 319

EFR32无线SoC开发指南：从环境搭建到性能优化

物联网边缘设备开发中，无线SoC芯片的选择与开发环境配置是关键第一步。EFR32作为Silicon Labs推出的多协议无线SoC系列，配合Simplicity Studio IDE，为开发者提供了完整的解决方案。本文以EFR32xG22开发套件为例，详细介绍开发环境搭建、工程创建、硬件配置等核心环节，特别针对RAILtest示例工程进行深入解析。通过实际案例演示如何配置无线参数、优化低功耗模式，并分享串口终端交互、吞吐量测试等实战技巧。对于开发者常见的问题如设备识别失败、无线通信异常等，提供了系统化的排查

weixin_30342363的博客 352

牛客周赛round24题解(pypy3版)

但k太大了,再加上分析最大值最小,决策单调性问题可以用二分值域来考虑。#本来应该是枚举操作次数k,贪心地用堆取模拟减小当前最大值。二分答案(因为k太大了,不然直接贪心最大堆模拟减小即可)#需要执行操作,当前元素比最大值大。#小数点前的整数尽量大且保证合法,贪心考虑。贪心，保证合法的前提下整数部分尽量大。分解所有因子后排序，从前往后枚举。

TCaaaaa的博客 526

【全解析 | PTA】浙大版《Python 程序设计》题目集-第一章

Python浙大版PTA题解

wzhh_的博客 5527

华大HC32F460 TCP Client 实验

华大HC32F460 TCP Client 实验

ZhuoWuKeJi的博客 649

24.4.21（链表模拟，板刷dp）（天梯赛）

区间dp用dfs递归实现，因为s的括号必两两对应，所以dfs的 l 和 r 从1，n开始，l 必定是（，r必定是），l，r的对应分三种情况，一是 r==l + 1，直接赋值即可 ， 二是 l 和 r 对应，但不相邻，枚举 l+1 和 r-1 的涂色方案，把合法状态加上即可， 三是不对应，则需要把 l 和 ma【l】，ma【l】+1和 r 两个对应的区间的方案算出，两区间方案数相乘。正解是bfs，map存的是单个物品价值，vi存的是bfs到达的点，每次跑一遍p，能去但没去的点就继续存入队列。

breath_of_yuan的博客 882

保姆级教程：在RK3588开发板上用CMake交叉编译ZLMediaKit（附完整toolchain配置）

本文提供了一份详细的RK3588开发板上使用CMake交叉编译ZLMediaKit的教程，包括完整的toolchain配置和实战避坑指南。从环境准备、工具链配置到依赖处理、编译部署，手把手指导开发者完成ARM64架构的流媒体服务搭建，特别适合嵌入式开发新手。

weixin_28681255的博客 383

24.9.1（康托展开）

思路：由平方数考虑到质因子分解，值域1000以内，若存在大于31的质因子，则必定只有一个，且31以内的质数也只有11个，可以状压处理，将所有数分解，若不存在大质数则分解后为1，若存在即为大质数，按此分组，对每组进行转移。最少要往回趟 s次，每次载 l个人，在贪心即每次运输体力最高的人的前提下，所有人 a的总和最少需要 s*l，若一个人的 a大于 s，那么超出的部分没有意义，所以计算总和时 a需要和 s取min，再和 s*l进行比较。补 24牛客多校 二 C。补 24牛客多校 二 I。

breath_of_yuan的博客 994

MT4-EA自动化交易研究笔记（2022-04-22）

自从接触到mt4的EA自动化交易，更让我这个10多年的老程序员看到了曙光，目前来看也确实出了一点成果，只是是否能稳定盈利有待时间的考验，所以开此专栏，一来做做记录与分析，更好的优化我的EA，二来也希望能与更多的高手交流，以完善我的交易系统

t35254056的博客 2291

9.6华为OD机试真题 新系统【仓储货物有序出库】

华为OD机试真题 新系统【仓储货物有序出库】，提供C语言、Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解，以及在线OJ模拟做题。华为OD机试真题 【仓储货物有序出库】多语言题解。

qq_45776114的博客 882

牛客2019湘潭大学程序竞赛

官方题解 　　都是中文题不需要翻译，话说，我居然sb的在a题看错题目错了3发 　　ABD签到题，D题贪心思维，没啥好说的 CMath Problem 　　我觉得这题是我卡了最久的题，数学不好推不出来，然后打了个表发现的，官方题解里有证明为什么a=192*q+1,q是自然数。知道这个之后就很好做了，我们就可以求出在r范围内有多少符合的数，和l-1范围内有多少符合的数做差就可以了。像对于x，我...

weixin_30561177的博客 121

使用Qt和MX Component插件实现与菱PLC的通信

在本文中，我们介绍了如何使用Qt和MX Component插件实现与菱PLC的通信。我们首先安装和配置了MX Component插件，并在Qt项目中初始化和使用MX Component来连接、读取和写入PLC的数据。安装完成后，您需要在Qt项目中配置MX Component的路径，以便Qt可以找到所需的库文件。在本文中，我们将探讨如何使用Qt和MX Component插件来实现与菱PLC的通信。在主函数中，我们将初始化MX Component，并创建一个与PLC通信的示例。在上面的代码中，我们使用了。

TlScratch的博客 996

【好题】好题分享

好题分享

小吉妙妙屋 1040

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

B站2019秋招笔试编程题解析：字符串与动态规划实战指南

在互联网秋招中，算法与数据结构始终是技术笔试的核心考察点，其中字符串处理和动态规划更是高频题型。理解这些基础算法的原理，掌握状态定义与边界条件分析，是提升编码能力与解题效率的关键。无论是循环右移、括号匹配，还是区间调度、一维DP，其本质都是将业务场景抽象为数学模型，并设计出最优解。这类技术能力广泛应用于弹幕过滤、播放器调度等真实互联网场景，也是应届生进入大厂必须跨越的门槛。本文以B站2019秋招真题为样本，深入拆解字符串操作与动态规划的典型题目，分析出题逻辑与常见陷阱，并给出备战建议，帮助读者系统梳理笔试考

weixin_34163553的博客 356

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能：商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传，基本资料下载，开钱箱、小票打印、收款结算，支持多币种付款方式（现金、储值卡、礼券、微信等）,支持多种促销。运行环境：.net 4.0登陆信息用户名:1001 密码:123456内置商品信息，商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

牛客练习赛114 解题报告 | 珂学家 | 贪心场 + 期望 + 线性基

本地常规场景很简单，只要将其中一个字符串的内容挨个去除即可，但若遇到字串1和字串2中间有重复的字母则会出现失败的可能，例如s:qwca x:acbd,t:qwa。社招，8月底面试，一面都没过，面试内容会根据简历来，我经历比较杂，当过财务和产品，大家看热闹就好，不用当成标准模版，给大家描述下我的面试问题1，你这边产品经理的。美团测评第一次没有发挥好，还可以报名第二次，鄙人已经报名了美团测评的时长不是从我们开始答题开始计算，而是邮件中写着的时间开始计算，家人们一定要准时点开测评链接美。

2301_79125642的博客 669

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox（带书签），MATLAB统计学习工具

牛客练习赛20

礼物 背包 1 #include <bits/stdc++.h> 2 using namespace std; 3 int f[1111]; 4 5 int main() { 6 int T; 7 scanf("%d", &T); 8 while(T--) { 9 int N, M, K,...

weixin_30765475的博客 81

近期总结2023.10.16

28.(839D)对于两个数 a,b,选x使得a=abs(a-x),b=abs(b-x),当x的值小于 (a+b)/2 时，它保持原本的单调性,当x的值等于(a+b)/2时，a==b,当x的值大于(a+b)/2时，单调性反一下。31.(820f)(s1s2s3...)%9=(s1+s2+...)%9,可前缀和，将值域处理成余数的暴力枚举来满足式子，例如(a+b)%m==k首次出现的a,b,将可以的处理成余数记录首次出现位置，暴力枚举余数。//按第一位从小到大。32.找到周期性开始点取余周期（811E）;

m0_75027890的博客 277

2021牛客暑期多校训练营3

2021牛客暑期多校训练营3 第五次暑假训练，选取题整理

C_eeking的博客 322

笔试强训：Week-4

本文总结了多个算法题解，主要涉及数学、动态规划、双指针等常见算法技巧。包括使用欧几里得算法求最大公约数、路径DP解决礼物价值问题、双指针判断字符串对称性、贪心算法处理非对称字符串、FloodFill解决城市群问题等。还介绍了01背包、滑动窗口、前缀和等经典算法应用，涵盖了字符串处理、数学运算、图论等多个领域，展示了不同场景下的算法优化策略和实现方法。

_dindong的博客 1344

网易秋招笔试编程题合集（一）：四道经典算法题深度解析

算法与数据结构是技术面试的基石，尤其在各大互联网公司的校招笔试中，对候选人的问题拆解与代码实现能力提出了较高要求。常见的算法模型如贪心算法、动态规划，往往隐藏在不同题目背景之下，需要透过现象识别本质。以资源分配问题为例，排序后从小到大匹配是典型的贪心策略；而面对具有无后效性的多阶段决策，动态规划的状态转移则能高效求解。此外，栈结构在处理局部连锁反应时具有天然优势，约瑟夫环问题又体现了从模拟到数学归纳的思维跃迁。这些算法不仅在笔试中高频出现，更直接关系到实际工程中的性能优化与逻辑设计。网易2019年秋招笔试编

weixin_34252686的博客 344
上一篇： 牛客-模拟、枚举与贪心 2022.10.23
下一篇： 牛客-模拟、枚举与贪心 2022.10.25
点赞 0
评论 0
书签 书签 0
Ls_attack
Ls_attack
博客等级 码龄10年 25粉丝 81原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值