- 博客(54)
- 收藏
- 关注
RSS订阅原创 LeetCode笔记（Array：求出现次数超过n/2和n/3的元素）
169 - 229 - 274。 169. 多数元素 普通的想法就是用哈希表 T:O(n),S:O(m) // 19.19 // 19.22 class Solution { public: int majorityElement(vector<int>& nums) { unordered_map<int, int> m; for(auto x : nums) { if(++m[x] >= (nums.
2020-12-10 13:10:53
275
原创 LeetCode笔记（array：）
118 - 119 - 134. 118. 杨辉三角 错位相加，最后添个1 // 15.18 // 15.25 class Solution { public: vector<vector<int>> generate(int numRows) { if(!numRows) return {}; vector<vector<int>> ans = {{1}}; vector<int> tm
2020-12-09 09:31:46
166
原创 LeetCode笔记（Array：原地哈希）
189 - 299 - 41。 189. 旋转数组 class Solution { public: void rotate(vector<int>& nums, int k) { if(nums.empty() || !(k % nums.size())) return ; k = k % nums.size(); reverse(nums.begin(), nums.end()); reve
2020-12-08 13:22:05
251
原创 LeetCode笔记（string， array）
12 - 26 - 27 - 80. 12. 整数转罗马数字 动态规划，减去上一个最大的特殊数字之后，加上已经得到的剩余数的表达式（慢且占空间大） // 19.47 // 20.02 // 动规 class Solution { public: string intToRoman(int num) { map<int, string> m = {{1,"I"},{4,"IV"},{5,"V"},{9,"IX"},{10,"X"},{40,"XL"},{50,"L"}
2020-12-05 13:46:55
114
原创 LeetCode笔记（String：最小不变顺序去重字符串）
38 - 316 - 168 - 171 . 38. 外观数列 太久没做有点生疏了 // 20.16 // 20.36 class Solution { public: string countAndSay(int n) { if(n == 1) return "1"; string last = countAndSay(n - 1); last = last + '-'; string next; int cnt
2020-12-03 07:16:39
308
原创 LeetCode笔记（String，自定义排序*）
179 - 6 179. 最大数 自定义排序：通过比较两个字符串连接起来后的大小进行排序 // 12.04 // 12.25 class Solution { static bool compare(int t1, int t2) { string a = to_string(t1); string b = to_string(t2); return a + b > b + a; } public: string large
2020-11-27 05:05:49
373
原创 LeetCode笔记（string）
290 - 242 - 49. 290. 单词规律 这题需要注意，用stringstream可以把字符串string作为输入流 // 13.03 // 13.25 class Solution { public: bool wordPattern(string pattern, string s) { if(s.empty()) return true; if(pattern.empty()) return false; unordered_map
2020-10-28 05:03:15
103
原创 LeetCode笔记（string）
345 - 345. 反转字符串中的元音字母 // 19.14 // 19.21 class Solution { public: string reverseVowels(string s) { if(s.empty()) return s; unordered_set<char> collect; collect.insert('a'); collect.insert('u'); collect.in
2020-10-25 14:43:05
84
原创 LeetCode笔记（string）
387 - 383 - 344 - 279。 387. 字符串中的第一个唯一字符 // 18.10 // 18.15 class Solution { public: int firstUniqChar(string s) { if(s.empty()) return -1; vector<int> index(300, -1); for(int i = 0; i < s.size(); i++) { if
2020-10-24 11:25:11
136
原创 LeetCode笔记（string：KMP***）
28 - 58 - 14。 28. 实现 strStr() - KMP // kmp class Solution { void getNext(vector<int> &next, string &s) { int k = 0; next[k] = 0; for(int i = 1; i < s.size(); i++) { while(k > 0 && s[i] !=
2020-10-23 13:03:42
67
原创 LeetCode笔记（图：图染色***）
1042. 不邻接植花 class Solution { public: vector<int> gardenNoAdj(int n, vector<vector<int>>& paths) { if(paths.empty()) return vector<int>(n, 1); vector<int> res(n, 0); vector<vector<int>
2020-10-08 04:36:07
281
原创 LeetCode笔记（树，dp：状态机）
965 - 107 - 309。 965. 单值二叉树 // 12.14 // 12.17 class Solution { bool checkValid(TreeNode* root, int prev) { if(root == nullptr) return true; if(root->val != prev) return false; bool left = checkValid(root->left, prev);
2020-10-07 04:45:08
257
原创 LeetCode笔记（图：二分图***）
785 - 886 - 213。 785. 判断二分图 可以用bfs或dfs写二分图的算法 // bfs class Solution { public: bool isBipartite(vector<vector<int>>& graph) { if(graph.empty()) return true; vector<int> color(graph.size(), 0); queue<int
2020-10-06 07:21:26
110
原创 LeetCode笔记（树：算深度*，dp：二维前缀和）
111. 二叉树的最小深度* 要注意递归结束条件 // 13.09 // 13.14 class Solution { int ans = INT_MAX; void dfs(TreeNode* root, int level) { if(root == nullptr) { return ; } if(!root->right && !root->left) { a
2020-09-27 05:41:08
199
原创 LeetCode笔记（图：算各并查集大小***，dp：正方形面积）
952 - 990 - 221。 952. 按公因数计算最大组件大小*** - 算各并查集大小 可以通过定义一个size数组，每次合并两个集合时，把更新集合的大小，这样就可以直接得到各并查集的大小了！ 此外这题还要用刷法选素数提高效率（一开始用辗转相除法太慢了。。。） // 12.00 // 12.46 class Solution { vector<int> parent; vector<int> size; bool visited[100005];
2020-09-26 05:09:49
311
原创 LeetCode笔记（树：树的高度，动规找正方形***）
110 - 1277。 110. 平衡二叉树 数树的高度 // 12.52 // 13.00 class Solution { int check(TreeNode* root) { if(root == nullptr) return 0; int left = check(root->left); if(left == -1) return -1; int right = check(root->ri
2020-09-24 07:08:26
116
原创 LeetCode笔记（树：迭代前序**）
144 - 589 - 429 - 174。 144. 二叉树的前序遍历 // 21.20 // 21.23 class Solution { public: vector<int> preorderTraversal(TreeNode* root) { if(root == nullptr) return {}; stack<TreeNode*> stk; vector<int> ans; st
2020-09-23 13:41:14
76
原创 LeetCode笔记（图：dfs找环***，并查集*）
802 - 839 - 120。 802. 找到最终的安全状态*** - dfs找环 用dfs找图中的环，其中visited[i] = -1为初始状态，= 0是形成回路， = 1是正在遍历， = 2是符合条件 class Solution { public: vector<int> eventualSafeNodes(vector<vector<int>>& graph) { if(graph.empty()) return {};
2020-09-22 07:44:26
434
原创 LeetCode笔记（图：拓扑排序***）
1202 - 210 - 64. 1202. 交换字符串中的元素 - 并查集 回看之前做过并查集的题目 // 16.43 // 17.25 class Solution { vector<int> parent; int find(int x) { while(parent[x] != x) { x = parent[x] = parent[parent[parent[x]]]; } return x;
2020-09-15 13:55:31
109
原创 LeetCode笔记（list：next-＞next = 新地址**）
21 - 63 - 445. 21. 合并两个有序链表** 卡了一下，注意是 next->next = 新地址，而不是 next // 22.18 // 22.32 class Solution { public: ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if(l1 == nullptr) return l2; if(l2 == nullptr) return l1; Lis
2020-09-14 14:57:21
655
原创 LeetCode笔记（树：迭代前/后序遍历）
144 - 145 - 121. 144. 二叉树的前序遍历 // 10.22 // 10.48 // 迭代前序遍历 class Solution { void getLeftNode(TreeNode *root, vector<int> &ans, stack<TreeNode *> &stk) { while(root) { ans.push_back(root->val); stk.push(root);
2020-09-12 04:19:44
134
原创 LeetCode笔记（图：多源bfs）
1162 - 827 两道图的算法题 1162. 地图分析*** 其实多源bfs没什么本质上的区别，只不过是第一次塞进queue时多塞几个点罢了，但没碰到过就很难想到这点。 class Solution { public: int maxDistance(vector<vector<int>>& grid) { if(grid.empty()) return -1; queue<int> que; int
2020-09-11 12:31:53
170
原创 LeetCode笔记（dp：最长定差子序列**）
1137 - 1218 1137. 第 N 个泰波那契数 // 21.40 // 21.45 class Solution { public: int tribonacci(int n) { int tmp[3] = {0, 1, 1}; if(n < 3) return tmp[n]; int t = 2; while(t != n) { t++; tmp[t % 3] = t
2020-09-08 13:39:39
110
原创 LeetCode笔记（图：bfs/dfs）
695 - 733 695. 岛屿的最大面积 这里我用了bfs，看答案多数用bfs，其实都差不多 // 22.52 // 23.23 // bfs class Solution { int bfs(vector<vector<int>> & grid, int x, int y, int n, int m) { queue<pair<int, int>> que; que.push(pair<int, int>(x, y
2020-09-07 15:18:29
144
原创 Leetcode笔记（图：链表复制，并查集）
138 - 138. 复制带随机指针的链表 做不出来。。。参考wang_ni_ma用map的做法。 然后题目不好理解，大概就是，给你一个链表，其中每个节点包含两个指针（next，random）和一个数值（val），深复制这条链表 // 16.47 // 17.24 class Solution { public: Node* copyRandomList(Node* head) { if(head == nullptr) return nullptr; Node *
2020-09-06 12:26:44
70
原创 Leetcode笔记
784 784. 字母大小写全排列 - medium //16.19 //16.31 class Solution { string tmp; vector<string> ans; void helper(int i, string &s) { if(i >= s.size()) { ans.push_back(tmp); return ; } //for(
2020-07-30 09:03:52
77
原创 Leetcode笔记（不重复的排列*）
46 - 47 46. 全排列 - medium 两种方法： 回溯法，每次都放进一个到 tmp 中，直到 tmp.size() == nums.size() 时，把 tmp 放进 ans 中。 递归，每次减小1个数据规模，具体解释很麻烦有需要就去看【算法设计与分析】- 厦门大学 - 张德富, 曾华琳, 链接中的这一集就解释了这种方法 // 回溯 class Solution { vector<vector<int>> ans; vector<int>
2020-07-29 14:47:28
151
原创 Leetcode笔记（组合）
216 216. 组合总和 III 前一两天都练过了，这道题就不多bb了 //15.01 //15.09 class Solution { vector<vector<int>> ans; vector<int> tmp; void helper(int &kk, int n, int i) { if(n == 0) { if(tmp.size() == kk) an
2020-07-28 10:05:39
53
原创 Leetcode笔记（回溯）
78 - 90 78. 子集 - medium 用dfs枚举 用01串选取字符 //22.13 //22.17 //dfs class Solution { vector<vector<int>> ans; vector<int> tmp; void helper(int i, vector<int> &nums) { if(i >= nums.size()) { //
2020-07-27 14:00:16
68
原创 Leetcode笔记（找不重复的组合*）
40 - 77 40. 组合总和 II - medium 有多个相同的元素，但要组成没有重复的组合，有两个方法做： 参考39题的做法，用set避免重复组合 参考39题的做法，但可以让同一层的数字不重复 //15.16 //15.28 //set class Solution { vector<vector<int>> ans; unordered_set<string> s; vector<int> tmp; string
2020-07-26 07:31:25
201
原创 Leetcode笔记（回溯基本功）
回溯 17 - 39 现在开始按大类做题，参照 花花酱Huahua 整理的分类 集合 去刷题 今天这两道题都是以前做过的。。。 17. 电话号码的字母组合 - medium //13.48 //14.01 class Solution { vector<string> ans; vector<string> letter; void helper(int i, string &digits, string str) { if(i ==
2020-07-25 06:41:17
74
原创 Leedcode笔记（股票** / 最长递增子序列：动态规划）
309 - 动态规划可以图像化为状态机，分清有多少个状态，有多少中状态转移方式！ 309. 最佳买卖股票时机含冷冻期 - medium 好吧，又把我难住了。。。 参考 liweiwei1419 解释 这道股票题和第二道股票题很想，区别在于多了一个冻结期，因此状态之间的转移只能是：（图片来自 liweiwei1419 ） 其中只要你想要持股，就必须在前一天没有进行过买卖，也就是说是从冷冻期过渡到持股期（即使你前一天没动作，所持有的金额也是等于上一次的冷冻期，相当于直接从冷冻期到持股期），所以图中关系成立
2020-07-24 14:14:42
131
原创 Leetcode笔记（股票：折线法，动态规划）
121 - 122 一个字懒。。。 121. 买卖股票的最佳时机 - easy 碰到股票题，再次回来做第一题来了，虽然已经做过， 但太久没练习生疏了。。。 动态规划 dp[i] = max(dp[i], dp[i-1] + prices[i] - minPrice); 我称之为 “折线法”（贪心），答案中画了折线图， 通过折线图可以看出规律，记录当前最小值，只要曲线是向上的（大于最小值），我们直接计算差值并与之前的差值进行比较取较大值，若曲线向下，则更新最小值。 //动态规划 //15.55 //16.
2020-07-23 09:54:27
245
原创 LeetCode笔记（动规*，栈*）
139. 单词拆分 - medium 用动态规划 第一个版本是没有经过优化的，一开始是用回溯发现超时了，之后用动规优化勉强及格 大概的思路是： 若想要以s[i]结尾的字符串可以被拆分，则以s[k]结尾的字符串，以及string(s, k, i-k)的字符串均可以被拆分即可 //14.07 //14.40 class Solution { unordered_set<string> dict; vector<vector<int>> dp; b
2020-05-23 14:29:34
79
原创 LeetCode笔记（拓扑排序***）
207. 课程表 - medium 方法一：动规（超慢） 正确答案不是这个。。。 好吧，自己想了一个半小时想到的，虽然慢了点啊（52ms，32.4%）且空间开销大（14.6M，18.75%），但还是想要记录下来 判断一个课程能否上，就是判断前置课程能否全上完，若有任何一个前置课上不了则该科上不了 若在检查该课时需要用到之前没检查完的课，则该课不能上 (后来我发现，把map改成unordered_map可以把时间减少到44ms，43.55%，空间开销基本没变) //19.52 //21.30 class
2020-05-21 09:04:53
140
原创 LeetCode笔记（环的入口**，BFS）
142. 环形链表 II 记得以前有很像的题目 287. 寻找重复数，做法是快慢指针，详情请看大佬 lrjets 在leetcode 上的解释 //19.10 //19.13 class Solution { public: ListNode *detectCycle(ListNode *head) { if(head == nullptr) return nullptr; ListNode *fast, *slow, *curr; curr =
2020-05-17 11:46:10
96
原创 LeetCode笔记
17. 电话号码的字母组合 - medium 做回溯做得有点感觉了（^ _^） //13.24 //13.42 class Solution { vector<string> letter; vector<string> ans; void helper(string &digits, int index, string &str) { if(index == digits.size()) { ans.
2020-05-14 12:46:21
108
原创 LeetCode笔记（三路快排***）
279. 完全平方数 - medium 动规的思想是，假设 N = A*A+B； 算N之前必定已经算了B，所以只要找到哪个B是最优的即可 下面是自己做的时候想到的，但可以被优化，不用记录那些是平方数 //12.42 //13.10 class Solution { public: int numSquares(int n) { if(n == 1) return 1; vector<int> res(n+1, -1); set<
2020-05-13 13:31:21
146
原创 LeetCode笔记（动规，前k大元素）
62. 不同路径 - medium 二维dp数组 //12.02 //12.05 class Solution { public: int uniquePaths(int m, int n) { vector<vector<int>> cnt(n, vector<int>(m, 1)); for(int i = 1; i < n; i++) { for(int k = 1; k < m; k++
2020-05-12 07:47:05
164
原创 LeetCode笔记（公共祖先**，栈**）
中等难度的题还是经常有不会的，唉~ 236. 二叉树的最近公共祖先 - medium 这道题难就难在，递归退出条件，这里的退出条件有两个， 当root等于p || q，则表明，剩下的那个节点必然在root之下，所以此时的root就是最近公共祖先（也可以说他们两个在同一颗子树中，如5，4） 当他们不在同一颗子树中（5，1），则根据第一个退出条件，两颗子树都会返回非空指针，表明分别在两个子树中找到他们，则此时root就是最近公共祖先 class Solution { public: TreeNod
2020-05-11 13:10:04
136
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人