Dynamic Programming on Jeanphilo Blog

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 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 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:

Hot100: Maximum Subarray (Kadane O(n) ACERS Guide)

Fri, 23 Jan 2026 13:21:02 +0800

Use Kadane's algorithm to compute the maximum subarray sum in O(n). Includes engineering scenarios, pitfalls, and multi-language implementations.