Count Visited Nodes in a Directed Graph - Practice Coding Problems

Count Visited Nodes in a Directed Graph - Problem

Imagine exploring a maze of one-way paths where each room has exactly one exit leading to another room. You're given a directed graph with n nodes numbered from 0 to n-1, where each node i has exactly one outgoing edge to node edges[i].

Your task is to simulate a traversal process starting from each node: keep following the edges until you revisit a node you've already seen in this journey. Count how many different nodes you visit during this process (including the starting node, but not counting the final revisited node).

Goal: Return an array where answer[i] represents the number of unique nodes visited when starting the traversal from node i.

Example: If you start at node 0 and follow the path 0→1→2→1, you visit nodes {0, 1, 2} before revisiting node 1, so the answer is 3.

Input & Output

example_1.py — Simple Path with Cycle

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

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

💡 Note: Starting from node 0: 0→1→2→0 (revisit 0), visited {0,1,2} = 3 nodes. Starting from node 1: 1→2→0→1 (revisit 1), visited {1,2,0} = 3 nodes. Starting from node 2: 2→0→1→2 (revisit 2), visited {2,0,1} = 3 nodes. Starting from node 3: 3→0→1→2→0 (revisit 0), visited {3,0,1,2} = 4 nodes.

example_2.py — Self Loop

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

› Output: [2,2,3]

💡 Note: Starting from node 0: 0→1→0 (revisit 0), visited {0,1} = 2 nodes. Starting from node 1: 1→0→1 (revisit 1), visited {1,0} = 2 nodes. Starting from node 2: 2→0→1→0 (revisit 0), visited {2,0,1} = 3 nodes.

example_3.py — Single Node Cycle

$ Input: edges = [0]

› Output: [1]

💡 Note: Starting from node 0: 0→0 (immediately revisit 0), visited {0} = 1 node.

Visualization

Tap to expand

Understanding the Visualization

Start Exploration

Begin exploring from a room, marking our path

Track the Journey

Keep following doors and recording visited rooms

Detect the Loop

When we revisit a room, we've found our cycle

Calculate Results

Rooms in the cycle get cycle length, others add their distance

Memoize & Reuse

Store results to avoid re-exploring the same paths

Key Takeaway

🎯 Key Insight: By detecting cycles and using memoization, we solve this in O(n) time instead of O(n²), making it efficient even for large castles!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited at most twice - once for cycle detection and once for result computation

✓ Linear Growth

Space Complexity

O(n)

We need space for recursion stack, memoization array, and cycle detection

⚡ Linearithmic Space

Constraints

n == edges.length
1 ≤ n ≤ 10⁵
0 ≤ edges[i] ≤ n - 1
edges[i] ≠ i for all i
Each node has exactly one outgoing edge

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses DFS with memoization to avoid redundant path computations. Key insight: once we compute the result for any node, we can reuse it for all nodes that eventually reach it. The algorithm detects cycles efficiently and handles both cycle nodes (which have count = cycle length) and tail nodes (which add their distance to the cycle length).

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Memoization (Optimal)	O(n)	O(n)	Use DFS with memoization to avoid recomputing paths
Brute Force (Simulate Each Path)	O(n²)	O(n)	For each starting node, simulate the traversal process independently

DFS with Memoization (Optimal) — Algorithm Steps

Initialize a memoization array to store computed results
For each unvisited node, start DFS to find cycles and paths
During DFS, detect cycles using a visited state tracking
For nodes in cycles, all have the same count (cycle length)
For nodes leading to cycles, add their distance to cycle length
Use memoization to avoid recomputing paths

Visualization

Tap to expand

Step-by-Step Walkthrough

DFS from node

Start DFS and track the path until cycle or computed node

Detect cycle

Identify cycle start and compute cycle length

Backtrack with results

Fill results backwards: cycle nodes get cycle length, others add 1

Reuse computed results

Skip nodes with already computed results

Code -

solution.c — C

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

int* countVisitedNodes(int* edges, int edgesSize, int* returnSize) {
    *returnSize = edgesSize;
    int* result = (int*)malloc(edgesSize * sizeof(int));
    for (int i = 0; i < edgesSize; i++) result[i] = -1;
    
    for (int i = 0; i < edgesSize; i++) {
        if (result[i] == -1) {
            int* visited = (int*)calloc(edgesSize, sizeof(int));
            int* path = (int*)malloc(edgesSize * sizeof(int));
            int pathLen = 0;
            int current = i;
            
            while (visited[current] == 0 && result[current] == -1) {
                visited[current] = pathLen + 1;
                path[pathLen++] = current;
                current = edges[current];
            }
            
            int cycleContribution, cycleStartIdx;
            if (result[current] != -1) {
                cycleContribution = result[current];
                cycleStartIdx = pathLen;
            } else {
                cycleStartIdx = visited[current] - 1;
                int cycleLength = pathLen - cycleStartIdx;
                cycleContribution = cycleLength;
            }
            
            for (int j = pathLen - 1; j >= 0; j--) {
                if (j >= cycleStartIdx) {
                    result[path[j]] = cycleContribution;
                } else {
                    result[path[j]] = result[path[j + 1]] + 1;
                }
            }
            
            free(visited);
            free(path);
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int edges[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        edges[n++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = countVisitedNodes(edges, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each node is visited at most twice - once for cycle detection and once for result computation

✓ Linear Growth

Space Complexity

O(n)

We need space for recursion stack, memoization array, and cycle detection

⚡ Linearithmic Space

Constraints

n == edges.length
1 ≤ n ≤ 10⁵
0 ≤ edges[i] ≤ n - 1
edges[i] ≠ i for all i
Each node has exactly one outgoing edge

28.4K Views

Medium Frequency

~25 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler