Blog

Deep dives into algorithms, data structures, and engineering problems — with explanations, visualizations, and code.

25 articles across 10 topics

Stacks & Queues

LIFO and FIFO patterns — monotonic structures for range queries and sliding window problems.

Monotonic Stack

Next greater element, stock span, and largest rectangle in histogram

Monotonic Queue & Deque

Sliding window maximum and bounded subarray problems

Data Structure Internals

How foundational data structures actually work under the hood — hashing, heaps, and union-find.

HashMap Internals

Collision handling, load factors, rehashing, and open addressing

Disjoint Set Union (Union-Find)

Path compression, union by rank, and connected components

Heap Internals (Priority Queue)

Binary heap operations, heapify, and k-way merging

Tree Data Structures

Tries, balanced BSTs, and segment trees for efficient querying and prefix operations.

Trie (Prefix Tree + Bitwise Trie)

Prefix matching, autocomplete, and XOR optimization

AVL Tree & Binary Indexed Tree

Self-balancing BSTs and prefix sum queries

Segment Tree (with Lazy Propagation)

Range queries, point updates, and deferred propagation

Fundamental Algorithms

The building blocks — sorting, searching, and graph traversals that everything else builds on.

All Sorting & Searching Algorithms

Comparison sorts, counting sort, and binary search variants

BFS vs DFS — When to Use Which

Level-order vs depth-first traversal with decision framework

Tree Traversals (Inorder, Preorder, Postorder, Level Order)

Iterative and recursive approaches with Morris traversal

Graph Algorithms

Shortest paths, spanning trees, flow networks, and connectivity — the heavy hitters of competitive programming.

Shortest Path (Dijkstra, Bellman-Ford, Floyd-Warshall)

Single-source and all-pairs shortest path algorithms

Minimum Spanning Tree (Kruskal, Prim)

Greedy algorithms for minimum cost connectivity

Strongly Connected Components (Tarjan, Kosaraju, 2-SAT)

DFS-based decomposition and boolean satisfiability

Articulation Points & Bridges (Cut Vertices, Biconnected Components)

Finding critical nodes and edges in undirected graphs

Network Flow (Max-Flow, Min-Cut, Bipartite Matching)

Ford-Fulkerson, Dinic's algorithm, and Hungarian method

Euler & Hamilton Paths (Hierholzer, Held-Karp)

Circuit finding and TSP via bitmask DP

String Algorithms

Pattern matching and string processing with linear-time guarantees.

KMP & Z Algorithm

Linear-time pattern matching and failure function construction

Problem-Solving Paradigms

DP, recursion, and backtracking — the thinking frameworks behind hard problems.

Dynamic Programming (Bottom-Up)

State design, transitions, and space optimization techniques

Recursion & Backtracking

Pruning strategies, state space trees, and constraint satisfaction

Interval Techniques

Sorting + greedy logic for merge, insert, overlap, and scheduling problems.

Intervals (Merge, Scheduling, Line Sweep)

Merge overlapping, insert, intersection, interval scheduling, and meeting rooms

Encoding & Transformation

Converting data structures to flat representations and back — serialization for trees, strings, and arrays.

Serialization & Deserialization

Encoding and decoding strings, arrays, binary trees, BSTs, and N-ary trees

Theory & Mathematics

Complexity theory, combinatorics, number theory, and the math that powers algorithms.

NP-Complete Problems (TSP, Knapsack, etc.)

Polynomial reductions, approximation, and hardness proofs

Combinatorics & Probability

Counting principles, expected value, and generating functions

Discrete Math (Number Theory, Bit Manipulation)

Modular arithmetic, sieve of Eratosthenes, and bit tricks