Core array techniques including in-place updates, prefix/suffix products, and traversal patterns.

Strings are a data structure used for storing sequences of characters and solving problems related to text manipulation, pattern matching, and efficient searching.

Comparison and distribution sorting techniques including selection variants.

Lookup-driven solutions using frequency maps, canonical keys, and grouping strategies.

Linear-time scanning using left-right pointers and sorted constraints.

Fast range queries and subarray counting with cumulative-sum techniques.

Window expansion and contraction for fixed-size and variable-size substring/subarray problems.

Maximum subarray-style dynamic accumulation and reset strategies in linear time.

2D traversal, in-place matrix transforms, and board simulation problems.

Binary-search variants over value space, rotated arrays, and answer space.

Pointer manipulation for linked list traversal, reversal, and partitioning.

LIFO and monotonic-stack patterns for parsing and range queries.

FIFO and monotonic-queue designs for throughput and bounded windows.

Priority-queue methods for streaming order statistics, scheduling, and k-way merge.

Interval merging, insertion, and event-scheduling with greedy ordering.

Recursion is a method where the solution to a problem depends on solutions to smaller instances of the same problem.

Backtracking is a problem-solving algorithm that incrementally builds candidates for solutions and abandons them if they are not valid or lead to a dead end.

Tree traversals and recursive decomposition across structural and path-based problems.

Ordered-set and BST invariants for online interval and range operations.

Prefix-tree indexing for dictionary lookup and incremental matching.

Greedy is a problem-solving algorithm that makes a locally optimal choice at each step, hoping that these local choices lead to a globally optimal solution.

A graph is a collection of nodes (vertices) and edges that connect pairs of nodes. It is used to represent relationships or connections between objects.

Unified dynamic programming roadmap covering knapsack, LCS, matrix-chain patterns, 1-D DP, LIS, grid DP, string DP, tree/graph DP, bitmask DP, digit DP, probability DP, and stock state machines.

Recursive divide-merge strategies for tree and structure construction tasks.

Bitwise operations for low-level optimization, masks, and integer-state tricks.

Number-theory and computational-geometry patterns for integer and point sets.

Design-heavy problems emphasizing API behavior and amortized complexity.

Advanced structures and string algorithms including segment tree and suffix methods.