What is the pricing and subscription model for Hi👋SpeedAlgo?

The entire core curriculum of 13 patterns and 225 practice problems is 100% free to access with no credit card required. New accounts get 40 free coins once, the daily claim adds +20 coins once a day, and inviting a friend earns you +25 coins when they complete their first practice step. These are the only ways to earn coins. Each AI coach question costs 1-5 coins, priced by the server according to its size. AI coaching is free with your own Google Gemini, OpenAI or OpenRouter API key (BYOK). Coins also unlock extras for 24 hours: a Recall hint level (1 coin), a Solve solution reveal (2), a LeetCode problem card's solutions (1) and a pattern's extra canonical problems (1). Nothing on the site is sold for money: coins can only be earned, never bought.

What is the refund and cancellation policy?

Hi👋SpeedAlgo sells nothing for money: there are no subscriptions, renewals or charges, so there is nothing to cancel or refund. Nothing on the site is sold for money: coins can only be earned, never bought.

Who creates and maintains the curriculum?

Hi👋SpeedAlgo is developed and maintained by Hi👋WebEnterprise (https://hiwebenterprise.com), an engineering organization focused on developer education, deliberate practice methodologies, and cognitive ergonomics for technical interviews.

How does Hi👋SpeedAlgo prepare candidates for senior and staff SWE interviews?

Rather than rote LeetCode grinding, Hi👋SpeedAlgo uses deliberate practice for each pattern: learn the loop invariant, Big-O proof and edge cases from a side-by-side template and a step-by-step debugger, rebuild the template from memory, then solve a new problem on your own against a graded test suite.

6. Topological Sort: Course Schedule II (LC 210) • Invariant Proof & Speed-Run

Theory Context•Graph Algorithms

MediumLC 210

Course Schedule II (LeetCode 210)

Target Frequency:MetaAmazonGoogleApple

You have numCourses courses to complete, numbered 0 through numCourses - 1, and a list prerequisites where each entry [a_i, b_i] means course b_i must be completed before course a_i.

So an entry [0, 1] means course 1 has to be finished before course 0.

Produce one valid order in which all courses can be taken; any correct order is acceptable. If no order can complete every course, return an empty list instead.

Worked Examples

Example 1

Input:numCourses = 2, prerequisites = [[1,0]]

Output:[0,1]

Explanation: Course 1 depends on course 0, so 0 must come first, giving the order [0, 1].

Example 2

Input:numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]

Output:[0,2,1,3]

Explanation: Course 3 depends on both 1 and 2, and each of those depends on course 0. Any order that places 0 first and 3 last works, e.g. [0, 1, 2, 3] or [0, 2, 1, 3].

Example 3

Input:numCourses = 1, prerequisites = []

Output:[0]

Explanation: There is one course with no prerequisites, so the order is just [0].

⚖️Formal Constraints & Bounds

1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= a_i, b_i < numCourses
a_i != b_i
All the pairs [a_i, b_i] are distinct

Deep-Dive & Conceptual Insights

Core Insight

Kahn's algorithm detects cycles naturally: if the finalized order length is less than numCourses, a cycle prevented some in-degrees from reaching 0.

Real-World Scenario & Production Applications

Build dependency task runners (e.g. Bazel/Make/npm package dependency resolvers) and university course curriculum scheduling.

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Adjacency List & In-Degree Initialization

Construct directed graph from edge pairs and compute in-degree for every vertex: in_degree[v] = number of prerequisite dependencies.

Mathematical Recurrence / Code Invariant

adj = defaultdict(list)
in_degree = [0] * numCourses
for dest, src in prerequisites:
    adj[src].append(dest)
    in_degree[dest] += 1

Step-by-Step Execution Trace Table

Step	Queue Before	Dequeued Course	Order Appended	Decremented In-Degrees	Newly Freed (In-degree 0)	Queue After
1	`[0]`	0	`[0]`	`in_degree[1]: 1→0`, `in_degree[2]: 1→0`	`1`, `2`	`[1, 2]`
2	`[1, 2]`	`1`	`[0, 1]`	`in_degree[3]: 2→1`	None (3 still waits on 2)	`[2]`
3	`[2]`	`2`	[0, 1, 2]	`in_degree[3]: 1→0`	`3`	`[3]`
4	`[3]`	`3`	`[0, 1, 2, 3]`	—	None	`[]`

Trace InputnumCourses = 2, prerequisites = [[1,0]]

Expected[0,1]

