lardoris928的博客

class Solution {public: vector<int> plusOne(vector<int>& digits) { for(int i=digits.size()-1;i>=0;i--) { ++digits[i]; if(digits[i]!=10) //如果该位没有继续产生进位,则直接return 结果 ...

（这个0的情况是用来递归的 真正输入只有0个的时候输出是0->看代码）class Solution {public: int translateNum(int num) { string str = to_string(num); int len = str.size(); if(len < 2) return len; vector<int> dp(len+1); dp[1] = 1...

class Solution {public: string minNumber(vector<int>& nums) { vector<string> strs; for(int i = 0; i < nums.size(); i++) strs.push_back(to_string(nums[i])); quickSort(strs, 0, strs.size() - 1);...

class Solution {public: int findNthDigit(int n) {//数位n long long start = 1;//每个digit起始的数字 int digit = 1;//位数 long long count = 9;//数位数量 while (n>count){ n -= count; start *= 10; digit++; count = start* digit * 9; }//这里做完定位到...

「力扣」第 53 题（最大子序和）是「力扣」第 124 题（二叉树的最大路径和）的线性版本，它们的状态设计思想和状态转移是类似的，希望大家能够通过本题题解进一步体会状态是如何想到的（即子问题的定义需要从哪些方面考虑）贪心这个暴力求解法也很妙啊：采取 贪心 策略，只要当前子段的和最大，就记录到res中，如果sum的结果小于0，必须将sum = 0，然后重新开始计算新的子段和，因为加上负数只会更小代码#include<iostream>#include<string>#i

方法一：自己写的方法 使用sort函数 超出时间限制class MedianFinder {public: /** initialize your data structure here. */ vector<int> res; MedianFinder() { } void addNum(int num) { res.push_back(num); sort(res.begin(),res.end())..

class Solution {public: vector<int> getLeastNumbers(vector<int>& arr, int k) { vector<int> res; sort(arr.begin(),arr.end()); //arr.sort(); for(int i=0;i<k;i++){ res.push_back(arr[i].

https://leetcode-cn.com/problems/combinations/solution/77-zu-he-hui-su-fa-jing-dian-ti-mu-by-carlsun-2/vector<vector<int>> result; // 存放符合条件结果的集合vector<int> path; // 用来存放符合条件结果vector<vector<int>> result; // 存放符合..

排序class Solution {public: int majorityElement(vector<int>& nums) { sort(nums.begin(), nums.end()); return nums[nums.size() / 2]; //因为出现频率大于n/2，所以排序后的中间位置必然是众数 }};作者：zrita链接：https://leetcode-cn.com/problems/.

深度优先搜索class Solution {public: vector<string> permutation(string s) { vector<string> res; dfs(res,s,0); return res; } void dfs(vector<string> &res,string &s,int .

class Solution {public: vector<vector<int>> res;//存储答案 vector<int> path;//存储当前路径 vector<vector<int>> pathSum(TreeNode* root, int sum) {//主函数 helper(root ,sum);//调用递归函数 return res; }private...

我刚开始写的不完整版class Solution {public: bool verifyPostorder(vector<int>& postorder) { //数组的最后一个数是树的根节点 int length=postorder.size(); int lastele=postorder[length-1]; //左树所有值小于根节点 右树所有值大于根节点 vector<int&.

运用reverse/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: vector<vector<.

打印的时候分行了这个方法太妙了吧 for循环的是上一层的父节点的数目 然后每个父节点按顺序压入他的左右孩子/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */c.

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: vector<int> levelOrde...

class Solution {public: bool validateStackSequences(vector<int>& pushed, vector<int>& popped) { stack<int> tmp; int i=0; for(auto s:pushed){ tmp.push(s);//stack没有push_back? ...

class MinStack { stack<int> x_stack; stack<int> min_stack;public: MinStack() { min_stack.push(INT_MAX); } void push(int x) { x_stack.push(x); min_stack.push(std::min(min_stack.top(), x));//这句是主.

第一种解法这个人真是个人才 coding的细节特别多#include<iostream>#include<algorithm>#include<vector>#include<unordered_map>using namespace std;class Solution {public: vector<int> spiralOrder(vector<vector<int>>& matrix).

递归太妙了/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: bool isSymmetric(TreeNod.

这两个题都是递归 有点上路了/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: TreeNode* mirro.

下面这个代码要多读读 非常简洁/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: boo...

递归：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { i.

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* reverseList(ListNode* head) { ListNode* pre=null..

自己写的 debug了一次 是边界条件的问题/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* getKthFromEnd(ListNode* head, int .

class Solution {public: //前奇数后偶数 vector<int> exchange(vector<int>& nums) { if(nums.size()<2) return nums; int i = 0; int j = nums.size() - 1; while (i != j){ if (isqo(nums[i]) == 1){ //前面指偶数 i++; } else.

https://leetcode-cn.com/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solution/biao-shi-shu-zhi-de-zi-fu-chuan-by-leetcode-soluti/class Solution {public: enum State { STATE_INITIAL, STATE_INT_SIGN, STATE_INTEGER, ..

https://leetcode-cn.com/problems/zheng-ze-biao-da-shi-pi-pei-lcof/solution/zhu-xing-xiang-xi-jiang-jie-you-qian-ru-shen-by-je/这个讲的也太清楚了class Solution { public boolean isMatch(String A, String B) { int n = A.length(); int m = B.l...

这个可以自己画一下 特别巧妙class Solution {public: int removeDuplicates(vector<int>& nums) { int n = nums.size(); if (n <= 2) { return n; } int slow = 2, fast = 2; while (fast < n) { ...

class Solution {public: int removeDuplicates(vector<int>& nums) { if(nums.size()==0) return 0; if(nums.size()==1) return 1; int index=0; int i; for(i=1;i<nums.size();i++){ if(nums[i]!=..

如果用快慢指针 快指针一次两步会不会一共单数个节点 快指针走不到最后一个？ 有可能，毕竟快慢指针是在环形链表的判别中第一次见的那就直接两次遍历，第一次把链表的长度get到,第二次找要删除节点的上一个节点。注意边界条件/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr)..

class Solution {public: int add(int a, int b) {//因为不允许用+号，所以求出异或部分和进位部分依然不能用+ 号，所以只能循环到没有进位为止 while(b!=0) {//保存进位值，下次循环用 int c=(unsigned int)(a&b)<<1;//C++中负数不支持左移位，因为结果是不定的//保存不进位值，下次循环用， ...

这个题和剑指上不太一样 剑指上把所有重复元素都删了 这个只保留一个答案：class Solution {public: ListNode* deleteDuplicates(ListNode* head){ if(head == nullptr) return nullptr; ListNode* pre = head ;ListNode* cur = head->next; while(cur != nullptr){ ..

环形链表： // 定义环形链表 std::list<int> numList; // 将数插入到链表中 for (int i = 0; i < n; i++) { numList.push_back(i); } // 定义当前遍历指针 auto curIter = numList.begin(); // 遍历链表中的数 while (numList.size() > 1) { .

)/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* deleteNode(ListNode* head, int val) { if(head.

https://leetcode-cn.com/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof/solution/fei-zi-jie-ti-ku-jian-17-jian-dan-da-yin-cong-1dao/这个多看看 讲的还行吧力扣把他当简单题了 所以应该没有考虑大数问题：（常规解法 面试不能）class Solution {public: vector<int> printNumbers(int n) { ..

//递归求解，每次都求N/2，直到N为0或1class Solution {public: double myPow(double x, int n) { if (n == 0) {return 1;} if (n == 1) {return x;} long long N = n;//因为如果 n = -2^31，那么后面 num = -num = 2^31，用 int 的话会溢出 if (N < 0) { N = -N; x = .

此题看书上笔记最优解class Solution {public: int hammingWeight(uint32_t n) { int count=0; while(n){ ++count; n=n&(n-1); } return count; }};非最优解：class Solution {public: int hammingWeight(u

这一题已经不能用动态规划了，取余之后max函数就不能用来比大小了。只能用贪心了这个解法特别清楚class Solution {public: int cuttingRope(int n) { if (n <= 3) return 1 * (n - 1); //长度小于等于3的情况 long long res = 1; if (n % 3 == 1) res = 4, n -= 4; //余数为1且总长度

方法一：自下而上动态规划 + 记忆化：两个循环class Solution {public: int cuttingRope(int n) { if(n <= 3) return n - 1; // 当绳子的总长度<=3时，做特殊情况处理 //长度<=3时 必须要剪 所以会小 但是一旦>3就不用动长度3以下的绳子了 vector<int> res(n + 1, 0); // res[i]表示长度为i的绳子剪成.