Competitive Programming

Transform a subarray-equality condition into repeated prefix-state counting.

Recognize when a two-pointer process has the monotonicity needed to advance safely.

Count pairs or subarrays satisfying a monotone condition with sorting and two pointers.

Combine coordinate compression with sweep-line events over large coordinates.

Compute an aggregate answer by counting each element's contribution.

Use prefix minima or maxima to test whether a partition position is feasible.

Choose among frequency arrays, hashing, sorting, and ordered containers from the required operations.

Reformulate an optimization problem as a yes-or-no feasibility predicate.

Prove that a feasibility predicate is monotone before applying binary search.

Derive valid search bounds from extremal feasible and infeasible cases.

Design a greedy feasibility check for binary search on the answer.

Detect when answer search is invalid because the proposed predicate is not monotone.

Binary-search a real-valued answer using a justified iteration count or error tolerance.

Derive a candidate greedy rule from an extremal item or the earliest unresolved position.

Prove a greedy choice with an exchange argument.

Prove a greedy process with a stays-ahead argument.

Use sorting and a priority queue for a deadline or resource-allocation problem.

Construct a valid sequence while maintaining a stated invariant.

Derive impossibility conditions from parity, conservation, or extremal arguments.

Design adversarial edge cases for a constructive algorithm with multiple valid outputs.

Transform divisor or multiple relationships into harmonic-series loops.

Use gcd and lcm identities to count values satisfying combined divisibility constraints.

Precompute factorials and inverse factorials for repeated binomial-coefficient queries.

Apply inclusion–exclusion to count objects satisfying overlapping divisibility conditions.

Compute an aggregate over pairwise AND, OR, or XOR by counting independent bit contributions.

Enumerate all submasks of every mask within the correct total complexity bound.

Apply Euler's totient function to count residues coprime to a given integer.

Translate state transitions into an implicit graph without materializing every edge.

Choose among BFS, 0–1 BFS, and Dijkstra's algorithm for the given edge-cost structure.

Augment a shortest-path state with limited resources or modes while preserving complexity bounds.

Formulate a dependency problem as dynamic programming over a topological ordering.

Process offline connectivity queries with disjoint-set union.

Decompose a directed graph into strongly connected components.

Build and use the condensation DAG of a strongly connected component decomposition.

Combine an Euler tour with a range-query structure for subtree updates or queries.

Build and query a binary-lifting table for lowest common ancestors.

Express a tree-path sum using root-prefix sums and an LCA correction.

Define a subtree dynamic-programming state with sufficient information for its parent.

Derive a rerooting transition from a solved parent state to a child state.

Use tree diameter or tree centers to solve an extremal-distance problem.

Choose among sparse tables, Fenwick trees, segment trees, and offline processing from the operation set.

Build a sparse table for an idempotent static range-query operation.

Convert range-add and range-sum operations into paired Fenwick-tree updates.

Define an associative segment-tree merge operation for a custom query.

Compose and propagate multiple lazy segment-tree update tags in the correct order.

Sort queries or events offline without changing the required output order.

Define a minimal dynamic-programming state that retains all information needed by future choices.

Derive transitions by conditioning on the last decision or predecessor state.

Identify the dependency order required to evaluate a nontrivial recurrence.

Represent unreachable states without introducing false solutions or overflow.

Reduce dynamic-programming memory when dependencies permit rolling storage.

Formulate an interval dynamic program over increasing segment lengths.

Formulate a bitmask dynamic program for assignments or visited subsets.

Optimize a quadratic transition using precomputed prefix or suffix optima.

Use prefix-function values to locate occurrences and derive border chains.

Use Z-function values to compare prefixes with many suffixes.

Derive candidate periods and repetition structure from border information.

Implement polynomial rolling hashing for constant-time substring-hash queries.

Control collision risk with double hashing or deterministic verification.

Accelerate repeated substring-equality checks inside dynamic-programming transitions.

Solve a maximum-XOR or minimum-XOR query using a binary trie.

Choose among prefix-function, Z-function, hashing, and trie methods from the comparison pattern required.

Use a monotonic stack to derive nearest-boundary intervals for contribution counting.

Use a monotonic deque to maintain a sliding-window optimum in linear time.

Apply meet-in-the-middle when full subset enumeration is too large.

Decompose a functional graph into cycles and attached in-trees.

Use square-root decomposition to balance preprocessing and per-query work.

Use Mo's ordering to maintain an add-remove answer across offline range queries.

Apply small-to-large merging to combine subtree frequency information.

Combine binary search on the answer with a dynamic-programming feasibility check.

Rank contest problems during an initial statement scan using expected solve time and confidence.

Write a concise solution sketch containing the key observation, algorithm, complexity, and proof idea before coding.

Set and apply a time-boxed rule for abandoning an unproductive approach.

Debug a wrong answer by testing one explicit failure hypothesis at a time.

Run a fixed pre-submission checklist for overflow, indexing, initialization, and edge cases.

Classify a failed problem as a knowledge, observation, proof, implementation, or time-management gap.

Upsolve one missed problem using progressively stronger hints while recording the missing insight.

Complete a 45-minute virtual-contest sprint while following precommitted process goals instead of focusing on possible rating change.