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

String matching and transformation patterns focused on pointer movement and token handling.

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

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.

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.

Comparison and distribution sorting techniques including selection variants.

State-space exploration via recursion, branching, and pruning.

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

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

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.

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

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

Design-heavy problems emphasizing API behavior and amortized complexity.

Local-choice optimization strategies for globally optimal schedules and costs.

Graph traversal, shortest paths, union-find, topological ordering, and flow-like patterns.

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

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

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

Dynamic programming is a method for solving problems by breaking them down into simpler subproblems and storing the results to avoid redundant calculations.

Advanced dynamic programming patterns including 1-D DP, LIS, Grid DP, String DP, Tree/Graph DP, Bitmask DP, Digit DP, Probability DP, and State Machine DP.

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.

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.

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.

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

A stack is a linear data structure that follows the Last In First Out (LIFO) principle, where the last element added is the first one to be removed.

A queue is a linear data structure that follows the First In First Out (FIFO) principle, where the first element added is the first one to be removed.

An array is a linear data structure that stores elements in contiguous memory locations, allowing direct access using an index.

A linked list is a dynamic linear data structure in which each element (node) contains data and a reference (pointer) to the next node, enabling efficient memory usage and flexible insertions or deletions without shifting elements.