Longest Cycle in a Graph - Practice Coding Problems

Longest Cycle in a Graph - Problem

Imagine you have a directed graph where each node can have at most one outgoing edge - like a one-way street system where each intersection has only one exit!

You're given n nodes numbered from 0 to n-1, represented by an array edges where edges[i] tells you which node you can reach from node i. If edges[i] = -1, it means node i has no outgoing edge (a dead end).

Your mission: Find the longest cycle in this graph! A cycle occurs when you can start at a node, follow the directed edges, and eventually return to your starting point.

Goal: Return the length of the longest cycle, or -1 if no cycle exists.

Example: If edges = [3,3,4,2,3], there's a cycle 3 → 2 → 4 → 3 with length 3.

Input & Output

example_1.py — Basic Cycle

$ Input: edges = [3,3,4,2,3]

› Output: 3

💡 Note: The graph has nodes 0→3, 1→3, 2→4, 3→2, 4→3. Starting from node 3, we get the path 3→2→4→3, forming a cycle of length 3.

example_2.py — Multiple Cycles

$ Input: edges = [2,-1,3,1]

› Output: 3

💡 Note: We have 0→2, 1→-1, 2→3, 3→1. The cycle is 1→3→1 (length 2) and 2→3→1→3 but since 1 doesn't connect back, the actual cycle is 1→3→1 (length 2). Wait, let me recalculate: 0→2→3→1→(dead end). Actually, there's no cycle here since 1→-1 is a dead end.

example_3.py — No Cycle

$ Input: edges = [1,2,-1]

› Output: -1

💡 Note: The path is 0→1→2→(dead end). No cycles exist since node 2 has no outgoing edge (edges[2] = -1).

Constraints

n == edges.length
2 ≤ n ≤ 10⁵
-1 ≤ edges[i] < n
edges[i] ≠ i (no self-loops)
Each node has at most one outgoing edge

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at an unvisited location and mark the time you arrived

Follow Arrows

Keep following the arrows, marking your arrival time at each new location

Detect Loop

If you reach a location you've already visited in this journey, you've found a loop!

Measure Loop

Calculate loop length by subtracting your original arrival time from current time

Key Takeaway

🎯 Key Insight: By using timestamps instead of complex state tracking, we can detect cycles in a single pass. When we revisit a location with a timestamp, the cycle length is simply the difference between current time and the stored timestamp!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a single DFS traversal with timestamps. As we explore each path, we assign timestamps to nodes. When we encounter a node that already has a timestamp from our current path, we've detected a cycle and can calculate its length as current_time - node_timestamp. This achieves O(n) time complexity with elegant cycle detection.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass DFS with Timestamps (Optimal)	O(n)	O(n)	Single DFS pass using timestamps to detect cycles efficiently
Two-Pass DFS with State Tracking	O(n)	O(n)	First pass marks all nodes, second pass detects cycles using timestamps
Brute Force (Start from Every Node)	O(n²)	O(n)	Try starting DFS from every node to find all possible cycles

One-Pass DFS with Timestamps (Optimal) — Algorithm Steps

Initialize timestamp array with -1 (unvisited)
For each unvisited node, start DFS with current time = 0
Assign timestamps incrementally during traversal
If we reach a node with existing timestamp, cycle detected
Calculate cycle length as current_time - node_timestamp

Visualization

Tap to expand

Step-by-Step Walkthrough

Assign timestamps

Mark each node with its position in current path

Follow edges

Continue until reaching visited node or dead end

Detect cycle

If we reach timestamped node, calculate cycle length

Mark processed

Mark all path nodes as processed (-2)

Code -

solution.c — C

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

int longestCycle(int* edges, int edgesSize) {
    int* timeStamp = (int*)malloc(edgesSize * sizeof(int));
    for (int i = 0; i < edgesSize; i++) {
        timeStamp[i] = -1; // -1 means unvisited
    }
    int maxCycle = -1;
    
    for (int i = 0; i < edgesSize; i++) {
        if (timeStamp[i] != -1) { // Already visited
            continue;
        }
        
        int currentTime = 0;
        int node = i;
        
        // Follow the path until we hit a cycle or dead end
        while (node != -1 && timeStamp[node] == -1) {
            timeStamp[node] = currentTime;
            currentTime++;
            node = edges[node];
        }
        
        // If we found a cycle (node has timestamp >= 0 from current path)
        if (node != -1 && timeStamp[node] != -2) {
            int cycleLength = currentTime - timeStamp[node];
            if (cycleLength > maxCycle) {
                maxCycle = cycleLength;
            }
        }
        
        // Mark all nodes in this path as fully processed
        node = i;
        while (node != -1 && timeStamp[node] >= 0) {
            int temp = edges[node];
            timeStamp[node] = -2; // Mark as processed
            node = temp;
        }
    }
    
    free(timeStamp);
    return maxCycle;
}

int main() {
    int edges[] = {3,3,4,2,3};
    printf("%d\n", longestCycle(edges, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited exactly once during the DFS traversal

✓ Linear Growth

Space Complexity

O(n)

Space for timestamp array and recursion stack (bounded by n)

⚡ Linearithmic Space

68.2K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass DFS with Timestamps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler