LeetCode

This section collects Hot100 greedy tutorials, focusing on which local state is enough, why it stays valid while scanning, and how that local choice proves the global answer. Recommended Reading Order LeetCode 121: Best Time to Buy and Sell Stock, derive one-transaction greedy from the historical minimum price LeetCode 55: Jump Game, use the farthest reachable range to decide reachability LeetCode 45: Jump Game II, upgrade reachability into minimum jump layers LeetCode 435: Non-overlapping Intervals, turn minimum removals into maximum kept intervals LeetCode 452: Minimum Number of Arrows, derive interval greedy from shared intersections

This section collects Hot100 Union-Find templates and problems, focusing on set representatives, path compression, merge conditions, connectivity checks, and connected component counting.

This section collects Hot100 Trie tutorials, focusing on node fields, child traversal, end markers, and loop invariants.

Problem Requirement You are given n non-negative integers in height. Each integer is the height of a bar with width 1, and all bars are adjacent from left to right. After rain, taller bars on both sides may hold water above shorter bars. Return the total amount of water trapped by the entire elevation map. LeetCode expects this interface: class Solution: def trap(self, height: List[int]) -> int: ... Example 1 Input: height = [0,1,0,2,1,0,1,3,2,1,2,1] Output: 6 Example 2 Input: height = [4,2,0,3,2,5] Output: 9 Constraints n == len(height) 1 <= n <= 2 * 10^4 0 <= height[i] <= 10^5 Step 1: First Answer How Much Water One Position Holds Do not calculate the whole elevation map yet. Focus on one position: ...

Subtitle / Summary Maximum Subarray is the classic 1D DP / greedy template. This ACERS guide explains Kadane’s idea, engineering use cases, and runnable multi-language solutions. Reading time: 10–12 min Tags: Hot100, dynamic programming, greedy SEO keywords: Maximum Subarray, Kadane, dynamic programming, O(n), Hot100 Meta description: Kadane O(n) maximum subarray sum with engineering scenarios and multi-language code. A — Algorithm Problem Restatement Given an integer array nums, find the contiguous subarray with the largest sum (must contain at least one element) and return the sum. ...

Subtitle / Summary A classic event-spacing validation model. This ACERS guide explains the one-pass logic, engineering use cases, and runnable multi-language solutions. Reading time: 10–12 min Tags: array, two pointers, event spacing SEO keywords: LeetCode 1437, event spacing, O(n) Meta description: One-pass validation for minimum spacing between 1s, with engineering use cases and multi-language code. A — Algorithm Problem Restatement Given an integer array nums and integer k, return true if every pair of 1s is at least k apart; otherwise return false. ...

Subtitle / Summary A classic bit-manipulation template: determine if a number is a power of two in O(1). This ACERS guide covers the core insight, practical uses, and runnable multi-language implementations. Reading time: 8–12 min Tags: bit manipulation, binary, math SEO keywords: Power of Two, bit manipulation, binary, O(1), LeetCode 231 Meta description: O(1) power-of-two check using bit tricks, with engineering scenarios and multi-language code. A — Algorithm Problem Restatement Given an integer n, determine whether it is a power of two. Return true if it is; otherwise, return false. ...

Subtitle / Summary A standard fixed-window counting problem. This ACERS guide explains the sliding-window model, engineering use cases, and runnable multi-language solutions. Reading time: 10–12 min Tags: sliding window, string, fixed window SEO keywords: Maximum Number of Vowels, Sliding Window, Fixed Window Meta description: Fixed-window sliding count for maximum vowels with engineering applications. A — Algorithm Problem Restatement Given a string s and an integer k, return the maximum number of vowels in any substring of length k. ...

Problem Requirement You are given an integer array nums and an integer k. A window of exactly k contiguous elements starts at the left edge of nums and moves one position to the right at a time. Return the maximum value from every window, in the same left-to-right order as the windows. The elements in a window must be contiguous. Their original order and positions do not change, and adjacent windows can overlap. Values do not need to be unique and may be negative. ...

Subtitle / Abstract A basic counting problem: use frequency + combinations to drop O(n^2) to O(n). Includes engineering use cases and portable implementations. Reading time: 8-10 minutes Tags: hash-table, counting, array SEO keywords: Good Pairs, hash map, frequency Meta description: Hash counting solution for Good Pairs with complexity and code. Target readers Beginners learning hash tables and counting Engineers who want to map interview patterns to real stats tasks Interview prep for basic counting models Background / Motivation Counting equal pairs is a classic problem. A double loop is O(n^2). With frequency counting, you can solve it in linear time and scale to large data. ...

LeetCode 1: Two Sum Summary Find two indices such that nums[i] + nums[j] = target. Use a hash map for O(n) time. Approach Iterate and store value -> index. For each number x, check if target - x exists. Complexity Time: O(n) Space: O(n) Python reference implementation def two_sum(nums, target): seen = {} for i, x in enumerate(nums): y = target - x if y in seen: return [seen[y], i] seen[x] = i

LeetCode 2300: Successful Pairs of Spells and Potions Summary For each spell, count how many potions make spell * potion >= success. Sort potions and binary search the threshold. Approach Sort potions. For each spell, compute need = ceil(success / spell). Use binary search to find the first potion >= need. Complexity Time: O(n log n) Space: O(1) extra (or O(n) if sorting a copy) Python reference implementation import bisect import math def successful_pairs(spells, potions, success): potions = sorted(potions) n = len(potions) res = [] for s in spells: need = (success + s - 1) // s idx = bisect.bisect_left(potions, need) res.append(n - idx) return res

LeetCode 2379: Minimum Recolors to Get K Consecutive Black Blocks Summary Given a string of ‘B’ and ‘W’, find the minimum recolors to make a substring of length k all black. Approach Use a sliding window of length k and count the number of whites in the window. The minimum whites across all windows is the answer. Complexity Time: O(n) Space: O(1) Python reference implementation def minimum_recolors(blocks, k): whites = sum(1 for c in blocks[:k] if c == 'W') ans = whites for i in range(k, len(blocks)): if blocks[i-k] == 'W': whites -= 1 if blocks[i] == 'W': whites += 1 ans = min(ans, whites) return ans