- 博客(323)
- 收藏
- 关注
RSS订阅原创 2021秋招面试记录
文章目录腾讯天美实习天美校招一面总结一下印象深刻的一些点，基本都是我答不上来的。腾讯岗位：渲染引擎开发天美实习投的校招，被捞成了实习，面到HR面，说你不来实习没法发offer，气死。死锁数字在计算机中怎么存储？补码碎片，虚拟内存智能指针具体用法，注意事项move构造，有什么意义？函数参数为什么从右往左入栈？lambda函数底层实现天美校招一面结构体数组和数组结构体，是什么？哪个效率高？没找到具体说法。效率搞要看干什么？static_cast和reinterpre
2021-08-20 19:07:45
282
1
原创 LeetCode 446. 等差数列划分 II - 子序列
难度：困难。标签：数组，动态规划。看题解。哈希表数组，我也是傻了。。。有两个元素的序列成为弱等差序列。定义dp[i][d]表示最后一项为nums[i]，公差为d的弱等差序列的个数。由于数据范围比较大，将第二维d用哈希表表示。正确解法：class Solution {public: int numberOfArithmeticSlices(vector<int>& nums) { int n = nums.size(); vector
2021-08-11 14:10:05
132
原创 LeetCode 413. 等差数列划分
难度：中等。标签：数组，动态规划。正确解法：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
2021-08-10 14:19:03
134
原创 LeetCode 148. 排序链表
难度：中等。标签：链表，双指针，分治，排序，归并排序。归并排序，注意处理一段链表，要注意这一段链表的前后节点的连接。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {
2021-08-09 17:41:49
74
原创 LeetCode 147. 对链表进行插入排序
难度：中等。标签：链表，排序。正确解法：/** * 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
2021-08-09 16:36:59
76
原创 LeetCode 313. 超级丑数
难度：中等。标签：数组，哈希表，数学，动态规划，堆（优先队列）。跟剑指 Offer 49. 丑数一样的做法，但是我已经完全忘了这个题咋做的了。看了下剑指那题的解法，然后写出了该题的解法。正确解法：class Solution {public: int nthSuperUglyNumber(int n, vector<int>& primes) { if(n == 1)return 1; vector<int> dp(n);
2021-08-09 16:01:38
69
原创 LeetCode 457. 环形数组是否存在循环
难度：中等。标签：数组，哈希表，双指针。没有好的思路，只能去模拟，绕进去了，问题好多。错了两次，写了个时间复杂度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
2021-08-09 15:33:50
74
原创 LeetCode 1137. 第 N 个泰波那契数
难度：简单。标签：记忆化搜索，数学，动态规划。正确解法：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
2021-08-09 11:01:54
75
原创 LeetCode 847. 访问所有节点的最短路径
难度：困难。标签：位运算，广度优先搜索，图，动态规划，状态压缩。想法：将度最小的几个节点作为起点；将每个节点的每条路径的最长长度记录下来；用广搜的话需要多个节点同时开始遍历，需要在queue中记录访问过的节点序列。结果：看题解吧。需要对节点的状态进行压缩，使用一个int来表示访问过的节点。状态压缩的基本操作：访问第 i 个点的状态：state = (1 << i) & mask更改第 i 个点状态为 1：mask = mask | (1 << i)需要使用
2021-08-06 14:38:27
137
原创 LeetCode 802. 找到最终的安全状态
难度：中等。标签：深度优先搜索，广度优先搜索，图，拓扑结构。用深搜来做，用isSafeNodes来存储节点是否安全，1表示安全，0表示不安全，-1表示没有确定。若一个节点是不安全的，则它对应的visited数组里的所有节点都是不安全的，反之，若一个节点遍历到了不安全的节点，则其肯定也是不安全的。遍历过程中还要注意循环连接的部分，若遍历到的该节点已经访问过，且其安全状态没有确定，则说明循环访问了，直接判定该节点是不安全的。正确解法：class Solution { bool dfs(i
2021-08-05 12:55:00
81
原创 LeetCode 611. 有效三角形的个数
难度：中等。标签：贪心，数组，双指针，二分查找，排序。枚举第一个边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
2021-08-04 12:32:29
79
原创 LeetCode 581. 最短无序连续子数组
难度：中等。标签：栈，贪心，数组，双指针，排序，单调栈。用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
2021-08-03 13:08:29
91
原创 LeetCode 743. 网络延迟时间
难度：中等。标签：深度优先搜索，广度优先搜索，图，最短路，堆（优先队列）。看题解，Dijkstra就没记住过。使用Dijkstra算法进行求解，求出节点 k到其余所有点的最短路，其中的最大值就是答案。Dijkstra算法将点分为未确定点和确定点，每次从未确定点中找到与起点k距离最近的点x，然后更新所有未确定点的距离，并将x加入确定点集中。正确解法：class Solution {public: int networkDelayTime(vector<vector<int&g
2021-08-02 12:51:14
82
原创 LeetCode 146. LRU 缓存机制
难度：中等。标签：设计，哈希表，链表，双向链表。想到了要用哈希表和双向链表。但具体不想想了，累了。看题解吧。一下代码get和put和初始化函数是照着教程写的，moveToHead，addToHead，removeTail是自己写的。注意第18行，一定要判断当前节点是否已经在头部，如果在就直接返回。正确解法：struct DLinkedNode{ int key, val; DLinkedNode* prev, *next; DLinkedNode(
2021-08-01 20:27:09
60
原创 LeetCode 1337. 矩阵中战斗力最弱的 K 行
难度：简单。标签：数组，二分查找，矩阵，排序，堆（优先队列）。正确解法：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;
2021-08-01 11:43:56
57
原创 LeetCode 200. 岛屿数量
难度：中等。标签：深度优先搜索，广度优先搜索，并查集，数组，矩阵。使用深搜来完成，用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
2021-07-31 15:44:16
55
原创 LeetCode 135. 分发糖果
难度：困难。标签：贪心，数组。想了好久，觉得就是贪心，但想不到方案。看题解。方法一将【评分更高的孩子必须比他两侧的邻位孩子获得更多的糖果】这个规则分为两个部分：左规则：当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
2021-07-31 15:24:29
73
原创 LeetCode 136. 137. 只出现一次的数字 I II
文章目录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]; }
2021-07-31 14:28:33
62
原创 LeetCode 987. 二叉树的垂序遍历
难度：困难。标签：二叉树，深度优先搜索，广度优先搜索，哈希表。使用哈希表来记录col，row和val的信息，然后可以使用深搜或广搜来得到这些信息，之后需要对得到的信息进行排序。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(
2021-07-31 11:31:13
60
原创 技术岗面试题
面试考点：C++基础知识算法数据结构汇总设计模式总结OpenGL 图形学基础知识汇总还有一些其他类型的考点，汇总在此，持续记录。一个木棍分为三段，组成三角形的概率木棍长为L，三段长度分别为x，y，L-x-y，首先三段都必须大于0，因此x，y的取值在以下范围内：其次，要构成三角形，必须满足任意两边之和大于第三边，得到以下公式：因此，可以得到x，y的取值范围：则答案为1/41/41/4。在一个圆上随机选择三个点，组成锐角三角形的概率先随机选取A，B点，要组成锐角三角形
2021-07-30 22:53:08
142
原创 LeetCode 143. 重排链表
难度：中等。标签：栈，递归，链表，双指针。先使用快慢指针找到链表的分界点处，将分界点及以后的链表反转。然后将两个链表合并起来。注意第52行，需要将前面的链表尾节点指向nullptr，否则他之前指向的是后面链表的第一个节点，该节点已经被反转到后面链表的最后一个了。如果不加上这句，会报以下错：AddressSanitizer: heap-use-after-free正确解法：/** * Definition for singly-linked list. * struct ListNode
2021-07-30 12:59:44
61
原创 LeetCode 171. Excel 表列序号
难度：简单。标签：数学，字符串。正确解法：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
2021-07-30 12:17:29
47
原创 LeetCode 1104. 二叉树寻路
难度：中等。标签：二叉树，数学。从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
2021-07-29 12:48:53
47
原创 LeetCode 209. 长度最小的子数组
难度：中等。标签：数组，二分查找，前缀和，滑动窗口。动态规划写了一遍，没提交，肯定超时。代码：class Solution {public: int minSubArrayLen(int target, vector<int>& nums) { int n = nums.size(); vector<vector<int>> dp(n, vector<int>(n)); for(int
2021-07-28 22:36:21
111
原创 LeetCode 863. 二叉树中所有距离为 K 的结点
难度：中等。标签：二叉树，深度优先搜索，广度优先搜索。先找出根节点到target的路径上所有的点，将找与target的距离为k的点转换为找与路径上的点距离为find_dis的点。注意不要重复判断。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x)
2021-07-28 13:48:10
43
原创 LeetCode 322. 零钱兑换
难度：中等。标签：广度优先搜索，动态规划，数组。还想了半天，脑子秀逗了。动态规划很简单。正确解法：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
2021-07-27 22:46:30
62
原创 LeetCode 402. 移掉 K 位数字
难度：中等。标签：贪心，单调栈，字符串。用贪心的思想，反过来取出n-k个数字，使得数字最小。取第i个数字时，判断的范围是从取的上一个数字的索引的下一个数开始，到num中留有[n - k - i - 1]个数字结束，找出这个范围内最小的数（索引为min_idx），就是当前取的数字。下一个要取的数字就从min_idx开始判断。正确解法：class Solution {public: string removeKdigits(string num, int k) { int
2021-07-27 18:54:36
62
原创 Leet Code 671. 二叉树中第二小的节点
难度：简单。标签：二叉树，深度优先搜索。开始思路错了。重新写，dfs就是找以root位根节点的树中除了temp外的最小值。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {
2021-07-27 13:49:39
52
原创 LeetCode 152. 乘积最大子数组
难度：中等。标签：跟和最大的子数字比较像，但不一样，需要考虑负负为正的问题。没写出来，看题解。哭了。正确解法：class Solution {public: int maxProduct(vector<int>& nums) { int n = nums.size(); vector<int> maxNum(n), minNum(n); int ans = nums[0]; maxNum[0]
2021-07-26 23:36:44
56
原创 LeetCode 1713. 得到子序列的最少操作次数
难度：困难。标签：贪心，数组，哈希表，二分查找。首先，这道题就是最长公共子序列，我竟然没想到。（虽然会超时）看了两条提醒：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
2021-07-26 22:26:30
114
原创 LeetCode 1743. 从相邻元素对还原数组
难度：中等。标签：数组，哈希表。将对应关系存于字典中。正确解法：class Solution {public: vector<int> restoreArray(vector<vector<int>>& adjacentPairs) { int n = adjacentPairs.size(); unordered_map<int, vector<int>> maps;
2021-07-25 10:02:37
42
原创 LeetCode 134. 加油站
难度：中等。标签：贪心，数组。正确解法：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
2021-07-24 15:48:15
53
原创 LeetCode 1736. 替换隐藏数字得到的最晚时间
难度：简单。标签：字符串。错误用例：“?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){
2021-07-24 13:54:11
59
原创 LeetCode 133. 克隆图
难度：中等。标签：深度优先搜索，广度优先搜索，哈希表，图。按照138. 复制带随机指针的链表的思路来做，用一个哈希表存储旧节点到新节点的映射。然后用两次广搜，第一次生成节点，第二次建立节点之间的关系。/*// Definition for a Node.class Node {public: int val; vector<Node*> neighbors; Node() { val = 0; neighbors = vect
2021-07-23 17:59:38
60
原创 LeetCode 1893. 检查是否区域内所有整数都被覆盖
难度：简单。标签：数组，哈希表，前缀。正确解法：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>
2021-07-23 12:23:13
39
原创 LeetCode 130. 被围绕的区域
难度：中等。标签：深度优先搜索，广度优先搜索，并查集，数组，矩阵。这个题竟然把我整懵了，感觉不难，但是不知道如何用深搜，想到了需要从四周向中间进行搜索，但是还没想明白。看了题解，非常妙。正确解法：class Solution { int rows, cols; void dfs(vector<vector<char>>& board, int i, int j){ if(i < 0 || i >= rows || j
2021-07-22 12:38:52
70
原创 LeetCode 129. 求根节点到叶节点数字之和
难度：中等。标签：二叉树，深度优先搜索。用广搜做，队列中存储当前节点和当前节点组成的数字。正确解法：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode
2021-07-21 22:24:32
83
原创 LeetCode 128. 最长连续序列
难度：中等。标签：哈希表，数组，并查集。这种有限制条件的题，我一般都想不出来，有脑筋急转弯那味了。看题解，使用集合存储数组，枚举数组中的数x，以x作为连续序列的开始，判断x+1, x+2, …是否在集合中，更新长度。不用枚举数组中每个元素，当前数为y，若y-1在集合中，则不需要枚举以y为开始的序列。正确解法：class Solution {public: int longestConsecutive(vector<int>& nums) { unor
2021-07-21 22:12:29
57
原创 LeetCode 1877. 数组中最大数对和的最小值
难度：中等。标签：贪心，数组，双指针，排序。正确解法：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
2021-07-20 12:37:21
67
原创 LeetCode 1838. 最高频元素的频数
难度：中等。标签：数组，二分查找，前缀和，滑动窗口。用最简单的思路做，先排序，然后从大往小遍历，查看当前数是否是最大频数的数字。正确解法：class Solution {public: int maxFrequency(vector<int>& nums, int k) { int n = nums.size(); sort(nums.begin(), nums.end()); int ans = 0; f
2021-07-19 12:53:15
88
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人