Concepts48

πŸ—‚οΈData StructureIntermediate

Rollback DSU

Rollback DSU (Disjoint Set Union with undo) lets you union sets and later revert to any previous state in LIFO order.

#rollback dsu#dsu with undo#union find+11
πŸ—‚οΈData StructureIntermediate

DSU with Weighted Edges

A DSU with weighted edges (also called a potential or difference-constraint union-find) maintains relative values between elements while still supporting near-constant-time merges and finds.

#dsu#union-find#weighted edges+11
πŸ—‚οΈData StructureIntermediate

Disjoint Set Union (Union-Find)

Disjoint Set Union (Union-Find) maintains a collection of non-overlapping sets and supports fast merging and membership queries.

#disjoint set union#union-find#path compression+11
πŸ—‚οΈData StructureIntermediate

Policy-Based Data Structures

Policy-Based Data Structures (PBDS) are GNU C++ extensions that add advanced containers like an order-statistics tree, a fast hash table, and ropes for efficient string edits.

#policy based data structures#pbds#ordered set+12
πŸ—‚οΈData StructureIntermediate

Hash Table

A hash table stores key–value pairs and finds items in expected O(1) time using a hash function to map keys to buckets.

#hash table#unordered_map#unordered_set+12
πŸ—‚οΈData StructureIntermediate

Ordered Set and Map

std::set and std::map store elements in sorted order using a balanced binary search tree (typically a Red-Black Tree).

#ordered set#ordered map#std::set+12
πŸ—‚οΈData StructureIntermediate

Priority Queue (Heap)

A priority queue returns the highest-priority element first and is efficiently implemented by a binary heap.

#priority queue#binary heap#min-heap+11
πŸ—‚οΈData StructureIntermediate

Queue and Deque

A queue is a First-In-First-Out (FIFO) line where you add at the back and remove from the front in O(1) time.

#queue#deque#fifo+12
πŸ—‚οΈData StructureIntermediate

Monotonic Deque

A monotonic deque is a double-ended queue that keeps elements in increasing or decreasing order so that the front always holds the current optimum (min or max).

#monotonic deque#sliding window maximum#sliding window minimum+12
πŸ—‚οΈData StructureIntermediate

Stack

A stack is a Last-In, First-Out (LIFO) data structure where push, pop, and top operations run in O(1) time.

#stack#lifo#push+12
πŸ—‚οΈData StructureBeginner

Array and Vector

Arrays and vectors store elements contiguously, giving O(1) random access via index.

#std::vector#dynamic array#reserve+12
πŸ—‚οΈData StructureIntermediate

Monotonic Stack

A monotonic stack is a stack that keeps its elements in increasing or decreasing order to answer range queries in linear time.

#monotonic stack#next greater element#previous smaller element+12