07 2023 档案

1091. 二进制矩阵中的最短路径
摘要：题目： 思路： 【1】什么时候用BFS，什么时候用DFS 1.如果只是要找到某一个结果是否存在，那么DFS会更高效。 因为DFS会首先把一种可能的情况尝试到底，才会回溯去尝试下一种情况，只要找到一种情况，就可以返回了。 但是BFS必须所有可能的情况同时尝试，在找到一种满足条件的结果的同时，也尝试了很 阅读全文
posted @ 2023-07-31 17:46 忧愁的chafry 阅读(12) 评论(0) 推荐(0) 编辑
802. 找到最终的安全状态
摘要：题目： 思路： 【1】模拟的方式（这种方式虽然能跑，但是会超时） 【2】深度优先搜索 + 三色标记法（这种方式算是 模拟的方式 的优化版） 在深度优先搜索时，用三种颜色对节点进行标记，标记的规则如下： 白色（用 0 表示）：该节点尚未被访问； 灰色（用 1 表示）：该节点位于递归栈中，或者在某个环上 阅读全文
posted @ 2023-07-25 14:50 忧愁的chafry 阅读(21) 评论(0) 推荐(0) 编辑
1376. 通知所有员工所需的时间
摘要：题目： 思路： 【1】广度优先遍历 假设输入为： int n = 11, headID = 4; int[] manager = new int[]{5,9,6,10,-1,8,9,1,9,3,4}, informTime = new int[]{0,213,0,253,686,170,975,0, 阅读全文
posted @ 2023-07-24 12:13 忧愁的chafry 阅读(18) 评论(0) 推荐(0) 编辑
841. 钥匙和房间
摘要：题目： 思路： 【1】这道题说是中等但是感觉偏简单，也就是要遍历传入数组的全部元素，同时还要注意如何防止出现死循环的可能即可。 代码展示： //深度遍历 //时间0 ms 击败 100% //内存42.1 MB 击败 28.26% class Solution { boolean[] vis; in 阅读全文
posted @ 2023-07-24 11:58 忧愁的chafry 阅读(4) 评论(0) 推荐(0) 编辑
909. 蛇梯棋
摘要：题目： 思路： 【1】广度优先搜索 代码展示： 【1】广度优先搜索 //时间4 ms 击败 69.78% //内存42.3 MB 击败 49.22% class Solution { public int snakesAndLadders(int[][] board) { int n = board 阅读全文
posted @ 2023-07-21 16:40 忧愁的chafry 阅读(22) 评论(0) 推荐(0) 编辑
74. 搜索二维矩阵
摘要：题目： 思路： 【1】利用二分进行优化 代码展示： //时间0 ms 击败 100% //内存40.2 MB 击败 35.97% class Solution { public boolean searchMatrix(int[][] matrix, int target) { int row = 阅读全文
posted @ 2023-07-21 14:18 忧愁的chafry 阅读(5) 评论(0) 推荐(0) 编辑
33. 搜索旋转排序数组
摘要：题目： 思路： 【1】限制了时间复杂度那么便说明了必须要用二分来进行查找 代码展示： //时间0 ms 击败 100% //内存40 MB 击败 54.18% //时间复杂度： O(log⁡n)，其中 n 为 nums 数组的大小。 //整个算法时间复杂度即为二分查找的时间复杂度 O(log⁡n)。 阅读全文
posted @ 2023-07-21 12:29 忧愁的chafry 阅读(3) 评论(0) 推荐(0) 编辑
52. N 皇后 II
摘要：题目： 思路： 【1】皇后的走法是：可以横直斜走，格数不限。因此要求皇后彼此之间不能相互攻击，等价于要求任何两个皇后都不能在同一行、同一列以及同一条斜线上。 【2】基于集合的回溯（模拟的方式） 【3】基于位运算的回溯 代码展示： 【2】基于集合的回溯（模拟的方式） //时间3 ms 击败 37.25 阅读全文
posted @ 2023-07-20 18:22 忧愁的chafry 阅读(5) 评论(0) 推荐(0) 编辑
4. 寻找两个正序数组的中位数
摘要：题目： 思路： 【1】合并数组排序，然后计算 【2】二分查找 【3】划分数组 代码展示： 【1】合并数组排序，然后计算 //时间3 ms 击败 20.74% //内存43.3 MB 击败 51.79% class Solution { public double findMedianSortedAr 阅读全文
posted @ 2023-07-20 16:09 忧愁的chafry 阅读(16) 评论(0) 推荐(0) 编辑
剑指 Offer 53 - I. 在排序数组中查找数字 I（34. 在排序数组中查找元素的第一个和最后一个位置）
摘要：题目： 思路： 【1】本身这道题单次遍历其实就能做出来，但是考察点在于能不能对O(N)的时间复杂度进行优化，毕竟是有序的，所以可以考虑二分查找的方式。 代码展示： 利用二分查找的方式： //时间0 ms击败100% //内存44.4 MB击败44.65% //利用二分查找找到目标数字的下一个数字的开 阅读全文
posted @ 2023-07-20 15:13 忧愁的chafry 阅读(12) 评论(0) 推荐(0) 编辑
786. 第 K 个最小的素数分数
摘要：题目： 思路： 【1】将全部数据弄好然后排序取出结果 【2】利用优先队列实现堆的思想 【3】利用二分的方式进行优化 代码展示： 【1】将全部数据弄好然后排序取出结果 //时间419 ms 击败 18.67% //内存70.1 MB 击败 12.1% //把所有的数据都填进集合里面然后对集合进行排序， 阅读全文
posted @ 2023-07-20 15:02 忧愁的chafry 阅读(4) 评论(0) 推荐(0) 编辑
剑指 Offer II 061. 和最小的 k 个数对（373. 查找和最小的 K 对数字）
摘要：题目： 思路： 【1】常规的模拟方式（虽然使用break进行了截断，但是耗费的时间还是很久） 【2】对常规方式进行优化（尽量如何减少塞入比对的元素） 【3】二分的方式进行优化 代码展示： 【1】常规的模拟方式 //时间90 ms 击败 9.43% //内存57.1 MB 击败 26.54% clas 阅读全文
posted @ 2023-07-20 14:35 忧愁的chafry 阅读(13) 评论(0) 推荐(0) 编辑
502. IPO（意思为首次公开募股）
摘要：题目： 思路： 【1】利用堆的思想（优先队列）来完成贪心的操作，从而满足拿到最大资本 代码展示： //时间97 ms 击败 29.1% //内存63.6 MB 击败 21.61% //时间复杂度：O((n+k)log⁡ n)，其中 n 是数组 profits 和 capital 的长度，k 表示最多 阅读全文
posted @ 2023-07-19 17:36 忧愁的chafry 阅读(17) 评论(0) 推荐(0) 编辑
230. 二叉搜索树中第K小的元素
摘要：题目： 思路： 【1】常规的只查一次的话其实少不了遍历（最好是中序遍历，因为这样比较符合正常排好的顺序），遍历后需要弹出第K个位置就好 【2】如果是频繁的对某棵树进行查找的话（变更少或者不变更），那么最好是进行存储，用list存储，这样比那里一次但是根据下标就能快速找出想要的K值 【3】如果是频繁的 阅读全文
posted @ 2023-07-19 16:06 忧愁的chafry 阅读(10) 评论(0) 推荐(0) 编辑
剑指 Offer II 062. 实现前缀树（208. 实现 Trie (前缀树)）
摘要：题目： 思路： 【1】字典树 代码展示： //时间37 ms击败34.68% //内存50 MB击败58.24% //时间复杂度：初始化为 O(1)，其余操作为 O(∣S∣)，其中 ∣S∣ 是每次插入或查询的字符串的长度。 //空间复杂度：O(∣T∣⋅Σ)，其中 ∣T∣ 为所有插入字符串的长度之和， 阅读全文
posted @ 2023-07-19 14:28 忧愁的chafry 阅读(16) 评论(0) 推荐(0) 编辑
918. 环形子数组的最大和
摘要：题目： 思路： 【1】情况分为一下两种： 无环状态下，即为53. 最大子序和 有环状态下，要使得两端之和最大，必须让中间的子数组最小，即最后有环情况下的最大子数组和为：sum(nums)-min_ 代码展示： //时间6 ms 击败 50.69% //内存45.2 MB 击败 80.17% clas 阅读全文
posted @ 2023-07-17 17:48 忧愁的chafry 阅读(9) 评论(0) 推荐(0) 编辑
108. 将有序数组转换为二叉搜索树
摘要：题目： 思路： 【1】因为 题目要求 高度平衡，所以两边的层数大致要一致，那么如何一致呢，就是划分的左右子树的节点数大概也是差不多的，这样一想用二分就可以了，中间结点为根结点，然后分出来的两边又会再次形成原本的小问题（递归的做法） 代码展示： //时间0 ms 击败 100% //内存42.1 MB 阅读全文
posted @ 2023-07-14 16:38 忧愁的chafry 阅读(5) 评论(0) 推荐(0) 编辑
211. 添加与搜索单词 - 数据结构设计
摘要：题目： 思路： 【1】无，纯粹是要知道字典树这个东西。 代码展示： //时间170 ms 击败 88.81% //内存96.7 MB 击败 37.73% class WordDictionary { private Trie root; public WordDictionary() { root 阅读全文
posted @ 2023-07-13 12:32 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
153. 寻找旋转排序数组中的最小值（ 154. 寻找旋转排序数组中的最小值 II ）
摘要：题目： 思路： 【1】153. 寻找旋转排序数组中的最小值 【1.1】这种可以默认的是看作为有序的集合，并且从有序集合中找出最小值最合适的就是二分查找（其实找最大值也是可以的，因为最大值的下一位就是最小值） 【2】154. 寻找旋转排序数组中的最小值 II 代码展示： 【2】154. 寻找旋转排序数 阅读全文
posted @ 2023-07-13 12:24 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
433. 最小基因变化
摘要：题目： 思路： 【1】可以参考 剑指 Offer II 108. 单词演变（127. 单词接龙）这篇，本质上题目是类似的，或者说差不多 代码展示： //时间1 ms 击败 66.44% //内存39.8 MB 击败 11.69% class Solution { private Map<String 阅读全文
posted @ 2023-07-13 12:22 忧愁的chafry 阅读(10) 评论(0) 推荐(0) 编辑
222. 完全二叉树的节点个数
摘要：题目： 思路： 【1】利用层数来计算个数的大致范围，然后利用二分来确定个数的准确值。 代码展示： //时间0 ms 击败 100% //内存45 MB 击败 5.4% //时间复杂度和空间复杂度都是 O(n) /** * Definition for a binary tree node. * pu 阅读全文
posted @ 2023-07-12 12:44 忧愁的chafry 阅读(4) 评论(0) 推荐(0) 编辑
114. 二叉树展开为链表
摘要：题目： 思路： 【1】借助辅助空间的方式 【2】不借助辅助空间纯粹遍历的方式 代码展示： 【1】借助辅助空间的方式 //时间0 ms 击败 100% //内存40.1 MB 击败 50.85% //时间复杂度：O(n)。 //空间复杂度：O(n)。 /** * Definition for a bi 阅读全文
posted @ 2023-07-12 12:02 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
117. 填充每个节点的下一个右侧节点指针 II
摘要：题目： 思路： 【1】利用层次遍历的思维 【1.1】利用队列进行层次遍历 【1.2】利用链表替代队列进行层次遍历（这种基于原本Node就具备链表的属性，所以只需要创建一个常量头结点辅助即可，否则需要创建一个完整的链表的话还不如使用队列） 代码展示： //时间1 ms 击败 74.22% //内存42 阅读全文
posted @ 2023-07-11 12:36 忧愁的chafry 阅读(4) 评论(0) 推荐(0) 编辑
112. 路径总和
摘要：题目： 思路： 【1】重点在于这句【叶子节点 是指没有子节点的节点】即 root.left == null && root.right == null 代码展示： //时间0 ms 击败 100% //内存42.3 MB 击败 35.11% /** * Definition for a binary 阅读全文
posted @ 2023-07-11 12:35 忧愁的chafry 阅读(5) 评论(0) 推荐(0) 编辑
123. 买卖股票的最佳时机 III（进阶版本【188. 买卖股票的最佳时机 IV】）
摘要：题目： 思路： 【1】利用了第一次与第二次结合同时买入和卖出的想法，获取这种操作下能赚取的最大值。 代码展示： 【1】123. 买卖股票的最佳时机 III //时间1 ms 击败 100% //内存54.5 MB 击败 69.24% class Solution { public int maxPr 阅读全文
posted @ 2023-07-10 13:44 忧愁的chafry 阅读(6) 评论(0) 推荐(0) 编辑
221. 最大正方形
摘要：题目： 思路： 【0】本来一开始打算参考 剑指 Offer II 040. 矩阵中最大的矩形（85. 最大矩形）这篇，原因是十分相似，后来发现倒不如原生的操作会比较快。 【1】动态规划的思想，借助辅助空间将一些计算过的数值记录，减少遍历的次数 代码展示： //时间43 ms 击败 10.95% // 阅读全文
posted @ 2023-07-10 12:25 忧愁的chafry 阅读(3) 评论(0) 推荐(0) 编辑
72. 编辑距离
摘要：题目： 思路： 【1】动态规划对于这种肯定是需要多增加字符串为空的时候的处理的。 代码展示： //时间6 ms 击败 11.34% //内存42.6 MB 击败 17.6% //时间复杂度 ：O(mn)，其中 m 为 word1 的长度，n 为 word2 的长度。 //空间复杂度 ：O(mn)，我 阅读全文
posted @ 2023-07-10 12:21 忧愁的chafry 阅读(23) 评论(0) 推荐(0) 编辑
106. 从中序与后序遍历序列构造二叉树
摘要：题目： 思路： 【1】可以借鉴 剑指 Offer 07. 重建二叉树（105. 从前序与中序遍历序列构造二叉树） 这一篇，因为本质思路都是一样的。 【2】常规模拟分割的方式 代码展示： 【1】常规模拟分割的方式（这种方式通俗易懂，是将大树构建的方式划分为了小树的构建然后组合成大树，由于划分的时候需要 阅读全文
posted @ 2023-07-07 15:52 忧愁的chafry 阅读(10) 评论(0) 推荐(0) 编辑
100. 相同的树
摘要：题目： 思路： 【1】思路参考 剑指 Offer 28. 对称的二叉树（101. 对称二叉树） 这篇，因为比较对称也是比较两颗子树是否一样。 代码展示： //时间0 ms 击败 100% //内存38.8 MB 击败 69.97% /** * Definition for a binary tree 阅读全文
posted @ 2023-07-07 14:27 忧愁的chafry 阅读(2) 评论(0) 推荐(0) 编辑
212. 单词搜索 II
摘要：题目： 思路： 【1】常规的模拟方法（这种直接就超时了） 【2】回溯 + 字典树 【3】删除被匹配的单词 代码展示： 【1】常规的模拟方法（这种直接就超时了） class Solution { public List<String> findWords(char[][] board, String[ 阅读全文
posted @ 2023-07-07 12:15 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
98. 验证二叉搜索树
摘要：题目： 思路： 【1】其实可以借鉴 530. 二叉搜索树的最小绝对差（783. 二叉搜索树节点最小距离） 这篇的逻辑，因为二叉搜索树最大的特点就是中序遍历会形成一个升序的数组，所以不满足该升序的就必然不是二叉搜索树。 代码展示： //时间2 ms 击败 19.15% //内存42.9 MB 击败 1 阅读全文
posted @ 2023-07-07 12:09 忧愁的chafry 阅读(2) 评论(0) 推荐(0) 编辑
530. 二叉搜索树的最小绝对差（783. 二叉搜索树节点最小距离）
摘要：题目： 思路： 【1】首先最小差值必然是最接近的两个数的绝对值，根据示例一的树来看，由于是二叉搜索树，所以中序遍历后必然是一个有序的数组如【1,2,3,4,6】。那么相邻的两个数就是最接近的，故只需要遍历这个数组，获取两数之间的差值的绝对值即可。 代码展示： 【1】借用辅助空间的方式（这种比较直观） 阅读全文
posted @ 2023-07-07 11:54 忧愁的chafry 阅读(10) 评论(0) 推荐(0) 编辑
剑指 Offer II 083. 没有重复元素集合的全排列（46. 全排列）
摘要：题目： 思路： 【1】回溯的方式，如图 代码展示： //时间0 ms击败100% //内存41.6 MB击败75.18% //时间复杂度：O(n×n!)，其中 n 为序列的长度。 //空间复杂度：O(n)，其中 n 为序列的长度。 //除答案数组以外，递归函数在递归过程中需要为每一层递归函数分配栈空 阅读全文
posted @ 2023-07-06 18:04 忧愁的chafry 阅读(14) 评论(0) 推荐(0) 编辑
剑指 Offer 12. 矩阵中的路径（79. 单词搜索）
摘要：题目： 思路： 【1】思路：采用深度搜索，但首先还是要遍历一遍数组，将哪些下标与第一个字母对应的进行递归查找。【其次，重点在于边界值，数组的上下左右边界，字符的长度边界，还有深度遍历的话应该有一个类似动态规划的数据用于记录标志位，可以采用布尔值，但是布尔值是8bit的，改用int，4bit，更节约空 阅读全文
posted @ 2023-07-06 16:17 忧愁的chafry 阅读(12) 评论(0) 推荐(0) 编辑
82. 删除排序链表中的重复元素 II
摘要：题目： 思路： 【1】逻辑如图：（由于最后的pre是会存在以前的链接指向的，这个是需要清除的） 代码展示： //时间0 ms 击败 100% //内存42.1 MB 击败 5.69% //时间复杂度：O(n)，其中 n 是链表的长度。 //空间复杂度：O(1)。 /** * Definition f 阅读全文
posted @ 2023-07-06 15:35 忧愁的chafry 阅读(2) 评论(0) 推荐(0) 编辑
25. K 个一组翻转链表
摘要：题目： 思路： 【1】分段处理的思维，大致可以分为三个部分 pre ->【left，right】-> next ，pre代表已处理部分 ， 【left，right】代表需要翻转的正在处理部分，next代表未处理的部分，如图 【1.1】步骤分解: 1）链表分区为已翻转部分+待翻转部分+未翻转部分 2） 阅读全文
posted @ 2023-07-06 14:09 忧愁的chafry 阅读(18) 评论(0) 推荐(0) 编辑
61. 旋转链表
摘要：题目： 思路： 【1】关键点：首先k是会存在大于链表个数count的情况的（因为如果是大于的情况就相当于是绕了圈后再偏移），基于此就必须先遍历一遍拿出count是多少，然后计算出正确的偏移值k1 = k%count；然后将链表分为两部分， 断开链接(形成了 【head，pre】 和 【cur，end 阅读全文
posted @ 2023-07-06 12:06 忧愁的chafry 阅读(9) 评论(0) 推荐(0) 编辑
剑指 Offer II 022. 链表中环的入口节点（142. 环形链表 II && 141. 环形链表）
摘要：题目： 思路： 【1】剑指 Offer II 022. 链表中环的入口节点（142. 环形链表 II ） 【1.1】哈希表作为辅助空间的方式 【1.2】进阶的，不借助辅助空间，采用双指针的方式 双指针的原理： 当f与s在环内相遇时, s与f相对于入口起点的距离为c： f 总路程= a + xb + 阅读全文
posted @ 2023-07-06 11:33 忧愁的chafry 阅读(11) 评论(0) 推荐(0) 编辑
92. 反转链表 II
摘要：题目： 思路： 【1】采用分段处理的方式（这种方式时间复杂度为O(N+K)，其中N为链表长度，K为反转长度） 【2】采用分段处理+头插法的方式（一趟扫描完成反转） 代码展示： 【1】采用分段处理的方式 // 采用分段处理的方式 //时间0 ms 击败 100% //内存39.3 MB 击败 11.4 阅读全文
posted @ 2023-07-05 12:34 忧愁的chafry 阅读(15) 评论(0) 推荐(0) 编辑
86. 分隔链表
摘要：题目： 思路： 【1】模拟的方式 首先面对链表这个东西一般都是用指针辅助 如这种是分成两部分的 只需要生成 指向大元素的头节点指针 maxNode （因为是代表头指针的都是创建虚拟头节点） 指向小元素的头节点指针 minNode 指向大元素的当前节点指针 maxCur （因为是代表头指针的都是创建虚 阅读全文
posted @ 2023-07-05 12:34 忧愁的chafry 阅读(14) 评论(0) 推荐(0) 编辑
133. 克隆图
摘要：题目： 思路： 【1】所谓图克隆本质上就是另外开辟一块内存复制出跟给出的数据一致的内容 【2】既然是处理图那么最常用的便就是 思路一：DFS (深度遍历) 思路二：BFS (广度遍历) 辅助以字典相助 代码展示： //深度搜索的方式 //时间23 ms 击败 99.95% //内存40.8 MB 击 阅读全文
posted @ 2023-07-04 12:37 忧愁的chafry 阅读(6) 评论(0) 推荐(0) 编辑
162. 寻找峰值
摘要：题目： 思路： 【1】二分查找主要是需要理解上下坡的概念 代码展示： //时间0 ms 击败 100% //内存40 MB 击败 89.24% // 一次遍历获取最大值，即最大峰值 class Solution { public int findPeakElement(int[] nums) { i 阅读全文
posted @ 2023-07-03 18:59 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
17. 电话号码的字母组合
摘要：题目： 思路： 【1】利用树遍历的思维，回溯倒推回来即可 代码展示： //时间1 ms 击败 47.29% //内存39.6 MB 击败 99.28% class Solution { //将号码字母对应关系存储进Map private HashMap<Character, char[]> map 阅读全文
posted @ 2023-07-03 18:23 忧愁的chafry 阅读(7) 评论(0) 推荐(0) 编辑
149. 直线上最多的点数
摘要：题目： 思路： 【1】本质上都是需要用到两点组成一条直线的公式 y+k*x = b，其中k为斜率，x和y为横纵坐标，b为常量值。 代码展示： 【1】暴力模拟的方式： //时间7 ms 击败 99.36% //内存39.1 MB 击败 83.32% //时间复杂度：O(n^3)。 //空间复杂度：O( 阅读全文
posted @ 2023-07-03 17:57 忧愁的chafry 阅读(34) 评论(0) 推荐(0) 编辑