Shortest Cycle in a Graph - Practice Coding Problems

Shortest Cycle in a Graph - Problem

Imagine you're exploring a network of interconnected cities where roads are bi-directional and you want to find the shortest circular route that brings you back to where you started.

Given an undirected graph with n vertices labeled from 0 to n-1, represented by a 2D array edges where edges[i] = [ui, vi] indicates a bidirectional connection between vertices ui and vi, your task is to find the length of the shortest cycle.

Key constraints:

Each pair of vertices has at most one direct edge
No vertex connects to itself (no self-loops)
A cycle must use each edge exactly once

Return the length of the shortest cycle, or -1 if no cycle exists.

Example: In a graph with edges [[0,1],[1,2],[2,0],[2,3]], the shortest cycle is 0→1→2→0 with length 3.

Input & Output

example_1.py — Simple Triangle

$ Input: n = 7, edges = [[0,1],[1,2],[2,0],[3,4],[4,5],[6,3]]

› Output: 3

💡 Note: The shortest cycle is 0 → 1 → 2 → 0 with length 3. There are other components in the graph but they don't form cycles.

example_2.py — No Cycle

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

› Output: -1

💡 Note: The graph is a tree (no cycles exist), so we return -1.

example_3.py — Multiple Cycles

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

› Output: 3

💡 Note: There are two cycles: 0→1→2→3→0 (length 4) and 2→4→5→2 (length 3). The shortest is length 3.

Constraints

2 ≤ n ≤ 1000
1 ≤ edges.length ≤ min(2000, n * (n - 1) / 2)
edges[i].length == 2
0 ≤ u_i, v_i ≤ n - 1
u_i ≠ v_i
No repeated edges between the same pair of vertices

Visualization

Tap to expand

Understanding the Visualization

Choose starting intersection

Pick any vertex as the starting point for BFS exploration

Explore direct neighbors (Level 1)

Visit all vertices directly connected to the start, marking their distance as 1

Explore next level (Level 2)

From level 1 vertices, explore their unvisited neighbors at distance 2

Detect back edge

When we find an edge to a previously visited vertex (not our parent), we've found a cycle

Calculate cycle length

Cycle length = distance to current vertex + distance to found vertex + 1

Key Takeaway

🎯 Key Insight: BFS naturally finds shortest paths, so the first cycle we detect from any starting vertex is guaranteed to be the shortest cycle containing that vertex.

Asked in

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

The optimal approach uses BFS from each vertex to detect the shortest cycle. Since BFS explores vertices level by level, when we encounter a back edge (to a previously visited non-parent vertex), we've found the shortest cycle through the current starting vertex. The key insight is that BFS guarantees shortest paths, making this approach both correct and efficient with O(V × (V + E)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ BFS from Every Vertex (Optimal)	O(V * (V + E))	O(V + E)	Use BFS from each vertex to find the shortest cycle through that vertex

BFS from Every Vertex (Optimal) — Algorithm Steps

Build an adjacency list representation of the graph
For each vertex, run BFS treating it as a potential cycle member
During BFS, track distance and parent for each vertex
When we reach a visited vertex that's not our parent, we found a cycle
Calculate cycle length and update the global minimum
Return the shortest cycle found across all starting vertices

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize BFS from vertex

Start BFS with distance 0, exploring level by level

Explore level 1 neighbors

Visit direct neighbors, marking distances and parents

Explore level 2 neighbors

Continue BFS, checking for back edges to non-parent visited nodes

Detect shortest cycle

When we find a back edge, calculate cycle length using distances

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} ArrayList;

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

ArrayList* createArrayList() {
    ArrayList* list = malloc(sizeof(ArrayList));
    list->data = malloc(sizeof(int) * 10);
    list->size = 0;
    list->capacity = 10;
    return list;
}

void addToList(ArrayList* list, int value) {
    if (list->size >= list->capacity) {
        list->capacity *= 2;
        list->data = realloc(list->data, sizeof(int) * list->capacity);
    }
    list->data[list->size++] = value;
}

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

void enqueue(Queue* q, int value) {
    q->data[q->rear] = value;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

int dequeue(Queue* q) {
    int value = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return value;
}

int findShortestCycle(int n, int** edges, int edgesSize, int* edgesColSize) {
    if (edgesSize == 0) return -1;
    
    // Build adjacency list
    ArrayList** graph = malloc(sizeof(ArrayList*) * n);
    for (int i = 0; i < n; i++) {
        graph[i] = createArrayList();
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        addToList(graph[u], v);
        addToList(graph[v], u);
    }
    
    int minCycle = INT_MAX;
    
    // Try BFS from each vertex
    for (int start = 0; start < n; start++) {
        int* dist = malloc(sizeof(int) * n);
        int* parent = malloc(sizeof(int) * n);
        for (int i = 0; i < n; i++) {
            dist[i] = -1;
            parent[i] = -1;
        }
        
        Queue* queue = createQueue(n);
        enqueue(queue, start);
        dist[start] = 0;
        
        while (queue->size > 0) {
            int node = dequeue(queue);
            
            for (int i = 0; i < graph[node]->size; i++) {
                int neighbor = graph[node]->data[i];
                if (dist[neighbor] == -1) { // Not visited
                    dist[neighbor] = dist[node] + 1;
                    parent[neighbor] = node;
                    enqueue(queue, neighbor);
                } else if (parent[node] != neighbor) { // Found cycle
                    int cycleLength = dist[node] + dist[neighbor] + 1;
                    if (cycleLength < minCycle) {
                        minCycle = cycleLength;
                    }
                }
            }
        }
        
        free(dist);
        free(parent);
        free(queue->data);
        free(queue);
    }
    
    // Clean up
    for (int i = 0; i < n; i++) {
        free(graph[i]->data);
        free(graph[i]);
    }
    free(graph);
    
    return minCycle == INT_MAX ? -1 : minCycle;
}

Time & Space Complexity

Time Complexity

⏱️

O(V * (V + E))

We run BFS from each of V vertices, and each BFS explores at most V vertices and E edges

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list takes O(V + E), BFS queue takes O(V), and visited array takes O(V)

✓ Linear Space

52.3K Views

Medium 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

BFS from Every Vertex (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler