# Algo-Atlas: a mapped route through algorithm practice

> Algo-Atlas is not a course with exercises in it. It is an index: a hundred typical problems, then families of techniques, each family leading to a set of articles that solve several problems of that shape at once. The claim in the preamble is that a complete beginner can get through it in eight months with a planned schedule, and the structure of the index is the argument for that claim.

**lvy010/Algo-Atlas** — A Scientific Way - Solve 2000 LeetCode Problems in 8 Months 

- Repository: https://github.com/lvy010/Algo-Atlas
- Stars: 603 · Forks: 48
- Language: C++
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/lvy010-algo-atlas

## An index, not a course

The repository describes itself as a scientific way to solve two thousand problems in eight months, and the English subtitle of the readme is the one that matters for understanding what it is: a learning path in algorithms, starting from zero.

The preamble explains the origin. The author found programming interesting at university and started learning, and what follows is a set of notes and a share of what worked, with the claim that a complete beginner can get started with a scientific plan. The first line of the readme points to a discussion post on a problem site, and to two other platforms, so the project has a footprint outside the repository.

What the repository itself contains is a readme, a picture, and a small number of other directories. There is a C++ file with a name that reads like a problem statement rather than a program, a directory of tutorials, a directory of other material, a directory of images, and a directory of templates.

That inventory is the clearest statement of the project. The explanations are not here. The readme is a table of contents, and every entry in it is a link to an article on a writing platform, hosted under the author's own account. The repository is the map; the articles are the territory.

That is a deliberate choice, and it is worth understanding what it buys. A study path is not the same thing as a body of code. What a beginner needs most is an order, and an order is cheap to maintain and expensive to write well. A set of articles can be published, revised, and linked individually, and the index can be reorganised when the author learns something, without rewriting any of them.

The count in the description, two thousand problems in eight months, is the ambitious version of the claim, and the index is the plan for it. The visible part is the first hundred problems and the first few technique families, so what you can see is the beginning of a much longer structure.

## The three parts, and the first hundred problems

The readme says the project is divided into three main parts, and the first is building a framework for yourself.

The description of that part is that it gathers the abundant learning resources available online, the courses, the blog posts, the reference material, and organises them into notes. And then the sentence that explains the point of the whole thing: once you have your own framework, solving problems puts themselves into the right place in your head automatically.

That is a pedagogical claim, and it is the claim the whole project rests on. The problem with a beginner who collects a hundred solved problems without a framework is that the solutions become a hundred isolated anecdotes. The problem with a beginner who builds a framework without solving problems is that the framework is an abstraction with nothing attached to it. So the design is: a framework first, and then a large number of problems that the framework will sort themselves into.

The first part of the framework in the index is a list of one hundred typical problems, and it is the part of the readme with the most detail, because each entry is a link to an article and each article is titled with the problems it covers.

The numbering scheme in those titles is what makes the list usable rather than merely long. The entries run from the first group, on the two pointers technique, through a second group on the two pointers, a group on the sliding window, one on prefix sums, one on bit manipulation, one on simulation, two on divide and conquer with quicksort, and then on to hashing, strings, a stack, a queue with breadth first search, a priority queue, breadth first search with flood fill, shortest path, multi-source breadth first search, and topological sort. Each title carries a level, a technique, and a sub-number, so the hundred problems are not a random sample but a progression through techniques in the order a beginner would meet them.

The articles themselves bundle several problems of the same shape. One is on the two pointers with the move zeroes, the duplicate zeroes, and the happy number. Another is on the sliding window with the smallest subarray, the longest substring without repeats, the longest run of ones, and the minimum number of operations to reduce a number to zero. The pattern is consistent: a technique, a small family of problems that share a solution shape, and a write-up of the shape.

## Ordering, and the reason the notes give for it

The second part of the framework is organised by technique family, and the first family listed is recursion, search, and backtracking, with a short set of notes before the list of articles.

The notes are three lines long, and they are the clearest statement of methodology in the whole project. Search is a branch of recursion. Backtracking is a branch of search. Therefore the order of study is recursion, then search, then backtracking.

That is a very small piece of text doing a lot of work. It says that these are not three topics to be studied in parallel and hoped to be related, but one nested structure, and that the order is forced by the structure. A reader who takes that seriously does not need to decide what backtracking is, because the note has already told them: it is what search does when it undoes what it tried.

And the family is then walked through in that order. There is a summary article on recursion, search, and backtracking that also explains the towers of Hanoi in detail, and then articles on the recursive manipulation of linked lists, on tree depth first search, on adjacency matrices and adjacency lists, on validating a binary search tree, then the backtracking group with decision trees, permutations and subsets, then the combination and target sum problems, then a group of depth first search problems that includes the n queens and the valid sudoku, and then a group on flood fill which also revisits image rendering and the number of islands, and finally a group on memoised search.

The flood fill group is worth a note, because it comes after the backtracking group and it reappears in the first hundred problems as a separate entry. That duplication is the point of the framework: the same technique shows up once in the list of typical problems, in the position where a beginner meets it, and again in the technique family, in the position where a beginner learns it properly.

And the group on memoised search contains an article whose title is about understanding the difference between recursion, memoised search, and dynamic programming. That is a bridge between two families, placed inside a family, which is exactly what a framework is supposed to contain.

## Dynamic programming as a ladder

The dynamic programming section is the largest visible family, and it opens with the one sentence that defines the whole subject: the core idea of dynamic programming is to decompose the problem, remember what has already been computed, and avoid repeating the work.

