6Hzlia-CSDN博客

原创 Hot 100 刷题计划】 LeetCode 146. LRU 缓存 | C++ 哈希表+双向链表

本文介绍了LeetCode 146题LRU缓存的实现方法。该数据结构需要同时满足O(1)时间复杂度的查找和更新操作，采用哈希表+双向链表的组合方案：哈希表负责快速查找，双向链表维护访问顺序。最近使用的节点放在链表头部，最久未使用的放在尾部。当缓存容量超限时，自动淘汰尾部节点。文中详细解释了为何选择双向链表而非单链表或数组，并提供了完整的C++实现代码，包括节点移除、头部插入等核心操作。该实现通过虚拟头尾节点简化了边界条件处理，确保操作的高效性和正确性。

2026-04-29 16:53:34 213

原创【Hot 100 刷题计划】 LeetCode 15. 三数之和 | C++ 排序+双指针

本文介绍了LeetCode 15题三数之和的解法。题目要求在给定整数数组中找出所有不重复的三元组，使其和为0。最优解法采用排序+双指针策略：首先排序数组，然后固定一个数，用双指针在剩余数组中寻找两数之和等于固定数的相反数。关键在于三重去重处理：外层循环跳过重复固定数，内层在找到解后跳过重复的左右指针元素。该算法将时间复杂度从O(N³)降至O(N²)，有效解决了重复三元组问题。代码实现展示了完整的双指针夹逼过程及去重细节。

2026-04-29 16:50:02 374

原创【Hot 100 刷题计划】 LeetCode 189. 轮转数组 | C++ 三次反转经典魔法 (O(1) 空间)

文章摘要： LeetCode 189题要求将数组元素向右轮转k位，要求空间复杂度O(1)。最巧妙的解法是三次反转法：先反转前n-k个元素，再反转后k个元素，最后整体反转数组。这种方法通过数学上的"负负得正"原理实现原地轮转，避免了额外空间消耗。关键细节是处理k大于数组长度的情况（取模运算）。该解法时间复杂度O(n)，空间复杂度O(1)，完美满足题目要求，展示了算法设计中空间优化的精妙思路。

2026-04-29 16:46:18 205 1

原创【Hot 100 刷题计划】 LeetCode 19. 删除链表的倒数第 N 个结点 | C++ 双指针单趟遍历

本文介绍LeetCode第19题删除链表的倒数第N个节点的解题思路。通过使用双指针技巧，可以高效定位并删除目标节点。关键步骤包括：1)引入虚拟头节点dummy处理边界情况；2)使用前后指针pre和post，让post先走n步；3)当post走到链表末尾时，pre刚好停在倒数第N个节点的前驱位置；4)直接修改pre的next指针完成删除。该方法只需一次遍历，时间复杂度O(n)，空间复杂度O(1)，是解决这类链表问题的经典范例。

2026-04-28 17:12:20 150

原创【Hot 100 刷题计划】 LeetCode 148. 排序链表 | C++ 归并排序自顶向下

这篇文章介绍了LeetCode第148题排序链表的解法。题目要求在O(N log N)时间复杂度和常数空间复杂度下对链表进行排序。文章推荐使用归并排序算法，并详细解释了其实现步骤：1)使用快慢指针法找到链表中点进行分割；2)递归地对左右两部分进行排序；3)合并两个有序链表。特别强调了处理偶数节点时快指针初始化的关键细节，以避免递归死循环。提供的C++代码实现了自顶向下的递归归并排序，包括链表分割、递归排序和合并三个主要步骤，完整展现了算法思路和实现细节。

2026-04-28 17:10:39 170

原创【Hot 100 刷题计划】 LeetCode 23. 合并 K 个升序链表 | C++ 顺序合并

摘要：本文介绍了LeetCode第23题合并K个升序链表的解决方案。采用顺序合并法，通过将问题分解为多次两两合并来实现。核心思路是使用辅助函数mergeTwoLists合并两个链表，然后遍历链表数组逐个合并到结果链表中。该方法时间复杂度为O(k^2n)，空间复杂度O(1)，虽然效率不高但实现简单直观，适合作为理解该问题的入门解法。文章提供了完整的C++代码实现，包含详细的边界条件处理。

2026-04-28 17:09:58 242

原创【Hot 100 刷题计划】 LeetCode 24. 两两交换链表中的节点 | C++ 精准指针舞步

摘要： LeetCode 24题要求两两交换链表中的相邻节点，只能通过修改节点指针实现。解题核心是引入虚拟头节点（dummy）统一处理边界情况，通过三步指针操作完成交换：1) 前节点连接后续节点防止断链；2) 后节点反向指向前节点完成翻转；3) 前驱节点更新指向新头部。每次交换后移动指针到已交换对的末尾，继续下一轮操作。该方法时间复杂度O(n)，空间复杂度O(1)，巧妙利用指针重定向实现高效交换。

2026-04-28 17:09:12 172

原创【Hot 100 刷题计划】 LeetCode 2. 两数相加 | C++ 分支迭代法

这篇文章介绍了LeetCode第2题两数相加的解决方案。题目要求将两个逆序存储的非负整数链表相加，返回同样逆序的结果链表。解题核心思路是模拟竖式加法过程，维护一个进位变量sum，分三种情况处理：两个链表都有数字时相加；只有一个链表有数字时单独处理；最后处理可能的剩余进位。代码实现上采用了栈分配的虚拟头节点技术，既保证了内存安全又提高了效率。文章特别强调了C++实现中避免内存泄漏的技巧，通过栈上分配虚拟头节点而非动态内存分配，使解决方案更加健壮高效。

2026-04-27 12:30:08 240

原创【Hot 100 刷题计划】 LeetCode 142. 环形链表 II | C++ 哈希表直觉解法

文章摘要 LeetCode 142题要求找出链表中环的起始节点。提供两种解法：哈希表法和快慢指针法。哈希表法通过记录访问节点来检测环入口，时间复杂度O(n)，空间复杂度O(n)。快慢指针法更高效，通过数学推导分两阶段解决：先判断是否有环，再推导出环入口位置，时间复杂度O(n)，空间复杂度O(1)。后者是更优解，体现了算法与数学的巧妙结合。

2026-04-27 12:29:05 189

原创【Hot 100 刷题计划】 LeetCode 141. 环形链表 | C++ 哈希表直觉解法

摘要：本文介绍了LeetCode 141题环形链表的两种解法。哈希表法通过记录访问过的节点判断是否有环，空间复杂度O(n)。更优的快慢指针法（龟兔赛跑）使用两个指针，快指针每次走两步，慢指针每次走一步，若相遇则说明有环，空间复杂度O(1)。后者无需额外空间，是更高效的解决方案。两种方法的时间复杂度均为O(n)，但快慢指针法在空间上更优。

2026-04-27 12:27:38 248

原创【Hot 100 刷题计划】 LeetCode 234. 回文链表 | C++ 数组转换双指针法

文章摘要：LeetCode 234 回文链表解法本文介绍了一种简单有效的回文链表判断方法。核心思路是将链表转换为数组，利用数组的随机访问特性进行回文判断。具体步骤：1)遍历链表存储节点值到数组；2)使用双指针从数组两端向中间比较元素是否对称。这种方法时间复杂度O(n)，空间复杂度O(n)，代码简洁易懂，适合初学者掌握链表处理的基本技巧。文中提供了C++实现代码，通过示例演示了如何将链表问题转化为更易处理的数组问题。

2026-04-26 09:25:05 190

原创【Hot 100 刷题计划】 LeetCode 21. 合并两个有序链表 | C++ 经典迭代与 Dummy 技巧

