LeetCode on Chen Kai Blog

LeetCode Patterns: Greedy Algorithms

Tue, 13 Sep 2022 09:00:00 +0000

Greedy is the algorithm paradigm that feels too good to be true: at every step, take the choice that looks best right now, never look back, and somehow end up at the global optimum. When it works, the code is almost embarrassingly short. When it doesn’t, it produces confidently wrong answers — which is why the real skill is not writing greedy code, but recognising when greedy is allowed.

This article walks through the structural reason greedy is correct on some problems and broken on others, then applies that lens to seven LeetCode classics: Jump Game, Jump Game II, Gas Station, Best Time to Buy and Sell Stock II, Non-overlapping Intervals, Task Scheduler, and Partition Labels.

LeetCode Patterns: Stack and Queue

Mon, 29 Aug 2022 09:00:00 +0000

Stacks and queues look unassuming next to graphs or DP, but they sit underneath an astonishing fraction of interview problems. The reason is simple: most algorithmic questions are really questions about order of access. Stacks give you LIFO (last in, first out); queues give you FIFO (first in, first out); and once you add the variants — monotonic stack, deque, priority queue — you have efficient answers for bracket matching, next-greater-element, sliding-window extrema, top-K, BFS, and a long tail of “implement X using Y” puzzles.

LeetCode Patterns: Backtracking Algorithms

Sun, 14 Aug 2022 09:00:00 +0000

Backtracking is the algorithm you reach for whenever a problem asks you to enumerate something — every permutation, every subset, every legal board, every path through a grid. It is brute force with a brain: you build a candidate solution one decision at a time, abandon it the moment a constraint says “this cannot work”, and undo your last move so the next branch sees a clean slate. The whole technique fits in three lines:

LeetCode Patterns: Dynamic Programming Basics

Sat, 30 Jul 2022 09:00:00 +0000

Dynamic programming has a reputation for being the algorithm topic that separates “competent coder” from “interview wizard”. A lot of that reputation is unearned. DP is not a bag of clever tricks; it is a single recipe applied to problems that happen to have repeated subproblems. If you can answer three questions cleanly, you can solve almost any DP problem on LeetCode:

What does dp[i] actually mean? (state)
How do I build dp[i] from smaller answers? (transition)
What are the smallest answers I already know? (base case)

This article walks through that recipe, then applies it to the seven problems every DP study list eventually converges on: Climbing Stairs, House Robber, Coin Change, Longest Increasing Subsequence, 0/1 Knapsack, Longest Common Subsequence, and Edit Distance.

LeetCode Patterns: Binary Tree Traversal and Construction

Fri, 15 Jul 2022 09:00:00 +0000

A binary tree problem is rarely about the tree. It is about the order in which you touch nodes and what you remember from the children before deciding what to do at the parent. Once those two ideas click, the four traversal orders, the iterative rewrites, the construction problems, and even classics like Validate BST and Maximum Depth all collapse into a handful of variations on the same recipe. This article builds that recipe end to end.

LeetCode Patterns: Binary Search

Thu, 30 Jun 2022 09:00:00 +0000

Binary search is the algorithm everyone thinks they understand until they have to write it under interview pressure. The idea is one sentence — halve the search space at every step — but the implementation is a minefield of off-by-one errors, infinite loops, and subtly wrong return values. The goal of this article is not to give you yet another recitation of the standard template; it is to give you a mental model that explains why each template looks the way it does, and a small toolkit (three templates plus the answer-space pattern) that covers the vast majority of LeetCode problems.

LeetCode Patterns: Sliding Window Technique

Wed, 15 Jun 2022 09:00:00 +0000

If you have ever caught yourself writing a double for loop to inspect every contiguous subarray, sliding window is probably the optimisation you are missing. It turns an $O(nk)$ or $O(n^2)$ scan into a single linear pass by reusing the work it has already done. This article walks through the technique from first principles, then drills four canonical LeetCode problems plus a monotonic-deque variant.

1. The Idea in One Picture

A sliding window is a contiguous range [left, right] over an array or string. Instead of recomputing everything when the range moves, we add the element entering on the right and remove the element leaving on the left. Each element is touched at most twice, so the total cost is $O(n)$.

LeetCode Patterns: Linked List Operations

Tue, 31 May 2022 09:00:00 +0000

A linked list is the simplest data structure that forces you to think in pointers. Arrays let you index in $O(1)$ and forget about layout; linked lists hand you a head pointer and ask, “now what?” That single shift — from indices to references — is what makes linked-list problems so common in interviews. They are short to state, brutal to get right, and reward exactly the habits good engineers build: drawing pictures, naming pointers, and never dereferencing without checking for None.

LeetCode Patterns: Two Pointers

Mon, 16 May 2022 09:00:00 +0000

Hash tables buy you speed by spending memory. Two pointers is the opposite trade: spend a little structural assumption — the array is sorted, the list might have a cycle, the answer lives in a contiguous window — and you get $O(n)$ time with $O(1)$ extra space. The pattern looks trivial in code (two indices and a while loop) but it has more failure modes than any other beginner technique: off-by-one indices, infinite loops, missed duplicates, wrong pointer moved on tie. The cure is to think in invariants rather than in moves.

LeetCode Patterns: Hash Tables

Sun, 01 May 2022 09:00:00 +0000

A hash table is the cheapest superpower in your toolbox. You spend a constant amount of memory per stored item, and in return every “is x in here?” question costs roughly one CPU instruction. Whole families of O(n²) brute-force solutions collapse into a single O(n) pass once you reach for one.

This article is the first installment of the LeetCode Patterns series. We will build hash table intuition from scratch, then work through four template problems — Two Sum, Group Anagrams, Longest Substring Without Repeating Characters, and Top K Frequent Elements — each illustrating a reusable pattern you will see again and again on harder problems.