Count Visited Nodes in a Directed Graph

Count Visited Nodes in a Directed Graph - Problem

There is a directed graph consisting of n nodes numbered from 0 to n - 1 and n directed edges.

You are given a 0-indexed array edges where edges[i] indicates that there is an edge from node i to node edges[i].

Consider the following process on the graph:

You start from a node x and keep visiting other nodes through edges until you reach a node that you have already visited before on this same process.

Return an array answer where answer[i] is the number of different nodes that you will visit if you perform the process starting from node i.

Input & Output

Example 1 — Basic Cycle

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

› Output: [3,4,2,2]

💡 Note: Starting from node 0: 0→2→3→2 (visits 3 nodes). Starting from node 1: 1→0→2→3→2 (visits 4 nodes). Starting from node 2: 2→3→2 (visits 2 nodes). Starting from node 3: 3→2→3 (visits 2 nodes).

Example 2 — Self Loop

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

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

💡 Note: Node 0: 0→1→2→2 (visits 3 nodes, stops at self-loop). Node 1: 1→2→2 (visits 2 nodes). Node 2: 2→2 (visits 1 node, immediate self-loop). Node 3: 3→4→4 (visits 2 nodes). Node 4: 4→4 (visits 1 node).

Example 3 — Linear Chain

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

› Output: [3,3,3]

💡 Note: All nodes eventually cycle through 0→1→2→0, so each starting point visits all 3 nodes before repeating.

Constraints

n == edges.length
2 ≤ n ≤ 10⁵
0 ≤ edges[i] ≤ n - 1
edges[i] != i

Visualization

Tap to expand

Asked in

G Google 28 M Microsoft 15 A Amazon 12 f Meta 8

The key insight is that every path in a functional graph eventually leads to a cycle. We can use cycle detection with memoization to efficiently count visited nodes. The optimal approach uses DFS with node coloring (WHITE/GRAY/BLACK) to detect cycles and calculate results in O(n) time and O(n) space.

Common Approaches

✓ Dfs

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

Brute Force Simulation

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

For each starting node, follow the edges and track visited nodes until we encounter a node we've seen before in this walk. Count the unique nodes visited.

Cycle Detection with Path Tracking

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

Use a more efficient approach that tracks node states (unvisited, visiting, visited) to detect cycles and calculate results in one pass. This avoids redundant work by processing each node exactly once.

DFS with Memoization

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

Use depth-first search with memoization to avoid recalculating the number of visited nodes for paths we've already explored. Cache results for nodes we've completely processed.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* parseArray(char* input, int* size) {
    int len = strlen(input);
    int* result = (int*)malloc(len * sizeof(int));
    int count = 0;
    
    int i = 1; // Skip '['
    while (i < len && input[i] != ']') {
        if (input[i] >= '0' && input[i] <= '9') {
            int num = 0;
            while (i < len && input[i] >= '0' && input[i] <= '9') {
                num = num * 10 + (input[i] - '0');
                i++;
            }
            result[count++] = num;
        } else {
            i++;
        }
    }
    
    *size = count;
    return result;
}

int countVisitedNodes(int* edges, int n, int start) {
    int* visited = (int*)calloc(n, sizeof(int));
    int current = start;
    int count = 0;
    
    while (!visited[current]) {
        visited[current] = 1;
        count++;
        current = edges[current];
    }
    
    free(visited);
    return count;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline if present
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
    }
    
    int n;
    int* edges = parseArray(input, &n);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", countVisitedNodes(edges, n, i));
    }
    printf("]\n");
    
    free(edges);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.5K 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