一个努力生活的人的博客

STL标准模板库- vector1.vector的定义vector<int> v; vector<vector<int> > v2;2.元素访问1.通过下标访问v[i]2.迭代器for(vector<int>::iterator it = v.begin();it != v.end();it++){ printf("%d ",*it);}3.常用函数1.push_back(i):在后面添加一个元素i2.pop_back():删

堆1.堆的定义1.堆是一棵完全二叉树2.大顶堆：每个父亲节点的值大于或等于它的孩子节点的值 小顶堆：每个父亲节点的值小于或等于它的孩子节点的值3.堆一般用于实现优先队列：默认大顶堆2.堆的基本操作1.堆的存储结构//因为堆是完全二叉树，所以用数组存储最方便const int maxn = 100;int heap[maxn],n = 10; //heap为堆，n为元素个数2.建堆//向下调整void downAdjust(int low,int high){ int i =

树的静态写法//树的静态实现 struct node{ typename data; vector<int> child;}Node[maxn];//新建节点int index = 0;int newNode(int v){ Node[index].data = v; Node[index].child.clear(); return index++;} 树的先根遍历(DFS)//树的先根遍历(DFS)void PreOrder(int root){ pri

关键路径1.基本概念1.AOV网：顶点活动网，是指用顶点表示活动，而用边集表示活动优先关系的有向无环图。2.AOE网：边活动网，是指用带权的边集表示活动，而用顶点表示事件的有向无环图。AOV网和AOE网都不能存在环，否则会出现逻辑错误。3.一般而言，AOV网(AOE网)只有一个源点和一个汇点，即便存在多个源点或汇点，也可以通过添加超级源点和超级 汇点来将它变成只含有一个源点和一个汇点的AOV网（AOE网）4.AOV转换为AOE：（1）将AOV的每个顶点都拆成两个顶点，分别表示活动的起点

日期处理#include<cstdio>#include<iostream>#include<algorithm>using namespace std;int month[13][2] = { //平年和闰年的每个月的天数 {0,0},{31,31},{28,29},{31,31},{30,30},{31,31},{30,30},{31,31},{31,31},{30,30},{31,31},{30,30},{31,31} };bool isLea

图的定义1.表示方法：G（V，E） V为点集，E为边集2.图的分类：有向图和无向图3.

哈夫曼树1.哈夫曼树的定义1.哈夫曼树：带权路径长度最小的树（又称为最优二叉树） 带权路径长度 = 叶子结点的权值*到根节点路径长度 树的带权路径长度WPL = 所有叶子节点的带权路径长度之和2.求哈夫曼树的WPL//哈夫曼树 #include<cstdio>#include<queue>using namespace std;//代表小顶堆的优先队列 //所有元素从小到大排序 priority_queue<long long,vector&lt

动态规划1.动态规划的基本知识1.动态规划：解决最优化问题的算法思想。动态规划会将每个求解过的子问题的解记录下来，这样当下一次遇到 相同的子问题时，就可以直接使用之前记录的结果，而不必重复计算。2.动态规划解决的问题都需要有以下两个特性：（1）重叠子问题：如果一个问题可以被分解为若干个子问题，且这些子问题会重复出现，就称其拥有重叠子问题。（2）最优子结构：如果一个问题的最优解可以由其子问题的最优解有效的构造起来，就称其拥有最优子结构。2.动态规划的递归和递推写法（1）

扩展欧几里得算法问题：给定两个非零整数a和b，求一组整数（x，y），使得ax+by = gcd（a，b）利用递归的方法求解：首先欧几里得算法终止时，a存放gcd(a,b)，b存放0，所以有a1+b0 = gcd(a,b)，所以递归边界成立时为x=1、y=0。可以一次作为递归出口。首先有ax1 + by1 = gcd，下一步计算gcd（b，a%b），因此bx2+(a%b)y2 = gcd，因此有：ax1 + by1 = bx2 + (a%b)y2又因为a%b = a-(a/b)*b;整理

