All Algorithm Patterns

Use hash maps for O(1) lookups to solve frequency counting and pairing problems

Precompute cumulative information to answer range queries efficiently

Maintain a window of elements and slide it across the array to find optimal subarrays

Use two pointers moving towards each other or in the same direction to solve array problems efficiently

Use two pointers at different speeds to detect cycles and locate positions

Reverse entire list or sublists in-place without extra arrays

Merge multiple sorted lists, sort a list, or partition around a value

Augment stack to support O(1) getMin/getMax or use a deque for window min/max

Use a deque to maintain window candidates in increasing/decreasing order for O(1) queries per slide

Maintain increasing/decreasing stacks to find next/previous greater or smaller elements efficiently

Use heaps for top-k, k-way merge, scheduling, and streaming medians

Use stacks to parse structures, evaluate expressions, or simulate other data structures

Validate BST, search/insert/delete, and transform BSTs

Find the lowest common ancestor in binary trees and BSTs; use binary lifting on rooted graphs

Level-order traversal patterns: standard, zigzag, right view, and connecting next pointers

Traverse trees using preorder, inorder, or postorder to solve tree-based problems

Prefix tree for fast prefix queries, dictionary word search, and bitwise tricks

Single-source shortest paths on non-negative weighted graphs using a priority queue.

Traverse graphs to find components, islands, detect cycles, and test bipartite

Build MST using Kruskal or Prim algorithms

Dijkstra, 0-1 BFS, Bellman-Ford, and multi-source BFS for path costs

Decompose directed graphs into SCCs using Kosaraju or Tarjan

Order DAG vertices so edges go forward; detect cycles via DFS or Kahn's algorithm

Disjoint Set Union to maintain connectivity, Kruskal MST, and offline queries

Linear DP over arrays or sequences: Kadane, House Robber, Stocks, LIS

DP on grids for counting paths, minimal costs, and shapes

DP over subsets for assignments, TSP-like problems, and state compression

Count numbers with constrained digits using tight/loose states

DP on intervals by choosing the last/first action inside a range

0/1, unbounded, bounded, and multi-dimensional knapsack patterns

DP over sequences for edit distance, LCS, and palindromic subsequences

Sort intervals by start and combine overlapping ones in a single pass.

Solve problems by sorting with custom orders and making locally optimal choices that lead to a global optimum

Explore decision trees with pruning for subsets, permutations, and constraint satisfaction

Compact structure for prefix sums with O(log n) point updates and queries.

Prove a local choice leads to a global optimum; classic interval scheduling, exchange arguments, and Huffman coding

Linear-time substring search via prefix function (lps) to avoid re-scanning.

GCD/LCM, modular arithmetic, and bit manipulation tricks

Segment trees, Fenwick trees, and offline tricks for range updates/queries

Tree over array ranges for fast range queries and updates (sum/min/max).

Linear-time string matching and palindrome tricks: KMP, Z, rolling hash, Manacher

Divide search space by half to find boundaries, handle rotations, or search on the answer

Convert intervals/geometry into events, sort them, and sweep while tracking active state

Implement core data structures and rate-limited services with clear APIs and invariants