FairLikeSnow的博客

LCA最近公共祖先

动态规划理论与练习

题目示意:分析：解答源码：class solution{public: int max3(int a, int b, int c) { return max(a, max(b, c)); } std::vector<int> mem; int get1(int x) { if (x == 1) { return 1; } if (x == 2) { return 1; } if (x == 3) { retur

//记忆化搜索int fib(int n){ static vector<int> m_memory = vector<int>(n + 1, -1); if (n == 0 || n == 1) { return 1; } if (m_memory[n] == -1) { m_memory[n] = fib(n - 1) + fib(n - 2); } return m_memory[n];}//普通的递归-----原始的解法int fib2

其实也是利用了数学里的排列组合的知识，下面看看代码吧。算法思想是采用了回溯法。class doorsolution{public: vector<vector<int>> m_resVc; void fun1(int nstart,int n,vector<int> &p,int k) { if (p.size() == k) { m_resVc.push_back(p); return; } for (int i = ns

回溯法思路的简单描述是：把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。class pailiezuhe{public: //将要返回的最终结果 std::vector<vector<int>> m_resVc; //记录元素有没有被使用 std::vector<bool> usedVc; void fun1(vector<int> perms, int nindex,vec

实现九宫格字符串的输入比如Input: "23"Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].接下里实现代码代码：char *lettersmap[] = { "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz" };class TyKeyboard{ //将来要返回的所有字符组合 vector<string> res

题目：代码：int getPos(string str){ int a[26] = { 0 }; for (int i = 0; i < str.length();i++) { a[str.at(i) - 'a']++; } for (int i = 0; i < str.length(); i++) { if (a[str.at(i) - 'a'] == 1) { return i; } } return -1;}int main()

这里写目录标题标题动态规划一、基本思想案例：最长公共子序列问题1.子序列和子串的定义：2.两者之间的关系：二、算法分析1.分析问题的最优子结构2.建立递推公式:3.代码:4.测试结果:标题动态规划    通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。一、基本思想    一般来说，只要问题可以划分成规模更小的子问题，并且原问题的最优解中包含了子问题的最优解

1.算法的效率    虽然计算机能快速的完成运算处理，但实际上，它也需要根据输入数据的大小和算法效率来消耗一定的处理器资源。要想编写出能高效运行的程序，我们就需要考虑到算法的效率。算法的效率主要由以下两个复杂度来评估：时间复杂度：评估执行程序所需的时间。可以估算出程序对处理器的使用程度。空间复杂度：评估执行程序所需的存储空间。可以估算出程序对计算机内存的使用程度。    设计算法时，一般是要先考虑系统环境，然后权衡时间

计算n的阶乘（1）证明当n= n0时成立f(0)=1;f(1)=1;f(2)=2=2*f(1)f(3)=3*2*1=3*f(2)（2）假设n = k时f(n) = n*f(n-1)成立证明:即f(k) = k*f(k-1);则f(k+1)=(k+1)*f(k)故f(n) = n*f(n-1)

当n趋于+∞时lim(1/n) =0,则1/n = o(1),即1/n为当n->+∞时为高阶无穷小量。

先讲个故事：从前有座山，山里有座庙，庙里有个和尚，和尚在讲故事，从前有座山，山里有座庙，庙里有个和尚，和尚在讲故事，从前有座山…其实这就是递归，所以我们每个人都听说过。定义：递归就是自己调自己。思想：是把规模较大的一个问题，分解成规模较小的多个子问题去解决，而每一个子问题又可以继续拆分成多个更小的子问题。 最重要的一点就是假设子问题已经解决了，现在要基于已经解决的子问题来解决当前问题；或者说，必须先解决子问题，再基于子问题来解决当前问题。A依赖于B,B依赖于C,C依赖于D……当D解决了那C就解决

KMP算法指的是字符串模式匹配算法，问题是：在主串T中找到第一次出现完整子串P时的起始位置。该算法是三位大牛：D.E.Knuth、J.H.Morris和V.R.Pratt同时发现的，以其名字首字母命名。先看看暴力法：可以看到主串第i的位置和模式串的第j位置，匹配失败，对于暴力法则进行下面的比对。总结下来就是，比对失败就将模式串回退到首个字符然后继续和主字符串比对失败的那个字符继续进行对比。具体代码可以参看我的另一篇文章:BF算法匹配字符串KMP算法操作过程如下，i不回退，只操作模式串的位置。这

代码：//暴力法int ViolentMatch(char* s, char* p){ int m_slen = strlen(s); int m_plen = strlen(p); int i = 0; int j = 0; int nflag = -1; while (i<m_slen&&j<m_plen) { j = 0; if (s[i] == p[j])//如果第一个元素匹配上则进行下面的匹配 { nflag = i;

第1趟比较：拿第1个元素依次和它后面的每个元素进行比较，如果第1个元素大于后面某个元素，交换它们，经过第1趟比较，数组中最小的元素被选出，它被排在第一位第2趟比较：拿第2个元素依次和它后面的每个元素进行比较，如果第2个元素大于后面某个元素，交换它们，经过第2趟比较，数组中第2小的元素被选出，它被排在第二位…第n-1趟比较：第n-1个元素和第n个元素作比较，如果第n-1个元素大于第n个元素，交换它们作者：CoderJed链接：https://www.jianshu.com/p/5223afa8796

思想:接下来用图分解:19,97,9,17,1,8第一次排序完成比谁的对头小，谁小放前面把剩下的全部依次移动到数组，就剩余一个数组，如下，这个就是有序的。接下来看看代码:void mergety(int a[], int left, int nmid, int nright, int ntemp[]){ int i = left; int j = nmid + 1; int t = 0; //主要思想就是对比谁的头小，谁小就放谁。 while (i

实现思路：1.从数组的第二个数据开始往前比较，即一开始用第二个数和他前面的一个比较，如果 符合条件（比前面的大或者小，自定义），则让他们交换位置。2.然后再用第三个数和第二个比较，符合则交换，但是此处还得继续往前比较，比如有 5个数8，15，20，45, 17,17比45小，需要交换，但是17也比20小，也要交换，当不需 要和15交换以后，说明也不需要和15前面的数据比较了，肯定不需要交换，因为前 面的数据都是有序的。3.重复步骤二，一直到数据全都排完。void insertSort(int a[]

堆排序堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。堆堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。如下图：同时，我们对堆中的结点按层进行编号，将这种逻辑结构映射到数组中就是下面这个样子该数组从逻辑上讲就是一个堆结构，我们用简单的公式来描述一下堆的定义就是：大顶堆：arr[i]

思想采用了分而治之的思想算法步骤为:代码：#include<iostream>using namespace std;int GetMid(int a[],int nlow,int nhigh){ int nleft = nlow; int nright = nhigh; int npivot = a[nlow];//对比的值 while (nleft<nright) { //1.右边的先向左扫描，找到比npivot小的数然后放到left位置 whil

vector<int> GetSum(vector<int> m_vc, int ndest){ vector<int> m_xiabiao; map<int, int> m_temmap; for (int i = 0; i < m_vc.size();i++) { if (m_temmap.find(ndest - m_vc[i]) != m_temmap.end()) { m_xiabiao.push_back(m_temm

利用了小顶堆的数据结构特性#include<iostream>#include<queue>#include <functional>using namespace std;struct cmp{ bool operator()(int &a, int &b) const { //因为优先出列判定为!cmp，所以反向定义实现最小值优先 return a > b; }};int GetKthElement(int a

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。示例:输入: [-2,1,-3,4,-1,2,1,-5,4],输出: 6解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。int GetMaxSum(vector<int> array){ if (array.empty()) { return -1; } int nmaxSum = array[0]; //1, -2, 3, 10, -4, 7, 2,

1.原理：比较两个相邻的元素，将值大的元素交换到右边2.思路：依次比较相邻的两个数，将比较小的数放在前面，比较大的数放在后面。(1)第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。(2)比较第2和第3个数，将小数 放在前面，大数放在后面。…(3)如此继续，知道比较到最后的两个数，将小数放在前面，大数放在后面，重复步骤，直至全部排序完成(4)在上面一趟比较完成后，最后一个数一定是数组中最大的一个数，所以在比较第二趟的时候，最后一个数是不参加比较的。(5)在第二趟比较完成后，倒

/*需求示意：已知有M段不连续的时间段，[t1,t2],[t2,t3],[t3,t4],[t6,t7],[t7,t8],[t9,t10]合并后应为：[t1,t4]，[t6,t8],[t9,t10],则缺失[t4,t5]的时间段。条件:时间段前后为闭包，目的:将满足条件的零碎片段拼接为一段连续的大片段，并输出拼接后的片段.*/struct TyTime{ int start; int end;};vector<TyTime> merge(vector<TyTi

世上最好理解的二分查找法二分查找(折半查找)算法是建立在有序数组基础上的。算法思想为：1.查找过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则查找过程结束；2.如果某一待查找元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟第1点一样从中间元素开始继续进行查找。3.如果在某一步骤数组为空，则代表找不到。接下来看例子：int GetIndexByVal...