Hot100 on Jeanphilo Blog

LeetCode 49: Group Anagrams, from Scanning Groups to Building a Grouping Key

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

Build a Python solution one step at a time: compare two anagrams, scan group representatives, then derive sorted-string and character-count keys to understand why hash-table grouping works.

LeetCode 152: Maximum Product Subarray, Deriving Two DP States from a Negative Counterexample

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

Start by enumerating nonempty contiguous ranges, then use a negative counterexample to derive maximum and minimum product states and a constant-space Python solution.

LeetCode 279: Perfect Squares, Deriving Dynamic Programming from Remaining Sums

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

Start with a failed largest-square choice, then build recursion, memoization, and iterative dynamic programming to minimize the number of perfect squares.

LeetCode 139: Word Break, Starting from Prefix Reachability

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

Problem

Input and Output

Input: a string s and a list of strings wordDict
Every element in wordDict is an available word, and the same word may be reused
Output: return True if s can be split into one or more dictionary words; otherwise, return False
The split must cover the entire string without skipping or reordering characters

Examples

Input: s = "leetcode", wordDict = ["leet", "code"]
Output: True
Explanation: "leetcode" can be split into "leet" + "code"

Input: s = "applepenapple", wordDict = ["apple", "pen"]
Output: True
Explanation: "apple" + "pen" + "apple"; the same word may be reused

Input: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
Output: False
Explanation: some prefixes can be formed, but the split cannot cover the entire string

Constraints

1 <= s.length <= 300
1 <= wordDict.length <= 1000
1 <= wordDict[i].length <= 20
s and wordDict[i] contain only lowercase English letters
All strings in wordDict are unique

Step 1: Make the Completed Prefix Visible

Start with one concrete question. For s = "leetcode", before deciding whether the whole string can be split, can we record how much of it has already been completed?

LeetCode 213: House Robber II, Splitting the Circle into Two Linear Problems

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

Problem

Input and Output

Input: an integer array nums, where nums[i] is the money in the i-th house.
The houses form a circle. Adjacent houses cannot both be robbed, so houses 0 and n - 1 cannot both be robbed either.
Output: the maximum amount of money that can be robbed without triggering the alarm.
Constraints: 1 <= nums.length <= 100, 0 <= nums[i] <= 1000.

Examples

Input: nums = [2,3,2]
Output: 3
Explanation: Houses 0 and 2 are adjacent around the circle, so they cannot both be robbed; rob the house containing 3.

Input: nums = [1,2,3,1]
Output: 4
Explanation: We can rob indices 0 and 2, or indices 1 and 3.

Input: nums = [1,2,3]
Output: 3

This tutorial uses Python only and starts with the smallest first-last conflict.

LeetCode 322: Coin Change, Deriving Unbounded Knapsack DP from Smaller Amounts

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

Start from a greedy failure and smaller-amount subproblems, then build an unbounded knapsack DP that finds the minimum number of coins.

LeetCode 300: Longest Increasing Subsequence, Deriving Sequence DP from Ending at i

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

Problem

Input and Output

Input: an integer array nums
Output: return the length of the longest strictly increasing subsequence in nums
A subsequence preserves the relative order of the original array, but it does not need to be contiguous, so elements may be skipped
If the selected indices are i_1 < i_2 < ... < i_k, they must also satisfy nums[i_1] < nums[i_2] < ... < nums[i_k]
The subsequence is non-empty, so at least one element must be selected
Constraints: 1 <= nums.length <= 2500, -10^4 <= nums[i] <= 10^4

Examples

Input: nums = [10,9,2,5,3,7,101,18]
Output: 4
Explanation: [2,5,7,101] is a strictly increasing subsequence of length 4; its elements do not need to be contiguous in the original array.

Input: nums = [0,1,0,3,2,3]
Output: 4
Explanation: [0,1,2,3] has length 4; [0,1,3] is also valid, but shorter.

This article uses Python only. We start with the local question “how long can a subsequence ending at each position be?” and gradually turn it into a runnable solution.

LeetCode 416: Partition Equal Subset Sum, from the Half-Sum Target to Backward 0/1 Knapsack

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

Start from the constraints of Partition Equal Subset Sum, build the 0/1 knapsack state step by step, and see why one-dimensional compression requires backward iteration.

LeetCode 155: Min Stack, Keeping the Minimum in Sync With Stack State

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

Start from restoring the previous minimum after pop, build a correct scan baseline, and derive an O(1) Min Stack with synchronized prefix minima.

LeetCode 20: Valid Parentheses, Why Equal Counts Are Not Enough

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

Start from the counterexample ([)], separate equal bracket counts from correct types and closing order, and derive an O(n) stack solution.

LeetCode 394: Decode String by Saving and Restoring Nested Context

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

Start from the context lost by nested encoding, build a correct recursive parser, and make its saved frames explicit with a stack.

LeetCode 84: Which Bar Limits a Contiguous Rectangle?

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

Start from the shortest bar in a contiguous interval, build an interval baseline, then derive a linear monotonic-stack solution that settles maximal widths.

LeetCode 136: Single Number Without Growing Extra Storage

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

Start from a set-based pairing baseline, derive XOR cancellation, and solve LeetCode 136 in O(n) time with O(1) extra space.

LeetCode 338: Counting Bits by Reusing Smaller Results

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

Start by counting every value in 0..n independently, then derive answer[i] = answer[i & (i - 1)] + 1 for an O(n) solution.

LeetCode 739: Daily Temperatures and the First Warmer Day to the Right

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

Start from an O(n^2) right-scan baseline, derive a monotonic stack of unresolved indices, and solve LeetCode 739 in O(n) time.

LeetCode 45: Jump Game II From Reachability to Minimum Jumps

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

Solve LeetCode 45 Jump Game II in Python by upgrading the farthest reach idea from LeetCode 55 into a minimum-jump layer boundary with current_end and farthest.

LeetCode 435: Non-overlapping Intervals From Minimum Removals to Maximum Kept

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

Solve LeetCode 435 in Python by turning minimum removals into maximum kept non-overlapping intervals, then deriving the earliest-ending interval greedy scan.

LeetCode 452: Minimum Number of Arrows From Shared Intersections to Interval Greedy

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

Solve LeetCode 452 in Python by deriving arrow coverage from shared interval intersections, then compressing the baseline into an earliest-ending arrow_pos greedy scan.

LeetCode 121: Best Time to Buy and Sell Stock With Greedy

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

Solve LeetCode 121 in Python by deriving the one-transaction greedy idea from the buy-before-sell constraint, an O(n^2) baseline, and the historical minimum price.

LeetCode 55: Jump Game With Farthest Reach Greedy

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

Solve LeetCode 55 Jump Game in Python by deriving reachability from a zero barrier, a reachable-array baseline, and the farthest reachable range greedy.

LeetCode 200: Number of Islands With Union-Find

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

Solve LeetCode 200 Number of Islands in Python by deriving land-only count, 2D-to-1D ids, Union-Find merges, and exactly when count decreases.

Union-Find Template: Derive find / union / count

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

Derive the Python Union-Find template from a small set-merging task: parent, find, union, count, connected, and path compression.

LeetCode 208: Implement Trie (Prefix Tree) in Python

Thu, 25 Jun 2026 13:58:00 +0800

Solve LeetCode 208 in Python by deriving Trie node fields, children traversal, is_end, insert, search, startsWith, and the exact interface LeetCode expects.

Trie Template Guide: Node Fields, Child Traversal, and Loop Invariants

Thu, 25 Jun 2026 13:58:00 +0800

Build a Python Trie template from first principles: derive children, is_end, insert/search traversal, prefix lookup, and the loop invariants behind each method.

LeetCode 547: Number of Provinces, Turn an Adjacency Matrix into Connected Components

Fri, 29 May 2026 00:00:00 +0800

Turn LeetCode 547 Number of Provinces from direct connections in an adjacency matrix into connected component counting, then derive DFS, BFS, and Union Find solutions step by step.

LeetCode 198: House Robber, Deriving 1D DP from Rob or Skip

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

Problem

Input and Output

Input: an integer array nums
nums[i] is the money in the i-th house
Adjacent houses cannot both be robbed
Output: return the maximum amount of money that can be robbed
Constraints: 1 <= nums.length <= 100, 0 <= nums[i] <= 400

Examples

Input: nums = [1,2,3,1]
Output: 4
Explanation: rob indices 0 and 2, for 1 + 3 = 4

Input: nums = [2,7,9,3,1]
Output: 12
Explanation: rob indices 0, 2, and 4, for 2 + 9 + 1 = 12

This article uses Python only and derives 1D DP from the conflict between two choices.

LeetCode 78: Subsets, Derive the startIndex Backtracking Template

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

Problem Requirement

Input / Output

Input: nums, with 1 <= nums.length <= 10
Value range: -10 <= nums[i] <= 10
All elements in nums are distinct
Output: return all possible subsets of nums
Ordering: the result order does not matter, and subset element order is not the point

Example

Input: nums = [1,2,3]
Output: [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

This tutorial builds one minimal Python solution.

Start From the Search Tree for `[1,2]`

The smallest branching example is:

LeetCode 90: Subsets II, Derive Layer-Level Deduplication

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

Problem Requirement

Input / Output

Input: nums, with 1 <= nums.length <= 10
Value range: -10 <= nums[i] <= 10
nums may contain duplicates
Output: return all unique subsets
Ordering: the result order does not matter, but the same value sequence may appear only once

Example

Input: nums = [1,2,2]
Output: [[],[1],[1,2],[1,2,2],[2],[2,2]]

This tutorial starts with a correct but wasteful version, then derives sorting plus layer-level deduplication.