These are the habits and small techniques that decide whether a problem is a quick implementation or an unnecessary detour.
Core patterns that show up before the heavy machinery does.
This category is about the habits that make bigger techniques usable: complexity estimates, pointer movement, binary search patterns, small preprocessing tricks, and the ability to compress a problem before reaching for heavier machinery.
A large fraction of contest mistakes do not come from not knowing an advanced data structure. They come from using the right high-level idea on top of a weak foundation: an off-by-one binary search, an unnecessary logarithm, or a missing compression step that makes the rest of the solution impossible.
The labels are not cosmetic. They are there to signal the amount of prerequisite structure and implementation fragility you should expect before opening the note.
These are the shortest on-ramp notes in this category and the ones most likely to be usable immediately in contest practice.
Binary Search, Prefix Sums and Difference Arrays, Two Pointers and Sliding Window, Sorting and Events, Coordinate Compression
These notes assume the base routine is already familiar and focus on the first real structural upgrades.
Ternary Search, Bitmask Techniques, Greedy Exchange Argument, Meet-in-the-Middle
These are the finished note pages in this category, each with rendered TeX, C++ code, references, and practice suggestions.
A decision-to-answer pattern for monotone predicates, answer-space search, and continuous approximation.
Optimize a unimodal function on a discrete or continuous domain by keeping the side that still contains the optimum.
Turn repeated range work into constant-time queries or constant-time lazy marks by changing what the array stores.
Exploit one-way pointer movement to turn many quadratic scans into linear passes over arrays and strings.
Turn interval and query problems into a left-to-right sweep over sorted add, remove, and inspect events.
Compact subset state, fast bit operations, and the enumeration patterns that power many small-state solutions.
A proof pattern for showing that one locally optimal choice can be forced into some global optimum without making the solution worse.
Replace large or sparse values by their rank order so array-based structures become practical again.
Split an exponential search into two smaller exponential searches and join the halves with sorting or hashing.
The default order follows each note's dependency weight: early notes establish primitives, later notes reuse them or assume the same invariants without re-explaining them.
A decision-to-answer pattern for monotone predicates, answer-space search, and continuous approximation.
Optimize a unimodal function on a discrete or continuous domain by keeping the side that still contains the optimum.
Turn repeated range work into constant-time queries or constant-time lazy marks by changing what the array stores.
Exploit one-way pointer movement to turn many quadratic scans into linear passes over arrays and strings.
Turn interval and query problems into a left-to-right sweep over sorted add, remove, and inspect events.
Compact subset state, fast bit operations, and the enumeration patterns that power many small-state solutions.
A proof pattern for showing that one locally optimal choice can be forced into some global optimum without making the solution worse.
Replace large or sparse values by their rank order so array-based structures become practical again.
Split an exponential search into two smaller exponential searches and join the halves with sorting or hashing.
These are still intentionally shown as planned or outline topics rather than shallow filler. The branch should feel incomplete in honest places instead of fake-complete everywhere.
Raw files are still available here when you want the original TeX, C++, or statement assets.