本文介绍了LeetCode 160题相交链表的解法。题目要求找出两个单链表相交的起始节点，若不相交则返回null。文章提出了一个巧妙的双指针解法：让两个指针分别从两个链表头出发，当指针走到链表末尾时，跳转到另一个链表头部继续走。这样两个指针最终会在相交点相遇，或者同时到达null（表示不相交）。该方法时间复杂度为O(N)，空间复杂度为O(1)，完美符合题目要求。代码实现简洁明了，通过指针交替遍历两个链表来解决相交判断问题。

2026-04-26 09:24:24 181

原创【Hot 100 刷题计划】 LeetCode 160. 相交链表 | C++ 浪漫双指针 (空间 O(1) 最优解)

本文介绍了LeetCode 160题相交链表的解法。题目要求找出两个单链表相交的起始节点，若不相交则返回null。文章提出了一个巧妙的双指针解法：让两个指针分别从两个链表头出发，当指针走到链表末尾时，跳转到另一个链表头部继续走。这样两个指针最终会在相交点相遇，或者同时到达null（表示不相交）。该方法时间复杂度为O(N)，空间复杂度为O(1)，完美符合题目要求。代码实现简洁明了，通过指针交替遍历两个链表来解决相交判断问题。

2026-04-26 09:23:29 464

原创【Hot 100 刷题计划】 LeetCode 230. 二叉搜索树中第 K 小的元素 | C++ 栈迭代中序遍历

本文介绍了如何在二叉搜索树(BST)中找到第k小的元素。利用BST中序遍历得到有序数组的特性，通过迭代法(栈)实现高效查找。算法步骤包括：不断压入左节点到栈中，弹出栈顶元素时k减1，当k=0时立即返回当前节点值，否则转向右子树继续遍历。这种方法相比递归能更精准控制流程，在找到目标后立即终止遍历，时间复杂度为O(H+k)，其中H为树高度。

2026-04-25 13:59:00 252

原创【Hot 100 刷题计划】 LeetCode 199. 二叉树的右视图 | C++ DFS 逆序遍历

文章摘要： LeetCode 199题要求返回二叉树的右视图节点值。最佳解法采用深度优先搜索(DFS)，按根-右-左顺序遍历。关键点在于：当结果数组长度等于当前深度时，说明首次访问该层，当前节点即为右视图节点。这种方法相比BFS更节省空间，代码简洁高效。核心代码先递归右子树，再递归左子树，通过维护结果数组和深度参数实现右视图节点的收集。

2026-04-25 13:58:18 303

原创【Hot 100 刷题计划】 LeetCode 98. 验证二叉搜索树 | C++ 指针边界法

摘要 LeetCode 98题要求验证二叉树是否为有效的二叉搜索树(BST)。关键陷阱在于不能仅比较节点与直接子节点，而需考虑整个子树的范围约束。采用自顶向下的区间约束法，为每个节点维护合法值范围(min,max)。向左子树传递时更新上界，向右子树传递时更新下界。优化技巧是使用指针而非数值表示边界，避免数据溢出问题。代码通过递归实现，检查当前节点是否在范围内，并递归验证左右子树。时间复杂度O(n)，空间复杂度O(n)。

2026-04-25 13:57:26 199

原创【Hot 100 刷题计划】 LeetCode 543. 二叉树的直径 | C++ 后序遍历 (求深度的完美副产品)

文章摘要 LeetCode 543题要求计算二叉树的直径，即任意两节点间最长路径的边数。解题关键在于将直径问题转化为求子树深度的副产品：对于每个节点，穿过它的最长路径长度等于其左右子树深度之和。采用后序遍历递归计算子树深度，并在过程中维护全局最大直径。算法时间复杂度O(n)，空间复杂度O(h)，其中h为树高。这种巧妙思路将求深度和直径合二为一，高效解决问题。

2026-04-24 15:33:12 144

原创【Hot 100 刷题计划】 LeetCode 102. 二叉树的层序遍历 | C++ 极简 DFS 巧解

