Cycle Detection in Undirected Graph in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the adjacency list for the graph.

DSA Java

List<List<Integer>> graph = new ArrayList<>();
for (int i = 0; i < n; i++) {
    graph.[1](new ArrayList<>());
}

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

Aput

Binsert

Cadd

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using methods like put or insert which do not exist for ArrayList.

Trying to use append which is not a Java ArrayList method.

The adjacency list is a list of lists. We use add to add a new empty list for each node.

2fill in blank

medium

Complete the code to add an undirected edge between two nodes u and v.

DSA Java

graph.get(u).[1](v);
graph.get(v).add(u);

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

Ainsert

Badd

Cput

Dappend

Attempts:

3 left

💡 Hint

Common Mistakes

Using put or insert which are not methods of ArrayList.

Using append which is not a Java method.

To add an edge in the adjacency list, we use add to add the neighbor node.

3fill in blank

hard

Fix the error in the DFS method signature for cycle detection.

DSA Java

private boolean dfs(int node, int parent, boolean[] visited, List<List<Integer>> graph) {
    if (visited[node]) {
        return true;
    }
    visited[node] = true;
    for (int neighbor : graph.[1](node)) {
        if (neighbor != parent) {
            if (dfs(neighbor, node, visited, graph)) {
                return true;
            }
        }
    }
    return false;
}

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

Aput

Binsert

Cadd

Dget

Attempts:

3 left

💡 Hint

Common Mistakes

Using put or add which are not for accessing elements.

Using insert which is not a method of ArrayList.

To access the neighbors of a node in the adjacency list, we use get(node).

4fill in blank

hard

Fill both blanks to complete the cycle detection loop over all nodes.

DSA Java

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

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

An

B-1

C0

Dvisited.length

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as parent which is a valid node and causes wrong cycle detection.

Using visited.length instead of n for loop limit.

The loop runs from 0 to n-1 nodes. The parent of the starting node is set to -1 because it has no parent.

5fill in blank

hard

Fill all three blanks to complete the cycle detection method.

DSA Java

public boolean hasCycle(int n, List<List<Integer>> edges) {
    List<List<Integer>> graph = new ArrayList<>();
    for (int i = 0; i < n; i++) {
        graph.[1](new ArrayList<>());
    }
    for (List<Integer> edge : edges) {
        int u = edge.get(0);
        int v = edge.get(1);
        graph.get(u).[2](v);
        graph.get(v).add(u);
    }
    boolean[] visited = new boolean[n];
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            if (dfs(i, [3], visited, graph)) {
                return true;
            }
        }
    }
    return false;
}

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

Aadd

C-1

Dput

Attempts:

3 left

💡 Hint

Common Mistakes

Using put instead of add for lists.

Using 0 as parent which causes incorrect cycle detection.

We add empty lists for each node, add edges using add, and start DFS with parent -1.

Practice

1. What is the main idea behind detecting a cycle in an undirected graph using DFS?

easy

A. If the graph has more edges than nodes, it always has a cycle.

B. If all nodes are visited exactly once, the graph has a cycle.

C. If the graph is disconnected, it contains a cycle.

D. If we visit a node that is already visited and is not the parent, a cycle exists.

Solution

1. Step 1: Understand DFS traversal in undirected graph

   DFS visits nodes and tracks the parent node to avoid false cycle detection.

2. Step 2: Detect cycle condition

   If during DFS, a visited node is found that is not the parent, it means a back edge exists, indicating a cycle.

3. Final Answer:

   If we visit a node that is already visited and is not the parent, a cycle exists. -> Option D

4. Quick Check:

   Cycle detection in undirected graph = check visited node not parent [OK]

Hint: Check visited nodes excluding parent during DFS to find cycles [OK]

Common Mistakes:

• Confusing parent node with visited node
• Assuming disconnected graph always has cycles
• Thinking more edges than nodes always means cycle

2. Which of the following Java method signatures is correct for a DFS function used in cycle detection in an undirected graph?

easy

A. boolean dfs(int node, boolean[] visited, List graph)

B. void dfs(int node, int parent, boolean[] visited, List<Integer> graph)

C. boolean dfs(int node, int parent, boolean[] visited, List graph)

D. int dfs(int node, int parent, boolean[] visited, List graph)

