- 博客(112)
- 资源 (5)
- 收藏
- 关注
RSS订阅原创 LeetCode 1315. 祖父节点值为偶数的节点和 (遍历二叉树)
祖父节点值为偶数的节点和由于需要知道祖父节点的值，所以搜索的时候要带着祖父节点、父亲节点、以及当前节点。/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class
2020-06-30 21:16:22
269
1
原创 LeetCode 904. 水果成篮 （双指针 || 滑动窗口）
水果成篮class Solution {public: int totalFruit(vector<int>& a) { int ans = 1 , n = a.size(); int l=0,r = l+1,lr =l; while(l<n) { int x1 = a[l],x2 = -1; while(r<n && (x2==-1 || a[r]==
2020-06-30 20:43:40
2072
2
原创 LeetCode 26. 删除排序数组中的重复项 （双指针）
删除排序数组中的重复项选择l,r为双指针，它们表示着一个区间的左右端点，再用一个idx表示要修改的位置。class Solution {public: int removeDuplicates(vector<int>& nums) { int n = nums.size(); int idx = 0,l = 0,r = l; while(l<n){ r = l; whil.
2020-06-30 18:38:41
721
原创 LeetCode 763. 划分字母区间
划分字母区间对当前的字符，遍历找到它最后一次出现的位置，但是这个区间的长度可能小于最终长度——要对这个区间出现的字符一一进行查找它最后一次出现的地方，并用这个去更新区间长度，直到这个区间内所有的字符都满足要求。时间复杂度：O(n2)O(n^2)O(n2)class Solution {public: vector<int> partitionLabels(string S) { vector<int> ans; int n = S.si
2020-06-30 18:26:09
70
原创 LeetCode 1032. 字符流 （建树的思路——“后缀”树、后缀查询）
字符流此题主要是建立字典树的思路有点难。由于每次都要用到字符流的末尾，所以实际上是给定一个长字符串，判断字典树里是否有单词是它的后缀。比如 字典树{"bc","cd"}，字符串"abc"的后缀bc字典里出现。如果是朴素想法的话，那应该每次去切割长的字符串，然后去字典树里查询，这样时间复杂度高达O(len(s1)∗len(s2))O(len(s1)*len(s2))O(len(s1)∗len(s2))。但是如果倒过来考虑，就很简单了。字典树里的单词一开始就反向插入，带查询的字符串也是反向查询，刚好
2020-06-28 20:02:36
3349
原创 LeetCode 700. 二叉搜索树中的搜索（BST基本操作之查找）
二叉搜索树中的搜索/** * 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* searchBST(T
2020-06-27 19:23:19
202
原创 LeeCode 705. 设计哈希集合
设计哈希集合日后再补class MyHashSet {public: /** Initialize your data structure here. */ bool vis[1000010]; MyHashSet() { memset(vis,0,sizeof(vis)); } void add(int key) { vis[key] = 1; } void remove(int key) {
2020-06-26 06:50:00
203
原创 LeetCode 202. 快乐数 （set记录、出现循环节中的数则失败）
快乐数 class Solution {public: unordered_set<int> vis; bool isHappy(int n) { vis.insert(n); if(n==1){ return 1; } while(1){ long long sum = f(n); if(sum==1){ r
2020-06-26 06:44:31
88
原创 LeetCode 961. 重复 N 次的元素 (大水题)
重复 N 次的元素class Solution {public: unordered_set<int> s; int repeatedNTimes(vector<int>& A) { for(int x:A){ if(s.count(x)){ return x; } s.insert(x); } retu.
2020-06-26 06:31:47
102
原创 LeetCode 894. 所有可能的满二叉树 (递归的构造、记忆化递归)
所有可能的满二叉树这题的递归构造着实没想出来。。观察题给的样例，7个节点的满二叉树，左右子树的节点数目情况为：1、5 ； 3、3 ； 5、1；那如果共有5个节点呢，情况有：1、3 ； 3、1；那如果有 3个节点呢,情况有：1 1；那如果只有1个节点呢？直接返回一个根节点即可。上述的思维过程其实就是递归的思维过程。而且很明显发现，递归是有重复的，可以进行一下记忆化。/** * Definition for a binary tree node. * struct TreeNode {
2020-06-26 06:25:41
128
原创 LeetCode 面试题 02.01. 移除重复节点 (哈希表、链表节点的删除、内存的释放)
移除重复节点/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: bool vis[20010] = {0}; ListNode* removeDuplicateNodes(Lis
2020-06-26 05:59:08
163
原创 LeetCode 590. N叉树的后序遍历 (递归、迭代实现)
N叉树的后序遍历递归：/*// Definition for a Node.class Node {public: int val; vector<Node*> children; Node() {} Node(int _val) { val = _val; } Node(int _val, vector<Node*> _children) { val = _val; ch
2020-06-25 21:33:54
154
原创 LeetCode 面试题 04.04. 检查平衡性 (双重递归)
检查平衡性/** * 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 isBalanced(TreeNode*
2020-06-25 20:33:07
127
原创 LeetCode 212. 单词搜索 II (DFS+字典树)
单词搜索 II 它的简单版的功能是解决一个单词存在与否，如果此题直接套用这个函数，也是可行的，不过时间复杂度太高，O(m∗n∗len(str)∗size)O(m*n*len(str)*size)O(m∗n∗len(str)∗size)具体的来看，在一开始的搜索框架中，每次都是匹配一个字符串的某一个位置的字符。如何优化呢？用字典树去预存size个字符串，然后对于网格中的某一个节点去看字典树的这一层有没有这个字符，如果有，再去看它是不是某个字符串结尾（注意，如果是，不要回溯，继续往下搜）。这样，网格中的
2020-06-25 15:33:22
135
原创 LeetCode 79. 单词搜索 （回溯、DFS搜索）
单词搜索const int dx[] = {-1,0,1,0} ;const int dy[] = {0,1,0,-1} ;class Solution {public: bool vis[210][210] = {0}; int m,n; bool exist(vector<vector<char>>& board, string word) { m = board.size(); n = board[0].s
2020-06-25 14:07:05
85
原创 LeetCode 692. 前K个高频单词 (善用STL)
前K个高频单词class Solution {public: unordered_map<string,int> m; typedef pair<int,string> P; priority_queue<P,vector<P>,greater<P> > pq; vector<string> ans; vector<string> topKFrequent(vector<st
2020-06-25 10:34:57
118
原创 LeetCode 676. 实现一个魔法字典(Trie+暴力 || DFS)
实现一个魔法字典前缀树存储单词。然后对要查询的每个单词，对它的每个位置去替代一个不同的字符，然后去字典树里面查询存在与否即可。class MagicDictionary { struct Node{ bool isEnd=false; Node* children[26] = {0}; }; Node* root = nullptr; void insert(const string& s){ Node*
2020-06-25 09:54:37
101
原创 LeetCode 113. 路径总和 II (回溯、路径记录)
路径总和 II 与112路径总和思路是一样的，只是在这里多了一个路径记录罢了。/** * 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 {pu
2020-06-25 05:21:17
98
原创 LeetCode 112. 路径总和 (路径必须经过根节点和叶节点)
路径总和能够返回true的情况只有一种可能，就是在叶节点的时候，路径和刚好为目标值。/** * 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 {
2020-06-25 04:54:34
118
原创 LeetCode 236. 二叉树的最近公共祖先(LCA、向上染色法、巧妙的递归)
二叉树的最近公共祖先求LCA的朴素做法：向上染色。先让一个节点不断向上，并标记父节点。然后让另一个节点也向上寻找，然后第一次遇到的已经染色节点就是LCA。具体做法：先BFS求出每个节点的父节点。用unordered_map<TreeNode*,TreeNode*>记录，如果要数字，直接用int fa[];然后用unordered_set<TreeNode*>记录染色的节点。如果是数字，可以用int vis[]时间复杂度：O(n)O(n)O(n)加以优化，就得到了树
2020-06-24 15:05:09
230
原创 LeetCode 235. 二叉搜索树的最近公共祖先 (利用二叉搜索树的有序的性质、递归||迭代)
二叉搜索树的最近公共祖先BST的性质（定义）：①左子树的节点的值都比根节点值小。②右子树的节点的值都比根节点值大。③左子树、右子树都是BST。所以，假如p、q的值都比根节点的值要小，说明这个根节点还不是最近的，它的左子树的根可能更近。假如p、q的值都比根节点的值要大，说明这个它的右子树的根节点可能更近。如果一个大一个小，说明此时根节点已经是最近公共祖先了。当然此题也可以按照一般的二叉树做，繁一点递归实现：/** * Definition for a binary tree node.
2020-06-24 10:15:23
71
原创 LeetCode 166. 分数到小数（数学、模拟、细节）
分数到小数先说说几种可能出错的情况。0/x 直接输出0，没有正负号有负号的情况如果是整除，没有小数点卡int的边界问题，所以干脆直接开long long分析：大致有两种情况，整除和出现循环。于是模拟一下除法的进行。如：3/7第一步移位，3*10 = 30 ,移了一位第二步整除+取模30/7=4 … 220/7=2 … 660/7=8 … 440/7=5 … 550/7=7 … 110/7=1 … 330/
2020-06-24 03:37:47
105
原创 LeetCode 67. 二进制求和 （二进制数的模拟计算）
二进制求和class Solution {public: string addBinary(string a, string b) { int len = max(a.size(),b.size()); string ans(len+1,'0'); reverse(a.begin(),a.end()); reverse(b.begin(),b.end()); vector<int> cnt(len+1,0
2020-06-24 03:10:39
78
原创 LeetCode 1207. 独一无二的出现次数 (STL库 || 自己hash函数、数组映射)
独一无二的出现次数版本1:优点：耗空间少、可拓展性强缺点：时间开销大一点class Solution {public: unordered_map<int,int> m; unordered_set<int> vis; bool uniqueOccurrences(vector<int>& arr) { for(int x:arr){ m[x]++; } f
2020-06-23 21:02:08
88
原创 LeetCode 508. 出现次数最多的子树元素和 (递归求和、哈希表记录)
出现次数最多的子树元素和/** * 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: unordered_map<i
2020-06-23 20:48:20
97
原创 LeetCode 463. 岛屿的周长(看懂题意就好)
岛屿的周长const int dx[] = {-1,0,1,0};const int dy[] = {0,1,0,-1};class Solution {public: int islandPerimeter(vector<vector<int>>& grid) { int ans = 0; for(int i=0;i<grid.size();i++){ for(int j=0;j<grid[
2020-06-23 20:39:25
116
原创 LeetCode 面试题 16.24. 数对和 （双指针、哈希表）
数对和双指针：class Solution {public: vector<vector<int>> pairSums(vector<int>& nums, int target) { vector<vector<int>> ans; sort(nums.begin(),nums.end()); int l=0,r=nums.size()-1; whil.
2020-06-23 20:21:08
187
原创 LeetCode 133. 克隆图 （图的遍历、图的指针存储）
思路：① 遍历图，记录下所有的节点和边。② 将数值与指针一一对应。③ 新建节点，并根据边的关系把它的相连节点加进vector<Node*>。class Solution {public: Node* nodeList[110] = {0}; vector<int> graph[110]; int vis[110] = {0}; Node* cloneGraph(Node* node) { if(!node){
2020-06-22 10:34:04
97
LeetCode 1042. 不邻接植花 ( DFS回溯、一次遍历)
不邻接植花我这种写法， 实际上借鉴了判断二分图的做法。class Solution {public: vector<int> ans; vector<int> graph[10010]; vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) { ans.resize(N,0); for(auto&edge:p
2020-06-22 09:03:29
181
原创 LeetCode 1387. 将整数按权重排序(记忆化、递归)
将整数按权重排序迷之标签、迷之测试数据记录一下中间的计算结果就行。class Solution {public: unordered_map<int,int> vis; struct Node{ int v,x; Node(int v,int x):v(v),x(x){} bool operator<(const Node &b){ return v<b.v || (v==b.v
2020-06-22 08:19:35
182
原创 LeetCode 面试题 17.17. 多次搜索 （两种做法建立前缀树）
多次搜索思路1：将每个小字符串插入Trie然后对大字符串的每个位置向后切割出字符串去匹配，用它去作前缀。在搜索过程中，如果节点不存在，直接结束函数；对于每个节点，如果它是某个小字符串的结尾，插入答案。时间复杂度：其中len1是平均小字符串的长度，len2是大字符串的长度。O(n∗len1+len2∗len2)O(n*len1+len2*len2)O(n∗len1+len2∗len2)class Solution { struct Node{ int id = -1;
2020-06-22 07:28:56
254
原创 LeetCode 648. 单词替换 （字典树、字符串分割）
单词替换思路：将词根单词插入字符串、然后检索每个单词即可。用vector<char>记录下路径上的字符，再用string(首迭代器,尾迭代器)即可。手打分割字符串class Solution { struct Node{ bool isEnd=false; Node* children[26] = {0}; }; Node *root = new Node; void insert(const string &s)
2020-06-21 16:53:25
211
原创 LeetCode 1023. 驼峰式匹配 （模拟、字符串、双指针）
按题目直接模拟就好，有点像双指针 ，两个字符串都只需遍历一次就好。时间复杂度：O(n∗(len1+len2))O(n*(len1+len2))O(n∗(len1+len2))为什么力扣标签是字典树呢class Solution {public: vector<bool> camelMatch(vector<string>& queries, string pattern) { vector<bool> ans; f
2020-06-21 16:36:00
166
原创 LeetCode 124. 二叉树中的最大路径和 （树形DP、递归实现）
二叉树中的最大路径和 /** * 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: int ans = INT_MIN;
2020-06-21 04:04:18
191
原创 LeetCode 1306. 跳跃游戏 III (水题、DFS)
跳跃游戏 IIIclass Solution {public: vector<int> vis; bool canReach(vector<int>& arr, int start) { vis.resize(arr.size()+10,0); return dfs(start,arr); } bool dfs(int x,vector<int>& arr){ vis[x]
2020-06-20 04:37:43
110
原创 LeetCode 785. 判断二分图 (图论基础之判断二分图)
判断二分图class Solution {public: int vis[110] = {0},n,flag = 1; bool isBipartite(vector<vector<int>>& graph) { n = graph.size(); for(int i=0;i<n;i++){ if(!flag) return false;
2020-06-20 04:24:52
143
原创 1267. 统计参与通信的服务器 (深搜求连通块)
统计参与通信的服务器class Solution {public: int vis[260][260] = {0}; // vector<vector<int>> res; int m,n,ans=0; int countServers(vector<vector<int>>& grid) { m = grid.size(); n = grid[0].size(); f
2020-06-20 03:27:54
122
1
原创 LeetCode 996. 正方形数组的数目 (回溯、结果去重、等价情况剪枝)
正方形数组的数目思路：回溯题基本写法。用multiset<int>去记录数字的使用情况。用set<vector<int>>去重。剪枝：虽然数字可以重复使用（如果有的话），但是每一层的数字不应出现重复枚举。比如：2 2 2 2 2每一层都应该放只能放2，而不是对2这个数字进行多次搜索。class Solution {public: multiset<int> nums; set<vector<int>&g
2020-06-20 03:13:13
182
原创 LeetCode 677. 键值映射 (暴力法、前缀树)
键值映射插入时间复杂度: O(K)O(K)O(K)查找时间复杂度: O(K)O(K)O(K)思路:每个节点保存和，之后可以直接查询。另外尾结点值存储键所对应的值。 struct Node{ long long val = LLONG_MAX; int sum = 0; Node* children[260] = {0}; };插入时，如果键不存在，插入这条链，路径上经过的节点值累加。如果已经存在，将路径上的点更新一个增量，另
2020-06-19 01:11:07
84
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人