Think in patterns before you code.

Use this sequence

1. Define what each pointer represents.
2. Move the pointer that can improve the current state.
3. Prove why the discarded range cannot contain a better answer.

Complexity

Usually O(n) time and O(1) extra space.

Watch for

Moving both pointers every time, or using it when the input is not ordered and no invariant exists.

Use this sequence

1. Choose the state needed to describe the current window.
2. Expand the right pointer and update that state.
3. Shrink from the left until the condition is valid again.

Complexity

Usually O(n) time because each element enters and leaves once.

Watch for

Shrinking before recording a valid answer, or forgetting to remove the left element from the window state.

Use this sequence

1. Define the cumulative value at each index.
2. Write the target equation before choosing the map key.
3. Seed the map with the empty prefix when zero-length ranges matter.

Complexity

Usually O(n) time and O(n) space.

Watch for

Using the current prefix before checking the map, or forgetting duplicate prefixes can represent multiple valid starts.

Use this sequence

1. State the search interval and whether its ends are inclusive.
2. Write the predicate that is monotonic.
3. Discard half the search space while preserving the answer region.

Complexity

O(log n) checks, multiplied by the cost of each check.

Watch for

Mixing inclusive and exclusive bounds, or applying binary search without proving monotonicity.

Use this sequence

1. Define the movement speed and the stopping condition.
2. Check null boundaries before advancing the fast pointer twice.
3. Use the meeting point only after proving what it represents.

Complexity

Usually O(n) time and O(1) extra space.

Watch for

Dereferencing fast.next without checking it, or assuming the meeting point is automatically the cycle entrance.

Use this sequence

1. Choose the sort key that makes future decisions local.
2. Compare the next start against the current end.
3. Merge by extending the end, or close the interval and start another.

Complexity

Usually O(n log n) time for sorting and O(n) space for the result.

Watch for

Comparing the next end instead of the next start, or treating touching intervals inconsistently.

Use this sequence

1. Decide whether the stack should increase or decrease.
2. Pop while the new value resolves the top item.
3. Push the current index so a future value can resolve it.

Complexity

Usually O(n) time because every index is pushed and popped at most once.

Watch for

Storing values when indexes are needed for distance, or choosing the wrong strictness for equal values.

Use this sequence

1. Model the neighbors and decide whether the graph is implicit or explicit.
2. Mark nodes at the correct time so they are not processed repeatedly.
3. Track depth, parent, or component state only if the question needs it.

Complexity

O(V + E) time for an explicit graph and O(V) visited space.

Watch for

Marking nodes too late in BFS, forgetting disconnected components, or confusing a tree with a general graph.

Use this sequence

1. Model each dependency as an edge from prerequisite to dependent.
2. Start with nodes whose indegree is zero, or use DFS postorder.
3. If not every node is processed, the graph contains a cycle.

Complexity

O(V + E) time and O(V + E) space for the graph and queues.

Watch for

Reversing the edge direction, or returning an incomplete order without checking for a cycle.

Use this sequence

1. Decide whether the heap should keep the best K or the discarded remainder.
2. Choose a min-heap or max-heap based on which candidate must leave first.
3. State the heap invariant before pushing and popping.

Complexity

Usually O(n log k) time and O(k) extra space for a Top K scan.

Watch for

Using a full sort when K is small, or choosing the wrong heap direction for the result you need.

Use this sequence

1. Define the choices available at the current position.
2. Choose, recurse, and undo the choice in a predictable order.
3. Prune as soon as the partial answer violates a constraint.

Complexity

Often exponential, depending on the number of possible choices and pruning.

Watch for

Forgetting to undo mutable state, reusing an item when reuse is forbidden, or pruning without proving the branch is impossible.

Use this sequence

1. Give every item its own representative initially.
2. Find each root and merge roots when a relationship connects them.
3. Use a repeated connection to detect a cycle or redundant edge.

Complexity

Amortized near O(1) per operation, commonly written as O(alpha(n)).

Watch for

Merging non-roots, omitting path compression, or failing to count components after all unions.

Use this sequence

1. Write the smallest state that describes a subproblem.
2. Define the transition from already-solved states.
3. Set base cases, choose an evaluation order, and reduce space if safe.

Complexity

Usually O(number of states x transitions per state) time.

Watch for

Starting with a memorized table instead of a state definition, or using a state that loses information needed by later choices.