Step	Queue Before	Dequeued Course	Order Appended	Decremented In-Degrees	Newly Freed (In-degree 0)	Queue After
1	`[0]`	0	`[0]`	`in_degree[1]: 1→0`, `in_degree[2]: 1→0`	`1`, `2`	`[1, 2]`
2	`[1, 2]`	`1`	`[0, 1]`	`in_degree[3]: 2→1`	None (3 still waits on 2)	`[2]`
3	`[2]`	`2`	[0, 1, 2]	`in_degree[3]: 1→0`	`3`	`[3]`
4	`[3]`	`3`	`[0, 1, 2, 3]`	—	None	`[]`

Code Shape

Archetype Code Shape

Python

1	for dest, src in prerequisites:
2	adj[src].append(dest)
3	in_degree[dest] += 1
4	queue = deque(every course with in_degree 0)
5	order = []
6	while queue:
7	node = queue.popleft()
8	order.append(node)
9	for neighbor in adj[node]:
10	in_degree[neighbor] -= 1
11	if in_degree[neighbor] == 0:
12	queue.append(neighbor)
13	return order if len(order) == numCourses else []

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

Topological sorting orders vertices in a DAG(Directed Acyclic Graph) such that for every directed edge $u \to v$ , vertex $u$ comes before $v$ . Kahn's algorithm maintains in-degrees for all nodes. Nodes with in-degree 0 have no prerequisites and are enqueued. As each node is scheduled, outgoing edges are removed. If the final ordered list contains all $V$ courses, a valid curriculum order is returned; if not, a circular prerequisite deadlock exists.

📋 The Analogy: Peeling Off Tasks With No Blockers

Imagine a to-do list where every task lists which other tasks must finish first. You scan the whole list once and pull out every task that has zero blockers — those can start immediately, in any order. Every time you finish a task, you go tell everyone who was waiting on it "one of your blockers is done" — and the moment a waiting task's blocker count hits zero, it joins the ready pile too. If you ever run out of ready tasks while some are still stuck waiting, those remaining tasks must be blocking each other in a cycle — an impossible schedule.

🔑 The Key Idea in the Code

len(order) == num_nodes at the end is the cycle detector: if every node were eventually reachable, all of them would eventually hit zero in-degree and get processed — anything left unprocessed must be stuck in a mutual dependency loop.

Silent partial order return on directed cycles: Returning the accumulated order array without verifying len(order) == numCourses. If a cycle exists, Kahn's algorithm terminates early; returning a partial order fails the problem requirement to return an empty array [].
Reversed prerequisite dependency edge: For prerequisite pair [a, b], course $b$ must be taken before $a$ . The directed edge is $b \to a$ , and the in-degree of $a$ must increase. Reversing this ( $a \to b$ ) generates an inverted topological order.
Disconnected component queue seeding: Only enqueueing course 0 instead of finding all courses with in_degree[i] == 0. Unconnected courses or multiple entry points will never be processed.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Each pair [a_i, b_i] says course b_i must be completed "before" course a_i, and you must produce "one valid order" for all courses, or an empty list when "no order can complete every course". Prerequisites plus an order plus "impossible" point to Topological Sort.

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Every node in order or in queue comes after all of its prerequisites, and in_degree[v] counts the prerequisites of v not yet in order. The decision: node joins queue at the moment in_degree[node] reaches 0.

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

return order if len(order) == num_courses else []: courses on a cycle never reach 0, so a shorter order means no valid order exists; returning the partial order is wrong.
for dest, src in prerequisites: [a, b] means b before a, so the edge is b -> a (adj[src].append(dest)) and in_degree[dest] goes up; reversed, the order comes out backwards.
queue = deque([i for i in range(num_courses) if in_degree[i] == 0]): seed every course with no prerequisites, not just course 0, or courses in other groups never start.

The 60-Second Interview Pitch

Say this out loud before you type a single line

This is Topological Sort with Kahn's algorithm. Each pair b before a is an edge from b to a, so I build the adjacency list and count every course's in-degree, the prerequisites it still waits for. I put every course with in-degree zero in a queue. Each time I pop a course, I add it to the order and lower the count of every course it unlocks; a course whose count reaches zero joins the queue. That is correct because a course only enters the queue once all its prerequisites are already in the order. The trap is the cycle: courses on a cycle never reach zero, so if the order is shorter than the number of courses I return an empty list, never the partial order. Every course is queued once and every prerequisite is read twice, so it's O(V plus E) time and space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(V + E)

