LINZEYU666的博客

#include <iostream>#include <vector>#include <queue>using namespace std;#if 0using uint = unsigned int;const uint INF = INT_MAX;#if 0// 迪杰斯特拉算法接口int Dijkstra(vector<vector<uint>>& graph, int start, // 起点

40亿个QQ号码如何去重？文件中有40亿个QQ号码，请设计算法对QQ号码去重，相同的QQ号码仅保留一个，内存限制1G.在原题中，实际有40亿个QQ号码，为了方便起见，在图解和叙述时，仅以4个QQ为例来说明。方法一：排序很自然地，最简单的方式是对所有的QQ号码进行排序，重复的QQ号码必然相邻，保留第一个，去掉后面重复的就行。原始的QQ号为：排序后的QQ号为：去重就简单了：去重一定要排序吗？显然，排序的时间复杂度太高了！！！方法二：hashmap既然直接排序的时间复杂度太高，那就用h

代码如下#include <iostream>#include <vector>#include <algorithm>using namespace std;struct ListNode{ int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {}};ListNode* init_link(initializer_list<int> list){ Li

题目如下给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。例如，给定三角形：[ [2], [3,4], [6,5,7], [4,1,8,3]]2可以往3或者4走，3可以往6或者5走，4可以往5或者7走，以此类推解题方法自顶向下的最小路径和为?11（即，2?+?3?+?5?+?1?= 11）。要么从正下方走，要么从右下方走，看哪个值最小可以自底向上回溯判断，会有重复求解子问题。但是我们可以只使用 O(n)的额外空间（n 为三角形的总行数）来解

Kruskal克鲁斯卡尔算法理论Kruskal克鲁斯卡尔算法是处理边的，所以在稀疏的边比较少的连通网中，用Kruskal克鲁斯卡尔算法效率就比较高。在边比较多的连通网中，用Prim普里姆算法效率比较高。所选边的2个顶点应属于两棵不同的树，意思是，不能形成回路。首先，A-C边的权值最小，所以我们选择A-C边，在A和C没有连接起来的时候，A和C哪里都去不了，所以A和C连起来是没有回路的。然后D-F边的权值最小，我们选出来。而且D-F连接起来也不产生回路。然后此时B-E边的权值最小，我们选择

最小生成树Prim普里姆算法理论最小生成树的应用场景：顶点代表城市的话，比如说修路，架设电线，网络，怎么让这几个城市连起来，而且花费是最小的，成本最低，权值是最小的，但是不允许形成环路。第一步的U,V集合类似于迪杰斯特拉的S和U集合。U集合放的是已经选好的点，V集合放的是未选好的点首先选择权值最小的节点。我们选择从A开始，A-B,A-C,A-D中，权值最小的边是A-C，加入到最小生成树当中。把C加入到U集合中，也就是选进去了。然后把剩余顶点（BDEF)的权值都和C算一下，如果谁和C的权值

Dijkstra迪杰斯特拉算法每个顶点之间的边都带着1个权值，这个权值可以表示任意的花费，距离，时间等等。比如说我们指定一个起始的顶点A，和一个末尾的顶点E，

倒排索引理论我们在打开百度，或者是谷歌，360浏览器，我们输入关键字以后，浏览器作为客户端把关键字发到对应的搜索引擎的服务器server端，服务器去分析这个关键字，在全网的所有网页html中（几千万，上亿个文件）中快速搜索出我们想要的内容，我们输一个关键字，敲一个回车，很快的所有的搜索结果都出来了，不到1秒的时间内搜索几千万个网页。为什么搜索这么快？我们在自己的电脑上去搜索一个文件，速度却非常的慢，有时候几十分钟都搜索不出来。为什么搜索引擎的服务器搜索那么多的文件内容很快就可以定位到哪些文件包含这些关

KMP算法在布鲁特-福斯算法的基础上，进行如下改进：每当匹配过程中出现相比较的字符不相等时，不需要回溯主串字符的位置指针，而是利用已经得到的“部分匹配”的结果，将模式串向右“滑动”尽可能远的距离，再继续进行比较。KMP 算法是一种改进的字符串匹配算法，由 D.E.Knuth，J.H.Morris 和 V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称 KMP 算法）。KMP 算法的关键是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是实

