Cycle Detection in Directed Graph in DSA Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a cycle in a directed graph?

A cycle in a directed graph is a path that starts and ends at the same vertex, following the direction of edges.

beginner

Which data structure is commonly used to detect cycles in a directed graph using DFS?

A recursion stack (or call stack) is used to keep track of vertices in the current path during DFS to detect cycles.

intermediate

What does it mean if a node is found in the recursion stack during DFS?

It means a cycle is detected because the node is already in the current path of traversal.

intermediate

Why can't we use a simple visited set alone to detect cycles in directed graphs?

Because a node can be visited multiple times in different paths; only tracking nodes in the current path (recursion stack) can detect cycles.

intermediate

What is the time complexity of cycle detection in a directed graph using DFS?

The time complexity is O(V + E), where V is vertices and E is edges, because each vertex and edge is visited once.

What indicates a cycle during DFS in a directed graph?

A Finding a node with no outgoing edges

B Finding a node already in the recursion stack

C Finding a node never visited before

D Finding a node with no incoming edges

A cycle is detected if a node is found in the recursion stack, meaning it is part of the current path.

Which of these is NOT used in cycle detection in directed graphs?

A Recursion stack

B Visited set

C Queue for BFS

D Adjacency list

Cycle detection in directed graphs commonly uses DFS with recursion stack and visited set, not BFS queue.

What is the purpose of the visited set in cycle detection?

A To store all edges

B To mark nodes currently in the path

C To store the cycle nodes

D To mark nodes that are fully processed

The visited set marks nodes that have been fully processed to avoid reprocessing.

If no cycle is found, what does the DFS finish with?

A All nodes visited and no node found in recursion stack twice

B Some nodes unvisited

C Recursion stack never emptied

D Cycle nodes stored

If DFS finishes visiting all nodes without finding a node in recursion stack twice, no cycle exists.

What is the main difference between cycle detection in directed and undirected graphs?

A Directed graphs use recursion stack; undirected graphs use parent tracking

B Directed graphs use BFS; undirected graphs use DFS

C Directed graphs have no cycles

D Undirected graphs do not need visited sets

Directed graphs detect cycles using recursion stack; undirected graphs detect cycles by checking visited nodes excluding the parent.

Explain how DFS with recursion stack helps detect cycles in a directed graph.

Think about how the current path is remembered during DFS.

Describe the difference between visited set and recursion stack in cycle detection.

Consider what each set tracks during DFS.

Practice

1. What does cycle detection in a directed graph help us find?

easy

A. Whether there is a path that starts and ends at the same node following edge directions

B. The shortest path between two nodes

C. The total number of nodes in the graph

D. The maximum degree of any node

Solution

1. Step 1: Understand cycle in directed graph

   A cycle means a path that starts and ends at the same node following the direction of edges.

2. Step 2: Identify what cycle detection finds

   Cycle detection checks if such a path exists in the graph.

3. Final Answer:

   Whether there is a path that starts and ends at the same node following edge directions -> Option A

4. Quick Check:

   Cycle detection = finding directed loops [OK]

Hint: Cycle means path loops back following edge directions [OK]

Common Mistakes:

• Confusing cycle with shortest path
• Ignoring edge directions
• Thinking cycle means any repeated node without direction

2. Which TypeScript data structure is commonly used to track nodes currently in recursion stack during cycle detection?

easy

A. Queue

B. Array

C. Map

D. Set

Solution

1. Step 1: Identify recursion stack tracking

   We need to quickly check if a node is in the current recursion path.

2. Step 2: Choose data structure for fast membership check

   A Set allows O(1) membership check, ideal for tracking nodes in recursion stack.

3. Final Answer:

   Set -> Option D

4. Quick Check:

   Recursion stack tracking uses Set [OK]

Hint: Use Set for fast membership check in recursion stack [OK]

Common Mistakes:

• Using Array and checking membership with loops (slow)
• Using Queue which is FIFO, not suitable here
• Using Map without key-value need

3. What will be the output of the following TypeScript code snippet detecting cycle in a directed graph?

const graph = new Map([
  [1, [2]],
  [2, [3]],
  [3, [1]]
]);

function hasCycle(node: number, visited: Set<number>, recStack: Set<number>): boolean {
  if (!visited.has(node)) {
    visited.add(node);
    recStack.add(node);
    for (const neighbor of graph.get(node) || []) {
      if (!visited.has(neighbor) && hasCycle(neighbor, visited, recStack)) {
        return true;
      } else if (recStack.has(neighbor)) {
        return true;
      }
    }
  }
  recStack.delete(node);
  return false;
}

console.log(hasCycle(1, new Set(), new Set()));

medium

A. false

B. undefined

C. true

D. Error

Solution

1. Step 1: Analyze graph edges

   Graph edges: 1->2, 2->3, 3->1 form a cycle.

2. Step 2: Trace recursion and cycle detection

   Starting at 1, recursion visits 2, then 3, then back to 1 which is in recursion stack, so returns true.

3. Final Answer:

   true -> Option C

4. Quick Check:

   Cycle exists in 1->2->3->1 path [OK]

Hint: Cycle if recursion stack revisits a node [OK]

Common Mistakes:

• Ignoring recursion stack check
• Assuming no cycle if visited is true
• Confusing visited and recursion stack sets

4. Identify the bug in this TypeScript cycle detection function for a directed graph:

function detectCycle(node: number, visited: Set<number>, recStack: Set<number>): boolean {
  if (visited.has(node)) {
    return false;
  }
  visited.add(node);
  recStack.add(node);
  for (const neighbor of graph.get(node) || []) {
    if (detectCycle(neighbor, visited, recStack)) {
      return true;
    }
  }
  recStack.delete(node);
  return false;
}

medium

A. Missing check if neighbor is in recursion stack to detect cycle

B. Visited set is not updated correctly

C. recStack is never cleared

D. Function does not return boolean

Solution

1. Step 1: Review cycle detection logic

   Cycle detection requires checking if neighbor is already in recursion stack to detect back edge.

2. Step 2: Identify missing condition

   The code calls recursion but does not check if neighbor is in recStack, so misses cycles.

3. Final Answer:

   Missing check if neighbor is in recursion stack to detect cycle -> Option A

4. Quick Check:

   Check recStack for back edges to detect cycles [OK]

Hint: Always check recursion stack for back edges [OK]

Common Mistakes:

• Skipping recursion stack membership check
• Confusing visited and recursion stack roles
• Not removing node from recursion stack after recursion

5. Given a directed graph represented as adjacency list:

const graph = new Map([
  [1, [2, 3]],
  [2, [4]],
  [3, [4, 5]],
  [4, [6]],
  [5, [3]],
  [6, []]
]);

Which nodes are part of at least one cycle?

hard

A. [1, 2, 4, 6]

B. [3, 5]

C. [2, 4, 6]

D. [1, 3, 5]

Solution

1. Step 1: Analyze edges for cycles

   Edges: 3->5 and 5->3 form a cycle between nodes 3 and 5.

2. Step 2: Check other nodes

   Nodes 1, 2, 4, 6 do not form cycles as no back edges lead to them.

3. Final Answer:

   [3, 5] -> Option B

4. Quick Check:

   Cycle nodes = 3 and 5 only [OK]

Hint: Look for back edges forming loops between nodes [OK]

Common Mistakes:

• Including nodes not in any cycle
• Missing nodes that form cycles
• Confusing path with cycle