Solution

1. Step 1: Identify parameters needed for DFS cycle detection

   DFS needs current node, parent node, visited array, and adjacency list graph.

2. Step 2: Check return type and parameter types

   Return type boolean indicates if cycle found; graph must be List of Lists for adjacency; parent is needed.

3. Final Answer:

   boolean dfs(int node, int parent, boolean[] visited, List<List<Integer>> graph) -> Option C

4. Quick Check:

   DFS signature with parent and boolean return = boolean dfs(int node, int parent, boolean[] visited, List graph) [OK]

Hint: DFS needs parent node and boolean return for cycle detection [OK]

Common Mistakes:

• Using void return type instead of boolean
• Passing graph as List<Integer> instead of List
• Omitting parent parameter

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

import java.util.*;
public class GraphCycle {
    static boolean dfs(int node, int parent, boolean[] visited, List graph) {
        visited[node] = true;
        for (int adj : graph.get(node)) {
            if (!visited[adj]) {
                if (dfs(adj, node, visited, graph)) return true;
            } else if (adj != parent) {
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int n = 4;
        List graph = new ArrayList<>();
        for (int i = 0; i < n; i++) graph.add(new ArrayList<>());
        graph.get(0).add(1); graph.get(1).add(0);
        graph.get(1).add(2); graph.get(2).add(1);
        graph.get(2).add(3); graph.get(3).add(2);
        graph.get(3).add(1); graph.get(1).add(3);
        boolean[] visited = new boolean[n];
        boolean hasCycle = false;
        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                if (dfs(i, -1, visited, graph)) {
                    hasCycle = true;
                    break;
                }
            }
        }
        System.out.println(hasCycle);
    }
}

medium

A. true

B. false

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Analyze graph edges and structure

   Graph edges: 0-1, 1-2, 2-3, 3-1 form a cycle (1-2-3-1).

2. Step 2: Trace DFS cycle detection logic

   DFS finds visited node 1 again from 3 (not parent), so returns true indicating cycle.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Cycle detected in graph = true [OK]

Hint: Look for back edge to visited node not parent to confirm cycle [OK]

Common Mistakes:

• Ignoring the edge 3-1 that closes the cycle
• Assuming no cycle because graph is connected
• Misunderstanding parent check in DFS

4. Identify the bug in the following Java code snippet for cycle detection in an undirected graph:

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

medium

A. Incorrect parent check condition

B. Missing return statement for recursive dfs call result

C. Visited array not updated correctly

D. Graph adjacency list type is wrong

Solution

1. Step 1: Review recursive DFS calls

   Recursive call dfs(adj, node, visited, graph) is made but its boolean result is ignored.

2. Step 2: Understand impact of ignoring return value

   If a cycle is detected deeper, it won't propagate true back, causing false negatives.

3. Final Answer:

   Missing return statement for recursive dfs call result -> Option B

4. Quick Check:

   Return recursive call result to detect cycles correctly [OK]

Hint: Always return recursive DFS call result when checking for cycles [OK]

Common Mistakes:

• Not returning true from recursive calls
• Confusing parent check logic
• Not marking nodes visited before recursion

5. Given an undirected graph represented as adjacency list:

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

Which of the following modifications will correctly detect a cycle in this graph using DFS cycle detection method?

hard

A. Start DFS from node 0 and pass -1 as parent; check visited nodes for back edges.

B. Start DFS from node 4 only; ignore parent parameter in DFS calls.

C. Use BFS instead of DFS without parent tracking to detect cycles.

D. Mark nodes visited after all recursive calls complete.

Solution

1. Step 1: Understand graph structure and cycle presence

   Edges form a cycle: 0-1-3-2-0. Starting DFS from 0 covers all nodes.

2. Step 2: Apply correct DFS cycle detection method

   Starting DFS from 0 with parent -1 and checking visited nodes excluding parent detects cycle correctly.

3. Final Answer:

   Start DFS from node 0 and pass -1 as parent; check visited nodes for back edges. -> Option A

4. Quick Check:

   Proper DFS start and parent check detects cycle [OK]

Hint: Start DFS from any node with parent -1 and track visited nodes [OK]

Common Mistakes:

• Ignoring parent parameter causing false positives
• Starting DFS from leaf node only
• Marking visited nodes too late