字符串模式匹配模式串(或子串)在主串中的定位操作通常称为串的模式匹配，它是各种串处理系统中最重要的运算之一。BF算法布鲁特-福斯算法从主串的第一个字符起与模式串的第一个字符比较，若相等，则继续逐个字符进行后续比较，否则从主串的第二个字符起与模式串的第一个字符重新开始比较，直至模式串中每个字符依次与主串中的一个连续的字符序列相等时为止，此时称为匹配成功；如果在主串中不存在与模式串相同的子串，则匹配失败。图解过程给定主串“ABCDABCDABBABCDABCDABDD”，子串“ABCDABD”

基数排序算法的思想基数排序也称作：桶排序思想：把所有元素的个位进行排序，然后十位进行排序，然后百位进行排序，依次向高位递进，最后得到一个全局的小到大或者大到小的序列。我们看下面序列如果每次比较的都是1位的话，比如说57和54，先比较个位，7大于4，十位，是5==5，也就是说，每次比较的这一位的话，取值范围就是0-9每一位取的范围是0-9我们现在对下面这个序列进行桶排序：从左向右，依次遍历原始的数据，最开始，是个位进行比较43的个位是3，我们把43放在3号桶，47的个位是7，我们把4.

算法库的头文件问题1qsort源码：（堆排序）_Ideal是元素的个数每次递归：_Ideal都要缩小_Ideal来控制栈的深度，让树趋于平衡的情况，如果超过这个，认为树的倾斜度高，而且如果元素过多，快排递归次数过多，会把栈撑破。当递归达到 _Ideal<=0，而且此时元素量也比较少了，序列就短了，就把快排转为堆排序，空间复杂度是O(1)如果用归并，占用额外的内存空间会比较多。（快速排序算法+插入排序算法）问题2问题3在sort源码，通过参数_Ideal(元.

希尔&快排&归并&堆排-性能测试#include <iostream>#include <algorithm>using namespace std;//堆的下沉调整void siftDown(int arr[], int i, int size){ int val = arr[i]; while (i < size / 2) { int child = 2 * i + 1; if (child + 1 < size &

堆排序算法的思想如果我们要从小到大排序，实现的就是大根堆如果我们要从大到小排序，实现的就是小根堆我们实现的是从小到大排序：首先，题目给我们的是一组原始的未排序的序列我们把存在数组中的元素，在逻辑上看成1个二叉堆我们要做的第一件事是：第1个非叶子节点的下标：(最后一个节点的下标-1)/2就是图中的值为8的节点然后进行一个大根堆的调整和它的孩子进行比较进行判断，看看要不要下沉调整大根堆：当前节点的值要大于它的两个孩子如果孩子的值大于当前节点，要和当前节点进行交换。然后到值为2的

归并排序算法的思想归并排序算法不仅仅可以做内排序(内存上的排序)，还可以做外排序(磁盘上文件的数据的排序)归并排序算法：归就是递归的归，递的过程是缩减数据规模到头，规模小到结果是已知的，然后归的过程是在计算各个规模的结果，累计出原始数据规模的结果。我们看下面这一行待排序的序列要归并，首先要先递，递的过程是在缩小数据规模，对于数组来说，缩小数据规模就是缩小起始和末尾下标的数据的长度，递到序列里只剩下1个元素为头。序列中起始下标是0，末尾下标是9首先，进行递把原始序列进行分段我们采用的

快速排序算法的思想下面是一组待排序的序列，我们现在要使用快速排序算法的思想解决1、我们选取基准数，我们把第一个数字当做基准数进行元素的调整，对于数组来说，我们要涉及1个范围，用起始下标和末尾下标。我们用L表示左边的起始下标，R表示右边的起始下标我们用val=46，即首元素，作为基准数2、从R开始往前遍历，找第一个小于基准数val=46的数字，放到L的地方，53不小于基准数46，所以我们让R–，R访问到65这个元素，65不小于基准数46，所以我们让R–，R访问到32这个元素，32小

性能测试代码#include <iostream>#include <stdlib.h>#include <time.h>using namespace std;//希尔排序void ShellSort(int arr[], int size){ for (int gap = size / 2; gap > 0; gap /= 2)//100W 19 1000W 24 { for (int i = gap; i < size; i++

希尔排序算法的思想希尔排序可以认为是插入排序的一个优化，升级。如果数据序列从大的方向，从全局看，已经是趋于有序的，那么插入排序是所有排序算法中效率最高的。希尔排序就是从插入排序的这句中总结优化的，它以自己最大的能力在全局中不断地把数据调整成趋于有序的，这样使得插入排序效率就越来越高。插入排序是按顺序从左到右，依次定位到元素，然后在前面已排序的序列中找到合适的位置插入。也就是说，随着插入排序的进行，只是前面那部分是有序的，从整体上表现出来，并不是越排越有序。而希尔排序对插入排序的优化是，让全局数据序

插入排序算法的思想对于插入排序算法来说，不仅仅没有交换，而且比较的次数也少！插入排序：每次会把前面的一组序列当做已经排序好的，然后把后面的元素，按照有序的方式插入到前面的序列就可以了。具体该怎么做呢？下面这是我们原始的一组待排序的序列。我们认为第一个元素25本身就是有序的序列，因为就一个元素25嘛。我们从第二个元素开始处理：第1趟：认为25是有序的序列，然后把40按照顺序插入到其前面已经有序的序列，因为前面已经是有序的序列，所以40就往前找，找第一个小于或者等于40的数字，插入到其后面

选择排序算法的思想假如说，我们现在有一组未排序的序列先定位到元素65，也就是说，从数组的0号位置开始，定位0号位置的元素除我们定位的元素之外，在其后边的所有元素中去找一个最小值，然后和当前定位的元素进行交换。也就是说，每一次我们都要选择出来1个最小的元素放在定位的位置。我们是从0号位置65开始定位的。接下来，然后遍历65后面的元素，一个一个和65比，找到第一个比65小的是40，用min记录这个40，然后继续遍历40之后的元素，一个一个和40比，然后找到第一个比40小的元素：34，用min记

冒泡排序算法的思想上图是无序的数据，要进行排序。冒泡排序就是：每一趟都是从开始的这个元素，两两进行比较，把大的元素往下交换（沉淀到底），把小的元素往上交换（冒泡），每一趟操作的数据都是除去前面的每一趟沉淀到底的数据之外的数据每一趟处理的方式是一样的，只是数据量是不同的。第一趟：从开始的这个元素，两两进行比较，把大的元素往下交换（沉），把小的元素往上交换（冒泡）第一趟下来，整体没排序，但是把整个序列的最大值94沉到底了，第二趟：不用处理94了，我们的目的是每一趟把当前处理的序列的最大值沉到底

如果数据序列是无序的，我们采用的是线性搜索，时间复杂度是O(n）二分搜索算法(折半查找)是基于有序序列的搜索我们定义2个下标，first和lastfirst初始值是0，last初始值是10每次进行搜索，采用的策略是：首先，计算出1个中间值：（0+10）/2=5然后把中间的值57和我们要搜索的元素val值比较如果我们要搜索的元素的值是57，等于这个中间值，那么就找到了。如果我们要搜索的元素的值大于这个中间值57因为是数据有序的序列，所以我们要搜索的元素值大于这个中间值57的话

大/小根堆求topK问题问题1：如果我们用普通排序算法，时间复杂度是O(n^2)，如果我们使用高级排序算法，时间复杂度是O(logn)。但是现在要求时间复杂度是O(n）相当于把原始数据遍历一遍就找到topK元素。我们需要一个大根堆（堆顶元素的值是最大的）（二叉堆访问的就是堆顶，其他位置我们访问不到，和栈一样，我们只能访问栈顶，其他位置访问不到）我们先遍历序列的前3(k)个元素，先把它们构建成1个大根堆，堆顶元素就是64，然后前面这3个元素已经遍历过了，然后从第4个元素开始继续遍历，因.

在缓存服务器redis，在黑名单过滤，钓鱼网站过滤，URL过滤这些场景中，布隆过滤器很常见布隆过滤器就是把哈希表方法和位图算法结合起来布隆过滤器图解比如说，我们有3个哈希函数，位数组的长度是7个我们通过第一个哈希函数，我们把这个key所要存储的数据不管是整数，还是字符串，还是IP地址，还是URL，作为输入参数，通过哈希函数得到的位置，就是位图数组范围内的一个下标。假设一个输入参数通过第一个哈希函数得出的结果是0通过第二个哈希函数得出的结果是4通过第三个哈希函数得出的结果是6也就是说

大数据查重-位图算法位：内存管理的最小单位是字节，一个字节是8个位。有1亿个整数，最大值不超过1亿，问都有哪些元素重复了？谁是第一个重复的？ 内存限制100M1亿 = 100M如果是放到哈希表上：100M * 4 = 400M * 2 = 800M内存限制100M，不让我们用哈希表，我们用位图算法：什么是位图算法？我们有下面一行数字：我们用一个位存储数字是否出现过的状态，那么这几个数字，我们的位图数组需要定义多长呢？我们一般是这样处理：实现我们要找出这组数据的最大的数字19，

大数据查重-哈希应用模拟问题1vector中放原始的数据，放着10000个随机的数字，有的数字有重复，有的数字没有重复，找第一个出现重复的数字#include <iostream>#include <vector>#include <unordered_set> #include <unordered_map>#include <stdlib.h>#include <time.h>#include <strin

C++或者Java无序关联容器底层采用链式哈希表实现为什么不采用线性探测哈希表？如果采用线性探测哈希表，缺陷是：1、发生哈希冲突时，需要从当前发生哈希冲突的位置向后不断的去找，找到第一个空闲的位置把元素放上，这个过程的时间复杂度就趋近于O(n)了，存储变慢了，查询和删除也变慢，哈希冲突的发生越严重，就越靠近O(n)的时间复杂度，这个时间复杂度能否优化？哈希冲突是无法避免的，但是发生哈希冲突以后，在进行增删查的时候，能不能把时间效率提高一点，不让它趋近于O(n)的时间复杂度呢？不能，因为它是一个线性表，

哈希表-线性探测法理论线性探测法的理论我们在上一篇博客已经阐述了。现在我们来看看线性探测法的增删查的代码思想：哈希表的增加元素：注意：往后遍历寻找空闲位置的时候，要注意是环形遍历哦！不然访问数组就越界了。我们还要注意：在添加元素，发生位置被占用，即发生哈希冲突后，在向后遍历寻找空闲位置的时候，我们要知道，这个空闲的位置是有两种情况的：1、这个位置一直是空的，没放过元素。2、这个位置是空的，以前放过元素，后来被删除了。哈希表的查询操作：当用哈希函数计算得出的下标值是3，然后去访问数组，查

寻找迷宫最短路径在迷宫里面怎么找最短的路径？？？使用广度遍历迷宫路径搜索最短路径：0 0 1 1 1 11 0 0 0 0 11 0 1 1 0 11 0 0 0 0 11 0 1 1 1 11 0 0 0 0 0广度优先遍历求最短路径如果(0,0)的值为1，则表示迷宫的路口是封住的，直接return掉。如果(0,0)的值为0，则表示路口是通的，把0入队。然后开启循环，如果队列不为空，看队头元素，它的右边能不能走，能走，则把右边元素入队，然后还要看(0,0)元素的下边，左边

深度优先遍历搜索迷宫路径深度遍历搜索迷宫路径，软件运行要求如下：请输入迷宫的行列数(例如：10 10):5 5请输入迷宫的路径信息(0表示可以走，1表示不能走):0 0 0 1 11 0 1 0 11 1 0 1 11 1 0 0 11 1 1 0 0迷宫路径搜索中...>>>如果没有路径(左上角的0到右下角的0没有一条通的路径)直接输出<<<不存在一条迷宫路径！迷宫路径搜索中...0 0 0 1 11 0 0 0 11 1 0 1 1

分支限界算法解决0-1背包问题-FIFO队列相当于左子树加约束条件了，右子树限界。我们把根节点描述成nullptr//分支限界算法 - 01背包问题 FIFO队列 int w[] = { 16,15,15 };//物品的重量int v[] = { 45, 25, 25 };//物品的价值int c = 30;//背包的容量const int n = sizeof(w) / sizeof(w[0]);//物品的个数int cw = 0;//已选择物品的重量int cv = 0;//

集装箱装载问题有一批共n个集装箱要装上2艘载重量分别为c1,c2的轮船，其中集装箱的重量为wi,且要求确定是否有一个合理的装载方案可将这n个集装箱装上这2艘轮船。我们要尽最大可能把一个轮船塞得越满越好，然后c1的轮船最大化装载。然后把剩下的集装箱装上另一个轮船。我们定义int w[] = { 12, 8, 15 };//集装箱的重量const int n = sizeof(w) / sizeof(w[0]);//集装箱的数量int c = 27;//轮船的容量int cw = 0;//已选择物

分支限界算法思想分支限界算法是广度优先（最小耗费优先）广度优先指的是在遍历节点的时候，是一层一层地遍历，和层序遍历一样，从根节点开始，左右孩子依次入队。最小耗费优先的方式就是入到优先级队列里面。分支限界算法是找出满足约束条件的1个解。或者是找出某种意义下的最优解。遍历的时候，根节点就是扩展节点，扩展出的左右孩子，就是活节点。活节点一旦成为扩展节点，就一次性生成所有孩子。也就是说，在扩展节点的过程中，有判断，不满足判断条件的，就会被舍弃掉限界相当于剪枝操作...

贪心算法思想符合每一步的最优解，但是不一定是原问题的最优解硬币问题1,3,5分的硬币，现在给定一个价值c：11，问组成价值c需要的最少的硬币的数量？？？#include <iostream>#include <algorithm>using namespace std;int main(){ int arr[] = { 1,3,5 }; int length = sizeof(arr) / sizeof(arr[0]); int c = 11; sort

动态规划算法-0-1背包问题0-1背包问题：有一组物品，其重量为w1,w2,…,wn，其价值为 v1,v2,…,vn，现在有一个背包，其容量是c，问怎么样装入物品，可以使背包的价值最大化？我们要找的是问题的状态和状态转移方程能用动态规划算法解决问题的两个要素：两个要素：1.最优子结构性质2.划分的子问题非独立（有重叠）我们把原问题的规模缩小，从第一个开始装或者从最后一个开始装。wn -> c //把wn装入c wn-1 -> c-wn //把wn-1装入背包 状态（

LCS：求两个序列的最长公共子序列的长度 子串（连续的） 子序列不一定是连续的例如：helloworldhlweord我们要求X : X1,X2…XnY: Y1,Y2…Ym求两个序列的LCS最长公共子序列长度我们进行子问题的划分helloworl hlweord => 情况1helloworlr hlweor => 情况2X : X1,X2...XnY: Y1,Y2...Ym状态的转移方程如果Xn == Ymdp(X[1...n],Y[1..

LIS问题：求序列的最长非降（升序）子序列的长度5 3 4 1 8 7 9我们看上面这个序列。显然，5和3不能构成非降子序列。3和4就可以构成非降子序列。以此类推。最长的非降子序列是3479朴素解法：不一定得到最优解，无效的解法 但是要求算法时间复杂度：O(n^2)动态规划算法解决#include <iostream>#include <algorithm>using namespace std;/*朴素解法：不一定得到最优解，无效的解法 但是

题目如下11-4+13=20#include <iostream>#include <algorithm>using namespace std;/*最大子段和状态：dp[i] 以第i个元素结尾的字段和的值状态转移方程：dp[0] = val < 0 ? 0 : val; 0dp[1] = ar[1] + dp[0] = 11dp[2] = ar[2] + dp[1] = -4 + 11 = 7dp[3] = ar[3] + dp[2] = 13

分治算法解决斐波那契数列// 分治算法如下 //参数n表示斐波那契数列中数字的个数。//返回相应个数的斐波那契数列数字的值。int fabnacci(int n, int dp[]) { if (dp[n] > 0) { //子问题n之前被求解过了 return dp[n]; } if (n == 1 || n == 2) { dp[n] = 1; return 1; } else { dp[n] = fabnacci(n - 1, dp

硬币选择问题：有1，3，5分面额的硬币，给定一个面值11，问组成给定面值所需要的最少的硬币数量是多少？？？我们先用分治算法解决现在我们使用动态规划算法解决#include <iostream>#include <algorithm>using namespace std;/*硬币选择问题：有1，3，5分面额的硬币，给定一个面值11，问组成给定面值所需要的最少的硬币数量是多少？？？11: 1 + (10)