< Back to notes

Browse 15 notes tagged Blind 75.

#Blind 75

LeetCode 198: House Robber with take-or-skip rolling states

My House Robber solution, why its p1 and p2 updates work, and a clearer O(n)-time, O(1)-extra-space rolling-state version.

LeetCode 70: Climbing stairs from repeated recursion to two rolling states

My Climbing Stairs path from a factorial dead end and exponential recursion to an O(n)-time, O(1)-extra-space rolling-state solution.

LeetCode 152: Why maximum product subarray needs both extremes

My Maximum Product Subarray attempt, the counterexample that broke it, and the final O(n) maximum-and-minimum state solution with an invariant and brute-force checks.

LeetCode 53: Maximum subarray without rescanning every starting point

My O(n²) backward scan and final O(n) solution, with the distinction between endingHere and best, all-negative inputs, loop invariants, and executable tests.

LeetCode 238: Product of array except self with prefix and suffix products

My division-based solution and prefix/suffix version, with zero handling, loop invariants, executable tests, and the difference between extra and output space.

LeetCode 15: 3Sum in TypeScript, Why Skipping Duplicates Does Not Lose Answers

My progression from a global Set that loses answers to two pointers, with an explanation of all three duplicate checks, complexity, and executable assertions.

LeetCode 11: Container With Most Water in TypeScript, Why Move the Shorter Side?

My two-pointer solution, with a brute-force comparison, a proof for discarding the shorter side, and executable checks for O(n) time and O(1) extra space.

LeetCode 125: Valid Palindrome in TypeScript, From Cleaning to In-Place Two Pointers

Keep the submitted cleaned-string solution, then explain an in-place charCodeAt-based two-pointer alternative.

LeetCode 424: Longest Repeating Character Replacement in TypeScript

Keep the submitted frequency-counting sliding-window solution and explain why maxFreq can retain its historical maximum.

LeetCode 3: Longest Substring Without Repeating Characters in TypeScript

Keep an initial reset-and-rescan attempt, explain its O(n²) limit, then use a one-pass Map sliding window.

LeetCode 49: Group Anagrams in TypeScript, From Sorting Keys to Count Signatures

Work through a sorting-based Group Anagrams solution, its repeated-array-copy cost, and a count signature for the fixed lowercase alphabet.

LeetCode 347: Top K Frequent Elements in TypeScript, From Frequency Sorting to Buckets

Start with Map frequency counting and sorting, then remove the O(n log n) sort with frequency buckets.

LeetCode 242: Valid Anagram in TypeScript, From Sorting to Character Counts

Compare sorting, Map-based frequency differences, and a fixed-size count array for Valid Anagram, including correctness, invariants, and complexity.

LeetCode 1: Two Sum in TypeScript with a Map

Replace nested pair checks with a Map of earlier values and indices, then explain complement lookup, the loop invariant, and expected O(n) time.

LeetCode 217: Contains Duplicate in TypeScript with a Set

Compare a Set's size with the array length, or stop early during one scan, while explaining the Set solution's correctness and expected O(n) complexity.

En中文