Then there is the part that makes it usable for a beginner: a starting point that costs nothing. The section points at an article on the nth Fibonacci number and the three step problem, and says that somebody with no background can build the intuition for the subject from that one article.

That is the same pedagogy as the first hundred problems list, applied to the hardest family. Instead of starting with the knapsack problem, you start with a sequence whose answer you can already guess, and you notice that the naive way to compute it repeats itself. The article about the smallest cost to climb stairs and the article about decoding a message are where the real teaching begins, and the second of them carries a note about a virtual base case, which is the trick that makes the first genuine dynamic program work.

From there the family is a ladder, and the titles show the rungs. A starting article for the intuition, then an article on the cost of a step and on decoding, then a group on path problems, then one on path problems with obstacles, then a group on multiple state problems, then a group on the stock trading problem in five increasingly constrained forms, then a group on subarrays, then another on subarrays, then one on subsequences, then one on the longest increasing subsequence, then a group on subsequences that are not contiguous, then a group on palindromic substrings, then one on the longest arithmetic progression, then a group on palindromic strings, then a group on two arrays, then another, then another, then the knapsack introduction and the zero one knapsack, then the target sum, then the complete knapsack.

Look at the labels rather than the problems. Zero one knapsack and complete knapsack are separated because they are different problems with the same shape. The five stock trading variants are in one article because they are one idea with five constraints. The path problems are a group because the grid variant is a variation on the same recurrence.

That is a curriculum arranged by what changes between problems rather than by what the problem is called, and it is a curriculum that a person who already knows the standard list of dynamic programming problems would not have designed, because they already have the grouping in their head.

## The greedy family, and what the repository holds

The third named family in the index is the greedy approach, and it is the last of the three parts of the framework named in the readme's overview.

That the greedy family is listed last among the three is itself a statement about order. Recursion, search, and backtracking come first because they are the foundation, dynamic programming comes next because it is the hardest and needs the most, and greedy comes last because it is the one you can most easily get wrong by being too sure of yourself. A greedy solution looks right, passes the small cases, and fails on the one input that matters, and the way to learn that is to have already done the harder families where the same kind of reasoning is checked properly.

The repository also holds the raw material, and it is worth looking at what is there rather than only at the links. There is a C++ file with a problem statement for a name, a directory of deep tutorials in the language, a directory of other material, an images directory, and a directory of templates.

The templates directory is the interesting one, because templates in a competitive programming repository mean one thing: the skeleton code for each category of problem, with the input handling, the output handling, and the timing already done. A sliding window template, a prefix sum template, a graph traversal template, a binary search template. The readme's first hundred problems list actually names a template article in its second entry, one on the one dimensional and two dimensional prefix sum templates.

So the project is not only an index of write-ups. It is an index of write-ups plus the reusable parts of the answers, which is the thing a solver actually copies and forgets about, and forgetting is fine for a template in a way it is not fine for an algorithm.

The images directory and the picture in the readme are for the presentation of the map itself, and the C++ file is the one thing in the repository that is a solution rather than a pointer. It is at the top level, ungrouped, which suggests it was added as a one-off rather than as part of a family, and it is a reasonable place for the kind of contribution a reader makes when they solve something and want to leave it behind.

## Conclusion

Algo-Atlas fits a self-taught programmer who has never solved a problem deliberately and needs a route rather than a pile of links, and who reads Chinese comfortably. It does not fit a reader who needs the explanations in English, because the articles themselves are the substance and the index is only a table of contents, and it does not fit somebody who already knows the standard families and wants harder problems. Verify first that the articles are reachable from where you are, since they are hosted on a separate writing platform rather than in the repository, that the ordering within a family matches the order you should learn it in, and that the newer entries are the ones worth reading first, since the numbering makes the earlier groups the foundation rather than the most recent work.

## FAQ

### What is the Algo-Atlas repository?

It is a learning path in algorithms for beginners, written in Chinese, and the repository itself is an index rather than a course. The readme organises links to study articles into a framework, beginning with a hundred typical problems and continuing with technique families, and the articles themselves are hosted on a separate writing platform.

### How is the Algo-Atlas study plan organised?

In three parts: building your own framework from the available learning resources, a list of one hundred typical problems grouped by technique, and then the technique families themselves, beginning with recursion, search, and backtracking, followed by dynamic programming and the greedy approach.

### Why does Algo-Atlas teach recursion, search, and backtracking in that order?

Because the notes argue that they are one nested structure rather than three topics: search is a branch of recursion, backtracking is a branch of search, so the study order is forced. The family is then walked in that order, from the summary article through the recursive list and tree work to the backtracking groups and the flood fill and memoised search groups.

### How does the Algo-Atlas dynamic programming section start?

With an article on the nth Fibonacci number and the three step problem, which the readme recommends as the way for somebody with no background to build intuition, and then it climbs through the path problems, the multiple state problems, the five variants of the stock trading problem, the subarray and subsequence groups, the palindrome groups, the two array groups, and finally the knapsack problems, split into the zero one and complete variants.

### What is actually stored in the Algo-Atlas repository?

The readme and its index, an image, a directory of deep tutorials in the language, a directory of other material, an images directory, a directory of templates for the problem categories, and a C++ file at the top level. The explanations and the solved problems live in the linked articles, not in the tree.

## Sources

- [Issues](https://github.com/lvy010/Algo-Atlas/issues)
- [lvy010/Algo-Atlas on GitHub](https://github.com/lvy010/Algo-Atlas)
- [README](https://github.com/lvy010/Algo-Atlas/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/lvy010-algo-atlas