Algorithm Arcade

First principles

Foundations. Calls, costs & divide and conquer

1. Lesson 1: Pillars of problem solving

   Meet the machine behind every algorithm.

   4 labs

2. Lesson 2: The cost of an algorithm

   Count work. Build a recurrence. Look beyond one operation.

   3 labs

3. Lesson 3: Quick sort

   One partition makes two smaller promises.

   3 labs

Build the structure

Data structures. Trees, heaps & invariants

1. Lesson 4: Binary search trees I

   Build an ordering you can navigate.

   2 labs

2. Lesson 5: Binary search trees II

   Traverse, validate, and delete without breaking order.

   3 labs

3. Lesson 6: Heaps & priority queues

   Keep the next best choice at the root.

   4 labs

Explore the possibilities

Backtracking. Choose, explore, undo

1. Lesson 7: Backtracking I · Subsets

   Turn recursion into a tree of decisions.

   2 labs

2. Lesson 8: Backtracking II · Arrangements

   The same search engine, a different choice set.

   2 labs

3. Lesson 9: Backtracking III · Constraints

   Spend less time in impossible futures.

   2 labs

Follow the connections

Graph foundations. Represent, visit & discover

1. Lesson 10: Graph representations

   One network, two ways to store it.

   2 labs

2. Lesson 11: Depth-first search

   Recursion learns to handle cycles.

   3 labs

3. Lesson 12: Breadth-first search

   Explore one distance layer at a time.

   3 labs

Remember & optimize

DP & greedy. States, choices & repeated work

1. Lesson 13: Dynamic programming I · Careful brute force

   A call returns a value; repeated questions can reuse that value.

   5 labs

2. Lesson 14: Dynamic programming II · Is it even DP?

   Test a greedy claim; change max to counting on the same state.

   3 labs

3. Lesson 15: Greedy I · Safe choices

   A local choice needs a global argument.

   2 labs

4. Lesson 16: Greedy II · Counterexamples

   Know when a fast choice needs a rethink.

   3 labs

5. Lesson 17: Dynamic programming III · Values, not tasks

   Turn the memo into a table and justify its fill order.

   2 labs

6. Lesson 18: Dynamic programming IV · The invisible parameter

   Demonstrate why index alone is not enough, then define (i, remaining).

   2 labs

7. Lesson 19: Dynamic programming V · Two sequences, and getting the answer back

   Define two suffix pointers, then recover an actual subsequence.

   2 labs

8. Lesson 20: Dynamic programming VI · Diagnosis and defence

   Choose the state on unfamiliar problems before revealing the code.

   3 labs

Bring it all together

Advanced graphs. Routes, dependencies & transfer tasks

1. Lesson 21: Dijkstra’s shortest paths

   BFS meets the priority queue.

   1 lab

2. Lesson 22: Topological sorting

   Respect every dependency.

   2 labs

3. Lesson 23: Minimum spanning trees

   Connect everything at the lowest total cost.

   2 labs

4. Lesson 24: The synthesis arena

   Use the full toolkit. Defend the choices.

   3 labs