I Got Tired of Watching YouTube Videos to Understand Graph Algorithms. So I Built This Instead.

#beginners #algorithms #datastructures #programming

Let me be honest with you.

Graph algorithms always felt odd to me.

Every time I sat down to learn BFS or Dijkstra, the same thing happened. I'd read an article. Get confused. Open YouTube. Watch one video. Then another. Then a third one at 1.5x speed. Two hours later, I'd close my laptop thinking "okay, I kind of get it"... and forget everything by next week.

Sound familiar?

The problem was never the videos. Some of them are great. The problem was that I was always watching someone else's understanding. I was never touching the algorithm myself.

So I did something about it

A while back, I started building Subroute — an interactive playground for technical concepts. I started this journey with topics like rate limiting and caching.

The idea is simple: learn by touching the system, not just reading about it.

And now, the topic that troubled me the most is finally live — Graph Algorithms.

👉 Check it out here: subroute.dev/topics/graph-algorithms

What's inside

Ten algorithms. Each one with its own page, its own live prototype you can play with, and a small quiz to check yourself.

Breadth-First Search (BFS) — visit a graph in expanding rings
Depth-First Search (DFS) — go deep first, then back up
Topological Sort — the build-order and task-scheduling trick
Dijkstra — the classic shortest path
Bellman-Ford — shortest path that survives negative edges
Floyd-Warshall — every distance, between every pair
Union-Find (DSU) — connectivity in near-constant time
Kruskal's MST — cheapest network, sorted edges first
Prim's MST — cheapest network, grown from one node
A* — the pathfinder behind games, GPS, and robots

The whole track takes about 100 minutes. Not 100 minutes of watching. 100 minutes of doing.

The one thing that changed everything for me

While building this, I realized something that no video ever told me clearly:

You don't need to memorize ten algorithms. You only need to know which question each one answers.

"What can I reach from here?" → BFS / DFS
"What's the cheapest route?" → Dijkstra (or Bellman-Ford if weights can be negative)
"How do I connect everything for the least cost?" → Kruskal / Prim
"What's the fastest path to that goal?" → A*

Once that clicked, the code became easy. Most of these are barely twenty lines. The hard part was never the code — it was knowing when to use what. So I added a side-by-side comparison table and a decision guide right on the page, because that's the cheat sheet I always wished I had.

Why this is not "just another tutorial site"

Because every concept here has a live prototype. You don't read about how Dijkstra grows its frontier — you watch it happen, you poke it, you break it, you run it again.

That's the whole point of Subroute. Reading gives you familiarity. Touching gives you intuition.