Longest Cycle in a Graph

Longest Cycle in a Graph - Problem

You are given a directed graph of n nodes numbered from 0 to n - 1, where each node has at most one outgoing edge.

The graph is represented with a given 0-indexed array edges of size n, indicating that there is a directed edge from node i to node edges[i]. If there is no outgoing edge from node i, then edges[i] == -1.

Return the length of the longest cycle in the graph. If no cycle exists, return -1.

A cycle is a path that starts and ends at the same node.

Input & Output

Example 1 — Graph with Cycle

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

› Output: 3

💡 Note: The longest cycle is 3 → 2 → 4 → 3 with length 3. There's also a self-loop at node 1 (1 → 1) with length 1, but 3 is longer.

Example 2 — No Cycles

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

› Output: -1

💡 Note: Following paths: 0→2→3→1→(dead end), no cycles exist in this graph, so return -1.

Example 3 — Self Loop

$ Input: edges = [1,0,0]

› Output: 2

💡 Note: There's a cycle 0 ↔ 1 with length 2. Node 2 points to node 0 but doesn't create a longer cycle.

Constraints

1 ≤ edges.length ≤ 10⁵
edges[i] == -1 or 0 ≤ edges[i] < edges.length
Each node has at most one outgoing edge

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 A Apple 6

The key insight is that since each node has at most one outgoing edge, we can use DFS with timestamps to efficiently detect cycles. The optimal approach uses a single pass with O(n) time complexity by tracking visit states and calculating cycle lengths using time differences.

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force - Try All Starting Points

⏱️ Time: O(n²) Space: O(n)

For each node, follow the edges and detect cycles by checking if we revisit a node. Keep track of the longest cycle found across all starting points.

DFS with Global Visited Tracking

⏱️ Time: O(n) Space: O(n)

Perform DFS from each unvisited node, using a global visited set to avoid re-exploring nodes. For each path, detect cycles using a separate path tracking mechanism.

Optimized DFS with Time Stamps

⏱️ Time: O(n) Space: O(n)

Use DFS with time stamps to track when nodes are first visited. When we encounter a node that's already in the current path, we can calculate the cycle length using the time difference.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct Node {
    int val;
    int count;
    struct Node* next;
};

int* solution(int* nums, int numsSize, int* returnSize) {
    int threshold = numsSize / 3;
    struct Node* head = NULL;
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 0;
    
    // Count frequencies using linked list
    for (int i = 0; i < numsSize; i++) {
        struct Node* curr = head;
        bool found = false;
        
        while (curr) {
            if (curr->val == nums[i]) {
                curr->count++;
                found = true;
                break;
            }
            curr = curr->next;
        }
        
        if (!found) {
            struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
            newNode->val = nums[i];
            newNode->count = 1;
            newNode->next = head;
            head = newNode;
        }
    }
    
    // Find elements with count > threshold
    struct Node* curr = head;
    while (curr) {
        if (curr->count > threshold) {
            result[(*returnSize)++] = curr->val;
        }
        struct Node* temp = curr;
        curr = curr->next;
        free(temp);
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

38.4K Views

Medium Frequency

~35 min Avg. Time

892 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