本文介绍了使用DFS实现二叉树层序遍历的巧妙方法。核心思路是在DFS递归时携带深度参数level，当发现结果集res的大小等于当前level时，为这一层创建新数组。将节点值精准放入res[level]中，递归处理左右子树时level+1。这种方法避免了传统BFS的队列操作，实现了"降维打击"。关键点包括：1)结果集res必须作为局部变量而非全局变量，避免多测试用例污染；2)通过引用传递res，确保递归过程中维护状态一致性。这种DFS解法简洁高效，时间复杂度O(n)，空间复杂度O(n)。

2026-04-24 15:30:19 204

原创【Hot 100 刷题计划】 LeetCode 108. 将有序数组转换为二叉搜索树 | C++ 分治法详解

这篇题解介绍了LeetCode 108题将有序数组转换为二叉搜索树的解法。文章首先说明题目要求将升序数组转换为高度平衡的二叉搜索树，然后提出分治与二分法的解题思路：通过取数组中间元素作为根节点，递归构建左右子树来保证平衡性。给出的C++代码实现采用递归方式，每次选择当前区间的中点作为根节点，并正确处理数组引用以避免性能问题。解法时间复杂度为O(n)，空间复杂度为O(logn)，符合题目要求。

2026-04-24 15:29:15 205

原创【Hot 100 刷题计划】 LeetCode 101. 对称二叉树 | C++ DFS 极简递归模板

本文介绍了LeetCode第101题对称二叉树的递归解法。题目要求判断给定的二叉树是否为轴对称结构。解题思路采用深度优先搜索(DFS)同步双指针法，通过比较左右子树的镜像关系来判断对称性。核心递归逻辑包括：1)当两个指针同时为空时返回true；2)当只有一个为空或值不等时返回false；3)递归比较外侧节点(l->left与r->right)和内侧节点(l->right与r->left)。代码实现简洁，时间复杂度为O(n)，空间复杂度为O(h)，其中h为树的高

2026-04-23 17:49:48 144

原创【Hot 100 刷题计划】 LeetCode 226. 翻转二叉树 | C++ DFS 极简递归模板

本文介绍了LeetCode 226题翻转二叉树的递归解法。题目要求翻转给定的二叉树并返回根节点，难度为简单。核心思路是利用二叉树的递归特性：先交换当前节点的左右子树，然后递归翻转左右子树。C++代码实现极简，仅需5行核心逻辑：检查空节点、交换左右子树、递归调用自身处理左右子树，最后返回根节点。这种先序遍历的递归方法简洁高效，充分体现了二叉树问题的递归解决思路。

2026-04-23 17:47:20 292

原创【Hot 100 刷题计划】 LeetCode 104. 二叉树的最大深度 | C++ 自底向上递归最优解

本文介绍了LeetCode 104题二叉树的最大深度的解法。题目要求计算从根节点到最远叶子节点的最长路径节点数。采用自底向上的递归思路（后序遍历）：每个节点询问左右子树的深度，取较大值加1作为自身深度。空节点返回0。提供了C++代码实现，包含详细注释和1行极简版本。时间复杂度O(n)，空间复杂度O(h)，h为树高度。

2026-04-23 17:46:10 174

原创【Hot 100 刷题计划】 LeetCode 739. 每日温度 | C++ 逆序单调栈

这篇文章介绍了LeetCode 739题每日温度的解法。题目要求对于每一天的温度，找出下一个更高温度出现的天数差。文章提出使用单调栈的优化解法，采用从右向左遍历的方式。核心思路是维护一个单调递减栈，栈中只存储温度数组的索引。对于每一天的温度，弹出栈中所有比当前温度低的元素，剩下的栈顶元素就是第一个更高温度的索引。通过计算索引差得到结果。这种方法时间复杂度为O(n)，空间复杂度为O(n)，相比暴力解法更高效。文章最后给出了C++实现代码，展示了如何仅存储索引来优化空间使用。

2026-04-22 14:18:02 214

原创【Hot 100 刷题计划】 LeetCode 394. 字符串解码 | C++ 单栈回压法

本文介绍了一种优雅的字符串解码方法，使用单栈解决LeetCode 394题。该解法创新性地采用回压法处理嵌套括号问题，通过将解压后的字符串重新压回栈中，使其参与外层括号的后续处理。算法亮点包括：1) 使用权重变量w精确还原多位数字；2) 仅需一个字符栈即可完成所有操作，避免了双栈的复杂性。代码实现简洁高效，通过弹栈操作逐步解析编码字符串，最终拼接出完整解码结果。这种方法特别适合处理多层嵌套的编码字符串场景。

2026-04-22 14:15:44 159

原创【Hot 100 刷题计划】 LeetCode 84. 柱状图中最大的矩形 | C++ 两次单调栈基础扫法

本文介绍了LeetCode 84题柱状图中最大的矩形的解题思路。该问题要求找出柱状图中能勾勒出的最大矩形面积。关键解法是采用单调栈技术进行三次遍历：第一次从左到右找出每个柱子左侧第一个比它矮的位置；第二次从右到左找出右侧第一个比它矮的位置；第三次计算以每个柱子为高的最大矩形面积。文章特别提醒要避免使用变长数组(VLA)，建议使用vector容器。代码实现展示了规范的C++解法，通过维护单调递增栈来高效地确定边界，最终计算出最大矩形面积。

2026-04-22 14:14:43 136

原创【Hot 100 刷题计划】 LeetCode 32. 最长有效括号 | C++ 动态规划严密推导 (Hard)

摘要：LeetCode 32题要求找出字符串中最长的有效括号子串长度。使用动态规划解法，定义dp[i]为以s[i]结尾的最长子串长度。关键点在于处理两种匹配情况：相邻匹配 () 时直接加2，嵌套匹配 )) 时需跨越内部括号检查前面是否有匹配的左括号，并拼接前面的有效长度。时间复杂度O(n)，空间复杂度O(n)。该解法通过状态转移巧妙处理了括号嵌套和连续匹配的问题。

2026-04-21 18:08:07 165

原创【Hot 100 刷题计划】 LeetCode 155. 最小栈 | C++ 打包状态法 (最优雅的 O(1) 检索)

摘要： LeetCode 155题要求设计一个能在O(1)时间内获取最小元素的栈。本文提出使用"状态打包法"，通过将每个元素与其入栈时的最小值打包成pair存储在栈中。具体实现使用C++的pair结构，first存储实际值，second存储当前最小值。每次push时比较新值与栈顶最小值，取较小者存入；pop时直接弹出pair，自动恢复前状态。这种方法避免了维护两个平行栈的复杂性，以简洁的方式实现了所有操作均为O(1)时间复杂度的要求。

2026-04-21 18:06:51 207

原创【Hot 100 刷题计划】 LeetCode 94. 二叉树的中序遍历 | C++ 递归法 & 迭代法

本文介绍了二叉树中序遍历的两种实现方法。递归法利用树结构的递归特性，按照左-根-右顺序遍历，通过引用传递结果数组优化内存。迭代法使用栈模拟递归调用栈，通过一路向左、撞墙回头、访问节点、转向右子树"的循环过程实现遍历。两种方法时间复杂度均为O(n)，空间复杂度O(n)，其中迭代法避免了递归的系统开销。文章提供了清晰的C++代码实现，帮助理解中序遍历的核心思想。

2026-04-21 18:05:33 478

原创【Hot 100 刷题计划】 LeetCode 416. 分割等和子集 | C++ 0-1背包 1D空间极致优化

文章摘要： LeetCode 416题要求判断一个正整数数组能否分割成两个和相等的子集。解题关键在于将其转化为0-1背包问题：若数组总和为偶数，则寻找子集使其和等于总和的一半。采用动态规划解法，使用一维数组进行状态压缩，通过倒序遍历避免重复计算。核心步骤包括：计算总和并检查奇偶性，初始化DP数组，遍历数字时反向更新状态。该方法时间复杂度O(n×target)，空间复杂度O(target)，能高效解决问题。

