Time Taken to Mark All Nodes - Practice Coding Problems

Time Taken to Mark All Nodes - Problem

Time Taken to Mark All Nodes

Imagine a network of computers connected in a tree structure where information spreads at different rates depending on the computer type. You have n computers numbered 0 to n-1 connected by n-1 direct links forming a tree.

Each computer has a unique spreading pattern:
• Even-numbered computers: Receive information every 2 time units from their neighbors
• Odd-numbered computers: Receive information every 1 time unit from their neighbors

Starting from any computer at time t=0, information spreads through the network. Your task is to determine how long it takes for all computers to receive the information when starting from each possible computer.

Goal: Return an array where times[i] represents the total time needed to mark all nodes when starting from node i.

Input & Output

example_1.py — Simple Tree

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

› Output: [2, 4, 2]

💡 Note: When starting from node 0: Node 1 (odd) gets marked at time 1, Node 2 (even) gets marked at time 2. Max time = 2. When starting from node 1: Node 0 (even) gets marked at time 2, then node 2 gets marked at time 4. Max time = 4. When starting from node 2: Node 0 (even) gets marked at time 2, then node 1 gets marked at time 3. Max time = 3.

example_2.py — Linear Tree

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

› Output: [4, 6, 6, 4]

💡 Note: Linear tree where information must propagate through multiple hops. The middle nodes (1,2) require more time as they need to spread information in both directions.

example_3.py — Single Node

$ Input: edges = []

› Output: [0]

💡 Note: Edge case with only one node. No spreading needed, so time is 0.

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start spreading from the chosen root node at time 0

First Wave

Odd neighbors receive information after 1 time unit, even neighbors after 2 time units

Propagation

Information continues to spread outward through the tree structure

Completion

Record the time when the last node receives information

Key Takeaway

🎯 Key Insight: The tree rerooting technique allows us to compute all answers efficiently by leveraging the fact that when we change the root, only a small part of the tree structure changes, enabling O(1) updates per root transition.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n starting positions, we perform a BFS traversal that visits all n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the adjacency list, queue for BFS, and visited array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i ≤ n - 1
The given input represents a valid tree

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 15

This problem requires understanding tree rerooting and dynamic programming on trees. The optimal approach uses two DFS traversals: first to compute subtree information, then to efficiently reroot and calculate the answer for each starting position. The key insight is that when moving the root from one node to an adjacent node, most of the tree structure remains unchanged, allowing us to update only the affected parts in O(1) time per transition.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n²)	O(n)	Simulate the marking process from each starting node using BFS
Tree Rerooting with Dynamic Programming	O(n)	O(n)	First compute distances from one root, then reroot efficiently to get all answers

Brute Force Simulation — Algorithm Steps

For each starting node i from 0 to n-1
Initialize a queue with the starting node at time 0
Use BFS to simulate the marking process
For each unmarked neighbor of a marked node, calculate when it gets marked
Even nodes: marked at time t+2, Odd nodes: marked at time t+1
Track the maximum time needed to mark all nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with node 0, mark it at time 0

Spread to Neighbors

Node 1 (odd) gets marked at time 1, Node 2 (even) gets marked at time 2

Continue BFS

Process all reachable nodes until tree is fully marked

Record Max Time

The maximum time needed becomes our answer for this starting position

Code -

solution.c — C

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

typedef struct {
    int node;
    int time;
} QueueItem;

int* timeOfMarkingAllNodes(int** edges, int edgesSize, int* returnSize) {
    int n = edgesSize + 1;
    *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;
    }
    
    int* result = (int*)malloc(n * sizeof(int));
    
    // Try each starting node
    for (int start = 0; start < n; start++) {
        bool* marked = (bool*)calloc(n, sizeof(bool));
        QueueItem* queue = (QueueItem*)malloc(n * sizeof(QueueItem));
        int front = 0, rear = 0;
        
        queue[rear++] = (QueueItem){start, 0};
        marked[start] = true;
        int maxTime = 0;
        
        while (front < rear) {
            QueueItem current = queue[front++];
            if (current.time > maxTime) {
                maxTime = current.time;
            }
            
            // Check neighbors
            for (int i = 0; i < graphSize[current.node]; i++) {
                int neighbor = graph[current.node][i];
                if (!marked[neighbor]) {
                    marked[neighbor] = true;
                    int nextTime = current.time + (neighbor % 2 == 0 ? 2 : 1);
                    queue[rear++] = (QueueItem){neighbor, nextTime};
                }
            }
        }
        
        result[start] = maxTime;
        free(marked);
        free(queue);
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n starting positions, we perform a BFS traversal that visits all n nodes

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the adjacency list, queue for BFS, and visited array

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
edges.length == n - 1
0 ≤ u_i, v_i ≤ n - 1
The given input represents a valid tree

28.5K Views

Medium-High Frequency

~35 min Avg. Time

856 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler