Jeanphilo Blog

LeetCode 1282: Group the People, from Capacity Buckets to Emitting Full Groups

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

Distinguish person IDs from group sizes, collect and split capacity buckets, then build a one-pass Python solution that emits full groups without mutating saved results.

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 609: Find Duplicate File in System, from Parsing Records to Grouping by Content

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

Solve LeetCode 609 step by step: parse directory descriptions, build a correct pairwise baseline, group by content, and account for path construction and real-filesystem limitations.

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 74: Search a 2D Matrix

Thu, 13 Aug 2026 00:00:00 +0000

You are given an m x n integer matrix matrix and an integer target. Return True if target is in the matrix; otherwise, return False.

The matrix satisfies two conditions:

Every row is sorted in non-decreasing order.
The first integer of each row is strictly greater than the last integer of the previous row.

The required time complexity is O(log(m * n)).

For example, consider this matrix:

1 3 5 7
10 11 16 20
23 30 34 60

When target = 3, return True.
When target = 13, return False.

The constraints are:

LeetCode 153: Find Minimum in Rotated Sorted Array

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

Start from a linear scan, derive a closed minimum-containing interval, and return the rotated array's minimum in O(log n) time and O(1) auxiliary space.

LeetCode 33: Search in Rotated Sorted Array

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

Derive sorted-half recognition and target-range tests from a linear baseline to search a rotated array in O(log n) time and O(1) auxiliary space.

LeetCode 503: Where Does the Right Side End in a Circular Array?

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

Start from the exact circular next-greater query, build a verifiable scan, then derive a linear monotonic-stack solution that pushes each original index once.

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 191: Number of 1 Bits and How to Skip Irrelevant Zeros

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

Start from a right-shift baseline, derive how n & (n - 1) clears one lowest set bit, and prove LeetCode 191 with a loop invariant.

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.

LeetCode 684: Redundant Connection With Union-Find

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

Solve LeetCode 684 Redundant Connection in Python by deriving the already-connected edge pressure, 1-indexed parent array, bool-returning union, and ordered edge scan.

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 70: Climbing Stairs, Deriving 1D DP from dp[i]

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

Problem

Input and Output

Input: an integer n
Meaning: climb to the top of the n-step staircase
Each move can climb 1 or 2 steps
Output: return the number of distinct ways to reach the top
Constraints: 1 <= n <= 45

Examples

Input: n = 2
Output: 2
Explanation: 1+1, 2

Input: n = 3
Output: 3
Explanation: 1+1+1, 1+2, 2+1

This article uses Python only and derives the final solution step by step from the meaning of dp[i].

LeetCode 746: Min Cost Climbing Stairs, Deriving DP from the Top Position

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

Problem

Input and Output

Input: an integer array cost
cost[i] is the cost of stepping on stair i
Each move can climb 1 or 2 steps
You may start from index 0 or index 1
Output: return the minimum cost to reach the top
Constraints: 2 <= cost.length <= 1000, 0 <= cost[i] <= 999

Examples

Input: cost = [10,15,20]
Output: 15
Explanation: start from index 1, pay 15, then reach the top directly

Input: cost = [1,100,1,1,1,100,1,1,100,1]
Output: 6

Start from the Top Position of [10,15,20]

Look at the small example:

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.