2301_80071187的博客

该题解使用深度优先搜索(DFS)在二维字符网格中查找给定单词。算法首先遍历网格每个位置，作为搜索起点。对于每个起点，通过DFS递归检查四个方向(上、下、左、右)是否能匹配单词后续字符。为避免重复使用同一单元格，搜索时临时将访问过的字符标记为空字符，搜索结束后恢复原值。若找到完整匹配路径则返回true，否则继续搜索其他起点。这种方法通过回溯遍历所有可能路径，确保正确判断单词是否存在网格中。

本文介绍了一种通过回溯算法生成所有有效括号组合的方法。给定n对括号，通过深度优先搜索(DFS)递归构建合法组合：维护当前左括号与右括号的平衡状态，确保任何前缀中左括号数量不少于右括号。算法使用一个路径数组记录左括号位置，当填满所有括号后将其转换为字符串存入结果列表。关键步骤包括枚举可能的右括号数量并递归处理后续选择，最后回溯移除当前选择。该方法高效地生成了所有可能的有效括号组合，时间复杂度为O(4^n/√n)，空间复杂度为O(n)。

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为 target 的不同组合数少于 150 个。

该题解使用回溯算法解决电话号码字母组合问题。通过建立数字到字母的映射关系，递归遍历每个数字对应的所有字母可能性，逐步构建字母组合。当组合长度等于输入数字串长度时，将结果加入最终列表。算法时间复杂度为O(3^N×4^M)，其中N是3字母数字个数，M是4字母数字个数。空间复杂度为O(N)，主要用于存储递归栈和结果列表。

该问题要求返回给定整数数组的所有可能子集（幂集）。采用位掩码法解决：对于长度为n的数组，遍历0到2^n-1的所有掩码值，每个掩码对应一个子集。通过检查掩码的二进制位是否为1来决定是否包含对应元素。这种方法可以高效生成所有不重复的子集。例如，输入[1,2,3]时，会输出8个子集，包括空集和全集。算法时间复杂度为O(n*2^n)，空间复杂度为O(n)。

本文介绍了使用回溯算法生成数组所有排列的Java实现。通过深度优先搜索(DFS)递归遍历，维护当前路径(path)和已使用数字标记(used)。每次递归处理未使用的数字，创建新路径和标记数组以避免引用问题。当路径长度等于数组长度时，保存结果。算法时间复杂度为O(n*n!)，空间复杂度为O(n)。该实现能正确处理所有输入情况，包括空数组和单元素数组。

摘要： Trie（前缀树）是一种高效存储和检索字符串的数据结构，支持自动补全和拼写检查功能。本文实现了一个Trie类，包含插入(insert)、查找(search)和前缀匹配(startsWith)三个核心方法。通过节点数组存储子节点和结束标记来构建树形结构，其中insert方法构建路径，search检查完整单词，startsWith验证前缀存在性。算法采用二十六叉树结构，每个节点对应一个字母，时间复杂度为O(L)(L为单词长度)，空间复杂度O(N*26)(N为节点数)。示例演示了插入"apple

这道题目考察课程安排的可行性，本质上是检测有向图中是否存在环。我们可以使用拓扑排序来解决： 构建入度数组和邻接表，记录每门课程的先修关系 将所有入度为0的课程入队 通过BFS逐步处理课程，将处理完的课程从图中"移除" 检查最终处理的课程数是否等于总课程数 如果存在环，则某些课程的入度永远不会降为0，导致无法完成所有课程。时间复杂度为O(V+E)，空间复杂度为O(V+E)，其中V是课程数，E是先修关系数。

这是一道关于网格中橘子腐烂过程的广度优先搜索(BFS)问题。给定一个m×n网格，其中0表示空单元格，1表示新鲜橘子，2表示腐烂橘子。每分钟腐烂橘子会感染周围4个方向的新鲜橘子。算法使用队列来存储所有初始腐烂橘子位置，然后逐一处理它们对周围新鲜橘子的影响，每轮处理代表1分钟。如果最终仍有新鲜橘子剩余则返回-1，否则返回所需最小分钟数。关键点在于使用BFS模拟腐烂过程，并准确统计剩余新鲜橘子数量。

文章摘要： 该题要求计算二维网格中由相邻'1'（陆地）组成的岛屿数量。解题思路是遍历网格，遇到'1'时通过BFS或DFS将其相邻陆地标记为已访问，避免重复计数。示例代码使用BFS实现：当发现新岛屿时增加计数，并扩散标记所有相连陆地。例如，输入网格1输出1个岛屿，网格2输出3个岛屿。时间复杂度为O(M×N)，空间复杂度最坏情况下为O(M×N)。（字数：149）