Look at the code: for dest, src in prerequisites reads each of the E pairs once to build adj and in_degree, O(E); seeding queue scans the V counts, O(V). In while queue, every course is popped at most once (it is pushed only when its count reaches 0, which happens once), and for neighbor in adj[node] walks each edge once over the whole run. Total O(V + E).

SPACE COMPLEXITY

O(V + E)

adj stores every edge, O(V + E); in_degree, queue and order hold at most V entries each, O(V). There is no recursion, so the call stack is O(1). order is also the output, V entries.

Formal Recurrence Relation

T(V, E) = E (build) + V (seed) + V (pops) + E (count updates) = O(V + E)

Derivation Progression

Graph build

for dest, src in prerequisites: adj[src].append(dest); in_degree[dest] += 1 → E steps

Each prerequisite pair is read once and does O(1) work.

Seed the queue

deque([i for i in range(num_courses) if in_degree[i] == 0]) → V checks

One pass over the V counts.

Peel

while queue: node = queue.popleft(); for neighbor in adj[node]: in_degree[neighbor] -= 1 → V pops + E decrements

A course is pushed only when its count reaches 0, once, so there are at most V pops; across all pops the inner loop walks each edge once.

Variable Definitions

$V$

Number of courses, num_courses (nodes)

$E$

Number of prerequisite pairs (edges)

Memory Architecture & Bounds

🟣 Call Stack

O(1): no recursion

🔵 Auxiliary Heap

O(V + E): adj holds every edge; in_degree and queue hold V entries

🟢 Output Space

O(V): order

Boundary Best / Worst Cases

Best Case

$O(V + E)$

Average Case

$O(V + E)$

Worst Case

$O(V + E)$

Graph & Tree Traversal Frontier

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

Triggers: "must be completed before", "one valid order", "return an empty list" when no order exists. An order that respects every prerequisite, plus a report of impossibility: Topological Sort. At scale the same shape is any dependency graph that has to be processed in order: builds, migrations, task pipelines.

CONSTRAINTS & BOUNDS

$V \le 2000$ courses, $E \le V(V - 1)$ pairs. Budget: $O(V + E)$ steps and memory for adj (every edge) plus three arrays of $V$ . On a graph too large for one machine, adj is the part to shard; in_degree is one counter per node.

FAANG PRODUCTION TRAPS & EDGE CASES

Nodes left out of order are exactly the nodes on or behind a cycle: report them (not just "impossible") so the cycle can be found. A node listed as a prerequisite but never defined is a separate error to check before sorting.

Core Algorithmic State Invariants

Any Valid Order Is Accepted

LC 210 accepts any order that respects every prerequisite. Kahn's queue gives one of them; which one depends on the order courses enter queue, so a different but valid answer is still correct.

Popped Order Is Also a Schedule of Rounds

The courses in queue at one moment have no prerequisite between them. Processing queue one level at a time (as in Level-Order BFS) gives the fewest rounds when courses of one round can be taken together.

Theory Context•Graph Algorithms

MediumLC 210

Course Schedule II (LeetCode 210)

Target Frequency:MetaAmazonGoogleApple

So an entry [0, 1] means course 1 has to be finished before course 0.

Produce one valid order in which all courses can be taken; any correct order is acceptable. If no order can complete every course, return an empty list instead.

Worked Examples

Example 1

Input:numCourses = 2, prerequisites = [[1,0]]

Output:[0,1]

Explanation: Course 1 depends on course 0, so 0 must come first, giving the order [0, 1].

Example 2

Input:numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]

Output:[0,2,1,3]

Explanation: Course 3 depends on both 1 and 2, and each of those depends on course 0. Any order that places 0 first and 3 last works, e.g. [0, 1, 2, 3] or [0, 2, 1, 3].

Example 3

Input:numCourses = 1, prerequisites = []

Output:[0]

Explanation: There is one course with no prerequisites, so the order is just [0].

⚖️Formal Constraints & Bounds

1 <= numCourses <= 2000
0 <= prerequisites.length <= numCourses * (numCourses - 1)
prerequisites[i].length == 2
0 <= a_i, b_i < numCourses
a_i != b_i
All the pairs [a_i, b_i] are distinct

Deep-Dive & Conceptual Insights

Core Insight

Kahn's algorithm detects cycles naturally: if the finalized order length is less than numCourses, a cycle prevented some in-degrees from reaching 0.

