02 2020 档案
摘要：基本思想： 提前打表，直接算； 关键点： 无； #include<iostream> #include<vector> #include<algorithm> #include<string> #include<cmath> #include<set> #include<map> using nam
阅读全文
摘要：基本思想： 无； 关键点： 无； #include<iostream> #include<vector> #include<algorithm> #include<string> #include<cmath> #include<set> using namespace std; int main(
阅读全文
摘要：基本思想： 想到贪心，但是觉得时间复杂度太高，结果一不小心写出来个更复杂的贪心； 关键点： 注意特殊用例，有可能无法遍历出正确结果，即没有切换得到正确的值，此时要避免进入死循环； #include<iostream> #include<vector> #include<algorithm> #inc
阅读全文
摘要：https://www.nowcoder.com/practice/04c8a5ea209d41798d23b59f053fa4d6?tpId=40&tqId=21334&tPage=1&rp=1&ru=/ta/kaoyan&qru=/ta/kaoyan/question-ranking 基本思想：
阅读全文
摘要：https://www.nowcoder.com/practice/0383714a1bb749499050d2e0610418b1?tpId=40&tqId=21333&tPage=1&rp=1&ru=/ta/kaoyan&qru=/ta/kaoyan/question-ranking 基本思想：
阅读全文
摘要：基本思想： 附带路径代价的最短路径生成； 关键点： 无； #include<iostream> #include<fstream> #include<sstream> #include<vector> #include<string> #include<cstring> #include<algor
阅读全文
摘要：基本思路： 主要有两点： 1.多路径保存问题，主要是vector<int>，来保存每个节点的多个前驱节点； 2.对于逆序前驱数组，采用DFS，枚举每个分支，采用逆序访问进行根节点遍历； 关键点： 上述两个问题； #include<iostream> #include<fstream> #includ
阅读全文
摘要：基本思想： 主题思想是迪杰斯特拉算法，但是在其基础上做了相关的改进； 1.要求统计等长路径条数； 2.在等长路径的基础上，需要再次选择节点权值最大的哪个； 关键点： 路径保存pre，利用前驱节点保存； 等长路径统计用num[]; 权值统计用weight[]; 比较套路化的流程； 但是注意一点，等长路
阅读全文
摘要：之前自己看过和总结过相关的东西，今天再总结说一下； 感觉权值问题，是否无向有向，权值正负可以直接用不同的算法进行解决； 这次还是主要说一说四种算法：迪杰斯特拉算法、BF算法、SPFA算法、弗洛伊德算法； 迪杰斯特拉算法: 老生常谈最简单的一种算法,从某一点出发,建立Distance数组,不断地寻找当
阅读全文
摘要：后续在做题时的时候遇到了一个从文件里去读取一串逗号分隔的double数字，并排序的问题； 还是挺操蛋的一道题，用直接读入在分割的方法贼麻烦，所以还是要寻求简单的的库函数和Cpp11特性来进行解决； 查阅相关blog，简单聊一下相关的问题； 其实最主要的有两个问题： 1.如何读入？能不能一次分割得到s
阅读全文
摘要：牛顿迭代法主要解决的是方程近似求根问题，关于牛顿迭代法的详细推导和数学原理见此链接； https://www.matongxue.com/madocs/205.html https://oi-wiki.org/math/newton/ 接下来主要说一下怎么利用牛顿迭代法进行求根，其实就是利用这种迭代
阅读全文
摘要：老生常谈的问题，N年前仔细做过总结，现在全忘光了； 重载函数： 一定要参数列表不同，名字相同，C++编译器可以根据参数的类型自动调用； void exc(char& a, char& b) { char temp = a; b = a; b = temp; } void exc(int& a, in
阅读全文
摘要：主要针对于机试中的IO读写问题，c语言实现和使用太过于繁琐，所以以后遇到类似题目还是用C++的； 主要包含头文件 #include<iostream> #include<fstream> #include<sstream> 一般来说，用fstream就足够够用了，他包含了istream和ostrea
阅读全文
摘要：基本思想： 上三角判断，简单逻辑； 关键点： 无； #include<stdlib.h> #include<stdio.h> #define maxn 21 int n,num; int ma[maxn][maxn]; int charge(int n) { //判断是否是上三角 for (int
阅读全文
摘要：基本思想： 和三维矩阵的遍历类似，注意别超出数组大小； 关键点： 无； #include<stdlib.h> #include<stdio.h> #define maxn 21 int m,n; int index = 0; int ma[maxn][maxn]; int X[4] = { 0,1
阅读全文
摘要：基本思想： 注意一下副对角线使i+j=n的规律； 关键点： 无； #include<stdlib.h> #include<stdio.h> #define maxn 11 int n; int ma[maxn][maxn]; int main(){ int a; scanf("%d",&n); in
阅读全文
摘要：基本思想： 弱智题; 关键点： 无； #include<stdlib.h> #include<stdio.h> int m, n; int main(){ int a; scanf("%d %d", &m, &n); for (int i = 0; i < m; i++) { int sum = 0
阅读全文
摘要：基本思想： 平年365 2月28 不能被4整除； 闰年 366 2月29 能被4整除； 比如2020年，366天，二月二十九天； 关键点： 无； #include<stdlib.h> #include<stdio.h> #include<iostream> using namespace std;
阅读全文
摘要：基本思想： 直接计算，和7-3思想差不多； 关键点： 才发现自己侥幸逃脱的一个坑点：这题隐含了一个高阶阶乘的问题，如果贸然使用int来计算阶乘，会出现溢出问题； 后续总结一下； #include<stdlib.h> #include<stdio.h> #include<iostream> using
阅读全文
摘要：基本思想： 仍然是按照展开式的计算问题； 关键点： 无； #include<stdlib.h> #include<stdio.h> #include<iostream> using namespace std; double factor(double x) { if (x == 1.0) retu
阅读全文
摘要：基本思想： 按照公式逐项求和，最后对比给出的误差范围，确定求到第几步，是机试的一个典型题目； 关键点： 卡在了怎么输入指数浮点数的问题上，第一次件scanf("%le")中的le规格； 使用cin>>或者scanf("%le")其实都是可以输入1E-5作为浮点存储； 但是当时看内存踩坑里了，误以为1
阅读全文
摘要：https://blog.csdn.net/InNoVaion_yu/article/details/84975529 之前做过相关总结，再多说两句； 01背包必定是不能用贪心策略解决的。因为01背包选了就没有，而贪心则是可以选择多种； 对于01背包问题，只能用动态规划； 这里注意一下，最近遇到了关
阅读全文
摘要：基本思路： 典型的01背包问题； 关键点： 后续总结； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algori
阅读全文
摘要：之前做过相关总结，但是没有今天二次看的时候这么深入https://blog.csdn.net/InNoVaion_yu/article/details/84892297 经过自己这两天的理解和实践后，个人再对动态规划、贪心、DFS、递归的关系再做一个总结； 首先，DFS和贪心、递归的关系： DFS是
阅读全文
摘要：基本思想： 后续总结，详见数据结构典型问题——动态规划篇； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algo
阅读全文
摘要：基本思想： 后续动态规划问题总结，但是注意一点的是，初始化一定要使dp[i]=1，因为每个元素都可以独立的构成一个子串； 如果不初始化会有问题； 6 7 4 5 如果不初始化会有dp数组； 1 2 0 1 实际应该是： 1 2 1 2 关键点： 无； #include<iostream> #incl
阅读全文
摘要：基本思想关键点详见 “数据结构典型问题” #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #i
阅读全文
摘要：基本思想： 感觉也不用贪心思想，直接打表就可以了； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<
阅读全文
摘要：基本思想： 简而言之就是贪心，对需求数进行排序，先满足最小需求，把他原先有的拿回来，再满足需求数目大的； 其实就是OS里银行家算法的翻版； 关键点： 注意有百分之四十五的case情况为拥有数目完全大于需求数目，这个需要注意一下； #include<iostream> #include<stdlib.
阅读全文
摘要：基本思路： 和之前一题类似，只不过算的是总体等待时间； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #includ
阅读全文
摘要：基本思想： 才想到短作业优先SJB其实也是贪心的一种，想让等待时间短，就不能先处理长的。所以要进行排序然后重新计算； 并且一定要注意平均等待时间的计算； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector>
阅读全文
摘要：基本思想： 贪心思想掌握的还不是很好，在枚举情况漏了一种： 010 111 此时需要翻两次； 如果使用贪心策略，则是先寻找当下最优解，即：直接遇到不一样的直接翻，之后进行后续的判断； 关键点： 无； #include<iostream> #include<stdlib.h> #include<std
阅读全文
摘要：基本思想： 贪心问题的简单题，一般不用考虑启发式贪心，可以直接进行贪心求解； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math
阅读全文
摘要：基本思想： 三维BFS遍历，注意可以XYZ变换数组进行快速遍历； 关键点： 注意访问的标志位问题； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<m
阅读全文
摘要：基本思想： 就是树形DFS遍历，没啥新意； 关键点： 最主要的是出现了一个问题，如果用for循环，在相同的剪枝条件和递归边界下，会遇到TLE和爆栈得风险； 后来和k神讨论，发现是for循环强行每次迭代枚举，多了很多不可能得情况； 例如如果第一位是6，后续每轮从6~0枚举，但是如果第一位变成5的话，后
阅读全文
摘要：基本思想： 利用栈进行压栈，重新调整顺序。单纯利用栈输出的话无法快捷预知后续的节点首地址，计算索引非常麻烦； 关键点： 注意无效节点的统计； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #inclu
阅读全文
摘要：基本思想： 注意遍历方式； 关键点： 注意一下节点的前后地址输出问题； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #includ
阅读全文
摘要：基本思想： 一直不知道模拟思想是个什么思想，后续需要补全一下； 本质上就是模拟栈的弹出压入问题，主体部分写出来了，但是忘了判断压栈过程中可能容量爆栈； 关键点： 模拟问题； #include<iostream> #include<stdlib.h> #include<stdio.h> #includ
阅读全文
摘要：基本思想： 注意一个新的点，对于map如果有排序去重的问题，完全可以map<string,set<int>>来解决，没必要用vector进行push； 关键点： 新的TLE问题点，对于大型复杂性数据结构，可以采用引用传入而不是值拷贝的形式，这个尤其要注意下； #include<iostream> #
阅读全文
摘要：基本思想： 无，简单的排序问题，注意pair排序的另解； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #inclu
阅读全文
摘要：基本思想： 和进制思想类似，但是唯一不同的是，取余为0的时候个位忽略； 关键点： 普通枚举转换也可以，但是此次示例给的是打表方式； 当打表的时候可以直接枚举情况采用拼接字符串来进行快速运算，注意一下； #include<iostream> #include<stdlib.h> #include<st
阅读全文
摘要：基本思想： 主要是指数计算，通过去除先导零来进行情况枚举，注意一下； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h>
阅读全文
摘要：基本思想： 自己的方法是直接用set记录，直接遍历两个一起添加得笨办法，但是示例代码中的值得学习； 关键点： 集合并集交集思想，可以直接记录第一个set得数目，直接遍历第二个； 如果在使用第一个set.find，找到相同元素，直接记录交集数目+1；找到不同元素，则交集元素+1； double cha
阅读全文
摘要：set最大的特点：去重，自己具有排序功能； set<xxx>vec; 基本使用函数： insert(); find() //find返回指针类型，和尾指针end()比较； earse()，删除单个元素或者区间元素。单个元素给指针或者数值；区域元素给范围； size()； clear()；直接清除所有
阅读全文
摘要：基本思想： 无； 关键点： 主要是性能优化的问题：1.能尽量使用scanf和printf尽量使用，cin&&cout性能过低，会tl； 2.大型样本空间下，使用char[]要比string高效； 3.极其重要：一种新的思想，针对于字符串排序可以直接排序索引，可以省去大量的复制和移动操作； #incl
阅读全文
摘要：基本思想： 水题，用map可能会超标，范例代码和自己思想类似； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #in
阅读全文
摘要：基本思想： 雷同的并查集； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #
阅读全文
摘要：基本思想： 难倒是不难，利用并查集进行查询，但是卡在了最后一个测试点，存在TL的问题，最后发现是cin和scanf效率的问题； 关键点： 以后输入输出在OJ方面用scanf； char a[]转string直接用.c_str()和s=a即可； #include<iostream> #include<
阅读全文
摘要：基本思想： 主要考察并查集的使用，其中注意节点合并的思想； 关键点： map排序似乎无法进行，可以转成Vector<pair<string,int>>进行sort排序，条件改写一下就行了； #include<iostream> #include<stdlib.h> #include<stdio.h>
阅读全文
摘要：基本思想： 路径节点权值统计，倒是不难，但是卡在了输出路径的权值排序上； 由于要求路径权值总和相等，但是里面的节点要求降序，这就不能用简单的sort来进行解决； 而是要直接把子节点进行排序，使得无论如何，先遍历的都是权值最大的，所以就可以保证在权值和想等情况下，先访问的都是大值节点； 关键点： 无；
阅读全文
摘要：基本思想： 层序遍历问题； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #
阅读全文
摘要：基本思想： 雷同题目，不再赘述； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm
阅读全文
摘要：基本思想： 层序遍历问题； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #
阅读全文
摘要：基本思想： 之前刷过的雷同题目； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm
阅读全文
摘要：基本思想： 层序和标记layer，别忘了； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algo
阅读全文
摘要：基本思想： 无； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #inclu
阅读全文
摘要：基本思想： 一定要注意以下几个关键点: 1.二叉排序树的中序遍历是有序序列； 2.完全二叉树使用数组存储时可以直接初始化，可以不初始化直接三种顺序访问； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<
阅读全文
摘要：基本点： 题目繁琐无新意； 关键点： 左右节点子树交换，可以直接preorder的访问顺序就可以； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<m
阅读全文
摘要：基本思想： 首先确定边界没啥问题； 关键在于后续的枚举上，直接打表可以避免很多重复计算的问题； 关键点： 打表和枚举，枚举时候不用考虑位数，直接一直取余即可； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vecto
阅读全文
摘要：基本思想： 两种方法： 1.利用map进行查重处理，多个单词可能时间复杂度过高； 2.利用hash字符； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string>
阅读全文
摘要：基本思想： 两种方法： 1.进行变换情况的枚举，构成9*9矩阵，麻烦且凌乱； 2.直接再数位显示上进行标记，利用二进制来定类，对比不同的位数即可； 进行显现管标记，然后给出每个数字的7位二进制数串； 关键点： 主要是这种标记分类取异或的思想，再很多分类问题中也可使用，类似于以前学习过的多标签思维；
阅读全文
摘要：基本思想： 没啥思想，弱智题，关键是注意，m和n为0的用例情况； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #i
阅读全文
摘要：基本思想： 没啥思想，弱智题； 关键点： 没关键点； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorit
阅读全文
摘要：基本思想： 和PAT数字黑洞类似，但是比哪个简单，没有输出和判零情况； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h>
阅读全文
摘要：基本思想： 从第一个数入手，可以简单的限定范围，100~333，否则不满足三位数提议； 开始枚举，利用数组来进行数位标记； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #includ
阅读全文
摘要：https://blog.csdn.net/chensilly8888/article/details/42834697 这里面说了(a*b)% c=((a%c)(b%c))%c 但是代码里实际表示则为： cnt *= num % 50000; cnt %= 50000; 等同于： cnt=(cnt
阅读全文
摘要：基本思想： 找素数，再取模； 关键点： 存在一个待解决的问题，后续进行总结； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #inc
阅读全文
摘要：基本思想： 没啥可说的，但是还是按照题目乖乖来，直接输出可能会导致情况考虑缺失； 注意的有两钟用例情况： 1.a为空，或者m为0； 2.a的长度大于M+N； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #includ
阅读全文
摘要：基本思想： 弱智题； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #inc
阅读全文
摘要：基本思想： 题中提示了，按秒计数，这样不用像蚂蚁问题一样考虑半秒； 关键点： 直接按秒计算； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math
阅读全文
摘要：基本思想： 水题，没什么可说的； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm
阅读全文
摘要：基本思想： 弱智题，没什么好说的； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorith
阅读全文
摘要：基本思想： 利用递归或者循环结构找规律输出； 关键点： 能用递归用递归，比较简单； 不能则用循环处理； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include
阅读全文
摘要：基本思想： 典型的分解质因数问题的求解。没啥问题； 关键点： 1.注意迭代问题，使用sqrt(n)可以减少一定的时间复杂度； 2.不用特意排序，枚举的时候自然排序； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<ve
阅读全文
摘要：基本思想： 两种方式，递归构造和循环构造都可以； 循环构造在前面求递增前n项和的时候都有应用，所以一定要注意下； 自己总结不出来固定的一步构造方法才想到用递归的。 关键点： 逐步列式子进行计算； #include<iostream> #include<stdlib.h> #include<stdio
阅读全文
摘要：基本思路： 典型的hash散列； 关键点： 输入问题： 这里涉及到了行号输入和EOF输入，需要注意一下； 本题完全可以利用EOF输入，但是示例中有了新的行号输入思想，要注意一下； 利用cin读入数字后，可以利用cin.get()来判断空格和回车问题，进行判断，按个进行判断，从而识别出换行符号； #i
阅读全文
摘要：基本思想： 这题考察的是详细的数学思维，使用模拟一步一步枚举的话并不能解决蚂蚁的碰头问题，因为蚂蚁碰头可以不在整数位置，所以很难去解决； 最简单的思路： 对于一只感染的蚂蚁，当他向一个方向前进时，必然碰到和他相向而行的蚂蚁，这些蚂蚁必被感染，这点毫无疑问； 但是由于碰到后会两个蚂蚁都会改变方向，所以
阅读全文
摘要：基本思路： 题解里面很多人都是枚举方法做的，其实是最小公倍数的求法问题； 关键点： 之前做过相关的数学总结，不再赘述，本质上是先求最大公约数，再借助性质求最小公倍数； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<v
阅读全文
摘要：基本思想： 卡了很久，主要是仍然不知道百分之十四的用例错在什么地方，后续在更新； 关键点： 1.不能用穷举模拟，时间复杂度受不了； 2.注意等差数列求解中避免整形浮点损失的问题； 3.注意int 和long long的范围，这题是典型的精度问题； #include<iostream> #includ
阅读全文
摘要：基本思想： 难倒是不难，但是卡在了方法上； 自己的思想史正确的，通过规律枚举来进行枚举，但是卡在了后续的输出和反转上； 做每道题先三分钟思考为妙； 关键点： 1.一定要注意数学建模问题，对于边界计算一定要注意； 2.反转输出并不一定要靠字符串，可以直接在已知数据大小的情况下直接乘数达到反转的目的；
阅读全文
摘要：之前总结过类似的内容 链接 https://segmentfault.com/a/1190000018192147； 再提一下，主要是两种判定条件，分界点sqrt(n)； 提前打表，得知所有素数，挨个进行判定猛除，利用结构体进行存储和记录；由于int范围的限制，一般质因子个数不会超过十个，不确定大小
阅读全文
摘要：基本思想： 无； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #inclu
阅读全文
摘要：基本思想： 水题，唯一值得启发的可能也就是传递糖果的过程； 关键点： i-1递给i，然后从后向前遍历，只需要把最后一个提前保存给第一位小孩即可； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #inc
阅读全文
摘要：基本思路： 判断字符，没啥可说的； 关键点： 在判断的时候，不用整体截取在挨个判断，可以边截边判断，便于及时舍去； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #i
阅读全文
摘要：基本思路： 难点在于怎么输入整行元素，主要考察空格和回车的读入和甄别； 关键点： 这里注意几点： 1.while(cin)和while(scanf)雷同，都可以进行EOF的判断； 2.在读取时要注意，cin>>n由于回车结尾，会导致下一个getline直接把回车都进去，所以要getchar进行处理；
阅读全文
摘要：基本思路： 基本的判断素数，之前做过相关总结； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<al
阅读全文
摘要：基本思想： 弱智题； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorithm> #inc
阅读全文
摘要：基本思想： 没啥，ASCII的弱智题； 关键点： 蓝桥OJ的两个特点： 不支持边读入边输出，和PATOJ有区别； System pause 会导致超时问题； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector
阅读全文
摘要：基本思想： 弱智题，相邻计算可破； 关键点： 无； #include<iostream> #include<stdlib.h> #include<stdio.h> #include<vector> #include<string> #include<math.h> #include<algorith
阅读全文
摘要：基本思想： 主要是hash表中的平方探测法得问题； 关键点： 注意一个问题，平方探测法并不能完美解决散列问题； 并且在这个题目中，平方探测法的step取值为step=1*1,2*2,.....,(n-1)*(n-1)，其中n为散列表长度； #include<iostream> #include<st
阅读全文
摘要：1015 Reversible Primes (20point(s)) PAT中涉及到了多点测试问题，这个需要注意一下，一直没怎么注意过； 主要的表示为结尾不同寻常，是以不寻常输入作为结尾标志的。 73 10 23 2 23 10 -2 例如对上述输入，就不能按照格式按行读入，而是因该使用while
阅读全文
摘要：一直没注意这个问题，直接={XXX}初始化，这次吃了个亏； 尤其要注意，用这种简便方式初始化只能初始化bool数组的第一个元素，所以保守起见，一定要使用memset 和 fill函数； 但是memset函数由于按照字节进行初始化，所以对于int和大型整形数组只能初始化为1111111，所以最好使用f
阅读全文
摘要：基本思想： 主要考察这几个方面： 1.初始化问题； 2.输入问题； 3.进制转换； 4.素数判定和素数表得问题； 关键点： 1.初始化问题一定要注意，bool数组并不能用直接初始化； 2.输入问题涉及到多点测试问题，详见多点测试输入总结； 3.进制转换，已经很熟了，没什么好说的； 4.素数详见素数得
阅读全文
摘要：一、关于最小公倍数和最大公约数： 相关总结之前做过：链接https://segmentfault.com/a/1190000018188261 当时对于数学推论浅尝辄止，这里再详细说说： 首先，最大公约数的找法又称作辗转相除取余法，其最基本的数学表达如下所示： 对于两个数字a，b，假若a>b； 所以
阅读全文
摘要：基本思路： 排序相减问题，题是水题，但是暴露出几个编程的不好习惯； 关键点： 1.定义函数不费时间，也不会增加复杂度，模块化还是要用的； 2.注意数组转数字的方式，利用多项式相乘可以快捷解决，而不用算次方： int getnumber() { int n = 0; for (int i = 0; i
阅读全文
浙公网安备 33010602011771号