Stop memorising solutions.
Learn to see the pattern.

Just enough Java to write any algorithm: types, arrays, strings, classes, and the Collections you'll use every day.

How to tell, before running anything, whether a solution will be fast enough.

The most common input in coding problems: traverse, track state in one pass, and work in place.

Characters, counting, building strings efficiently, and palindromes.

Trade memory for speed: remember what you've seen and look it up in O(1).

Precompute running totals once so every range question becomes a subtraction.

Two indexes moving with a rule, turning O(n²) pair searches into O(n).

Keep a window over a contiguous range and update it as it moves instead of recomputing.

Nodes and next pointers: reversal, dummy heads, fast and slow pointers, and merging.

Last in, first out: matching brackets and the next-greater-element family.

First in, first out, both ends, and the sliding-window maximum trick.

Halve the search space each step, on indexes and on answers.

Solve a problem with a smaller copy of itself; think in base cases and trust.

Build answers step by step, undo, and try the next choice.

How sorts work inside, and sorting as a tool for other problems.

Sort by start, then merge, insert, or count overlaps.

Recursion on structure: DFS orders, level-order BFS, and returning values up the tree.

Ordered trees: search, insert, validate, and in-order tricks.

Always know the smallest or largest: top-K, two heaps, and K-way merge.

A tree of characters for prefix search and word games.

Vertices, edges, and how to store them: adjacency lists, matrices, and grids as graphs.

Explore level by level: shortest paths in unweighted graphs and multi-source BFS.

Go deep first: connected components, flood fill, and path finding.

Find loops in directed and undirected graphs.

Order tasks so every prerequisite comes first.

Merge groups and ask "same group?" in near-constant time.

Dijkstra, Bellman-Ford and Floyd-Warshall, and when to use which.

Connect everything at the lowest total cost with Kruskal and Prim.

From recursion to memoisation to tables: overlapping subproblems made fast.

Paths and costs on 2D grids.

Choose items under a budget: 0/1, unbounded, and subset sums.

LIS, LCS and edit distance: comparing and growing sequences.

Interval, bitmask, tree and state-machine DP.

Take the locally best choice, and learn how to prove it's safe.

XOR tricks, masks and counting bits.