Hot100 on Jeanphilo Blog

LeetCode 49：字母异位词分组，从逐组比较到构造分组键

Sat, 10 Oct 2026 10:00:00 +0800

用 Python 从两个字符串的异位词判断出发，先写出逐组扫描的正确解，再推导排序键与字符计数键，理解哈希表分组为什么成立。

LeetCode 152：乘积最大子数组，从负数反例推导双状态动态规划

Thu, 08 Oct 2026 00:00:00 +0000

先枚举非空连续区间，再用负数反例推导最大与最小乘积状态，逐步得到常数空间的 Python 解法。

LeetCode 279：完全平方数，从剩余和推导动态规划

Thu, 08 Oct 2026 00:00:00 +0000

从最大平方数优先的失败例子出发，逐步构建递归、记忆化与迭代动态规划，求组成整数所需的最少完全平方数。

LeetCode 139：单词拆分，从前缀是否可达开始

Tue, 22 Sep 2026 12:00:00 +0800

题目要求

输入输出

输入：字符串 s 和字符串列表 wordDict
wordDict 中的每个元素都是一个可以使用的单词；同一个单词可以重复使用
输出：如果 s 可以被拆成一个或多个字典单词，返回 True；否则返回 False
拆分必须覆盖整个字符串，不能跳过字符，也不能改变字符顺序

示例

输入：s = "leetcode", wordDict = ["leet", "code"]
输出：True
解释："leetcode" 可以拆成 "leet" + "code"

输入：s = "applepenapple", wordDict = ["apple", "pen"]
输出：True
解释："apple" + "pen" + "apple"；同一个单词可以重复使用

输入：s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
输出：False
解释：前面可以拼出一些片段，但最后不能覆盖完整字符串

约束

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s 和 wordDict[i] 只包含小写英文字母
wordDict 中的单词互不相同

Step 1：先让“已完成的前缀”变得可见

先只问一个具体问题：对于 s = "leetcode"，在确认整串能否拆开之前，我们能不能先记录“已经拆完了哪一段”？

LeetCode 213：打家劫舍 II，环形拆成两个线性问题

Tue, 22 Sep 2026 10:00:00 +0800

题目要求

输入输出

输入：整数数组 nums，nums[i] 表示第 i 间房子的金额。
房子首尾相连，不能偷相邻的两间房子，因此第 0 间和第 n - 1 间也不能同时偷。
输出：在不触发警报的前提下，最多能偷到的金额。
约束：1 <= nums.length <= 100，0 <= nums[i] <= 1000。

示例

输入：nums = [2,3,2]
输出：3
解释：第 0 间和第 2 间首尾相邻，不能同时偷；选择金额 3 的房子。

输入：nums = [1,2,3,1]
输出：4
解释：可以偷下标 0 和下标 2，也可以偷下标 1 和下标 3。

输入：nums = [1,2,3]
输出：3

这篇只用 Python，先从最小的首尾冲突开始。

Step 1：先处理首尾相邻的冲突

先问一个具体问题：nums = [2,3,2] 时，能不能沿用直线街道的做法，直接在整个数组上选择不相邻的房子？

当前基线只有一条规则：相邻房子不能同时偷。若把这三个数当成直线，可能会把下标 0 和下标 2 当成彼此不相邻，从而错误地选择两端，得到金额 4。

这在环形输入上就会失败：首尾也相邻，0 和 2 必须互斥。要消除这一个冲突，只增加一个分支规则：任何合法方案至少属于下面一个候选分支。

LeetCode 322：零钱兑换，从更小金额推出完全背包 DP

Tue, 22 Sep 2026 00:00:00 +0000

从零钱兑换中的贪心失败和更小金额问题出发，逐步构建求最少硬币数量的完全背包动态规划。

LeetCode 300：最长递增子序列，从“以 i 结尾”推出序列 DP

Tue, 22 Sep 2026 00:00:00 +0800

题目要求

输入输出

输入：整数数组 nums
输出：返回 nums 的最长严格递增子序列长度
子序列保持原数组中的相对顺序，但不要求连续，可以跳过元素
如果选择的下标是 i_1 < i_2 < ... < i_k，还必须满足 nums[i_1] < nums[i_2] < ... < nums[i_k]
子序列非空，因此至少选择一个元素
约束：1 <= nums.length <= 2500，-10^4 <= nums[i] <= 10^4

示例

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：[2,5,7,101] 是一个长度为 4 的严格递增子序列；它不要求在原数组中连续。

输入：nums = [0,1,0,3,2,3]
输出：4
解释：[0,1,2,3] 的长度为 4；`[0,1,3]` 也是合法但更短的选择。

这篇只用 Python，从“每个位置结尾能形成多长”这个局部问题开始，逐步写出可运行解法。

Step 1：先问“以哪个位置结束？”

先看第一个例子：

下标： 0 1 2 3 4 5 6 7
数值： 10 9 2 5 3 7 101 18

答案 [2,5,7,101] 跳过了 9 和 3。当我们走到值为 7 的位置时，不能只问“它左边相邻的数是谁”，而要问：

LeetCode 416：分割等和子集，从目标总和推到 0/1 背包倒序遍历

Tue, 22 Sep 2026 00:00:00 +0800

从分割等和子集的题目压力出发，逐步建立 0/1 背包状态，并解释为什么一维压缩必须倒序遍历。

LeetCode 155：最小栈，如何让最小值跟着栈一起变化

Fri, 21 Aug 2026 00:00:00 +0000

从弹出当前最小值后必须恢复历史最小值的压力出发，逐步构建 LeetCode 155 Min Stack。

LeetCode 20：有效的括号，为什么数量相同仍然无效

Fri, 21 Aug 2026 00:00:00 +0000

从反例 ([)] 出发，区分括号数量相同与括号类型、闭合顺序真正匹配，为 LeetCode 20 建立可验证的题意基础。

LeetCode 394：字符串解码，如何保存并恢复嵌套上下文

Fri, 21 Aug 2026 00:00:00 +0000

从嵌套编码会打断外层解码的压力出发，逐步构建 LeetCode 394 Decode String。

LeetCode 153：寻找旋转排序数组中的最小值

Tue, 28 Jul 2026 16:13:57 +0800

从线性扫描基线推导包含最小值的闭区间与二分更新，在 O(log n) 时间、O(1) 额外空间内返回旋转数组的最小值。

LeetCode 33：搜索旋转排序数组

Tue, 28 Jul 2026 15:40:34 +0800

从线性扫描基线推导旋转数组中的有序半区与目标范围判断，在 O(log n) 时间、O(1) 额外空间内完成搜索。

LeetCode 84：柱状图中最大的矩形，连续区间的高度由谁决定

Mon, 20 Jul 2026 00:00:00 +0800

从连续区间的最矮柱限制出发，先构造枚举区间 baseline，再推导按柱高结算最大宽度的线性单调栈解法。

LeetCode 136：只出现一次的数字，如何在常量空间排除重复元素

Wed, 15 Jul 2026 00:00:00 +0800

从集合配对 baseline 出发，推导 XOR 抵消重复元素，在线性时间和常量额外空间内解决 LeetCode 136。

LeetCode 338：比特位计数，如何复用较小数字的结果

Wed, 15 Jul 2026 00:00:00 +0800

从对 0..n 每个数字重复统计的 baseline 出发，推导 answer[i] = answer[i & (i - 1)] + 1，在线性时间内完成比特位计数。

LeetCode 739：每日温度，如何找到右侧第一个更高温度

Wed, 15 Jul 2026 00:00:00 +0800

从向右扫描的 O(n²) baseline 出发，推导维护未解决日期的单调索引栈，在线性时间内解决 LeetCode 739 每日温度。

LeetCode 45：跳跃游戏 II，从可达边界升级到最少跳数

Wed, 08 Jul 2026 00:00:00 +0800

从 LeetCode 55 的 farthest 可达边界出发，推导 LeetCode 45 跳跃游戏 II：用 current_end 表示当前跳数覆盖边界，用 farthest 表示下一跳最远覆盖，最终得到最少跳数贪心。

LeetCode 435：无重叠区间，从删除最少转成保留最多

Mon, 06 Jul 2026 00:00:00 +0800

从删除哪个区间的选择压力出发，推导 LeetCode 435 无重叠区间：先把最少删除转换成最多保留，再逐步推出按结束位置排序的区间贪心。

LeetCode 452：用最少数量的箭引爆气球，从共同交集推出区间贪心

Mon, 06 Jul 2026 00:00:00 +0800

从一支箭能覆盖哪些气球出发，推导 LeetCode 452 用最少数量的箭引爆气球：先写共同交集扫描基线，再压缩成按结束位置排序的 arrow_pos 贪心。

LeetCode 121：买卖股票的最佳时机，从历史最低价推出一次交易贪心

Fri, 03 Jul 2026 00:00:00 +0800

从买入必须早于卖出的顺序压力出发，推导 LeetCode 121 买卖股票的最佳时机：先写 O(n^2) 正确基线，再压缩成维护历史最低价的一次扫描贪心。

LeetCode 55：跳跃游戏，用最远覆盖范围判断能否到达终点

Fri, 03 Jul 2026 00:00:00 +0800

从会卡在 0 的失败样例出发，推导 LeetCode 55 跳跃游戏：先用 reachable 数组建立正确基线，再压缩成维护 farthest 最远覆盖范围的贪心。

LeetCode 200：岛屿数量，把网格陆地看成连通分量

Thu, 02 Jul 2026 00:00:00 +0800

从网格中相邻陆地的合并压力出发，用并查集推导 LeetCode 200 岛屿数量，讲清二维坐标映射、陆地初始 count、union 后 count 什么时候减少。

并查集模板：find / union / count 从零推导

Tue, 30 Jun 2026 00:00:00 +0800

从一个集合合并小任务出发，推导并查集模板中的 parent、find、union、count 和路径压缩，最终得到可直接背写的 Python 模板。

LeetCode 208：实现 Trie（前缀树）模板题解析

Wed, 24 Jun 2026 17:38:48 +0800

LeetCode 208 Implement Trie 是 Trie 模板题，核心是按固定接口实现 insert、search 和 startsWith。

Trie 模板：从节点字段到插入查询 invariant

Wed, 24 Jun 2026 17:38:48 +0800

从零搭一个 Trie 模板，重点理解每个节点存什么、children 怎么走、is_end 为什么需要，以及 insert/search 的循环 invariant。

LeetCode 547：省份数量，把邻接矩阵看成图的连通分量

Wed, 27 May 2026 00:00:00 +0800

从邻接矩阵的直接连接关系出发，把 LeetCode 547 省份数量转成无向图连通分量计数问题，再逐步推出 DFS、BFS 和并查集解法。

LeetCode 198：打家劫舍，从偷或不偷推出一维 DP

Sun, 03 May 2026 14:33:39 +0800

题目要求

输入输出

输入：整数数组 nums
nums[i] 表示第 i 间房子的金额
不能偷相邻房子
输出：返回最多能偷到的金额
约束：1 <= nums.length <= 100，0 <= nums[i] <= 400

示例

输入：nums = [1,2,3,1]
输出：4
解释：偷下标 0 和下标 2，金额 1 + 3 = 4

输入：nums = [2,7,9,3,1]
输出：12
解释：偷下标 0、2、4，金额 2 + 9 + 1 = 12

这篇只用 Python，从这个二选一冲突推出一维 DP。

从 `[1,2,3,1]` 的相邻冲突开始

看例子：

nums = [1,2,3,1]

如果偷下标 2 的房子，金额是 3，那么下标 1 和下标 3 都不能偷。如果不偷下标 2，答案可能来自前面下标 0..1 的最优结果。

所以走到某一间房时，核心选择只有两个：

LeetCode 53：最大子数组和，从 dp[i] 含义推出 Kadane

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：整数数组 nums
输出：返回连续非空子数组的最大和
子数组必须连续
至少选一个元素
约束：1 <= nums.length <= 10^5，-10^4 <= nums[i] <= 10^4

示例

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：[4,-1,2,1] 的和最大，为 6

输入：nums = [1]
输出：1

这篇只用 Python，从 dp[i] 的含义一步一步推出 Kadane 算法。

从 `[-2,1,-3,4]` 的断点开始

看一个前缀例子：

nums = [-2, 1, -3, 4]

如果走到 4，有两种选择：

把前面的某个连续子数组接到 4 前面
从 4 自己重新开始

这里的关键不是“所有子数组怎么枚举”，而是：

当我们决定一个最优子数组必须以当前位置结尾时，它的来源只有两种：接上前一个位置的最优结尾，或者从当前位置重新开始。

这就是一维 DP 的入口。

Step 1：先定义一个更小的问题

直接问“整个数组的最大子数组和是多少”太大。我们先强加一个限制：

如果子数组必须以第 i 个元素结尾，它的最大和是多少？

这个值记为 dp[i]。

这里的 dp[i] 不是“前 i 个元素里的最大子数组和”。它更窄：

LeetCode 78：子集，从搜索树推出 startIndex 回溯模板

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：nums，长度 1 <= nums.length <= 10
元素范围：-10 <= nums[i] <= 10
所有元素互不相同
输出：返回 nums 的所有可能子集
顺序：结果顺序不限，子集内部不需要考虑排列顺序

示例

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

这篇只用 Python 构造一个最小可运行解法。

从 `[1,2]` 的搜索树开始

最小但有分叉的例子是：

nums = [1,2]

答案应该是：

[], [1], [1,2], [2]

注意这里没有 [2,1]。这说明问题不是“随便排列所有选择”，而是“每个元素选或不选，且同一组元素只出现一次”。

如果把构造过程画成树：

[]
|- [1]
| |- [1,2]
|- [2]

这棵树暴露出两个事实：

每个节点都是一个合法子集。
进入 [1] 之后，后面只能继续看 2，不能回头再选 1 或生成 [2,1]。

Step 1：先说清楚一个递归层在解决什么

如果当前已经选出一个 path，剩下的问题是：

从某个起点之后的元素里，继续选择若干个元素，扩展当前 path。

这个“某个起点”必须被记下来。否则 [1,2] 和 [2,1] 会从不同路径重复出现。

先写最小骨架。它只保留两个状态：

LeetCode 90：子集 II，从重复分支推出层内去重

Sun, 03 May 2026 14:25:07 +0800

题目要求

输入输出

输入：nums，长度 1 <= nums.length <= 10
元素范围：-10 <= nums[i] <= 10
nums 可能有重复元素
输出：返回所有不重复子集
顺序：结果顺序不限，但同一个值序列的子集只能出现一次

示例

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

这篇只用 Python，从一个能跑但浪费的版本，一步一步过渡到排序 + 层内去重。

从 `[1,2,2]` 的重复分支开始

最小能暴露问题的例子是：

nums = [1,2,2]

如果直接照搬 78. 子集 的模板，搜索树里会出现两条不同分支：

选择下标 1 的 2 -> [2]
选择下标 2 的 2 -> [2]

这两个分支路径不同，但值序列相同，最终答案重复。

所以这题真正新增的问题不是“会不会回溯”，而是：

怎样跳过重复分支，同时保留 [2,2] 这种合法答案？

Step 1：先复用 78 的状态，看看哪里会坏

当前部分答案仍然需要 path；当前层仍然需要 start 控制只能往右选。

先写出 78 的核心版本：

def dfs(start: int) -> None:
 res.append(path.copy())

 for i in range(start, len(nums)):
 path.append(nums[i])
 dfs(i + 1)
 path.pop()

这个版本在 nums 全部互不相同时是正确的。

Hot100：从前序与中序遍历序列构造二叉树（Construct Binary Tree from Preorder and Inorder Traversal）索引分治 ACERS 解析