Real-World Scenario & Production Applications

Build dependency task runners (e.g. Bazel/Make/npm package dependency resolvers) and university course curriculum scheduling.

Subproblems & Recurrence Decomposition3 Phases

🧩Subproblem 1: Adjacency List & In-Degree Initialization

Construct directed graph from edge pairs and compute in-degree for every vertex: in_degree[v] = number of prerequisite dependencies.

Mathematical Recurrence / Code Invariant

adj = defaultdict(list)
in_degree = [0] * numCourses
for dest, src in prerequisites:
    adj[src].append(dest)
    in_degree[dest] += 1

Step-by-Step Execution Trace Table

Step	Queue Before	Dequeued Course	Order Appended	Decremented In-Degrees	Newly Freed (In-degree 0)	Queue After
1	`[0]`	0	`[0]`	`in_degree[1]: 1→0`, `in_degree[2]: 1→0`	`1`, `2`	`[1, 2]`
2	`[1, 2]`	`1`	`[0, 1]`	`in_degree[3]: 2→1`	None (3 still waits on 2)	`[2]`
3	`[2]`	`2`	[0, 1, 2]	`in_degree[3]: 1→0`	`3`	`[3]`
4	`[3]`	`3`	`[0, 1, 2, 3]`	—	None	`[]`

Trace InputnumCourses = 2, prerequisites = [[1,0]]

Expected[0,1]

Step	Queue Before	Dequeued Course	Order Appended	Decremented In-Degrees	Newly Freed (In-degree 0)	Queue After
1	`[0]`	0	`[0]`	`in_degree[1]: 1→0`, `in_degree[2]: 1→0`	`1`, `2`	`[1, 2]`
2	`[1, 2]`	`1`	`[0, 1]`	`in_degree[3]: 2→1`	None (3 still waits on 2)	`[2]`
3	`[2]`	`2`	[0, 1, 2]	`in_degree[3]: 1→0`	`3`	`[3]`
4	`[3]`	`3`	`[0, 1, 2, 3]`	—	None	`[]`

Code Shape

Archetype Code Shape

Python

1	for dest, src in prerequisites:
2	adj[src].append(dest)
3	in_degree[dest] += 1
4	queue = deque(every course with in_degree 0)
5	order = []
6	while queue:
7	node = queue.popleft()
8	order.append(node)
9	for neighbor in adj[node]:
10	in_degree[neighbor] -= 1
11	if in_degree[neighbor] == 0:
12	queue.append(neighbor)
13	return order if len(order) == numCourses else []

Conceptual Narrative

🧭 Conceptual Foundation & Pattern Intuition

📋 The Analogy: Peeling Off Tasks With No Blockers

🔑 The Key Idea in the Code

Silent partial order return on directed cycles: Returning the accumulated order array without verifying len(order) == numCourses. If a cycle exists, Kahn's algorithm terminates early; returning a partial order fails the problem requirement to return an empty array [].
Reversed prerequisite dependency edge: For prerequisite pair [a, b], course $b$ must be taken before $a$ . The directed edge is $b \to a$ , and the in-degree of $a$ must increase. Reversing this ( $a \to b$ ) generates an inverted topological order.
Disconnected component queue seeding: Only enqueueing course 0 instead of finding all courses with in_degree[i] == 0. Unconnected courses or multiple entry points will never be processed.

Senior SWE Reasoning Architecture

4-Phase Thought Process Model

Pattern Recognition Signals

The 10-second spot

Formulating the Predicate & Invariants

Turning intuition into a boolean rule

Silent Failure Traps & Edge Cases

Where confident candidates still lose points

return order if len(order) == num_courses else []: courses on a cycle never reach 0, so a shorter order means no valid order exists; returning the partial order is wrong.
for dest, src in prerequisites: [a, b] means b before a, so the edge is b -> a (adj[src].append(dest)) and in_degree[dest] goes up; reversed, the order comes out backwards.
queue = deque([i for i in range(num_courses) if in_degree[i] == 0]): seed every course with no prerequisites, not just course 0, or courses in other groups never start.

The 60-Second Interview Pitch

Say this out loud before you type a single line

This is Topological Sort with Kahn's algorithm. Each pair b before a is an edge from b to a, so I build the adjacency list and count every course's in-degree, the prerequisites it still waits for. I put every course with in-degree zero in a queue. Each time I pop a course, I add it to the order and lower the count of every course it unlocks; a course whose count reaches zero joins the queue. That is correct because a course only enters the queue once all its prerequisites are already in the order. The trap is the cycle: courses on a cycle never reach zero, so if the order is shorter than the number of courses I return an empty list, never the partial order. Every course is queued once and every prerequisite is read twice, so it's O(V plus E) time and space.

