Distance to a Cycle in Undirected Graph

Distance to a Cycle in Undirected Graph - Problem

You are given a positive integer n representing the number of nodes in a connected undirected graph containing exactly one cycle. The nodes are numbered from 0 to n - 1 (inclusive).

You are also given a 2D integer array edges, where edges[i] = [node1i, node2i] denotes that there is a bidirectional edge connecting node1i and node2i in the graph.

The distance between two nodes a and b is defined to be the minimum number of edges that are needed to go from a to b.

Return an integer array answer of size n, where answer[i] is the minimum distance between the ith node and any node in the cycle.

Input & Output

Example 1 — Basic Cycle with Branches

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

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

💡 Note: The cycle is nodes 1→2→4→3→1. Node 0 is distance 1 from cycle node 1. Node 5 is distance 1 from cycle node 4. Node 6 is distance 2 from cycle (via node 5 to node 4).

Example 2 — Simple Triangle

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

› Output: [0,0,0]

💡 Note: All nodes 0, 1, 2 form the cycle, so distance to cycle is 0 for all nodes.

Example 3 — Cycle with Long Chain

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

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

💡 Note: Cycle is 0→1→2→0. Node 3 connects to cycle node 1 (distance 1). Node 4 connects via node 3 (distance 2). Node 5 connects via nodes 4→3→1 (distance 3).

Constraints

3 ≤ n ≤ 10⁵
n - 1 ≤ 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 simple cycle.

Visualization

Tap to expand

Asked in

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

The key insight is to first identify the cycle using DFS, then use multi-source BFS starting from all cycle nodes simultaneously. This approach finds minimum distances efficiently in O(n) time by expanding outward from the cycle.

Common Approaches

✓ Optimized

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

Brute Force BFS from Every Node

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

First identify all cycle nodes by detecting the cycle in the graph. Then for each node, run BFS to find the minimum distance to any cycle node.

Multi-Source BFS (Optimal)

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

First identify all cycle nodes using DFS. Then start BFS from all cycle nodes at once, expanding outward to calculate minimum distances to all other nodes.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int customer_id;
    char name[100];
    char email[100];
} Customer;

int parseJsonInt(const char* json, const char* key) {
    char searchKey[50];
    sprintf(searchKey, "\"%s\":", key);
    char* pos = strstr(json, searchKey);
    if (!pos) return 0;
    pos += strlen(searchKey);
    return atoi(pos);
}

void parseJsonString(const char* json, const char* key, char* result) {
    char searchKey[50];
    sprintf(searchKey, "\"%s\":\"", key);
    char* pos = strstr(json, searchKey);
    if (!pos) {
        result[0] = '\0';
        return;
    }
    pos += strlen(searchKey);
    char* end = strchr(pos, '"');
    if (end) {
        int len = end - pos;
        strncpy(result, pos, len);
        result[len] = '\0';
    } else {
        result[0] = '\0';
    }
}

int parseJsonArray(const char* json, Customer* customers) {
    if (strcmp(json, "[]") == 0) return 0;
    
    int count = 0;
    char* pos = strchr(json, '{');
    
    while (pos != NULL) {
        char* end = strchr(pos, '}');
        if (!end) break;
        
        char objStr[500];
        int len = end - pos + 1;
        strncpy(objStr, pos, len);
        objStr[len] = '\0';
        
        customers[count].customer_id = parseJsonInt(objStr, "customer_id");
        parseJsonString(objStr, "name", customers[count].name);
        parseJsonString(objStr, "email", customers[count].email);
        count++;
        
        pos = strchr(end + 1, '{');
    }
    
    return count;
}

int solution(Customer* customers, int n, Customer* result) {
    char seenEmails[1000][100];
    int seenCount = 0;
    int resultCount = 0;
    
    for (int i = 0; i < n; i++) {
        int found = 0;
        for (int j = 0; j < seenCount; j++) {
            if (strcmp(customers[i].email, seenEmails[j]) == 0) {
                found = 1;
                break;
            }
        }
        
        if (!found) {
            strcpy(seenEmails[seenCount], customers[i].email);
            seenCount++;
            result[resultCount] = customers[i];
            resultCount++;
        }
    }
    
    return resultCount;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    Customer customers[1000];
    Customer result[1000];
    
    int n = parseJsonArray(input, customers);
    int resultCount = solution(customers, n, result);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("{\"customer_id\":%d,\"name\":\"%s\",\"email\":\"%s\"}",
               result[i].customer_id, result[i].name, result[i].email);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

15.7K Views

Medium Frequency

~25 min Avg. Time

342 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