Loading practice workspace…
Store membership, frequencies or canonical signatures for direct lookup.
Find a matching earlier value by querying its complement before inserting the current value.
Establishes the lookup-before-update invariant reused in pair searches and prefix-state counting.
Compare character multiplicities through a normalized frequency representation.
Provides a small, direct introduction to multiset invariants before grouped signatures and frequency windows.
Group inputs by a canonical key that preserves the relevant equivalence relation.
Turns a pairwise anagram check into scalable grouping and teaches choosing a stable hashable signature.
Expand consecutive runs only from values whose predecessor is absent.
Teaches how a start-boundary invariant avoids repeatedly exploring the same sequence.
Accumulate ranges or complementary state; include prefix frequency maps for signed values.
Combine summaries of the values strictly before and after each position.
Introduces bidirectional aggregate decomposition without depending on division or special-case zero assumptions.
Count earlier prefix sums that differ from the current prefix by the target.
Covers signed-subarray counting that cannot generally be solved by a monotone sliding-window rule.
Coordinate two positions with an invariant; includes opposite ends and read/write movement.
Move inward while comparing only characters relevant to the palindrome rule.
Provides a clear first example of coordinated pointers and input normalization without extra storage.
Fix one sorted value and search the remaining suffix with converging pointers.
Combines ordered pair search with output deduplication, a meaningful step beyond a hash-based single pair.
Discard the endpoint that cannot improve the result unless its limiting height changes.
Requires a correctness argument for pointer movement rather than merely following a sorted target comparison.
Maintain a pointer gap so the trailing pointer identifies a tail-relative removal point.
Adds fixed-distance coordination and boundary-safe deletion rather than repeating fast/slow cycle detection.
Expand around every relevant center to find the longest contiguous palindrome.
Adds center-outward search and the odd/even distinction without requiring the core to introduce full interval DP.
Maintain a contiguous interval incrementally; distinguish fixed width and monotone feasibility.
Expand a character window and restore uniqueness when a duplicate appears.
Introduces the variable-window invariant used by many substring and subarray optimizations.
Maintain character-count agreement as a fixed-size window advances.
Adds fixed-size multiset maintenance, which differs from the uniqueness constraint in the first window problem.
Maintain a window whose length and dominant-character count respect a replacement budget.
Adds a quantitative validity condition and a useful opportunity to explain exact versus safely stale summary state.
Shrink each satisfying window while preserving the required character multiplicities.
Reverses the usual maximize-valid-window objective and tests precise count transitions as a window capstone.
Halve an ordered domain or monotone decision space; state boundary semantics explicitly.
Preserve a search interval that contains every still-possible target position.
Provides the boundary discipline needed before rotated-array and answer-space variations.
Map a globally ordered matrix to an implicit one-dimensional search space.
Reinforces binary search while teaching how a representation change exposes an existing order.
Identify the sorted portion of a rotated array before deciding which candidates to discard.
Introduces conditional search-space structure beyond a globally sorted array.
Locate the boundary containing the minimum by comparing against a stable endpoint.
Separates boundary discovery from target lookup; useful reinforcement, though less unique than answer-space search.
Search candidate rates using a feasibility predicate whose truth changes monotonically.
Ensures the core teaches binary search as optimization over answers, not only lookup in stored values.
Change next/previous links without losing nodes or violating topology.
Reverse links while retaining a reference to the unprocessed suffix.
Establishes the central pointer-update discipline used in more complex list transformations.
Build an ordered list by repeatedly attaching the smaller current stream head.
Introduces sentinel-based construction and sorted-stream merging before the k-way version.
Use unequal pointer speeds or an offset to expose middle, cycle or alignment information.
Detect repeated traversal state by advancing two pointers at different speeds.
Covers constant-space cycle detection, an invariant distinct from ordinary forward pointer rewiring.
Preserve nested or deferred state during expression evaluation, matching and simulation.
Use the most recent unmatched opener to validate each closing delimiter.
Establishes stack discipline through a simple but general nested-structure invariant.
Reduce postfix operators by consuming operands in the correct order.
Extends stack use from matching syntax to executable expression state and noncommutative operand handling.
Keep ordered unresolved candidates; remove elements once their answers or dominance are known.
Keep unresolved indices in monotone order and resolve them when a greater value arrives.
Provides the basic pending-query template behind nearest-greater and many range-boundary problems.
Maintain ordered candidates with expiry at both ends for moving-range queries.
Maintain undominated candidate maxima while expiring indices outside the window.
Adds time-based expiry to monotonic candidates and covers the major deque pattern missing from ordinary window questions.
Aggregate or carry state through recursive or explicit-stack depth-first traversal.
Return a subtree summary that a parent can combine into its own result.
Introduces the recursive tree contract needed by diameter, ancestry, and weighted-path problems.
Return the best downward arm while separately evaluating a path through each node.
Introduces the return-value versus global-answer distinction needed for more complex tree aggregation.
Combine evidence from child subtrees to find where two target paths meet.
Adds a compositional ancestry query that does not depend on BST ordering.
Traverse level frontiers; capture distance, width and next-level relationships.
Process one queue frontier at a time to collect nodes by depth.
Adds level-oriented traversal as a distinct tool from recursive subtree processing.
Exploit global key ordering for search, validation, updates or ordered iteration.
Propagate valid value bounds from every relevant ancestor to each descendant.
Prevents the common mistake of validating only parent-child comparisons and establishes global BST invariants.
Exploit inorder traversal to visit BST values in rank order.
Turns a structural ordering guarantee into selection and introduces controlled early termination.
Keep only an extremal candidate set; includes top-k and streaming selection.
Maintain a bounded heap containing the best candidates for an order statistic.
Introduces top-k heap invariants with a clear quickselect alternative for later tradeoff discussion.
Aggregate values into frequencies before selecting the highest-ranked keys.
Combines counting with selection and supports a useful heap-versus-bucket comparison.
Track the next candidate from each ordered source with a bounded frontier.
Choose the smallest active head and replace it from the same sorted stream.
Generalizes two-list merge to many streams and exposes a reusable heap-frontier pattern.
Partition a changing collection around an order statistic and rebalance it.
Maintain two ordered halves whose sizes and boundary values make the median available.
Adds the two-heaps archetype and operation-by-operation rebalancing, not merely another top-k query.
Explore choices with reversible state, validity checks and sound pruning.
Explore choices that include or exclude each input while recording valid partial selections.
Provides the simplest explicit choose-explore-undo model for combinatorial search.
Fill positions by choosing among unused values and restoring availability after recursion.
Changes the search from unordered selection to ordered arrangements and makes used-state tracking explicit.
Reuse eligible choices while restricting order so equivalent combinations are not repeated.
Adds reusable decisions, target-based pruning, and structural duplicate prevention.
Search neighboring cells while reserving and restoring cells used by the current path.
Transfers backtracking from abstract selections to spatial constraints and path-local visited state.
Represent shared prefixes explicitly; combine traversal with search or generation.
Represent shared prefixes explicitly while distinguishing complete words from intermediate nodes.
Introduces the trie structure needed for prefix queries and later dictionary-search combinations.
Explore reachability/components with visited state; grids are implicit graphs.
Start a traversal from each unvisited land component and mark all reachable cells.
Establishes component discovery and clarifies global visited state versus path-local backtracking state.
Memoize copied nodes before exploring edges so cycles preserve reference identity.
Extends the earlier arbitrary-pointer copy to general cyclic connectivity and adjacency preservation.
Explore equal-cost edges in layers, potentially from multiple sources.
Seed the queue with every initial source and expand all sources in synchronized layers.
Introduces multi-source shortest unweighted propagation and explicit unreachable-state handling.
Explore valid word transformations by distance without explicitly storing every possible edge.
Adds implicit state-graph construction and offers bidirectional search as a later optimization discussion.
Order a dependency DAG and detect when no legal ordering exists.
Process currently unblocked nodes and detect whether a dependency cycle leaves work unprocessed.
Covers directed dependency structure, which cannot be handled by undirected component logic alone.
Maintain equivalence/connectivity as edges or relations are added.
Track connected components as edges arrive and identify an edge joining already-connected endpoints.
Provides a compact disjoint-set representative with a clear contrast to repeated traversal.
Relax path costs with an algorithm matching weight and constraint semantics.
Relax weighted edges through a minimum-distance frontier and distinguish finalized progress from stale entries.
Ensures the core includes weighted shortest paths instead of treating every shortest-path task as ordinary BFS.
Sort interval boundaries and track merging, overlap or resource reuse.
Sort ranges and extend the current merged boundary while overlaps continue.
Establishes interval-order reasoning and a reusable one-frontier sweep.
Use the existing order to copy unaffected ranges and merge only the insertion region.
Reinforces exploiting a stronger input contract rather than sorting and recomputing everything.
Commit locally optimal choices under an exchange or stays-ahead argument.
Track the best eligible earlier value while evaluating each later sale.
Introduces a compact one-pass state and the importance of respecting decision order.
Retain compatible intervals using a choice that leaves the most room for future intervals.
Adds scheduling optimization and an exchange-style correctness argument, distinct from simply merging overlap.
Maintain the farthest position reachable while scanning only reachable starting points.
Provides a compact greedy reachability invariant and a proof-oriented alternative to exhaustive transition search.
Complete one reachable layer at a time to minimize the number of jumps.
Turns the reachability decision into an optimization by connecting greedy frontiers with BFS layer counting.
Summarize solved prefixes or scalar states with a recurrence and correct base cases.
Count ways to reach a state by combining the relevant earlier states.
Introduces recurrence design, base cases, and rolling-state optimization with little modeling overhead.
Compare taking the current value with skipping it while respecting the exclusion constraint.
Adds an optimization decision recurrence distinct from merely counting paths.
Decide whether the best subarray ending here should restart or extend the previous state.
Introduces ending-at-position state design and the distinction between local state and global optimum.
Combine earlier grid/cell states using allowed movements and boundary initialization.
Combine reachable predecessor counts in a grid while handling boundary cells consistently.
Introduces two-dimensional state topology with a simple recurrence before more complex paired-sequence DP.
Choose items or reusable amounts under capacity constraints; distinguish feasibility, counting and optimum.
Optimize a target state over reusable choices while preserving unreachable-state semantics.
Introduces unbounded knapsack and the difference between counting and minimizing decisions.
Determine attainable sums while preventing the current item from being reused in the same transition layer.
Makes the crucial 0/1-versus-unbounded distinction explicit rather than treating all knapsack loops as interchangeable.
Optimize or count relationships between sequences, subsequences or ordered predecessors.
Build the best subsequence ending at each position and compare it with the ordered-tails optimization.
Provides a clear sequence-DP baseline plus a non-obvious binary-search optimization for the same objective.
Align two prefixes by distinguishing matched endings from skipping either side.
Covers two-sequence state design, which is not represented by one-sequence LIS or plain grid paths.
Mark a prefix reachable when some earlier reachable split is followed by a dictionary word.
Adds segmentation DP and combines state transitions with an external membership structure.
Memoize acyclic dependencies or combine structural child states.
Separate the best extendable branch from the best complete path while handling negative contributions.
Extends the earlier diameter invariant to weighted optimization without requiring an unrelated tree template.
Exploit bit identities, masks, parity and fixed-width representations.
Use a cancellative bitwise invariant to isolate an unpaired value.
Provides a compact transferable bit invariant rather than a broad collection of isolated bit tricks.
Count set bits by repeatedly removing one set bit from the representation.
Adds concrete binary-state manipulation and representation reasoning beyond XOR cancellation.
Visit, transform or simulate indexed cells while preserving boundary/state invariants.
Transform matrix coordinates in place while preserving values that have not yet moved.
Covers coordinate mapping and update-order reasoning not supplied by grid traversal problems.
Traverse successive matrix boundaries while avoiding repeated cells when a dimension collapses.
Adds bounded simulation and edge-case discipline distinct from the coordinate transformation in rotation.
Reuse index positions or signs to record bounded-domain membership.
Store update decisions inside the matrix without destroying the information needed to finish marking.
Introduces in-place metadata encoding and a two-phase read-then-apply strategy.
Solve smaller parts and combine, or reduce the exponent/problem size multiplicatively.
Use complementary traversal information to partition and reconstruct each subtree.
Tests how independent views determine structure and how index maps avoid repeated scanning.
Reduce exponent work logarithmically while handling the sign and numeric limits of the exponent.
Ensures the core includes a clean mathematical divide-and-conquer example beyond search and tree structure.
Combine primitive structures so an operation contract remains efficient and correct.
Preserve enough minimum history to answer aggregate queries after every push and pop.
Introduces maintaining an auxiliary invariant across an API rather than computing one isolated answer.
Create copied nodes while preserving arbitrary reference relationships by original identity.
Teaches structural copying and identity mapping, providing a useful bridge from lists to graph cloning.
Combine indexed lookup with a mutable recency order while keeping both representations consistent.
Exercises coordinated invariants across two structures and a stateful operation sequence.