发表于"2018年10月"的文章

文章使用滑动窗口查找由给定等长单词拼接而成的子串。先统计目标单词出现次数，再按单词长度推进窗口，遇到未知词重置、重复超额则收缩左边界，匹配完整时记录起点。通过遍历不同起始偏移覆盖所有位置，兼顾重复单词的情况，并提供 C++ 与 Go 实现。

本文总结了LeetCode“串联所有单词的子串”题。题目给定字符串s和等长单词数组words，要求找出s中所有由words全部单词各用一次拼接而成的子串起始索引。题解采用滑动窗口与哈希表：先统计words词频，再按单词长度分多起点遍历，用窗口内词频与目标比较，动态调整左边界，记录合法起点。时间复杂度O(n)，空间复杂度O(km)。文末给出C++和Go实现。

文章讲解LeetCode第30题“串联所有单词的子串”的解法。题目要求在长字符串s中找出由words数组中所有单词（长度相同、可重复）各用一次拼接而成的子串的起始索引。作者指出该题与第三题思路一致，采用滑动窗口：先用哈希表记录每个单词的出现次数，再以外层循环偏移0至单词长度-1、内层按单词长度为步长遍历字符串，维护当前匹配计数，遇到不存在的单词则重置窗口，某单词超量则左边界逐步右移，计数满时记录结果。时间复杂度为O(n)，空间复杂度为O(km)，并附C++和Go两种AC代码实现。

题目链接：https://leetcode.com/problems/substring-with-concatenation-of-all-words/ 给出一个长字符串s和一个字符串数组words, 返回由words中字符串拼接成的长字符串(假设为x)在s中的索引集合(x由words中所有元素拼接而成, 每一个元素都包含且只有一个) Hint------------------ words中的每个字符串长度相等 words中的字符串可以重复(自己脑补了一波, 坑skr人T_T) Example 这个题目其实和LeetCode的第三题Substring Without Repeating Characters的解题思路核心是一样的…

文章讨论在禁用乘法、除法和取模运算时计算整数商。相比逐次减去除数，使用左移将除数成倍放大，一次扣除较大的可用倍数，并累计相应商值，重复直到余量不足。文中说明符号判断和溢出边界，展示 C++ 与 Go 实现，核心是用位运算减少重复减法次数。

本文讲解 LeetCode 两整数相除问题：在不能使用乘、除、取模运算且仅能存储 int32 的条件下，求整数商并处理溢出。朴素反复减法效率低，题解将商拆成 2 的幂之和，通过位移让除数成倍增长，再用被除数逐次减去 divisor<

文章讲解LeetCode第29题“两数相除”：在不使用乘法、除法和取模的前提下，用加减法和位运算求两个32位整数的商，溢出时返回2^31−1。朴素逐次减法会超时，优化思路是把商表示为2的幂之和，利用位移不断将除数左移找到最大的2^k倍数，从被除数中减去并累加对应的倍数，循环直至被除数小于除数。需特判除数为零、除数为1及INT32_MIN除以-1的溢出情况，并用异号判断处理正负号。时间复杂度O((log n)²)，空间复杂度O(1)，文末给出C++和Go的AC代码。

题目链接：https://leetcode.com/problems/divide-two-integers/ 给定一个除数和被除数, 要求不使用除法、乘法以及取模操作计算。返回两个数做除法的商(结果取整数, 就相当于两个int做计算) Hint 1. 被除数和除数都是32位整数(int32) 2. 除数永远不可能为0 3. 本题运行环境只能存储int32类型, 如果计算结果溢出, 返回2^31 − 1 Example 题目规定了无法使用乘除法取模运算, 因此就只有考虑加减法和位运算了。 假设商为s, 余数为r, 则有dividend=divisor∗s+rdividend=divisor*s+rdividend=divisor∗s…

文章使用 KMP 算法实现字符串查找，返回模式串在主串中首次出现的位置，未找到则返回负一。先为模式串建立前缀匹配表，扫描主串时借助该表在失配后调整匹配位置，避免重复比较。文中特别说明空模式串返回零，并提供 C++、Go 实现及时间空间复杂度分析。

本文总结了 LeetCode 的 implement strStr() 题：在字符串 haystack 中查找模式串 needle 首次出现的索引，不存在返回 -1，needle 为空时返回 0。题解采用 KMP 算法，先构造 next 数组，再进行线性匹配，时间复杂度 O(n+m)，空间复杂度 O(m)。文中给出了 C++ 与 Go 两种 AC 代码，并提醒空模式串是易错边界。

文章讲解LeetCode第28题“实现strStr()”，要求返回模式串needle在字符串haystack中首次出现的索引，找不到则返回-1，且模式串为空时应返回0。作者采用KMP算法求解，通过预处理模式串构建next数组实现失配跳转，时间复杂度为O(n+m)，空间复杂度为O(m)。文中给出C++和Go两种语言的AC代码，核心逻辑一致：先计算next数组，再遍历主串匹配，匹配成功时返回起始下标。

题目链接：https://leetcode.com/problems/implement-strstr/ 实现 返回haystack中第一次出现模式串的索引, 如果模式串不是haystack的一部分, 则返回-1。 Hint: 当模式串为空的时候, 返回0(没看到这个居然被坑了T_T) Example KMP算法, 关于KMP算法推荐一篇感觉讲的很有灵魂的博客! Click Here! 时间复杂度 空间复杂度 , m代表模式串(需要匹配的字符串)的长度 版本 版本

文章介绍在常数额外空间内移除数组中指定值的方法。扫描原数组时跳过等于目标值的元素，将其余元素依次覆盖写到数组头部，写入位置同时记录有效长度。返回长度之前的区间就是结果，之后的内容无需关心。文中配合输入输出示例，提供 C++ 与 Go 的线性时间实现。

本文介绍 LeetCode 移除元素题：给定数组 nums 和值 val，要求原地删除所有等于 val 的元素并返回新长度，只能使用 O(1) 额外空间，元素顺序可改变。题解通过一次遍历，用 res 指针记录保留位置，遇到不等于 val 的元素就写入 nums[res] 并递增，等于 val 则跳过。时间复杂度 O(n)，空间复杂度 O(1)，并给出 C++ 和 Go 实现。

文章讲解LeetCode第27题“移除元素”：给定数组nums和值val，需原地删除所有等于val的元素并返回新长度，要求O(1)额外空间，元素顺序可变。解法采用双指针思想，遍历数组时将不等于val的元素依次覆盖到数组头部，跳过等于val的元素，最后返回计数结果。时间复杂度O(n)，空间复杂度O(1)，并给出了C++和Go两种语言的AC实现代码。

题目链接：https://leetcode.com/problems/remove-element/ 给定数组nums和值val, 在适当位置删除该值的所有实例并返回新长度。 Hint: 不要为另一个数组分配额外的空间, 必须通过使用O(1)额外内存修改输入数组来实现此目的。元素的顺序可以改变. Example 利用原数组, 遍历的同时将遍历数据放到元素组头部, 跳过数值等于给定数值val的所有元素即可 时间复杂度 空间复杂度 版本 版本

文章讲解有序数组的原地去重，利用相同元素相邻的特点，在遍历时比较当前元素与前一个元素。发现新值后，将其写入数组前部的下一个有效位置，并更新计数，最终返回不重复元素的数量。文中处理空数组边界，提供 C++ 与 Go 代码，无需额外分配结果数组。

本文介绍 LeetCode“删除排序数组中的重复项”题解。题目要求对已排序数组原地去重，仅用 O(1) 额外空间修改输入，返回新长度，超出部分无需处理。核心思路是顺序遍历，用 index 指向下一个待放位置，当当前元素与前一个不同时，将其写入 index 并递增，同时计数。时间复杂度 O(n)，空间复杂度 O(1)，并给出 C++ 与 Go 实现。

文章讲解 LeetCode 第 26 题：对有序数组就地删除重复项并返回新长度，要求 O(1) 额外空间。核心思路是利用双指针：顺序遍历数组，维持一个 index 指向已去重部分的末尾，当当前元素与前一个元素不同时，将该元素写入 index+1 位置并计数加一。时间复杂度 O(n)，空间复杂度 O(1)，并给出 C++ 和 Go 两种 AC 实现。

题目链接：https://leetcode.com/problems/remove-duplicates-from-sorted-array/ 给定排序的数组nums, 就地删除重复项, 使每个元素只出现一次并返回新的长度。 Hint: 不要为另一个数组分配额外的空间, 必须通过使用O(1)额外内存修改输入数组来实现此目的。 Example O(1)空间复杂度要求, 即利用原数组, 顺序遍历数组, 把不重复的项放在数组头部即可。维持一个index用于存储下标, 直接顺序遍历, 找到数组当前数据与前一个数据不一致即出现一个新数字, 放在当前index+1的位置即可。 时间复杂度 空间复杂度 版本 版本

文章将两两交换链表节点推广为每 k 个节点一组反转。通过先行指针确认区间长度足够，再原地翻转该段指针，并把新头尾与前后链表重新连接；不足 k 个节点的尾段保持原状。文中使用哑头节点统一边界处理，提供 C++ 和 Go 的区间反转函数及完整调用代码。

本文是 LeetCode“K 个一组翻转链表”的题解，说明给定链表需每 k 个节点翻转一次，剩余不足 k 个节点保持原序，并给出 k=2、k=3 示例。解题采用快慢指针：快指针先走 k 步确定待翻转区间，再原地反转该区间并接回原链表，重复至结束。时间复杂度 O(kn)，空间复杂度 O(1)，代码提供 C++ 和 Go 两种实现。

文章讲解了LeetCode第25题“K个一组翻转链表”的解法。题目要求每次反转链表中k个节点，若剩余节点不足k个则保持原样。作者提出这是两两交换节点题目的进阶版，采用快慢指针方法：快指针先走k步，然后就地翻转两指针之间的节点，再处理翻转后链表的首尾连接，重复此过程直到结束。时间复杂度为O(kn)，空间复杂度为O(1)。文末附有C++和Go两种语言的AC代码实现。

题目链接：https://leetcode.com/problems/reverse-nodes-in-k-group/ 给定一个链表, 一次反转链表的k个节点(每k个节点翻转一次), 最后返回修改后的列表。 Hint: k是正整数, 并且小于或等于链表的长度。如果节点数不是k的倍数, 那么最后的剩余节点应该保持不变。 Example 这题算是24题Swap Nodes in Pairs的进阶版本。使用快慢指针, 先行指针先走k步, 就地转置慢指针与快指针之间的节点, 最后处理整个翻转链, 重复这个过程直至结束 时间复杂度 , k是需要翻转的区间长度 空间复杂度 版本 版本

文章通过调整节点链接实现链表的两两交换，而不修改节点值。使用哑头节点统一头部处理，依次更新前驱节点、当前节点和下一节点之间的指针，再推进到下一组；若末尾只剩一个节点则保留。文中配合示例给出 C++ 与 Go 实现，采用线性遍历和常数额外空间。

本文讲解 LeetCode“两两交换链表节点”题解。要求交换相邻节点，不能修改节点值，只能用常数级额外空间。思路是创建虚拟头结点统一边界操作，用 pre 和 cur 指针遍历链表，每轮调整指针完成相邻两节点交换，再推进指针。时间复杂度 O(n)，空间复杂度 O(1)。文末附 C++ 与 Go 实现代码。

文章讲解 LeetCode 第 24 题“两两交换链表中的节点”，要求在不交换节点值、仅调整指针且空间复杂度为 O(1) 的前提下，将链表节点两两交换。解法核心是引入一个虚拟空头节点统一处理边界，通过 pre 和 cur 两个指针逐对修改 next 指向完成交换。算法时间复杂度为 O(n)，空间复杂度为 O(1)，文中给出了 C++ 和 Go 两种语言的 AC 代码实现。

题目链接：https://leetcode.com/problems/swap-nodes-in-pairs/ 将链表中的节点两两交换。 Example Given 1->2->3->4, you should return the list as 2->1->4->3. Hint: 即不可采取交换节点的方式, 同时保证空间复杂度为常数级别 直接一张图说明, 定义一个无效空头结点便于统一化操作 时间复杂度 空间复杂度 版本 版本

文章复用两个有序链表的合并方法，以分治思想处理 k 条有序链表。每轮将链表两两配对归并，使待处理链表数量逐步缩减，直到只剩一条结果链表；空输入直接返回空。文中展示迭代分组的下标安排，并提供 C++ 与 Go 的两链表合并函数及整体实现。

文章是 LeetCode“合并 K 个排序链表”的题解。题目要求将 k 个已排序链表合并为一个排序列表。题解核心是复用第 21 题“合并两个有序链表”的方法，再借用归并排序的分治思想，对链表两两合并，逐步缩小规模，直到只剩一个链表。时间复杂度为 O(nlogn)，空间复杂度为 O(1)。最后给出 C++ 与 Go 的 AC 代码实现。

文章讲解了 LeetCode 第 23 题“合并 k 个升序链表”的解法。核心思路是复用第 21 题合并两个有序链表的方法，并借助归并排序的分治思想：每轮将链表数组两两配对合并，使链表数量减半，循环直至只剩一个链表即为结果。该算法时间复杂度为 O(nlogn)，空间复杂度为 O(1)。文中给出了 C++ 和 Go 两种语言的完整 AC 代码，均通过原地更新数组元素实现两两合并。

题目链接：https://leetcode.com/problems/merge-k-sorted-lists/description/ 合并k个已排序的链表并将其作为一个排序列表返回。 分析并描述其复杂性。 Example 直接借用21题 Merge Two Sorted Lists 的双链表合并借用归并排序的思想分治合并即可 时间复杂度 空间复杂度 版本 版本

