Where to Go Next: A Practice Roadmap

A staged practice plan

Reading about an [[dsa-algorithm|algorithm]] is not the same as being able to reach for it under pressure. The gap closes only through practice — but practice has a shape. Random grinding wears you out; staged, deliberate practice compounds. Here is an order that works.

1. Drill one pattern at a time. Pick a single pattern — say two pointers — and solve five or six problems that all use it, back to back. Doing them together teaches your eye to recognize when the pattern applies, which is the skill that transfers.
2. Space your repetition. Don't solve a problem once and move on forever. Revisit it after a few days, then a couple of weeks. Spaced repetition is how patterns move from "I followed that" to "I can produce that."
3. Read other people's solutions — after you've tried. Once you've made a genuine attempt, study a clean solution from someone else. You'll absorb idioms, sharper complexity, and patterns you wouldn't have invented. Then re-solve it yourself from memory.
4. Track what you miss. Keep a short list of problems that stumped you and the pattern each one needed. Reviewing that list is a map of your own weak spots — far more useful than counting how many problems you've solved.

A spaced-repetition practice loop (don't just solve once and move on):

   day 0          day 3            week 2             month 2
   solve  ----->  re-solve  ----->  re-solve  ----->  re-solve
   (from           (recall,          (recall,          (should be
    scratch)        not re-read)      fast now)         automatic)
     |                                                     |
     +----------- the gaps are where it consolidates ------+

Goal: move each pattern from "I followed that" to "I can produce that."

Advanced topics to grow into

Once the core patterns feel natural, a wider world opens up. You don't need all of these, and you certainly don't need them now — but knowing the names lets you recognize the right tool when a problem calls for it, and pick a direction that excites you.

1. String algorithms — efficient string matching like the KMP algorithm finds a pattern inside a text in O(n + m) instead of the naive O(n·m); also suffix arrays and the Z-algorithm. Essential for text processing and bioinformatics.
2. Network flow — model problems as flow through a graph with capacities (max-flow / min-cut). Surprisingly many matching and assignment problems reduce to flow.
3. Computational geometry — algorithms for points, lines, and polygons: convex hulls, line-segment intersection, closest pair. The home turf of graphics, mapping, and robotics.
4. Randomized & approximation algorithms — use controlled randomness for speed or simplicity (randomized quicksort, hashing, Monte Carlo methods), and accept provably-near-optimal answers for problems too hard to solve exactly. Don't fear the topics whose names are new; each is just another rung.

The one thing: consistency

If you remember one thing from this whole ladder, let it be this: steady, modest practice beats rare heroic bursts. A focused half hour most days will take you further in a year than a frantic all-nighter once a month. The brain consolidates these skills slowly, during the gaps between sessions — so the gaps are part of the work, not time wasted.

Expect plateaus, and expect to feel stuck — both are normal, and both pass. Progress in this field is rarely a smooth line; it is a staircase, with long flat stretches followed by a sudden step up when something clicks. When you hit a flat stretch, don't conclude you've reached your limit. Keep showing up. The next step is usually closer than it feels.