Big-O Invariant Derivation

Complexity & Mathematical Proof

TIME COMPLEXITY

O(V + E)

SPACE COMPLEXITY

O(V + E)

adj stores every edge, O(V + E); in_degree, queue and order hold at most V entries each, O(V). There is no recursion, so the call stack is O(1). order is also the output, V entries.

Formal Recurrence Relation

T(V, E) = E (build) + V (seed) + V (pops) + E (count updates) = O(V + E)

Derivation Progression

Graph build

for dest, src in prerequisites: adj[src].append(dest); in_degree[dest] += 1 → E steps

Each prerequisite pair is read once and does O(1) work.

Seed the queue

deque([i for i in range(num_courses) if in_degree[i] == 0]) → V checks

One pass over the V counts.

Peel

while queue: node = queue.popleft(); for neighbor in adj[node]: in_degree[neighbor] -= 1 → V pops + E decrements

A course is pushed only when its count reaches 0, once, so there are at most V pops; across all pops the inner loop walks each edge once.

Variable Definitions

$V$

Number of courses, num_courses (nodes)

$E$

Number of prerequisite pairs (edges)

Memory Architecture & Bounds

🟣 Call Stack

O(1): no recursion

🔵 Auxiliary Heap

O(V + E): adj holds every edge; in_degree and queue hold V entries

🟢 Output Space

O(V): order

Boundary Best / Worst Cases

Best Case

$O(V + E)$

Average Case

$O(V + E)$

Worst Case

$O(V + E)$

Graph & Tree Traversal Frontier

Synthesizing vector architecture diagram...

Staff+ Engineering Perspective

Senior SWE Deconstruction & Hardware Caveats

ARCHITECTURAL SIGNALS & INTERVIEW TRIGGERS

CONSTRAINTS & BOUNDS

FAANG PRODUCTION TRAPS & EDGE CASES

Core Algorithmic State Invariants

Any Valid Order Is Accepted

LC 210 accepts any order that respects every prerequisite. Kahn's queue gives one of them; which one depends on the order courses enter queue, so a different but valid answer is still correct.

Popped Order Is Also a Schedule of Rounds

Step

Queue Before

Dequeued Course

Order Appended

Decremented In-Degrees

Newly Freed (In-degree 0)

Queue After

[0]

in_degree[1]: 1→0, in_degree[2]: 1→0

1, 2

[1, 2]

1

[0, 1]

in_degree[3]: 2→1

None (3 still waits on 2)

[2]

2

[0, 1, 2]

in_degree[3]: 1→0

3

[3]

3

[0, 1, 2, 3]

—

None

[]

Step

Queue Before

Dequeued Course

Order Appended

Decremented In-Degrees

Newly Freed (In-degree 0)

Queue After

[0]

in_degree[1]: 1→0, in_degree[2]: 1→0

1, 2

[1, 2]

1

[0, 1]

in_degree[3]: 2→1

None (3 still waits on 2)

[2]

2

[0, 1, 2]

in_degree[3]: 1→0

3

[3]

3

[0, 1, 2, 3]

—

None

[]

🧭 Conceptual Foundation & Pattern Intuition

📋 The Analogy: Peeling Off Tasks With No Blockers

🔑 The Key Idea in the Code

Step

Queue Before

Dequeued Course

Order Appended

Decremented In-Degrees

Newly Freed (In-degree 0)

Queue After

[0]

in_degree[1]: 1→0, in_degree[2]: 1→0

1, 2

[1, 2]

1

[0, 1]

in_degree[3]: 2→1

None (3 still waits on 2)

[2]

2

[0, 1, 2]

in_degree[3]: 1→0

3

[3]

3

[0, 1, 2, 3]

—

None

[]

Step

Queue Before

Dequeued Course

Order Appended

Decremented In-Degrees

Newly Freed (In-degree 0)

Queue After

[0]

in_degree[1]: 1→0, in_degree[2]: 1→0

1, 2

[1, 2]

1

[0, 1]

in_degree[3]: 2→1

None (3 still waits on 2)

[2]

2

[0, 1, 2]

in_degree[3]: 1→0

3

[3]

3

[0, 1, 2, 3]

—

None

[]