Multi-Source BFS Explained: The Grid Algorithm Behind Rotting Oranges

Number of Islands Explained: DFS Flood Fill

Flood Fill Explained: The Graph Traversal Behind Grid Problems

Graph Algorithms: Find Connected Components with DFS

DFS Without Recursion: The Explicit Stack Explained

Depth-First Search Finally Makes Sense: Recursion, Backtracking & the Call Stack

BFS Shortest Path: The Distance Array Trick That Makes It Work

BFS Explained: The Ripple Trick Behind Shortest Paths

The Graph Complexity Formula You Need to Know: O(V + E)

You’re Not Solving 3 Problems—It’s One Graph (BFS Explained)

Adjacency Matrix vs Adjacency List: Why 97% of Your Graph Is Wasted

Graph Theory Fundamentals: Paths, Cycles, Components, DAGs & Trees

Graph Theory Explained: The One Idea Behind Every Network

The Dynamic Programming Finale

Dynamic Programming: 10 Patterns That Make Hard Problems Click

The DP Logic Blueprint: A 5-Step Method to Solve Dynamic Programming Problems

The Convex Hull Trick Explained: From DP Formula to 28 Lines of C++

The DP Optimization That Cuts O(n³) to O(n²) — Knuth Optimization

The DP Optimization That Escapes O(KN²) — Divide & Conquer DP Explained

The DP Optimization That Turns O(nk) Into O(n) | Monotonic Double-Ended Queue

The DP Speedup That Turns O(n·k) Into O(n) | Prefix Sums Explained

When DP Loops Back: Solving Cyclic Expected-Value Equations

The Probability DP Trick That Explains Knight Survival

Expected Rolls with Dynamic Programming: The Recurrence Behind Dice Problems

Digit DP Explained: The Dynamic Programming Blueprint for Counting Numbers

Digit DP Without Bugs: The Logic Blueprint for Counting Numbers

Digit DP Explained: Count Huge Numbers in O(Digits × Sum × 10)

Tree DP Without Repeating DFS: The Rerooting DP Blueprint

Tree Diameter Explained: The DFS Logic Blueprint for Longest Paths

Tree DP Explained: The 2-State Trick Behind House Robber III

DP on Trees: The Logic Blueprint for Solving Tree Problems

The Bitmask DP Trick That Turns 3ⁿ into n·2ⁿ | SOS DP

The DP State That Counts Every Path (Bitmask Hamiltonian Paths)

How Bitmask DP Solves the Travelling Salesman Problem(TSP)

The DP Trick That Turns n! Into 2^n · n (Bitmask DP)

The DP Trick That Turns Subsets Into Numbers (Bitmask DP)

The DP + Stack Pattern Behind Maximal Rectangle

The DP Trick That Counts Every Square in a Matrix

The DP Trick That Solves Every Grid Problem | Maximal Square

The DP Pattern That Makes Partition Problems Click

Palindrome Partitioning II Explained: From Recursion to Optimized DP

The DP Pattern That Solves Every Parentheses Problem | Boolean Parenthesization

The Interval DP Trick That Solves Burst Balloons

The DP Pattern That Solves Matrix Chain Multiplication | Interval DP Explained

The DP Pattern That Solves Interval Problems | Minimum Cost to Cut a Stick

Printing the Longest Increasing Subsequence

The DP Pattern That Solves Every Subsequence Problem | Longest Increasing Subsequence

Buy and Sell Stock With Fees

Buy & Sell Stock with Cooldown

Best Time to Buy and Sell Stock IV (K Transactions)

Best Time to Buy and Sell Stock III (2 Transactions)

Best Time to Buy and Sell Stock II

The One-Pass Array Pattern That Explains Stock DP | Best Time to Buy & Sell Stock

Wildcard Matching with Dynamic Programming: The Recurrence That Makes It Click

The DP Pattern That Solves String Transformation Problems | Edit Distance

The DP Trick That Builds the Shortest String From Two Strings

The LCS Trick That Solves Minimum Insertions and Deletions

Minimum Insertions to Make a String Palindrome | Dynamic Programming Explained

The DP Trick That Turns Longest Palindromic Subsequence Into LCS

Longest Common Substring in Dynamic Programming: Clean, Visual Explanation