本文介绍了如何寻找二叉树中两个节点的最近公共祖先(LCA)。通过递归方法，从根节点开始遍历左右子树，当找到目标节点或遍历到叶子节点时返回。如果左右子树均找到目标节点，则当前节点即为LCA；若仅单侧找到，则返回该侧结果。算法时间复杂度为O(n)，空间复杂度为O(n)。关键点在于利用递归和条件判断来定位LCA的位置。

该题目要求在二叉树中找出路径和等于目标值的路径数目，路径方向必须向下（父节点到子节点）。解法采用深度优先搜索(DFS)结合前缀和思路，使用哈希表记录路径和出现次数。算法从根节点开始递归遍历，维护当前路径和，查找是否存在满足条件的子路径。时间复杂度为O(n)，空间复杂度为O(n)，其中n为节点数。通过递归处理左右子树并维护哈希表状态，最终统计所有符合条件的路径数目。

这篇文章介绍了如何根据二叉树的前序遍历和中序遍历结果重建二叉树。通过递归方法，利用前序遍历确定根节点，在中序遍历中划分左右子树范围，逐步构建整棵树。文章提供了Java代码实现，包括使用HashMap存储中序遍历索引以提高查找效率，以及递归函数的详细解释。该方法的时间复杂度为O(n)，空间复杂度为O(n)，适用于处理给定的两种遍历序列来还原原始二叉树结构。

本文介绍了将二叉树展开为单链表的算法。通过修改指针指向，将二叉树按先序遍历顺序转换为右指针单向链接的链表。关键步骤是：当左子树存在时，找到其最右节点，将原右子树接在其后，再将左子树移到右子树位置并清空左指针。算法时间复杂度为O(n)，空间复杂度O(1)，采用原地修改的方式逐步将二叉树转为链表结构。

该题目要求返回二叉树的右视图，即从右侧看树时每层最右边的节点值。解题采用深度优先搜索(DFS)方法，先递归右子树再左子树，确保每层首次访问的节点就是最右侧节点。当当前深度等于结果列表长度时，将该节点值加入列表。对于空树返回空列表。时间复杂度为O(n)，空间复杂度为O(h)，h为树高。

文章摘要： 题目要求在二叉搜索树中查找第k小的元素。解题思路是利用二叉搜索树中序遍历的特性（节点值按升序排列），通过深度优先搜索（DFS）遍历树结构。代码实现中定义了一个Solution类，包含递归遍历方法dfs和主方法kthSmallest。当遍历到第k个节点时记录结果并返回。该方法的时间复杂度为O(n)，空间复杂度为O(h)，其中n是节点数，h是树高度。示例显示对于输入[3,1,4,null,2]和k=1，输出为1；输入[5,3,6,2,4,null,null,1]和k=3，输出为3。

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。解释：最长数字连续序列是 [1, 2, 3, 4]。输入：nums = [0,3,7,2,5,8,4,6,0,1]请你设计并实现时间复杂度为 O(n) 的算法解决此问题。输入：nums = [100,4,200,1,3,2]输入：nums = [1,0,1,2]

给定一个长度为 n 的整数数组 height。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i])。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。说明：你不能倾斜容器。示例 1：输入：[1,8,6,2,5,4,8,3,7]输出：49解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i!= j、i!= k 且 j!= k ，同时还满足 nums[i] + nums[j] + nums[k] == 0。请你返回所有和为 0 且不重复的三元组。注意：答案中不可以包含重复的三元组。示例 1：输入：nums = [-1,0,1,2,-1,-4]输出：[[-1,-1,2],[-1,0,1]]解释：不同的三元组是 [-1,0,1] 和 [-1,-1,2]

给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。示例 1:输入: s = “abcabcbb”输出: 3解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。示例 2:输入: s = “bbbbb”输出: 1解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。示例 3:输入: s = “pwwkew”输出: 3解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。示例 1:输入: s = “cbaebabacd”, p = “abc”输出: [0,6]解释:起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。示例 1：输入：nums = [1,1,1], k = 2输出：2示例 2：输入：nums = [1,2,3], k = 3输出：2。

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。示例 1：输入：nums = [-2,1,-3,4,-1,2,1,-5,4]输出：6解释：连续子数组 [4,-1,2,1] 的和最大，为 6。示例 2：输入：nums = [1]输出：1示例 3：输入：nums = [5,4,-1,7,8]输出：23。

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi]。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。请 不要使用除法，且在 O(n) 时间复杂度内完成此题。示例 1:输入: nums = [1,2,3,4]输出: [24,12,8,6]示例 2:输入: nums = [-1,1,0,-3,3]输出: [0,0,9,0,0]

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0。请使用 原地 算法。示例 1：输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[1,0,1],[0,0,0],[1,0,1]]示例 2：输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例 2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[[7,4,1],[8,5,2],[9,6,3]]示例 2：输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：每行的元素从左到右升序排列。每列的元素从上到下升序排列。

题目要求检测链表中是否存在环，并返回环的起始节点。如果链表无环，则返回 null。通过使用哈希集合（HashSet）存储已访问的节点，可以在遍历链表时判断是否遇到重复节点，从而检测环的存在。具体实现步骤如下：初始化一个指针指向链表头节点，并创建一个空哈希集合。遍历链表，检查当前节点是否已在集合中。如果存在，则说明链表有环，返回该节点；否则，将节点加入集合并继续遍历。如果遍历结束后未发现重复节点，则返回 null 表示链表无环。该方法的时间复杂度为 O(n)，空间复杂度为 O(n)。

本文介绍了删除链表倒数第n个节点的算法。通过创建虚拟头节点处理边界情况，先遍历链表获取长度，再计算目标位置索引。使用双指针法定位到目标节点的前驱节点后执行删除操作。该算法时间复杂度为O(N)，空间复杂度O(1)，适用于单链表结构。示例代码展示了完整的实现过程，包括链表长度计算、目标节点定位和删除操作等关键步骤。

本文介绍了一种高效的"两数之和"解法，适用于已排序数组。通过双指针法（一个从数组头开始，一个从数组尾开始），不断调整指针位置来寻找和等于目标值的两个数。当和大于目标值时，右指针左移；当和小于目标值时，左指针右移。该方法时间复杂度为O(n)，空间复杂度为O(1)，利用了数组已排序的特性，能够快速定位解而无需额外空间。示例展示了如何返回符合要求的下标（从1开始计数）。

本文介绍了如何通过递归方法两两交换链表中的相邻节点。题解给出了一个Java实现，当链表为空或只有一个节点时直接返回；否则递归处理后续节点，并将当前两个节点交换位置。该方法时间复杂度为O(n)，空间复杂度为O(1)，仅使用常数个额外变量完成节点交换。关键步骤包括获取第二个节点、递归处理后续节点对，以及调整节点指针完成交换。

本文介绍了如何深度复制带有随机指针的链表。通过三次遍历：第一次在原节点后插入复制节点，第二次设置复制节点的random指针，第三次将新旧链表拆分。这种方法保证了复制链表中的节点都是全新的，且不指向原链表节点。时间复杂度为O(n)，空间复杂度为O(1)（不包括返回的新链表）。关键点在于巧妙利用原链表结构来建立新旧节点间的映射关系，从而高效地完成深度复制。

本文介绍了如何对链表进行升序排序。使用分治法，先通过快慢指针找到链表中点并断开连接，然后递归排序左右两部分，最后合并两个有序链表。关键点包括：1) middleNode方法使用快慢指针找中点并断开连接；2) mergeTwoLists方法通过哨兵节点合并两个有序链表；3) sortList方法递归实现分治排序。时间复杂度为O(nlogn)，空间复杂度为O(logn)。这种方法将链表排序问题分解为876题（找中点）和21题（合并有序链表）的组合。

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。// 缓存是 {1=1}// 缓存是 {1=1, 2=2}// 返回 1// 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}// 返回 -1 (未找到)// 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}// 返回 -1 (未找到)// 返回 3// 返回 4。

本文介绍了二叉树的层序遍历实现方法。核心思路是使用队列进行广度优先搜索，每次处理一层节点。算法步骤如下：1)初始化队列，若根节点非空则入队；2)循环直到队列为空，每次记录当前层节点数；3)处理当前层节点，将其值存入临时列表，同时将子节点入队；4)将当前层结果加入最终结果列表。该方法保证节点按层级顺序输出，时间复杂度为O(n)，空间复杂度为O(n)。示例代码展示了Java实现，清晰演示了如何逐层遍历二叉树并收集结果。

摘要：本文介绍了如何判断一个二叉树是否为有效的二叉搜索树(BST)。BST需满足：左子树所有节点小于当前节点，右子树所有节点大于当前节点，且左右子树本身也是BST。通过递归方法实现，每个节点检查其值是否在允许范围内，并递归验证左右子树。给出的Java解法使用上下界约束，初始范围为Long的最小/最大值，逐步缩小范围进行验证。示例表明该方法能正确识别有效和无效的BST结构。