Xurui_Luo的博客

递归没终止===================================================================31==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x603000000084 at pc 0x0000003aa169 bp 0x7ffd45a6d850 sp 0x7ffd45a6d848READ of size 4 at 0x603000000084 thread T0 .

上头问题有时发生错误，半天想不到解决方法，这时候的建议是放松心情，全面检查，或者转移注意力，去做别的事，看别的题，不要死在一个点上输入判空有的时候不需要特别判空也能过，但是时刻要留心眼儿注意二维数组取行列，vector<vector<int>> vec 行数vec.size()，列数vec[0].size()，可能紧急的时候漏写0，导致出错...

递归很简单，这里省略栈一开始觉得无从下手结合递归和迭代栈的对比递归是函数调用函数，构成的是一个调用栈，其过程就是一般的二叉树图，从根到叶子 按照 “根左右 左根右 左右根”中的某个顺序去调用，是一个从上往下的过程迭代栈，也要达到这一目的。可你无法进行函数调用函数这一过程。现在需要用栈实现一层一层调用的效果。与此同时，在一层一层建立栈的同时，还需要考虑终止条件。函数调用函数，将结点压栈，和目标反向终止条件，即标记法整个过程中栈的变化：不同的遍历方式，栈的增长方式不同前序遍历：每有一

DFS每访问一个元素i，都直接去看i +1, i + 2… i + n直到这些元素不存在，通过记忆化搜索的方式，保证只会搜n次class Solution {public: int dfs(unordered_map<int, int>& mp, int v){ if (mp.find(v) == mp.end()) return 0; if (mp[v] != 0) return mp[

class Solution {public: vector<vector<int>> threeSum(vector<int>& nums) { vector<vector<int>> res; sort(nums.begin(), nums.end()); int n = nums.size(); for(int i = 0; i < n; i ++){

class Solution {public: struct Node1{ int w, id, tm; bool operator< (const Node1& t) const{ if (tm != t.tm) return tm > t.tm; if(w != t.w) return w > t.w; return id > t.id; }

反过来想，如果最后一位i能达到，那么 [i - a, i - b]之间是能达到的如果用f[i] = 1 表示能达到，那么[i - b, i - a]中至少有一个1，既 f[i - b] + f[i - b + 1] + f[i - b + 2] ... + f[i - a] > 0，这里可以用前缀和代码:const int N = 1e5 + 10;int s[N], f[N];class Solution {public: bool canReach(string str, .

每次选定分界点，根据分界点分好左右两端区间之后判断分界点位置和k的关系，从而去相应的区间继续递归找分界点，直到找到其它方法：排序(nlogn)，堆(nlogn, nlogk两种)class Solution {public: int quicksort(vector<int>& q, int l, int r, int k){ if(l >= r) return q[l]; int i = l - 1, j = r + 1, x .

LQ 要钱故跑到 Lintcode去做…首先看暴力解:就是res[i][j] 等于A的第i行和B第j列的点积class Solution {public: vector<vector<int>> multiply(vector<vector<int>> &A, vector<vector<int>> &B) { int m = A.size(), n = B[0].siz.

以每个元素作为最小值的区间static const int MOD = 1e9 + 7;const int N = 1e5 + 10;typedef long long LL;int h[N], l[N], r[N], q[N];LL s[N];class Solution {public: int maxSumMinProduct(vector<int>& nums) { int n = nums.size(); // 构造前.

双指针class Solution {public: int maxDistance(vector<int>& nums1, vector<int>& nums2) { int res = 0; for(int i = 0, j = 0; i < nums1.size(); i ++){ while(j < nums2.size() - 1 && nums2[j + 1]

https://www.1point3acres.com/bbs/thread-453640-1-1.html

LQ 233ACWing 338#include <iostream>#include <vector>using namespace std;// Get the number of k from 1 to nint kNumbers(int n, int k) { if (!n) return 0; // n = 123 answer = [3, 2, 1] vector<int> answer; while(n) .

class Solution {private: typedef pair<int, int> PII; typedef long long LL; public: vector<int> getOrder(vector<vector<int>>& tasks) { int len = tasks.size(); vector<int> index(len);

贪心如果下一个位置i+1有障碍的话，从当前位置i进行跳跃就有两种情况只有一个选择即当前i已经有了一个障碍，算上下一个的障碍，3-2=1 只需要选择剩下唯一的空跳即可有两个选择这时候就要判断该选哪个了方法就是贪心。分别看两个选择往后，在不跳跃的情况下，最远能走多久时间复杂度O(n2)O(n^2)O(n2)class Solution {public: int minSideJumps(vector<int> &ob) { in

优先队列里可加array具体声明：priority_queue<pair<double, array<int,2>>> pq;class Solution {public: double maxAverageRatio(vector<vector<int>>& classes, int extraStudents) { auto profit = [&](double a, double b).

m1：数组1中元素的个数最终目的：l=r=m1=k-m2。 此时此刻 nums1[m1-1],nums1[m1],nums2[m2-1],nums2[m2] 四个数刚好杂糅在一起// // [0…m1-1],[0…m2-1]共同构成序列的前一半，[m1…n1], [m2…n2]则共同构成后一半如果相等，说明[A_m1-1 A_m1 B_m2-1 Bm2 中，两个A只存在一个]class Solution {public: double findM..

刚开始老老实实推了半天，半天规律找不来个人认为需要整体得看一看其实，只要关注某个index i，当它经过变换，又回来的时候，就说明完成要求了class Solution {public: int reinitializePermutation(int n) { int init = 1; int cnt=0; int i=1; while(cnt==0 || init !=i){ c.

类似题 343割绳子，50快速幂快速幂中，数据类型根据题意来，可能是int, double, long long。中间计算结果防止溢出故再多乘1ll，同理如果是加法（本题中没遇到）就+0llclass Solution {public: int maxNiceDivisors(int primeFactors) { if(primeFactors==1) return 1; if(primeFactors==2) return 2; .

class Solution {public: int wiggleMaxLength(vector<int>& nums) { int preD=0; int curD=0; int cnt=1; for(int i=1; i<nums.size(); i++){ curD=nums[i]-nums[i-1]; if((curD>0 &&

class Solution {public: static const int N=2e4+7, M=8e4+7, mod=1e9+7; typedef pair<int, int> PII; int e[M], ne[M], w[M], h[N], idx; int n; bool st[N]; long long dist[N]; int memo[N]; void add(int a, int b, int c)

从各个点dfs，求出最小的高度memo的key和两者有关，一个是dfs的起点，一个是dfs的根结点，如下图图来源DFSclass Solution {public: // 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点 int h[20005]; //邻接表存储树，有n个节点，所以需要n个队列头节点 int e[20005]; //存储元素 int ne[20005]; //存储列表的next值 int idx; /.

兄弟题，不带重的全排列 LQ46先排序，然后回溯的时候，只让相同的元素被用一次。即[…A1,A2…]中，先由A1来作为dfs的起点往后跑，那么不希望之后也让A2作为dfs起点跑，这会造成重复。目标就是跳过它们个人觉得code1更好理解code1class Solution {public: vector<vector<int>> permuteUnique(vector<int>& nums) { vector<.

刚开始想到堆的方法，见后面然后发现还有count方法，可以实现O(n)复杂度，这种题目我认为需要有数学的sense，要善于在其中找出规律.这里直接count每个元素出现的次数，可以加快计算(int)ceil(A*1.0/B) 可以起到向上取整的作用O(n) countclass Solution {public: int minOperations(vector<int>& nums1, vector<int>& nums2) { .

vec中每个元素最多选两个vec拼接成两段，进行枚举，这样就达到目的了枚举题class Solution {public: int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) { int ans = INT_MAX; for (int i = 0; i < baseCosts.size(); i++).

前序+中序前序遍历是从左往右，从根结点到叶结点，优先把父亲结点遍历出来中序遍历可以给定结点，知道左右子树是什么由于每个值是unique的，可以以它为键，建立映射表根据前序遍历知道根结点索引index，映射表映射出根结点在中序遍历的位置index_in，然后再分别建立左右子树：左子树的根结点就是前序遍历索引index+1，理由是「前序遍历从左到右进行」右子树的根结点是 (index+1 + index_in-start_in) ，start_in是构建当前树中，中序遍历索引的起点。 index

这个思路比较有趣，但限定一定存在众数的情况把众数记为 +1，把其他数记为 -1，将它们全部加起来，显然和大于 0，从结果本身可以看出众数比其他数多。class Solution {public: // Boyer-Moore 摩尔投票算法 int majorityElement(vector<int>& nums) { int votes=0, res; for(auto e: nums){ if(vote.

题意：将给定的字符串转二叉树再转回来一开始理解错了，看到题目样例中有[1,2,3,null,null,4,5]只有两个null，感觉根本无从下手。实际上这个并不重要，只要能完成最终转换都可，算是题目的锅。ostringstream, istringstream 输入输出流在本题中，将一系列数如1 2 3写成1 2 3中间用空格隔开，在输入输出流中即可进行直接处理，不需要考虑拼成字符串逗号分割等to_string 和 stoi用法字符串比较层序遍历/** * Definitio.

哈希赋值random时，通过哈希表可以实现给定旧节点获取新节点的效果/*// Definition for a Node.class Node {public: int val; Node* next; Node* random; Node(int _val) { val = _val; next = NULL; random = NULL; }};*/class Solution {pu

每次需要想用flag的时候，再想想看有没有其它的代替方案，会不会那个flag还有其它的很明显的改变比如 pre==null 就相当于找到了刚开始想到中序遍历很好，紧接着没有新的idea。如果这时候，顺着中序遍历走一遍，可能就会发现要实现目标功能，要修改的东西很少很简单/*// Definition for a Node.class Node {public: int val; Node* left; Node* right; Node() {} .

双端队列，相当于两个栈。在连续使用的情况下，能实现一组“数组”取逆序，另一组“数组”取正序的效果。用队列进行层级遍历，巧用size可以划分等级每完成一个层级的遍历，该层的size也相应固定住，这是可以用一个变量存取，用一个for循环即可遍历该层全部的元素/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *ri.

//LeetCode 772#include <cstdio>#include <iostream>#include <map>#include <stack>using namespace std;typedef long long ll;string transform(string s){ map<char, int>hash={{'+', 1}, {'-', 1}, {'*', 2}, {'/', 2}};

刚开始没想到怎么存最小值，特别是存下来后，如果pop掉了，怎么把最小值去掉后来看答案才知道，除了原来的主栈外，再另设一个辅助栈，每次push新元素时，1 如果这个数比当前最小的小(也就是辅助栈顶元素)，那么辅助栈push新元素2 反之，再push一个栈顶元素3 这样无论主栈push还是pop操作，辅助栈进行同步操作也不会受影响class MinStack {public: /** initialize your data structure here. */ MinSt.

思路一开始没有思路，多画一画简单样例，复杂样例分解样例，连续样例短期地想，长期地想最终发现，可以构造一个栈遍历输入的元素，如果如果刚好能和输出元素对上，就都跳过，反之入栈最终遍历完成后，栈中元素应当能和剩余输出元素恰好对应上。最后栈空class Solution {public: bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {.

要注意的考虑指数取−231-2^{31}−231即$-2147483648$4时，如果还是用int取正，得不到对应的正数，因为超过取值范围。因此选用unsigned int 来作为指数的数据类型判断指数正负时，记得用给定指数n，而不是自己创建的unsigned int k，因为k无符号无法判断…快速幂方法不用递归，推荐递归class Solution {public: double myPow(double x, int n) { bool neg=false;.

33 Search in Rotated Sorted Arrayclass Solution {public: // 四种情况 /** 1. mid落在哪个区间 2种 2. 每一种中，target是否可以在区间中搜到？比较端点值和target以及中间数和target **/ int search(vector<int>& nums, int target) { int left = 0, right = nums.s

class Solution {public: string longestPalindrome(string s) { if(s.size()==0) return s; string res; for(int i=0; i<s.size()-1; i++){ string s1 = palindrome(s, j, i); string s2 = palindrome(s, i, i+1);

26 Arrayclass Solution {public: int removeDuplicates(vector<int>& nums) { if(nums.size()==0) return 0; int slow=0, fast = 1; while(fast<nums.size()){ if(nums[fast]!=nums[slow]){ nums[++

code 1思路，一个一个看。i位置的值，就是i左右两侧最小值减去height[i]。把这些都算出来加起来即可备忘录l_max[i] i左边最大的墙壁r_max[i] i右边最大的墙壁时间复杂度O(N)O(N)O(N)空间复杂度O(N)O(N)O(N)class Solution {public: int trap(vector<int>& height) { int len = height.size(); if(len

class Solution {public: int countPrimes(int n) { if(n<3) return 0; vector<bool> nums(n,true); for(int i=2; i*i<n; i++){ // i*i<n减少循环次数 if(nums[i]){ for(int j=i*i ;j<n; j=j+i){ //从i*