Shortest Cycle in a Graph

Shortest Cycle in a Graph - Problem

There is a bi-directional graph with n vertices, where each vertex is labeled from 0 to n - 1. The edges in the graph are represented by a given 2D integer array edges, where edges[i] = [ui, vi] denotes an edge between vertex ui and vertex vi.

Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.

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

A cycle is a path that starts and ends at the same node, and each edge in the path is used only once.

Input & Output

Example 1 — Simple Triangle

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

› Output: 3

💡 Note: The graph forms a triangle: 0→1→2→0. This cycle has length 3, which is the shortest possible cycle.

Example 2 — Multiple Cycles

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

› Output: 4

💡 Note: There's a 4-cycle: 1→2→3→4→1, and vertex 5 is connected but doesn't form a shorter cycle.

Example 3 — No Cycle

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

› Output: -1

💡 Note: This is a simple path with no cycles, so return -1.

Constraints

2 ≤ n ≤ 1000
1 ≤ edges.length ≤ n * (n - 1) / 2
edges[i].length == 2
0 ≤ ui, vi ≤ n - 1
ui != vi
There are no repeated edges

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is to use BFS from each vertex to find the shortest cycle containing that vertex. When BFS encounters a visited vertex through a different path, we've found a cycle. The cycle length is the sum of distances from both endpoints plus 1. Best approach uses BFS from each vertex. Time: O(V*(V+E)), Space: O(V+E)

Common Approaches

✓ BFS from Each Vertex

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

For each vertex, perform BFS to explore neighbors level by level. When we encounter a visited vertex through a different path, we've found a cycle. BFS guarantees finding the shortest cycle from each starting vertex.

Try All Paths (DFS)

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

For each vertex, perform DFS to explore all paths. When we encounter a visited vertex that's not the immediate parent, we've found a cycle. Track the shortest cycle found across all starting vertices.

BFS from Each Vertex — Algorithm Steps

Build adjacency list from edges
For each vertex, start BFS with queue
Track distance and parent for each node
When we reach a visited node via different parent, calculate cycle length

Visualization

Tap to expand

Step-by-Step Walkthrough

Start BFS

Begin BFS from each vertex with distance 0

Explore Levels

Visit neighbors level by level, tracking distances

Detect Cycle

When we reach a visited node via different path, calculate cycle

Code -

solution.c — C

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

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX_N 1000

typedef struct Node {
    int vertex;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
} AdjList;

typedef struct {
    int vertex;
    int dist;
} QueueNode;

typedef struct {
    QueueNode* data;
    int front;
    int rear;
    int capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->capacity = capacity;
    queue->front = 0;
    queue->rear = 0;
    queue->data = (QueueNode*)malloc(capacity * sizeof(QueueNode));
    return queue;
}

void enqueue(Queue* queue, int vertex, int dist) {
    queue->data[queue->rear].vertex = vertex;
    queue->data[queue->rear].dist = dist;
    queue->rear++;
}

QueueNode dequeue(Queue* queue) {
    return queue->data[queue->front++];
}

int isEmpty(Queue* queue) {
    return queue->front == queue->rear;
}

void freeQueue(Queue* queue) {
    free(queue->data);
    free(queue);
}

void addEdge(AdjList* graph, int u, int v) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->vertex = v;
    newNode->next = graph[u].head;
    graph[u].head = newNode;
    
    newNode = (Node*)malloc(sizeof(Node));
    newNode->vertex = u;
    newNode->next = graph[v].head;
    graph[v].head = newNode;
}

int bfs(AdjList* graph, int n, int start) {
    int* dist = (int*)malloc(n * sizeof(int));
    int* parent = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        dist[i] = -1;
        parent[i] = -1;
    }
    
    Queue* queue = createQueue(n * n);
    enqueue(queue, start, 0);
    dist[start] = 0;
    
    int minCycle = INT_MAX;
    
    while (!isEmpty(queue)) {
        QueueNode current = dequeue(queue);
        int u = current.vertex;
        int d = current.dist;
        
        Node* temp = graph[u].head;
        while (temp != NULL) {
            int v = temp->vertex;
            
            if (dist[v] == -1) {
                dist[v] = d + 1;
                parent[v] = u;
                enqueue(queue, v, d + 1);
            } else if (parent[u] != v) {
                minCycle = MIN(minCycle, d + dist[v] + 1);
            }
            
            temp = temp->next;
        }
    }
    
    freeQueue(queue);
    free(dist);
    free(parent);
    
    return minCycle;
}

int solution(int** edges, int edgesSize, int n) {
    AdjList* graph = (AdjList*)malloc(n * sizeof(AdjList));
    for (int i = 0; i < n; i++) {
        graph[i].head = NULL;
    }
    
    for (int i = 0; i < edgesSize; i++) {
        addEdge(graph, edges[i][0], edges[i][1]);
    }
    
    int minCycleLength = INT_MAX;
    
    for (int start = 0; start < n; start++) {
        int cycleLen = bfs(graph, n, start);
        minCycleLength = MIN(minCycleLength, cycleLen);
    }
    
    for (int i = 0; i < n; i++) {
        Node* temp = graph[i].head;
        while (temp != NULL) {
            Node* toFree = temp;
            temp = temp->next;
            free(toFree);
        }
    }
    free(graph);
    
    return minCycleLength == INT_MAX ? -1 : minCycleLength;
}

int main() {
    char line[100000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    int edgesSize = 0;
    int bracketDepth = 0;
    for (int i = 0; line[i] != '\0'; i++) {
        if (line[i] == '[') {
            bracketDepth++;
            if (bracketDepth == 2) {
                edgesSize++;
            }
        } else if (line[i] == ']') {
            bracketDepth--;
        }
    }
    
    int** edges = (int**)malloc(edgesSize * sizeof(int*));
    for (int i = 0; i < edgesSize; i++) {
        edges[i] = (int*)malloc(2 * sizeof(int));
    }
    
    char* ptr = line;
    int edgeIdx = 0;
    bracketDepth = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            bracketDepth++;
            if (bracketDepth == 2 && edgeIdx < edgesSize) {
                ptr++;
                edges[edgeIdx][0] = (int)strtol(ptr, &ptr, 10);
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                edges[edgeIdx][1] = (int)strtol(ptr, &ptr, 10);
                edgeIdx++;
                bracketDepth = 1;
            }
        } else if (*ptr == ']') {
            bracketDepth--;
        }
        ptr++;
    }
    
    int maxVertex = 0;
    for (int i = 0; i < edgesSize; i++) {
        if (edges[i][0] > maxVertex) maxVertex = edges[i][0];
        if (edges[i][1] > maxVertex) maxVertex = edges[i][1];
    }
    int n = maxVertex + 1;
    
    int result = solution(edges, edgesSize, n);
    
    printf("%d\n", result);
    
    for (int i = 0; i < edgesSize; i++) {
        free(edges[i]);
    }
    free(edges);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V * (V + E))

BFS from each vertex takes O(V + E), done V times

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list, queue, and distance arrays

✓ Linear Space

18.5K Views

Medium Frequency

~25 min Avg. Time

485 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

BFS from Each Vertex — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler