almost_afei的博客

难度：困难。标签：数组，动态规划。看题解。哈希表数组，我也是傻了。。。有两个元素的序列成为弱等差序列。定义dp[i][d]表示最后一项为nums[i]，公差为d的弱等差序列的个数。由于数据范围比较大，将第二维d用哈希表表示。正确解法：class Solution {public: int numberOfArithmeticSlices(vector<int>& nums) { int n = nums.size(); vector

难度：中等。标签：数组，动态规划。正确解法：class Solution {public: int numberOfArithmeticSlices(vector<int>& nums) { int n = nums.size(); int ans = 0; int len = 0; for(int i = 2; i < n; ++i){ if(nums[i] - nums[i

难度：中等。标签：链表，双指针，分治，排序，归并排序。归并排序，注意处理一段链表，要注意这一段链表的前后节点的连接。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {

难度：中等。标签：链表，排序。正确解法：/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *nex

难度：中等。标签：数组，哈希表，数学，动态规划，堆（优先队列）。跟剑指 Offer 49. 丑数一样的做法，但是我已经完全忘了这个题咋做的了。看了下剑指那题的解法，然后写出了该题的解法。正确解法：class Solution {public: int nthSuperUglyNumber(int n, vector<int>& primes) { if(n == 1)return 1; vector<int> dp(n);

难度：中等。标签：数组，哈希表，双指针。没有好的思路，只能去模拟，绕进去了，问题好多。错了两次，写了个时间复杂度O(n2)O(n^2)O(n2)的解法。错误用例：[1,2,3,4,5][-2,-3,-9]正确解法：class Solution {public: bool circularArrayLoop(vector<int>& nums) { int n = nums.size(); for(int i = 0; i &l

难度：简单。标签：记忆化搜索，数学，动态规划。正确解法：class Solution { int arr[38] = {0};public: int tribonacci(int n) { if(n == 0 || arr[n] != 0)return arr[n]; else if(n == 1 || n == 2){ arr[n] = 1; return 1; } a

难度：困难。标签：位运算，广度优先搜索，图，动态规划，状态压缩。想法：将度最小的几个节点作为起点；将每个节点的每条路径的最长长度记录下来；用广搜的话需要多个节点同时开始遍历，需要在queue中记录访问过的节点序列。结果：看题解吧。需要对节点的状态进行压缩，使用一个int来表示访问过的节点。状态压缩的基本操作：访问第 i 个点的状态：state = (1 << i) & mask更改第 i 个点状态为 1：mask = mask | (1 << i)需要使用

难度：中等。标签：深度优先搜索，广度优先搜索，图，拓扑结构。用深搜来做，用isSafeNodes来存储节点是否安全，1表示安全，0表示不安全，-1表示没有确定。若一个节点是不安全的，则它对应的visited数组里的所有节点都是不安全的，反之，若一个节点遍历到了不安全的节点，则其肯定也是不安全的。遍历过程中还要注意循环连接的部分，若遍历到的该节点已经访问过，且其安全状态没有确定，则说明循环访问了，直接判定该节点是不安全的。正确解法：class Solution { bool dfs(i

难度：中等。标签：贪心，数组，双指针，二分查找，排序。枚举第一个边i和第二个边j，两边之和记为cur，找到数组中第一个大于等于cur的值的索引k，则[j + 1, k - 1]之间的个数是可以与i，j组成三角形的个数。正确解法：class Solution {public: int triangleNumber(vector<int>& nums) { int n = nums.size(); sort(nums.begin(), num

难度：中等。标签：栈，贪心，数组，双指针，排序，单调栈。用left[i]记录i左边最大的数的索引，用right[i]记录i右边最小的数的索引。然后根据left和right可以计算得到需要排序的序列的左右边界。正确解法：class Solution {public: int findUnsortedSubarray(vector<int>& nums) { int n = nums.size(); if(n <= 0)return 0

难度：中等。标签：深度优先搜索，广度优先搜索，图，最短路，堆（优先队列）。看题解，Dijkstra就没记住过。使用Dijkstra算法进行求解，求出节点 k到其余所有点的最短路，其中的最大值就是答案。Dijkstra算法将点分为未确定点和确定点，每次从未确定点中找到与起点k距离最近的点x，然后更新所有未确定点的距离，并将x加入确定点集中。正确解法：class Solution {public: int networkDelayTime(vector<vector<int&g

难度：中等。标签：设计，哈希表，链表，双向链表。想到了要用哈希表和双向链表。但具体不想想了，累了。看题解吧。一下代码get和put和初始化函数是照着教程写的，moveToHead，addToHead，removeTail是自己写的。注意第18行，一定要判断当前节点是否已经在头部，如果在就直接返回。正确解法：struct DLinkedNode{ int key, val; DLinkedNode* prev, *next; DLinkedNode(

难度：简单。标签：数组，二分查找，矩阵，排序，堆（优先队列）。正确解法：class Solution { int getNum(vector<int>& vec){ int n = vec.size(); int left = 0, right = n - 1, ans = n; while(left <= right){ int mid = (left + right) / 2;

难度：中等。标签：深度优先搜索，广度优先搜索，并查集，数组，矩阵。使用深搜来完成，用2标记已经遍历过的位置。正确解法：class Solution { void dfs(vector<vector<char>>& grid, int i, int j){ if(i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size())return; if(gr

难度：困难。标签：贪心，数组。想了好久，觉得就是贪心，但想不到方案。看题解。方法一将【评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果】这个规则分为两个部分：左规则：当ratings[i−1]<ratings[i]ratings[i−1]<ratings[i]ratings[i−1]<ratings[i]时，i号的糖果数量比 i - 1号的糖果数量多。右规则：当 ratings[i]>ratings[i+1]ratings[i] > ratings[i + 1

文章目录136. 只出现一次的数字137. 只出现一次的数字 II136. 只出现一次的数字难度：简单。标签：位运算，数组。正确解法：class Solution {public: int singleNumber(vector<int>& nums) { int ans = 0; for(int i = 0; i < nums.size(); ++i){ ans ^= nums[i]; }

难度：困难。标签：二叉树，深度优先搜索，广度优先搜索，哈希表。使用哈希表来记录col，row和val的信息，然后可以使用深搜或广搜来得到这些信息，之后需要对得到的信息进行排序。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(

难度：中等。标签：栈，递归，链表，双指针。先使用快慢指针找到链表的分界点处，将分界点及以后的链表反转。然后将两个链表合并起来。注意第52行，需要将前面的链表尾节点指向nullptr，否则他之前指向的是后面链表的第一个节点，该节点已经被反转到后面链表的最后一个了。如果不加上这句，会报以下错：AddressSanitizer: heap-use-after-free正确解法：/** * Definition for singly-linked list. * struct ListNode

难度：简单。标签：数学，字符串。正确解法：class Solution {public: int titleToNumber(string columnTitle) { int n = columnTitle.length(); int ans = 0; int last = 1; for(int i = n - 1; i >= 0; --i){ ans += last * (int)(column

难度：中等。标签：二叉树，数学。从label向上找parent。正确解法：class Solution { int getParent(int label, int row){ int row_begin = pow(2, row); int row_end = row_begin * 2 - 1; int now_index = row_end - label; if(row % 2 == 0){ // ou

难度：中等。标签：数组，二分查找，前缀和，滑动窗口。动态规划写了一遍，没提交，肯定超时。代码：class Solution {public: int minSubArrayLen(int target, vector<int>& nums) { int n = nums.size(); vector<vector<int>> dp(n, vector<int>(n)); for(int

难度：中等。标签：二叉树，深度优先搜索，广度优先搜索。先找出根节点到target的路径上所有的点，将找与target的距离为k的点转换为找与路径上的点距离为find_dis的点。注意不要重复判断。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x)

难度：中等。标签：广度优先搜索，动态规划，数组。还想了半天，脑子秀逗了。动态规划很简单。正确解法：class Solution {public: int coinChange(vector<int>& coins, int amount) { int n = coins.size(); vector<int> dp(amount + 1, amount + 1); dp[0] = 0; fo

难度：中等。标签：贪心，单调栈，字符串。用贪心的思想，反过来取出n-k个数字，使得数字最小。取第i个数字时，判断的范围是从取的上一个数字的索引的下一个数开始，到num中留有[n - k - i - 1]个数字结束，找出这个范围内最小的数（索引为min_idx），就是当前取的数字。下一个要取的数字就从min_idx开始判断。正确解法：class Solution {public: string removeKdigits(string num, int k) { int

难度：简单。标签：二叉树，深度优先搜索。开始思路错了。重新写，dfs就是找以root位根节点的树中除了temp外的最小值。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {

难度：中等。标签：跟和最大的子数字比较像，但不一样，需要考虑负负为正的问题。没写出来，看题解。哭了。正确解法：class Solution {public: int maxProduct(vector<int>& nums) { int n = nums.size(); vector<int> maxNum(n), minNum(n); int ans = nums[0]; maxNum[0]

难度：困难。标签：贪心，数组，哈希表，二分查找。首先，这道题就是最长公共子序列，我竟然没想到。（虽然会超时）看了两条提醒：1.The problem can be reduced to computing Longest Common Subsequence between both arrays.2. Since one of the arrays has distinct elements, we can consider that these elements describe an arr

难度：中等。标签：数组，哈希表。将对应关系存于字典中。正确解法：class Solution {public: vector<int> restoreArray(vector<vector<int>>& adjacentPairs) { int n = adjacentPairs.size(); unordered_map<int, vector<int>> maps;

难度：中等。标签：贪心，数组。正确解法：class Solution {public: int canCompleteCircuit(vector<int>& gas, vector<int>& cost) { int n = gas.size(); for(int begin = 0; begin < n; ++begin){ int gasSum = gas[begin], costSu

难度：简单。标签：字符串。错误用例：“?4:03”没考虑第二位对第一位的影响。正确解法：class Solution {public: string maximumTime(string time) { int n = time.length(); for(int i = 0; i < n; ++i){ if(time[i] == '?'){ if(i == 0){

难度：中等。标签：深度优先搜索，广度优先搜索，哈希表，图。按照138. 复制带随机指针的链表的思路来做，用一个哈希表存储旧节点到新节点的映射。然后用两次广搜，第一次生成节点，第二次建立节点之间的关系。/*// Definition for a Node.class Node {public: int val; vector<Node*> neighbors; Node() { val = 0; neighbors = vect

难度：简单。标签：数组，哈希表，前缀。正确解法：class Solution { static bool cmp(vector<int>& a, vector<int>& b){ if(a[0] == b[0])return a[1] < b[1]; return a[0] < b[0]; }public: bool isCovered(vector<vector<int&gt

难度：中等。标签：深度优先搜索，广度优先搜索，并查集，数组，矩阵。这个题竟然把我整懵了，感觉不难，但是不知道如何用深搜，想到了需要从四周向中间进行搜索，但是还没想明白。看了题解，非常妙。正确解法：class Solution { int rows, cols; void dfs(vector<vector<char>>& board, int i, int j){ if(i < 0 || i >= rows || j

难度：中等。标签：二叉树，深度优先搜索。用广搜做，队列中存储当前节点和当前节点组成的数字。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode

难度：中等。标签：哈希表，数组，并查集。这种有限制条件的题，我一般都想不出来，有脑筋急转弯那味了。看题解，使用集合存储数组，枚举数组中的数x，以x作为连续序列的开始，判断x+1, x+2, …是否在集合中，更新长度。不用枚举数组中每个元素，当前数为y，若y-1在集合中，则不需要枚举以y为开始的序列。正确解法：class Solution {public: int longestConsecutive(vector<int>& nums) { unor

难度：中等。标签：贪心，数组，双指针，排序。正确解法：class Solution {public: int minPairSum(vector<int>& nums) { int n = nums.size(); sort(nums.begin(), nums.end()); int ans = 0; for(int l = 0; l < n / 2; ++l){ int r

难度：中等。标签：数组，二分查找，前缀和，滑动窗口。用最简单的思路做，先排序，然后从大往小遍历，查看当前数是否是最大频数的数字。正确解法：class Solution {public: int maxFrequency(vector<int>& nums, int k) { int n = nums.size(); sort(nums.begin(), nums.end()); int ans = 0; f

难度：中等。标签：字符串，排序，哈希表。正确解法：class Solution {public: vector<vector<string>> groupAnagrams(vector<string>& strs) { int n = strs.size(); unordered_map<string, int> maps; vector<vector<string>&g

难度：困难。标签：广度优先搜索，字符串，哈希表。直接用广搜做，超时了。超时代码：class Solution { bool canTranlate(string& a, string& b){ int n = a.length(); int diff = 0; for(int i = 0; i < n; ++i){ if(diff > 1)return false;