问题：n！有多少个质因子p规律为：n！中有(n/p + n/p2 + n/p3…)个质因子pint cal(int n,int p){ int ans = 0; while(n){ ans += n/p; n /= p; } return ans;} n！中有(n/p + (n/p)！）个质因子pint cal(int n,int p){ if(n<p) return 0;//递归出口 return n/p + cal(n/p,p);}组合数1.定义

栈的应用简单计算器题目描述：输入一个非负整数计算表达式，计算该表达式的值。eg：30/90-26+97-5-6-13/88*6+51/29+79*87+57*92#include<iostream>#include<cstdio>#include<string>#include<stack>#include<queue>#include<map>using namespace std;struct node{

进制转换P进制转十进制 (y是转换后的值）int y = 0,product = 1;while(x != 0){ y = y + (x%10)* product; x = x/10; product = product * P;}十进制转Q进制int z[40],num = 0; //z数组存放Q进制数y的每一位，num位位数do{ z[num++] = y % Q; y = y/Q;}while(y != 0);...

二叉查找树1.二叉查找树的递归定义1.要么二叉查找树是一颗空树2.要么二叉查找树由根节点、左子树、右子树组成，其中左子树和右子树都是二叉查找树，且左子树上所有节点的 数据域均**小于或等于**根节点的数据域，右子树的所有节点的数据域均**大于**根节点的数据域。2.二叉查找树的性质二叉查找树的中序遍历是有序的，增序（非递减）3.二叉查找树的基本操作struct node{ typename data; node* lchild; node* rchild;}Node[maxn]

素数1.素数的判断bool isPrime(int n){ if(n<=1) return false; //long long防止溢出 long long sqr = (long long)sqrt(1.0*n); for(int i=2;i<=sqr;i++){ if(n%i==0) return false; } return true;}2.素数表的获取情景：从1-n枚举所有素数，n<10^5复杂度利用上述算法便可以求解。当n>10^5时，则需

并查集1.并查集的功能与实现1.合并：合并两个集合2.查找：判断两个元素是否在一个集合实现：int father[N]; 1.father[i]：表示i的父节点是father[i]; 2.如果father[i] = i;那么i是该集合的根节点，一个集合只有一个根节点，因此可用作标识一个集合。2.并查集的基本操作1.初始化并查集void init(int n){ for(int i=1;i<=n;i++){ father[i] = i; }} 查找的改进：&nbs

避免hash冲突1.线性探查法2.平方探查法3.链地址法字符串hash//字符串S不能过长，len<=14 int hashFunc(char S[],int len){ int id = 0; for(int i=0;i<len;i++){ id = id*26+(S[i]-'A'); } return id;}//如果还包含a~z，则模变为52 ...

最小生成树1.基本概念1.定义：（1）在给定一个无向图中求一棵树T（2）使得这棵树拥有图G的所有顶点，边都是来自图G的边（3）并且满足边权之和最小2.性质：（1）因为是树，所以边数=顶点数-1（2）对给定的图G，其最小生成树可以不唯一，但边权之和一定是唯一的（3）根节点可以是这棵树上的任意一个结点2.最小生成树的求法（1）prim算法特点：类似于Dijkstra算法，只是在求解最短距离时，用集合S代替了起点s伪代码： Prim(G,d[]){ 初始化; for(循环n

单源最短路径1.Dijkstra算法伪代码： //G为图，一边设成全局变量，数组d为源点到达各点的最短路径长度，s为起点 Dijkstra(G,d[],s){ 初始化; for(循环n次){ u = 使d[u]最小的还未被访问的顶点的标号; 记u已被访问; for(从u出发能到达的所有顶点v){ if(v未被访问&&以u为中介点使s到顶点v的最短距离d[v]更优){ 优化d[v]; 记录pre[v];*************用

树的性质1.树可以没有结点，这种情况下把树称为**空树**2.树的**层次**从根节点开始算起，即根节点为第一层，根节点子树的根节点为第二层，以此类推3.把结点的子树棵树成为节点的**度**（一个结点的孩子结点个数），其中最大值称为**树的度**4.由于一条边连接两个节点，且树中不存在环，因此对有n个结点的树，边数一定是n-1。 且满足连通、边数等于顶点数减1的结构一定是一棵树。5.叶子节点被定义为度为0的结点。只有一个根节点时，根节点也算作叶子节点。6.节点的深度是指从根节点开始

拓扑排序1.基本概念1.有向无环图：如果一个有向图的任意顶点都无法通过一些有向边回到自身，那么称这个有向图为有向无环图。2.拓扑排序：将有向无环图的所有顶点排成一个现性序列，使得对图G中的任意两个顶点u、v，如果存在u->v， 那么在序列中u一定在v前面。这个序列又被称为拓扑序列。3.解决的问题：如课程学习先后顺序的问题2.实现方法（1）拓扑排序的流程：1.定义一个队列Q，并把所有入度为0的结点加入队列。2.取队首结点，输出。然后删去所有从他出发的边，并令这

浮点数保留位数问题：保留n位有效数字，四舍五入#include<iomanip>int main(){ double a = 3.141564; cout << setprecision(3) << a; // a = 3.14 return 0;}保留n位小数，四舍五入#include<iomanip>int main(){ double a = 3.141564; cout << se

最大公约数//辗转相除法 gcd(a,b)==gcd(b,a%b) //a , b均为正整数 int gcd(int a,int b){ if(b==0) return a; else return gcd(b,a%b);} 最小公倍数//辗转相除法 gcd(a,b)==gcd(b,a%b) //a , b均为正整数 int gcd(int a,int b){ if(b==0) return a; else return gcd(b,a%b);} // a/gcd(a,b)

平衡二叉树1.平衡二叉树的定义1.AVL树是一棵二叉查找树，只是在其基础上增加了“平衡”的要求。2.平衡：对AVL的任意结点来说，其左子树和右子树的高度之差的绝对值不超过13.平衡因子：左子树与右子树的高度之差。heightLeft-heightright2.平衡二叉树的基本操作struct node{ typename v; int height; node* lchild; node* rchild;};//新建结点node* newNode(int v){ node*

质因子分解质因子分解：将一个正整数n携程一个或多个质数乘积的形式，例如6 = 23，180 = 2233*51.质因子的表示//2*3*5*7*1113*17*19*23*29会超过int范围，//所以fac数组只需要开到10个即可 struct factor{ int x,cnt}fac[10];2.质因子的求解对一个正整数n来说，如果它存在[2,n]范围内的质因子，1.要么这些质因子全部小于等于sqrt(n)，2.要么就是只存在一个大于sqrt(n)的质因子，其他质因子全小于sq

文章目录跳跃游戏1.解法2.总结python跳跃游戏leetcode链接1.解法对于这道题，最直接的思路就是使用暴力遍历的方法，找到所有的情况，然后看这些情况中是否能够到达数组的最后一个位置。举个例子：nums = [2,3,1,1,4]1.首先遍历0号位的数值2，2表示：从0号位可以到达1号位和2号位此时的覆盖范围变为2号位（1）然后遍历1号位，1号位的数值是3，那么就可以到达2、3、4号位（这里已经到了最后一个位置，为了把暴力原理说明白，我们继续遍历）（2）然后遍历2号位，2号

文章目录买卖股票的最佳时机 II1.解法解法1解法2总结买卖股票的最佳时机 IIleetcode链接1.解法解法1首先第一个想法就是先找到一个比较低的股价买入，然后找到一个比较高的股价卖出，然后不断重复。所以当前问题就是如何确定比较低的股价和比较高的股价的位置。这道题类似于之前的摆动序列（不清楚的可以看看我之前写的博客），比如举一个例子：我们先把股价画成上面的形状，然后找递增区间，递增区间的首尾就是买入和卖出的时间。上图的递增区间是[0,1]，[2,5]，[7,8]。（区间是按照索引来确定

文章目录最大子数组和两种解法暴力贪心最大子数组和leetcode链接两种解法暴力最直观的方法就是使用暴力来遍历区间的开头和结尾，然后对区间求和，取最大值。如果对暴力方法优化的话，可以固定区间开头为0，然后遍历区间结尾，对每个区间求和，然后通过这些区间之间做减法可以得到不同开头的区间的和，再进行比较。举例：nums = [1,2,3,4]先求出区间[0,0],[0,1],[0,2],[0,3]的和，分别为1,3,6,10，然后如果想求区间[1,2]的和，就可以用区间[0,2]-[0,0]，即为

文章目录摆动序列解法摆动序列leetcode链接解法题目可以理解为：在不改变给定nums序列的顺序的情况下，找到一个最长的摆动序列。（摆动序列是指每相邻的两个数的差值是正负交替的），如果画出图来，该序列会呈现一个锯齿状。贪心策略为：局部最优：在不改变单调性的情况下，找到距离当前数最远的一个数值。（比如选1，单调性先是增大，所以再选17，然后单调性变为减小，然后再选5，然后单调性变为增大，此时有10，13，15三个数，选择距离5最远的，所以选择15…）这样选择可以保证下一个数有足够大的空间可以选

文章目录分发饼干1.解法分发饼干1.解法思路：难点在于使用什么策略可以使得在满足相同数量的孩子的情况下，相对大的饼干的消耗最小？所以我们想到贪心算法，每次给胃口小的孩子分配刚刚好比他胃口大一点的饼干，这样就能保证能为胃口大的孩子分配更大一点的饼干，这样才能尽可能的满足更多的孩子。我们先将胃口g和饼干s的数值从小到大排序，i=0，j=0，对于胃口g[j]的孩子，我们给他分配s[i]号饼干。如果s[i]>=g[j]，那么就刚好可以满足这个孩子；如果s[i]<g[j]，那么就不能满足，要从后面

文章目录解数独1.解法2.总结python算法解数独leetcode链接1.解法这道题是一个棋盘问题，而棋盘问题是一个典型的回溯问题。首先思考普通人（这里指没有受过专业训练的人）解数独的方法，那就是首先在空白位置假设一个数字，然后在这个假设的基础上去填别的数，如果发现到最后无法填满，则证明假设不成立，然后换一个数继续假设。上面的思想非常符合回溯的思想，画成图如下所示：所以我们现在可以进行回溯三部曲：确定函数头首先思考函数的参数，因为一般的回溯都是通过每次修改参数（比如让参数+1等等）

文章目录n皇后1.解法2.总结pythonn皇后1.解法n皇后问题是比较经典的棋盘问题。而棋盘问题也是回溯问题中的一种。总体思路是：按照行（或列）遍历，首先确定第一行的一个皇后的位置，然后去确定第二行皇后的位置（确定的方法就是1.不能同行 2.不能同列 3.不能在对角线），然后去确定第三行的皇后…直到确定到最后一行。如果最后一行能找到一个答案，那么就可以把答案保存下来；如果在中途（即遍历的行小于n）就找不到了，那么对把上一行确定的皇后取消，然后使得上一行的下一个位置为皇后，重复同样的操作。n=3时

文章目录重新安排行程1.解法--题目分析2.解法--代码实现3.总结python重新安排行程leetcode链接1.解法–题目分析这部分的分析对理解题意很重要，但最后写出的代码会超时，如果已经思考过题目的读者可以跳过这部分直接看2首先来理解题意，题意就是找到一个从"JFK"出发的，能用完所有机票的，字典序最靠前的一条行程安排。从题意中我们可以提取出几个关键信息：从JFK出发能用完所有机票（每个机票只能用一次）行程能够成功（即上一张机票的终点是当前使用机票的起点）字典序最靠前的

文章目录全排列II1.解法2.总结全排列IIleetcode链接1.解法这道题和简单全排列的区别在于，集合中有重复元素，所以我们只要使用一种方法去重即可。如果不明白简单全排列要怎么做的，可以看我以前的博客（全排列）先画出树图：首先我们先讲为什么需要去重，换句话说，为什么会产生重复解？举个例子，比如[1,1,2]。对于第一个1而言，如果先把他选出来，那么对于剩余集合[1,2]而言，就可以产生[1,1,2]、[1,2,1]两个解。然后我们来看第二个1，如果先把他选出来，那么剩余集合也

文章目录全排列1.解法2.总结全排列leetcode链接1.解法排列问题也是回溯问题的一种。所以我们可以先画出树图：排列问题和组合问题的区别在于，剩余集合中元素相同时，组合只取其中一种，不考虑顺序问题，而排列则要考虑到顺序问题。例如剩余集合[2,3]时，组合[2,3]、[3,2]是同样的，而排列[2,3]、[3,2]是不同的。所以由图可知，我们每从（剩余）集合中选择一个数，就要再遍历一次集合，从里面选择没选过的数，所以我们可以用一个数组used来记录哪些数值没选择过，这样一来就可以写下如下代

文章目录递增子序列1.解法2.总结递增子序列leetcode链接1.解法这道题是一个找子集问题，只不过是要在不改变集合顺序的前提下，从有重复元素出现的集合中，挑选出符合一定条件的子集。(条件指递增并且子集元素数量大于1)我们先不考虑上面的黑体部分，那么这道题就变为了简单的找子集问题。我们可以先把子集问题的代码写上，不懂子集问题如何求解的可以看我之前的博客（子集）代码如下：def subsets(nums): result = [] path = [] def back

文章目录子集 II1.解法2.总结子集 IIleetcode链接1.解法这道题和我之前解的一道题比较类似（组合II）首先想如果我们先不考虑集合中有重复元素的情况，那么这道题就成了一个简单的子集问题，而简单的子集问题之前我已经写过了，可以先看看（子集）代码如下：def subsets(nums): result = [] path = [] def backtracking(nums,startindex): path1 = path.copy() #

文章目录子集1.解法2.总结算法子集leetcode链接1.解法子集问题也是回溯问题中最经典的一种。我们先把树图画出来：由图可以看出，如果想得到一个集合的子集，其实就是从一个集合中挑选元素，挑选方法为：首先选出第一个元素，然后再把这个元素之后的所有元素作为新集合思考同样的挑选问题之后选出第二个元素，然后再把这个元素之后的所有元素作为新集合思考同样的挑选问题…以此类推，直到新集合为空由上可知他们的递归逻辑我们根据回溯三部曲来写代码：确定函数头和一些辅助函数： result

文章目录复原IP地址1.解法2.优化复原IP地址leetcode链接1.解法这道题的本质还是切割问题，只不过使用小数点来切割。而切割问题又是典型的回溯问题。所以我们用回溯的方法来解决这道题。首先先画出树图：同样地，我们先不考虑切IP地址，只考虑切割这样一个集合有多少种切法。要想把切割一个集合，我们可以首先考虑切一个数字出来，然后对除了第一个数字以外的集合思考同样的切割问题。切两个数字出来，然后对除了第一和第二个数字外的集合思考同样的切割问题。…以此类推，知道切的数字长度和原集合长度

文章目录分割回文串1.解法3.总结python算法分割回文串leetcode链接1.解法切割问题也是回溯问题中的一种，它类似于组合问题，但又不完全一样。对于这道题而言，我们可以先画出它的树图来帮助理解为什么他也是回溯问题：对于这个例子[a,a,b]而言：先不考虑回文的问题，只考虑切割[a,a,b]，有多少种切法。想要切分[a,a,b]。我们可以先切出a，然后就要考虑如何切分[a,b]，然后我们再切出a，就要考虑如何切分[b]，到这里可以看出每切出一个元素，就要考虑相同的问题，所以这是一个递

文章目录组合总和 II1.解法2.优化3.总结python算法组合总和 IIleetcode链接1.解法刚开始看起来这道题没有什么特点，就是简单的组合问题求解，不懂组合问题如何求解的可以看我之前的博客，于是我就使用递归三部曲写出了如下代码：def combinationSum2(candidates, target): result = [] path = [] candidates = sorted(candidates) def backtracking(c