2026-04-20 15:24:14 432

原创【Hot 100 刷题计划】 LeetCode 287. 寻找重复数 | C++ 数组判环 (快慢指针终极解法)

摘要： LeetCode 287题要求在n+1个元素的数组中找出唯一重复的数字，限制条件是不修改数组且只使用O(1)空间。这道题的巧妙解法是将数组视为链表，利用Floyd快慢指针算法（龟兔赛跑）来解决。通过将数组下标作为节点，数组值作为指针，重复数字会导致链表成环。算法分两步：首先让快慢指针在环内相遇，然后将慢指针重置到起点，两指针以相同速度前进，再次相遇点即为重复数字。这种解法时间复杂度O(n)，空间复杂度O(1)，完美满足题目要求。

2026-04-20 15:23:36 162

原创【Hot 100 刷题计划】 LeetCode 31. 下一个排列 | C++ 经典三步走 (STL 原理剖析)

摘要：LeetCode 31题要求找到整数数组的下一个字典序更大的排列。解题关键在于三步操作：1) 从后向前找到第一个升序对确定修改位置；2) 在右侧降序序列中找到比该位置数大的最小值并交换；3) 将右侧序列反转成升序以保证最小增幅。若整个数组降序，则直接反转成升序。该算法原地修改，空间复杂度O(1)。

2026-04-20 15:22:43 368

原创【Hot 100 刷题计划】 LeetCode 72. 编辑距离 | C++ 经典 DP 增删改状态转移

本文介绍了LeetCode 72题编辑距离的动态规划解法。题目要求计算将一个单词转换为另一个单词所需的最少操作次数（插入、删除或替换字符）。解题思路采用二维DP，定义f[i][j]为word1前i个字符转换为word2前j个字符的最小操作数。通过分析三种操作路径（删除、插入、替换/跳过）的状态转移方程，并正确处理边界条件（空串转换情况）。代码实现采用哨兵技巧避免下标越界，时间复杂度O(mn)。该解法清晰展示了如何将复杂字符串问题分解为可管理的子问题。

2026-04-16 20:08:10 307

原创【Hot 100 刷题计划】 LeetCode 51. N 皇后 | C++ 回溯算法&状态数组

这篇文章介绍了解决 LeetCode 51题 N皇后问题的两种回溯算法实现。第一种是基础DFS解法，逐行放置皇后并通过遍历检查冲突，时间复杂度为O(N^2)。第二种是优化版本，使用三个状态数组(col、dg、udg)来记录列、对角线和反对角线的占用情况，将检查冲突的时间复杂度降为O(1)。文章包含详细的解题思路、几何特性分析和C++代码实现，展示了如何通过回溯算法高效解决N皇后问题，特别强调了优化版本如何利用数学特性实现降维打击。两种方法都采用递归回溯框架，但后者

2026-04-16 20:07:12 312

原创【Hot 100 刷题计划】 LeetCode 152. 乘积最大子数组 | C++ 动态规划 (绝妙 swap 翻转技巧)

这篇文章介绍了LeetCode第152题乘积最大子数组的解题思路。题目要求找出数组中乘积最大的非空连续子数组。作者指出这道题与最大子数组和类似，但乘法的特殊性在于负数相乘会变成正数，因此需要同时记录当前的最大乘积和最小乘积。文章的核心创新点是提出了一种巧妙的解法：当遇到负数时，交换当前的最大值和最小值，这样就能正确处理负负得正的情况。这种解法通过动态规划实现，时间复杂度为O(n)，空间复杂度为O(1)，代码简洁优雅。

2026-04-16 20:04:21 137

原创【Hot 100 刷题计划】 LeetCode 1143. 最长公共子序列 | C++ 二维DP 与哨兵技巧