文章将生成 n 对有效括号的过程看作搜索树，使用深度优先搜索与回溯枚举路径。剪枝条件是左括号数量未达 n 时可以继续添加，右括号数量少于左括号时才能闭合；两者都达到 n 时保存结果。文中结合三对括号的示例解释有效性约束，并提供 C++ 与 Go 实现。

文章总结了 LeetCode“生成括号”题：给定 n 对括号，要求输出所有合法组合。解法采用递归加回溯的 DFS，依次添加括号，并用剪枝条件保证有效：左括号数小于 n 时可加左括号，右括号数小于左括号数时可加右括号；当左右括号数都等于 n 时记录结果。原文给出 C++ 与 Go 实现，并称时间复杂度 O(2^n)、空间复杂度 O(n)。

文章讲解LeetCode“生成括号”题：给定n，生成所有n对括号的合法组合。解法采用递归加回溯的DFS搜索，把结果视为二叉树根到叶子的路径集合，并用剪枝条件保证合法：左括号数小于n时可添加左括号，右括号数小于左括号时可添加右括号。时间复杂度O(2^n)，空间复杂度O(n)，文末给出C++和Go两种AC实现代码。

题目链接：https://leetcode.com/problems/generate-parentheses/description/ 给出数字n, 生成共有n对括号的所有正确的形式, 有效形式见例子 Example 如下图所示此题结果是一颗二叉树根节点到每个叶子节点的路线集合(已经略去不符合题目要求的无效结果), 利用递归+回溯的搜索过程即可完成这个过程, 要结果有效需要满足如下条件, 利用条件合理剪枝, dfs搜索即可 时间复杂度 空间复杂度 版本 版本

文章使用归并思路合并两个有序链表。设置哑头节点后，反复比较两条链表当前节点，将较小者接到结果尾部并推进对应指针；一条链表耗尽后，直接接上另一条的剩余部分。文中提供 C++ 和 Go 代码，通过复用原节点完成合并，额外空间保持常数级。

文章介绍 LeetCode 合并两个有序链表问题，给定两个有序链表，要求合并为一个新的有序链表。示例输入 1->2->4、1->3->4，输出 1->1->2->3->4->4。题解采用归并思路，逐个比较节点值，将较小节点接入结果链表，遍历结束后接上剩余部分。时间复杂度 O(n)，空间复杂度 O(1)，并提供 C++ 和 Go 的 AC 代码。

文章讲解 LeetCode 上“合并两个有序链表”一题。题目要求将两个有序链表合并为一个新的有序链表并返回。作者给出的一句话题解是采用归并思想：由于只有两条已排序链表，直接逐个比较两链表当前节点，将较小者接到结果链表后面，最后把未遍历完的链表直接拼接即可。该算法时间复杂度为 O(n)，空间复杂度为 O(1)。文末附上 C++ 和 Go 两种语言的 AC 代码，均使用虚拟头节点简化边界处理。

题目链接：https://leetcode.com/problems/merge-two-sorted-lists/description/ 合并两个有序链表并返回一个新的列表。 Example 简单归并排序(由于这儿只有两条链表还是有序的, 所以时间复杂度退化为) 时间复杂度 空间复杂度 版本 版本

文章利用栈的后进先出特性判断括号字符串是否有效。遍历字符时，若当前字符与栈顶构成同类型的一对括号，就弹出栈顶，否则入栈；扫描结束后检查栈是否为空。文中列举类型不匹配、嵌套顺序错误等例子，说明空串也有效，并提供 C++ 和 Go 的线性时间实现。

本文讲解 LeetCode 有效括号题：给定仅含括号的字符串，判断同类型括号是否按正确顺序闭合，空串视为有效。题解指出该过程符合后进先出原则，用栈模拟：遍历字符，若与栈顶匹配则弹出，否则压入，遍历后栈空即有效。时间复杂度 O(n)，空间复杂度 O(n)，并提供 C++ 与 Go 的 AC 代码。

文章讲解了LeetCode上“有效括号”题目的解法。题目要求判断由括号组成的字符串是否有效，即开括号必须由同类型括号按正确顺序关闭，空串视为有效。由于括号匹配符合后进先出原则，可用栈模拟：遍历字符串，若当前字符与栈顶匹配则栈顶出栈，否则当前字符入栈，遍历结束后栈为空即有效。时间与空间复杂度均为O(n)，并给出了C++和Go两种AC代码实现。

题目链接：https://leetcode.com/problems/valid-parentheses/description/ 输入一个由各种括号组成的字符串, 按照如下规则判断字符串是否有效 条件: 开括号必须由相同类型的括号来关闭, 即'('由')'关闭、'['由']'关闭, '{'由'}'关闭. 按照正确的顺序打开的括号必须按照同样顺序关闭。 Hont: Note that an empty string is also considered valid. Example 括号匹配的规则符合后进先出的原则, 直接使用stack模拟流程即可。每次选取栈顶和当前输入比较, 看是否匹配；匹配则栈顶元素出栈, 否则当前元素入栈, …

文章采用快慢指针删除链表的倒数第 n 个节点。设置哑头节点后，让先行指针先走 n 步，再同步移动两个指针；当前者到达末尾时，后者正好位于待删节点之前，通过修改链接完成删除。该方法统一了删除头节点的情况，文中提供 C++ 与 Go 实现及复杂度分析。

本文讲解LeetCode删除链表倒数第n个节点的题解。题目给定链表和n，要求删除倒数第n个节点后返回链表。核心解法为快慢指针：先行指针先走n步，再与慢指针同步前进，当先行指针到达末尾时，慢指针位于待删节点的前驱，修改next即可删除。时间复杂度O(n)，空间复杂度O(1)，并给出C++和Go的AC代码实现。

文章讲解 LeetCode 第19题“删除链表的倒数第N个节点”。题目要求删除链表中倒数第n个节点并返回结果链表。解法采用快慢指针（双指针）法：先让先行指针前进n步，然后快慢指针同步前移，当快指针到达链表末尾时，慢指针正好位于倒数第n个节点前，即可就地删除该节点。时间复杂度为O(n)，空间复杂度为O(1)。文中还给出了C++和Go两种语言的AC代码实现。

题目链接：https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/ 给定一个链表和数字n, 删除链表倒数第n个节点并返回结果链表 Hint: Given n will always be valid. Example 快慢指针法, 先行指针先走n步后, 快慢指针再同时前行。这样当先行指针走到链表末尾, 后续指针正好可以操作倒数第n个节点, 直接就地删除即可 时间复杂度 空间复杂度 版本 版本

文章将三数之和的方法扩展到四数之和：数组排序后，用两层循环固定前两个数，再以双指针寻找剩余两个数，根据总和与目标值调整位置。为避免重复组合，外层枚举和内部命中后的移动都需要跳过重复值。文中说明思路与复杂度，并给出 C++ 和 Go 实现。

本文是 LeetCode 四数之和题解。题目要求在整数数组中找出所有不重复的四元组，使其和等于目标值。思路基于三数之和，先排序，再用两层循环固定前两个数，剩余区间用双指针寻找后两个数；各层通过跳过相同元素去重。时间复杂度 O(n^3)，空间复杂度 O(1)，并给出 C++ 与 Go 实现。

文章讲解LeetCode第18题4Sum的解法：给定数组和目标值，找出所有四数之和等于目标值的组合。该题是3Sum的变种，思路为先对数组排序，再用两层循环枚举前两个数，在剩余区间用双指针查找后两个数，使四数之和等于目标值。关键在于去重：外层两层循环需跳过与前一次相同的数字，内层双指针命中后也要跳过重复值。时间复杂度为O(n³)，空间复杂度O(1)，文中附有C++和Go两种实现代码。

题目链接：https://leetcode.com/problems/4sum/description/ 给出一个包含n个整数的数组nums以及一个目标值target, 这个数组是否存在有元素a,b,c,d使得, 找出所有满足条件的a,b,c,d的组合 Example 这题其实是第15题的变种, 相信看了这篇题解举一反三很容易能拿下这题, LeetCode:15.3Sum题解, Click Here! 这道题由于是求4个数的目标值, 所以需要滚动查询的数字由15题的两个变成了3个, 很暴力的一个方法, 在原来的循环上再加一层循环, 内部继续再剩余数组上枚举两个数求和即可 Hint: 如何优雅的避免重复也是一个坑, 外层两个循环都需要…

文章求解电话号码对应的全部字母组合，先建立数字到按键字母的映射，再用搜索逐位扩展结果。广度优先方案将已有组合与当前字母拼接，深度优先方案则选择字符、递归并回溯。文中提供 C++ 的两种实现及 Go 示例，说明空输入处理，并讨论组合数量随位数增长的特点。

本文讲解 LeetCode 电话号码的字母组合题，给定数字序列，要求返回所有可能字母组合。文章指出可用常规 BFS 或 DFS 搜索解决，并给出 C++ 的 BFS、DFS 实现及 Go 的 BFS 实现。时间复杂度为 O(4^n)，空间复杂度为 O(4^n)，其中 4 表示每个数字最多映射的字符数。核心是按数字映射表逐位扩展或递归拼接字符，最终得到全部组合。

文章是一道LeetCode算法题的题解，题目为“电话号码的字母组合”：给定数字序列，仿照九键输入法（如2对应abc、3对应def），输出所有可能的字母字符串组合。作者指出这是基础搜索题，用BFS或DFS即可求解，时间与空间复杂度均为O(4^n)（n为数字个数，4为单个数字最多映射的字符数）。文中给出了C++的BFS与DFS两种实现，以及Go语言的BFS实现，并处理了空输入的边界情况。

题目链接：https://leetcode.com/problems/letter-combinations-of-a-phone-number/description/ 题目给出的图和九键拼音输入法类似, 2对应的是abc,3对应的def, 这样。现在给出一个数字序列, 要求输出这个数字序列可以打出的所有字符串组合。 Example 基础的搜索题目, 直接常规bfs或者dfs即可 时间复杂度 , 4表示每个数字最多可以映射的字符个数 空间复杂度 bfs版本 dfs版本 版本

文章使用双指针求解盛最多水的容器问题。容积由两条线的间距与较短高度共同决定，因此先从数组两端出发，每次记录面积并向内移动较短的一侧，寻找可能更高的边界。文中结合示例解释这一选择，给出 C++ 和 Go 实现，时间复杂度为线性，额外空间为常数。

该文总结 LeetCode “盛最多水的容器”题。题目给定非负整数数组，每个元素表示垂直线高度，选取两条线与 x 轴构成容器，求最大盛水面积。题解采用双指针：从数组两端向中间移动，面积由较矮高度乘以两线下标差决定；每次移动较矮一侧，并持续更新最大值。时间复杂度 O(n)，空间复杂度 O(1)，并给出 C++ 与 Go 实现。

这篇文章讲解了LeetCode“盛最多水的容器”题目的解法。题目要求从n条垂直线中选两条，使其与x轴构成的容器装水最多。解题采用双指针法：初始时左右指针分别指向序列首尾，此时宽度最大；容器高度由较短边决定，每次移动较短一边的指针向内收缩，过程中不断计算面积并维护最大值。该思路基于木桶原理，通过舍弃较矮边保证不会遗漏最优解。算法时间复杂度为O(n)，空间复杂度为O(1)，文中给出了C++和Go两种语言的AC代码实现。

题目链接：https://leetcode.com/problems/container-with-most-water/description/ 给定n个非负整数a1,a2,...,an, 其中每个代表一个点坐标(i,ai), 通过每个点做x轴的垂直线, 最后取任意两条线, 使得两条线与x轴所构成的容器能装最多的水。 Note: You may not slant the container and n is at least 2.(即水的面积不是容器的面积, 而是最大矩形的面积, 并且一定有解) Example 解题思路： 按照常识(木桶原理), 两条线段构成的容器有效高度由较短的一边确定, 整个容器的面积由坐标点index的差…

文章把最接近的三数之和视为三数之和问题的变体。先排序并固定一个元素，再用双指针扫描剩余区间，根据当前总和与目标值的大小移动指针，同时记录绝对差更小的结果；遇到精确命中即可返回。文中讲解判断条件的调整和重复值处理，并提供 C++、Go 代码。

文章讲解 LeetCode 3Sum Closest：给定整数数组和目标值，找出三数之和最接近目标值并返回该和。解法沿用第15题3Sum思路，先排序，固定一个数后用双指针查找，根据当前和与目标大小移动指针并更新最小差值。示例 nums=[-1,2,1,-4], target=1，结果为2。时间复杂度O(n^2)，空间复杂度O(1)，并给出C++和Go实现。

文章讲解LeetCode第16题“最接近的三数之和”：给定数组和目标值，找出三个数使其和最接近目标。解法是第15题三数之和的变种：先对数组排序，固定第一个数，用双指针在剩余区间中选取另外两个数；若三数之和等于目标直接返回，大于目标则右指针左移，小于目标则左指针右移，同时跳过重复元素，每次更新与目标差值最小的答案。时间复杂度O(n²)，空间复杂度O(1)，并给出C++和Go的AC代码。

题目链接：https://leetcode.com/problems/3sum-closest/description/ 给出一个包含n个整数的数组nums和一个目标数字target, 在数组中找到三个整数使得它们的总和最接近目标target, 输出这个最接近目标值的数字 Example 这题其实是第15题的变种, 相信看了这篇题解举一反三很容易能拿下这题, LeetCode:15.3Sum题解, Click Here! 第15题是找到所有三个数的和等于0的组合, 这题是找到三个数的和接近目标值, 其实除了返回的结果不同整个过程都是类似的, 只需要在15题的判断条件上进行修改即可, 判断条件修改如下 由于数组有序, 根据当前选取三个…

文章从三重枚举出发，推导三数之和的排序加双指针解法。固定一个数后，从剩余有序区间两端取数，根据三数之和的正负向内移动指针，命中零时记录组合。通过跳过重复值避免重复答案，并在首个数大于零时结束搜索。文中提供 C++ 与 Go 代码，时间复杂度为平方级。

文章讲解 LeetCode 三数之和问题：在整数数组中找出所有和为 0 且不重复的三元组。核心解法是先排序数组，固定第一个数，再用左右双指针在剩余区间夹逼寻找后两个数；根据三数之和与 0 的大小移动指针，并跳过重复元素避免重复结果。若首数大于 0 可提前结束。时间复杂度 O(n^2)，空间复杂度 O(1)，并给出 C++ 与 Go 实现。

文章讲解LeetCode“三数之和”题目的解法：给定整数数组，找出所有和为0的三元组。暴力三重循环会超时，优化方法是先对数组排序，固定第一个数，再用双指针从剩余区间两端向中间收缩：三数之和大于0则右指针左移，小于0则左指针右移，等于0则记录结果并跳过重复元素。同时通过跳过重复的首个数字和提前终止（首数大于0）来去重剪枝。时间复杂度O(n²)，空间复杂度O(1)，并给出C++和Go两种AC实现代码。

题目链接：https://leetcode.com/problems/3sum/description/ 给出一个包含n个整数的数组nums, 这个数组是否存在元素有a,b,c使得, 找出所有满足条件的a,b,c的组合 Example 很容易想到暴力解法, 三重循环穷举所有可能进行判断, 但很明显这种方法会超时, 想一想有什么办法能够优化不必要的循环？ 排序？ 将数组排序, 从起始点进行大小长度为三的滚动判断即可, 这样就好像省去了两重循环, 事件复杂度变成了 O(3*n)? 由于数字可能为负数, 所以选取当前有序数组两端的数字更可能构成目标数字零, 所以数字的滚动不应该选取连续的。 选择一个标志点作为第一个数字从零开始往后推进, …

文章采用按数值从大到小匹配的方式，将整数转换为罗马数字。映射表同时包含基本符号与四、九类减法组合，转换时不断扣除当前可用的最大数值并追加对应字符串，从而避免为特殊写法额外编写分支。文中列举转换示例，并提供 C++ 与 Go 的完整实现。

本文是 LeetCode“整数转罗马数字”的题解，先说明罗马数字符号、减法规则及示例，再给出思路：按从大到小列出含 900、400 等特殊组合的映射表，循环比较目标数字，能减则减去对应值并拼接符号，否则后移，从而避免对 4、9 单独判断。时间复杂度 O(n)，空间复杂度 O(n)，并附 C++ 与 Go 的 AC 代码。

文章讲解 LeetCode 第 12 题“整数转罗马数字”：将给定整数转换为罗马数字，其中 4、9 等数需用小符号置于大符号前的特殊表示。解法是简单模拟：预先构造从大到小的数值与符号映射表，把 900、400、90、40、9、4 等特殊情况也作为独立映射项，从而避免额外判断；然后从大到小依次减去对应数值并拼接符号，直至数字归零。时间与空间复杂度均为 O(n)，文中附有 C++ 和 Go 两种语言的 AC 代码。

题目链接：https://leetcode.com/problems/integer-to-roman/description/ 输入一个整型数字, 将这个数字转换为罗马数字 有如下约定 Example 一个简单模拟, 按照罗马数字的构造方式模拟即可(**Hint:**关于9或者4的特殊情况可以通过手动构造符号映射避免额外的判断) 时间复杂度 空间复杂度 版本 版本

文章介绍罗马数字转整数的顺序扫描方法。先建立符号与数值的映射，逐个累加当前符号；若前一符号小于当前符号，则将此前加上的值减去两次，修正为减法组合。文中列出基本符号及四、九等特殊规则，并提供 C++、Go 实现，以一次遍历完成转换。

本文介绍 LeetCode“罗马数字转整数”题目及解法。题目要求按罗马数字规则将字符串转为整数，并说明 I、X、C 可作减法前缀的六种情况。题解采用简单模拟：顺序读取每个符号并累加其数值；若当前符号值大于前一符号，则减去两倍前一符号值，以修正 IV、IX、CM 等特殊情况。时间复杂度为 O(n)，文末给出 C++ 和 Go 实现。

文章讲解 LeetCode“罗马数字转整数”题：将罗马数字转换为整数，罗马数字通常从大到小排列，但存在六种减法特例（如 IV=4、IX=9、XL=40、CM=900 等）。解法为简单模拟：顺序读取每个符号并累加对应数值，若当前符号数值大于前一符号，说明出现减法特例，需减去前一符号数值的两倍进行修正。该算法时间复杂度为 O(n)，并附有 C++ 和 Go 两种语言的 AC 代码实现。

题目链接：https://leetcode.com/problems/roman-to-integer/description/ 给出一个罗马数字, 将这个罗马数字转换为数字 有如下约定 Example 一个简单模拟, 顺序读取罗马符号将对应数值相加即可。通过观察可以发现, 当当前符号的前一个符号代表数值小于当前符号时表示9或者4这种类似的特殊情况, 此时只需要在总的数值上减去2倍前一个字符代表数值即可确保结果正确 时间复杂度 版本 版本

文章通过逐步缩短候选前缀，求一组字符串的最长公共前缀。先以第一个字符串为参照，依次与后续字符串比较，遇到不同字符就收缩结束位置，并受当前字符串长度限制。最终返回保留的前缀，没有公共部分则返回空串。文中提供示例、复杂度说明及 C++ 与 Go 实现。

文章介绍 LeetCode 最长公共前缀题：给定若干单词，求最长公共前缀，若不存在则返回空字符串。解法以第一个单词作为初始前缀，依次与后续单词逐字符比较，遇到不同字符或单词更短时，将前缀结束位置收缩到当前匹配长度，最后返回该前缀子串。时间复杂度 O(nk)，空间复杂度 O(k)，并给出 C++ 和 Go 实现。

文章讲解 LeetCode 最长公共前缀题目的解法：以第一个单词作为初始前缀，逐个与其余单词按位比较，一旦某位置字符不同就将前缀长度缩减到该位置，同时不超过当前单词长度，最后返回前缀子串；若无公共前缀则返回空串。时间复杂度为 O(nk)，空间复杂度为 O(k)，并给出了 C++ 和 Go 两种语言的 AC 代码实现。

题目链接：https://leetcode.com/problems/longest-common-prefix/description/ 给出一串单词, 编写一个函数找到这串单词的最长公共前缀 **Hint:**If there is no common prefix, return an empty string "". Example 遍历所有输入单词, 由于是求解公共最长前缀, 因此假设第一个单词为前缀后续比对只要发现对应位置字符不同即可终止, 检测index缩减到当前比对位置, 最后返回0到前缀所在结束index的子串即可 时间复杂度 , k表示前缀的长度 空间复杂度 版本 版本

文章讨论支持点号和星号的完整字符串匹配，分别给出递归与动态规划解法。递归按当前字符是否匹配、星号代表零次或多次展开；动态规划则记录两个前缀的匹配状态，复用已有结果。文中解释状态转移和空串边界，比较重复计算的影响，并提供 C++ 与 Go 代码。

文章围绕 LeetCode 正则表达式匹配题，要求实现支持“.”和“*”且覆盖整个字符串的匹配。先给出递归法，按模式下一字符是否为“*”分情况处理零次或多次匹配；再给出动态规划法，定义 dp[i][j] 表示 s 前 i 个字符与 p 前 j 个字符是否匹配，并分析普通字符及“*”匹配零次、一次、多次的转移，复杂度 O(m*n)。最后附 C++ 递归、C++ DP 与 Go 代码实现。

文章讲解了 LeetCode 第 10 题“正则表达式匹配”的解法。题目要求实现支持 '.'（匹配任意单字符）和 '*'（匹配前一元素零次或多次）的完整字符串匹配。文章给出两种方法：一是递归求解，先处理不含 '*' 的逐位匹配，再分 '*' 前字符与当前字符相等与否两种情况讨论，分别跳过模式串两位或让匹配串前进一位递归；二是动态规划，设 dp[i][j] 表示 s 前 i 个字符与 p 前 j 个字符是否匹配，按 p 当前字符是否为 '*' 分情况推导状态转移方程，覆盖匹配零次、一次和多次的情形，时间复杂度为 O(m*n)。文末附有 C++ 递归版、C++ 与 Go 的动态规划版 AC 代码。

题目链接：https://leetcode.com/problems/regular-expression-matching/description/ 给定一个输入字符, 和一个匹配模式p, 实现正则表达式的匹配, 匹配模式支持和 匹配任何单个的字符 匹配前一个元素n次 要求模式p的匹配覆盖整个输入字符串, 而不是部分匹配 Example 由于 在模式匹配中可以匹配前一个字符0或者多次, 稍后单独讨论, 先思考只有的情况 递归返回条件： 模式串 p 为空, 当p为空时,返回当前串是否为空即可 在不考虑 时, 匹配按位进行, 由s和p当前位置的相等性决定整体相等性, 即当前比对达成条件即可, 此时将s和p的当前字符一同去掉递归调用即可…