Distance to a Cycle in Undirected Graph - Practice Coding Problems

Distance to a Cycle in Undirected Graph - Problem

Finding Distances to the Cycle in a Connected Graph

You're given a special type of connected undirected graph with exactly one cycle. Think of it like a tree with one extra edge that creates a single loop. Your task is to find how far each node is from this cycle.

Given:
• n nodes numbered from 0 to n-1
• A 2D array edges where edges[i] = [node1, node2] represents bidirectional connections
• The graph is connected and contains exactly one cycle

Goal: Return an array where answer[i] is the minimum distance from node i to any node in the cycle.

Distance is defined as the minimum number of edges needed to travel between two nodes.

Input & Output

example_1.py — Basic Cycle

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

› Output: [1,0,0,0,0,1,2]

💡 Note: Nodes 1,2,3,4 form a cycle. Node 0 is 1 edge from node 1 (cycle). Node 5 is 1 edge from node 2 (cycle). Node 6 is 2 edges from the cycle (6→5→2).

example_2.py — Triangle Cycle

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

› Output: [0,0,0,1]

💡 Note: Nodes 0,1,2 form a triangle cycle. Node 3 is connected to node 0 (cycle node) so its distance is 1.

example_3.py — Single Self-Loop

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

› Output: [2,0,0]

💡 Note: Nodes 1,2 form a cycle with 2 nodes. Node 0 is 2 edges away from the cycle (0→1→2 or 0→1, and 1 is in cycle so distance is 1, but 0→1 where 1 is in cycle gives distance 1).

Constraints

3 ≤ n ≤ 10⁵
n ≤ edges.length ≤ 10⁵
edges[i].length == 2
0 ≤ node1_i, node2_i ≤ n - 1
node1_i ≠ node2_i
The graph is connected
The graph has exactly one cycle
No multiple edges between same pair of nodes

Visualization

Tap to expand

Understanding the Visualization

Map the Neighborhood

Build a graph representation of all the streets connecting houses

Find the Central Loop

Use DFS to identify which houses are on the circular road (the cycle)

Start from the Loop

Begin BFS simultaneously from all houses on the circular road

Expand Outward

BFS naturally finds shortest distances to all houses on dead-end streets

Key Takeaway

🎯 Key Insight: Instead of calculating distances from each house individually, we start from the central loop and expand outward. This finds all distances in just one sweep - much like how emergency services would plan response times from a central station!

Asked in

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

The optimal solution uses multi-source BFS after identifying cycle nodes. First, detect the cycle using DFS with parent tracking. Then initialize BFS queue with all cycle nodes (distance 0) and expand outward simultaneously. This achieves O(n) time complexity - much better than running BFS from each node individually.

Common Approaches

Approach	Time	Space	Notes
✓ Multi-Source BFS (Optimal)	O(n)	O(n)	Find cycle first, then run BFS from all cycle nodes simultaneously
Brute Force (BFS from Every Node)	O(n²)	O(n)	Run BFS from each node to find distance to any cycle node

Multi-Source BFS (Optimal) — Algorithm Steps

Build adjacency list from edges
Find the cycle using DFS with parent tracking
Initialize BFS queue with all cycle nodes (distance 0)
Run multi-source BFS to calculate distances to all other nodes
Return the distance array

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Cycle

Find all nodes that are part of the cycle (marked in blue)

Initialize Queue

Add all cycle nodes to BFS queue with distance 0

BFS Wave 1

Process cycle nodes and mark their neighbors with distance 1

BFS Wave 2

Continue BFS to mark nodes at distance 2, and so on

Code -

solution.c — C

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

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

typedef struct {
    Node* front;
    Node* rear;
} Queue;

void enqueue(Queue* q, int val) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->val = val;
    node->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = node;
    } else {
        q->rear->next = node;
        q->rear = node;
    }
}

bool dequeue(Queue* q, int* val) {
    if (q->front == NULL) return false;
    
    Node* temp = q->front;
    *val = temp->val;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    return true;
}

bool findCycleDFS(int** graph, int* graphSize, int node, int parent,
                  bool* visited, int* parentArr, bool* cycleNodes, int n) {
    visited[node] = true;
    parentArr[node] = parent;
    
    for (int i = 0; i < graphSize[node]; i++) {
        int neighbor = graph[node][i];
        if (neighbor == parent) continue;
        
        if (visited[neighbor]) {
            // Back edge - trace cycle
            int curr = node;
            cycleNodes[neighbor] = true;
            while (curr != neighbor) {
                cycleNodes[curr] = true;
                curr = parentArr[curr];
            }
            return true;
        } else if (findCycleDFS(graph, graphSize, neighbor, node, 
                               visited, parentArr, cycleNodes, n)) {
            return true;
        }
    }
    return false;
}

int* distanceToCycle(int n, int** edges, int edgesSize, int* returnSize) {
    *returnSize = n;
    
    // Build adjacency list
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1];
        graph[u][graphSize[u]++] = v;
        graph[v][graphSize[v]++] = u;
    }
    
    // Find cycle nodes
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int* parentArr = (int*)malloc(n * sizeof(int));
    bool* cycleNodes = (bool*)calloc(n, sizeof(bool));
    
    for (int i = 0; i < n; i++) parentArr[i] = -1;
    
    findCycleDFS(graph, graphSize, 0, -1, visited, parentArr, cycleNodes, n);
    
    // Multi-source BFS
    Queue q = {NULL, NULL};
    int* distances = (int*)malloc(n * sizeof(int));
    
    // Initialize distances and queue with cycle nodes
    for (int i = 0; i < n; i++) {
        if (cycleNodes[i]) {
            distances[i] = 0;
            enqueue(&q, i);
        } else {
            distances[i] = -1;
        }
    }
    
    // BFS from all cycle nodes
    int current;
    while (dequeue(&q, &current)) {
        for (int i = 0; i < graphSize[current]; i++) {
            int neighbor = graph[current][i];
            if (distances[neighbor] == -1) {
                distances[neighbor] = distances[current] + 1;
                enqueue(&q, neighbor);
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) free(graph[i]);
    free(graph);
    free(graphSize);
    free(visited);
    free(parentArr);
    free(cycleNodes);
    
    return distances;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** edges = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        edges[i] = (int*)malloc(2 * sizeof(int));
        scanf("%d %d", &edges[i][0], &edges[i][1]);
    }
    
    int returnSize;
    int* result = distanceToCycle(n, edges, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    for (int i = 0; i < n; i++) free(edges[i]);
    free(edges);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) to find the cycle + O(n) for multi-source BFS = O(n) total

✓ Linear Growth

Space Complexity

O(n)

Space for adjacency list, visited arrays, and BFS queue

⚡ Linearithmic Space

87.3K Views

Medium-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

Multi-Source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler