Cycle Detection in Graph - Problem

Given a directed graph represented as an adjacency list, determine if the graph contains a cycle using Depth-First Search (DFS) and the coloring technique.

In the coloring technique:

WHITE (0): Node not visited yet
GRAY (1): Node currently being processed (in DFS stack)
BLACK (2): Node completely processed (DFS finished)

A cycle exists if during DFS traversal, we encounter a GRAY node (indicating a back edge to an ancestor in the current DFS path).

Input: Adjacency list representation of a directed graph as a 2D array where graph[i] contains all nodes that node i points to.

Output: Return true if the graph contains a cycle, false otherwise.

Input & Output

Example 1 — Graph with Cycle

$ Input: graph = [[1],[2],[0]]

› Output: true

💡 Note: Graph has nodes 0→1→2→0 forming a cycle. Node 0 points to 1, node 1 points to 2, node 2 points back to 0.

Example 2 — Acyclic Graph

$ Input: graph = [[1],[2],[]]

› Output: false

💡 Note: Graph is 0→1→2 with no back edges. Node 2 has no outgoing edges, so no cycle exists.

Example 3 — Self Loop

$ Input: graph = [[0]]

› Output: true

💡 Note: Node 0 points to itself, creating a self-loop which is a cycle of length 1.

Constraints

1 ≤ graph.length ≤ 10⁴
0 ≤ graph[i].length ≤ 10⁴
0 ≤ graph[i][j] < graph.length
graph[i][j] != i (no self-loops except in test cases)
All edges are unique

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using the three-color DFS technique where encountering a GRAY node indicates a back edge and thus a cycle. The optimal approach runs in O(V + E) time and O(V) space by visiting each vertex once and checking each edge once during DFS traversal.

Common Approaches

✓ Check All Possible Paths

⏱️ Time: O(V × 2^V) Space: O(V)

This approach explores every possible path from every node to detect cycles. For each starting node, it performs DFS and maintains a path array to track the current path being explored.

DFS with Three Colors (Optimal)

⏱️ Time: O(V + E) Space: O(V)

This is the standard and optimal approach using DFS traversal with a three-color system. We mark nodes as WHITE initially, GRAY when processing, and BLACK when completed.

Check All Possible Paths — Algorithm Steps

For each node in the graph, start a DFS traversal
Maintain a current path array to track nodes in the current path
If we visit a node already in the current path, we found a cycle
Backtrack and try all possible paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Node 0

Begin DFS from first node, track current path

Explore All Paths

Follow every connection recursively

Check for Revisits

If we revisit a node in current path, cycle found

Repeat for All

Repeat process for every starting node

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool hasCycleFromNode(int** graph, int* graphSizes, int node, int* path, int pathSize) {
    for (int i = 0; i < pathSize; i++) {
        if (path[i] == node) {
            return true;
        }
    }
    
    path[pathSize] = node;
    for (int i = 0; i < graphSizes[node]; i++) {
        if (hasCycleFromNode(graph, graphSizes, graph[node][i], path, pathSize + 1)) {
            return true;
        }
    }
    return false;
}

bool solution(int** graph, int* graphSizes, int n) {
    int* path = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        if (hasCycleFromNode(graph, graphSizes, i, path, 0)) {
            free(path);
            return true;
        }
    }
    
    free(path);
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* ptr = line + 1;
    while (*ptr != ']') {
        if (*ptr == '[') n++;
        ptr++;
    }
    
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSizes = (int*)malloc(n * sizeof(int));
    
    ptr = line + 1;
    for (int i = 0; i < n; i++) {
        while (*ptr != '[') ptr++;
        ptr++;
        
        int count = 0;
        char* start = ptr;
        while (*ptr != ']') {
            if (*ptr == ',') count++;
            ptr++;
        }
        if (ptr > start && *(ptr-1) != '[') count++;
        
        graph[i] = (int*)malloc(count * sizeof(int));
        graphSizes[i] = count;
        
        ptr = start;
        for (int j = 0; j < count; j++) {
            graph[i][j] = atoi(ptr);
            while (*ptr != ',' && *ptr != ']') ptr++;
            if (*ptr == ',') ptr++;
        }
        ptr++;
    }
    
    bool result = solution(graph, graphSizes, n);
    printf(result ? "true\n" : "false\n");
    
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V × 2^V)

For each vertex, we explore all possible paths which can be exponential

✓ Linear Growth

Space Complexity

O(V)

Recursion stack and path array can go up to V nodes deep

✓ Linear Space

73.3K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Cycle Detection in Graph - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Check All Possible Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler