Cycle Detection in Directed Graph in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to start DFS from each vertex to detect a cycle.

DSA Java

for (int i = 0; i < V; i++) {
    if (!visited[i]) {
        if (dfs(i, graph, visited, recStack) [1]) {
            return true;
        }
    }
}

Drag options to blanks, or click blank then click option'

A== true

B== false

C!= true

D!= false

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for false instead of true causes missing cycle detection.

Using != false is confusing and less clear.

The DFS function returns true if a cycle is detected. So we check if dfs(...) == true to return true.

2fill in blank

medium

Complete the code to mark the current node as visited and add it to recursion stack.

DSA Java

visited[node] = true;
recStack[node] = [1];

Drag options to blanks, or click blank then click option'

Anull

Btrue

Cfalse

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting recStack[node] to false causes cycle detection to fail.

Assigning node value instead of boolean causes errors.

We mark the node as true in recStack to indicate it is in the current recursion path.

3fill in blank

hard

Fix the error in the condition to detect a back edge indicating a cycle.

DSA Java

if (recStack[adj] [1]) {
    return true;
}

Drag options to blanks, or click blank then click option'

A== true

B!= true

C!= false

D== false

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for false instead of true misses cycles.

Using != true is confusing and incorrect here.

If the adjacent node is in the recursion stack (true), it means a cycle is found.

4fill in blank

hard

Fill both blanks to remove the node from recursion stack and return false when no cycle is found.

DSA Java

recStack[node] = [1];
return [2];

Drag options to blanks, or click blank then click option'

Afalse

Btrue

Cnode

Dnull

Attempts:

3 left

💡 Hint

Common Mistakes

Returning true here causes incorrect cycle detection.

Not removing node from recStack causes false positives.

After exploring all neighbors, remove node from recStack by setting false and return false as no cycle found.

5fill in blank

hard

Fill all three blanks to complete the DFS function signature and recursive call.

DSA Java

private boolean dfs(int [1], List<List<Integer>> [2], boolean[] visited, boolean[] [3]) {
    visited[node] = true;
    recStack[node] = true;
    for (int adj : graph.get(node)) {
        if (!visited[adj] && dfs(adj, graph, visited, recStack)) {
            return true;
        } else if (recStack[adj]) {
            return true;
        }
    }
    recStack[node] = false;
    return false;
}

Drag options to blanks, or click blank then click option'

Anode

Bgraph

CrecStack

Dvisited

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing parameter names causes compilation errors.

Passing wrong arrays causes logic errors.

The DFS function takes node, graph, visited array, and recursion stack array as parameters.

Practice

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

easy

A. The maximum degree of any node

B. The shortest path between two nodes

C. The total number of nodes in the graph

D. Whether there is a path that starts and ends at the same node following the direction of edges

Solution

1. Step 1: Understand cycle in directed graph

   A cycle means a path that starts and ends at the same node following edge directions.

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 the direction of edges -> Option D

4. Quick Check:

   Cycle detection = finding directed cycles [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 Java data structure is commonly used to keep track of nodes currently in the recursion stack during DFS for cycle detection?

easy

A. Stack

B. HashSet

C. Queue

D. ArrayList

Solution

1. Step 1: Identify recursion stack tracking

   During DFS, nodes in the current path are tracked to detect back edges indicating cycles.

2. Step 2: Choose suitable data structure

   A HashSet is used to quickly check if a node is in the current recursion stack.

3. Final Answer:

   HashSet -> Option B

4. Quick Check:

   Use HashSet to track recursion stack nodes [OK]

Hint: Use HashSet for O(1) check if node is in recursion stack [OK]

Common Mistakes:

• Using Queue which is FIFO, not suitable here
• Using Stack but not checking membership efficiently
• Using ArrayList which is slower for membership check

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

import java.util.*;

public class GraphCycle {
    private final int V = 3;
    private final List adj = new ArrayList<>();
    private final boolean[] visited = new boolean[V];
    private final boolean[] recStack = new boolean[V];

    public GraphCycle() {
        for (int i = 0; i < V; i++) adj.add(new ArrayList<>());
        adj.get(0).add(1);
        adj.get(1).add(2);
        adj.get(2).add(0);
    }

    private boolean dfs(int node) {
        if (recStack[node]) return true;
        if (visited[node]) return false;
        visited[node] = true;
        recStack[node] = true;
        for (int neighbor : adj.get(node)) {
            if (dfs(neighbor)) return true;
        }
        recStack[node] = false;
        return false;
    }

    public boolean hasCycle() {
        for (int i = 0; i < V; i++) {
            if (dfs(i)) return true;
        }
        return false;
    }

    public static void main(String[] args) {
        GraphCycle graph = new GraphCycle();
        System.out.println(graph.hasCycle());
    }
}

medium

A. true

B. false

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Analyze graph edges

   Edges: 0->1, 1->2, 2->0 form a cycle (0->1->2->0).

2. Step 2: Trace DFS cycle detection

   DFS from node 0 visits 1, then 2, then back to 0 which is in recursion stack, so returns true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Cycle exists in graph = true [OK]

Hint: Cycle if DFS revisits node in recursion stack [OK]

Common Mistakes:

• Ignoring recursion stack check
• Assuming no cycle because visited[] is true
• Confusing visited[] and recStack[] roles

4. Identify the bug in this cycle detection code snippet for a directed graph:

boolean dfs(int node, boolean[] visited, boolean[] recStack, List adj) {
    visited[node] = true;
    recStack[node] = true;
    for (int neighbor : adj.get(node)) {
        if (!visited[neighbor]) {
            dfs(neighbor, visited, recStack, adj);
        } else if (recStack[neighbor]) {
            return true;
        }
    }
    recStack[node] = false;
    return false;
}

medium

A. Loop iterates over wrong adjacency list

B. recStack is not reset to false

C. Missing return statement in recursive call

D. visited array is not updated

Solution

1. Step 1: Check recursive call handling

   Recursive call dfs(neighbor, ...) is made but its return value is ignored.

2. Step 2: Understand impact on cycle detection

   If dfs(neighbor) returns true (cycle found), this should be returned immediately to propagate detection.

3. Final Answer:

   Missing return statement in recursive call -> Option C

4. Quick Check:

   Return recursive call result to detect cycles [OK]

Hint: Return recursive dfs result to catch cycles early [OK]

Common Mistakes:

• Ignoring return value of recursive dfs
• Not resetting recStack[node] to false
• Confusing visited and recStack roles

5. Given a directed graph represented as adjacency list:

{
  0: [1],
  1: [2],
  2: [3],
  3: [1, 4],
  4: []
}

Which nodes are part of at least one cycle?

hard

A. [1, 2, 3]

B. [0, 1, 2, 3]

C. [1, 3]

D. [0, 4]

Solution

1. Step 1: Identify cycles in graph

   Edges: 1->2, 2->3, 3->1 form a cycle involving nodes 1, 2, 3.

2. Step 2: Check other nodes

   Node 0 points to 1 but is not in cycle; node 4 has no outgoing edges.

3. Final Answer:

   [1, 2, 3] -> Option A

4. Quick Check:

   Cycle nodes = [1, 2, 3] [OK]

Hint: Cycle nodes form closed loop edges [OK]

Common Mistakes:

• Including nodes that only lead to cycle but not in it
• Missing nodes inside the cycle
• Confusing cycle presence with reachability