本文介绍了LeetCode 1143题最长公共子序列的两种动态规划解法。第一种是标准的二维DP解法，通过构建二维数组记录状态转移过程，时间复杂度O(MN)，空间复杂度O(MN)。第二种通过一维滚动数组优化空间复杂度至O(min(M,N))，关键技巧是使用临时变量保存左上角的值。文章详细讲解了状态转移方程的设计思路，特别强调了哨兵技巧在简化边界条件处理中的作用，并提供了完整的C++代码实现。对于字符串匹配类问题，这种动态规划方法是经典且高效的解决方案。

2026-04-14 11:11:26 377

原创【Hot 100 刷题计划】 LeetCode 131. 分割回文串 | C++ 回溯算法基础切割法

文章摘要 LeetCode 131题要求将字符串分割为回文子串的所有可能方案。该问题适合使用回溯算法(DFS)解决，通过模拟切割线的方式遍历所有可能的分割点。关键思路是：1)递归参数表示当前切割起始位置；2)横向遍历尝试不同切割点；3)检查子串是否为回文；4)合法则继续递归，否则回溯。代码实现使用双指针法判断回文，并通过引用传递避免字符串拷贝开销。时间复杂度取决于回文子串数量，空间复杂度为递归栈深度。该解法体现了回溯算法在组合问题中的典型应用。

2026-04-14 11:08:54 333

原创【Hot 100 刷题计划】 LeetCode 300. 最长递增子序列 | C++ 动态规划 & 贪心二分

本文介绍了解决最长递增子序列问题的两种方法：动态规划和贪心+二分法。动态规划法时间复杂度为O(n²)，通过维护dp数组记录以每个元素结尾的最长子序列长度。贪心+二分法优化至O(n log n)，利用tails数组存储各长度子序列的最小末尾元素，通过二分查找维护严格递增特性。两种方法均能有效求解问题，后者效率更高，适合处理大规模数据。

2026-04-14 11:07:39 272

原创【Hot 100 刷题计划】 LeetCode 139. 单词拆分 | C++ 动态规划 (完全背包思维)

摘要 LeetCode 139题单词拆分要求判断字符串s能否由字典wordDict中的单词拼接而成。这是一个动态规划问题，可以类比为完全背包模型：背包容量是字符串长度，物品是字典单词，且单词可重复使用。解题关键在于定义dp[i]表示前i个字符能否被拼接，状态转移方程为dp[i] = dp[i] || dpi-sz。初始化dp[0]=true作为起点，最终返回dp[n]的结果。该解法通过外层遍历字符串长度、内层遍历字典单词的方式，以O(n*m)时间复杂度解决问题。

2026-04-13 11:30:19 356

原创【Hot 100 刷题计划】 LeetCode 79. 单词搜索 | C++ 标准方向数组 DFS 与回溯

摘要： LeetCode 79题要求判断给定单词是否能在二维字符网格中通过相邻单元格连接而成。解题采用DFS+回溯算法：首先遍历网格寻找与单词首字母匹配的起点，然后使用方向数组控制上下左右四个方向的搜索，通过状态数组标记已访问路径并在回溯时重置状态。当成功匹配完整单词时返回true。该解法通过系统性的网格遍历和状态管理，确保不重复使用单元格的同时高效搜索所有可能路径。时间复杂度为O(mn*3^L)，其中mn是网格大小，L是单词长度。

2026-04-13 11:29:40 199

原创【Hot 100 刷题计划】 LeetCode 64. 最小路径和 | C++ 二维动态规划基础版

摘要：LeetCode 64题要求计算从m×n网格左上角到右下角的最小路径和，每次只能向右或向下移动。采用动态规划方法，定义dp[i][j]表示到达(i,j)的最小路径和。状态转移方程为dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]。边界条件包括起点初始化、第一行和第一列的特殊处理。C++实现通过二维数组存储中间结果，最终返回右下角的值。时间复杂度O(mn)，空间复杂度O(mn)。

2026-04-13 11:28:55 328

空空如也

空空如也