Which pattern fits this problem?

Graphs

• Breadth-first search (BFS)Explore in rings from the start; the first time you reach a node is the fewest steps.
• Dijkstra's shortest pathBFS with a heap: always expand the cheapest path found so far.
• Depth-first search (DFS)Go as deep as you can, mark what you've visited, and come back.
• Topological sortTake what has no remaining prerequisites, remove it, repeat.
• Union-Find (disjoint sets)Keep each group's leader; joining two groups points one leader at the other.

Recursion

• BacktrackingChoose, explore, un-choose: build every candidate and drop dead ends early.

Trees

• Tree BFS (level order)A queue, one level at a time.
• Binary search tree orderLeft is smaller, right is bigger: an in-order walk is sorted, and you can go one way at each node.
• Tree DFS (recursion)Ask each child for its answer, then combine them at the parent.

Linked lists

• Fast and slow pointersOne pointer moves twice as fast; where they meet tells you the middle or a cycle.
• In-place list reversalprev, curr, next: point each node back, one at a time.
• Dummy head and mergeStart a new list behind a dummy node and attach the right node each step.

Heaps

• Heap (priority queue)Keep the smallest (or largest) on top; push and pop in O(log n).

Design

• Hash map + doubly linked listThe map finds a node in O(1); the list keeps them in order of use.
• Trie (prefix tree)One node per letter; words that share a prefix share a path.

Stacks

• StackThe last thing opened is the first thing closed.
• Monotonic stackKeep a stack in order; each new item pops everything it beats, and that's their answer.

Greedy

• Sort, then merge intervalsSort by start, then each interval either extends the last one or starts a new one.
• GreedyMake the locally best move every time, and prove it never hurts.

Sliding window

• Fixed-size sliding windowAdd the item coming in, remove the one going out, never re-add the whole window.
• Variable-size sliding windowGrow the right edge; while the window breaks the rule, shrink the left.

Arrays

• Prefix sumsRunning totals: any stretch's sum is one subtraction.
• Hash map / setRemember what you've seen; look it up in O(1).
• One pass, carrying a summaryWalk once, keeping the one or two numbers you need (best so far, running total).

Dynamic programming

• Kadane's algorithmAt each item: extend the best stretch ending here, or start fresh.
• Dynamic programmingDefine the answer for a smaller version; build up, remembering each one.

Binary search

• Binary searchLook at the middle; throw away the half that can't hold the answer.
• Binary search on the answerGuess an answer, check it with yes/no, halve the range.

Two pointers

• Two pointers from both endsStart at both ends; the sum tells you which pointer to move.
• Two pointers, same directionOne pointer reads every item; the other marks where the next kept item goes.

Math & bits

• Bit manipulationWork on the binary: XOR cancels pairs, n & (n − 1) drops the lowest 1.